Struct microtensor::Variable

pub struct Variable<T: Real + 'static> { /* private fields */ }

Variables track the computational operations used to create them and allow for computing their gradient with respect to all input variables involved.

They get created by calling tracked or trained on any differentiable Tensor type.

Variables dereference to their underlying Tensor automatically for non-differentiable operations. Differentiable operations, on the other hand, will always return another Variable.

Implementations

impl<T: Real + 'static> Variable<T>

pub fn id(&self) -> usize

pub fn tensor(&self) -> &Tensor<T>

pub fn grad(&self) -> Option<&Tensor<T>>

Examples found in repository

examples/basic.rs (line 15)

fn main() {
  // Define some tensors
  let x = Tensor::vec(&[1.0, 2.0]);
  let w = Tensor::randn(&[2, 8]).trained();
  let b = Tensor::zeros(&[8]).trained();

  // Do some computation
  let z = (x.tracked().mm(&w) + b - 0.5).sqr().mean(0);

  // Compute gradients
  z.backward();

  println!("Gradient of z with respect to w: {}", w.grad().unwrap());

  // Nudge w and b in order to minimize z
  for mut param in z.parameters() {
    param -= param.grad().unwrap() * 0.01
  }
}

examples/graph.rs (line 56)

fn load_model(filename: &str) {
  let graph = Graph::load(filename).unwrap();

  // Feed new data using #run.
  // Updating the entire graph in this way is more efficient
  // than calling #forward on each individual output.
  graph.run(&[
    &Tensor::vec(&[5.0, 6.0]).tracked(),
    &Tensor::randn(&[16]).tracked(),
  ]);

  // Get new output..
  let z = &graph.outputs[1];
  println!("z is now {}", z.item());

  // ..or train the model further
  let z = &graph.outputs[1];
  z.backward();
  for mut param in z.parameters() {
    param -= param.grad().unwrap() * 0.01
  }
}

examples/perceptron_eager.rs (line 77)

fn main() {
  // Construct model that stores all trainable tensors explicitly
  let model = Perceptron::new(28 * 28);

  // Train with labeled samples
  let learning_rate = 0.01;
  for _ in 0..100 {
    // Insert real training data here
    let images = Tensor::ones(&[32, 28 * 28]);
    let labels = (Tensor::rand(&[32]) * 10.0).cast::<u8>().one_hot(10);

    // Run the model, creating a fresh computation graph in the process
    let output = model.run(&images.tracked());

    // Compute loss
    let loss = (&labels.tracked() - &output).sqr().mean(0);

    // Compute gradients
    loss.backward();

    // Minimize loss by updating model parameters
    for mut param in loss.parameters() {
      param -= param.grad().unwrap() * learning_rate
    }

    // Reset gradients
    loss.reset();
  }
}

examples/perceptron_graph.rs (line 57)

fn main() {
  // Define model by performing all computations on a placeholder once
  let image_input = Tensor::zeros(&[32, 28 * 28]).tracked();
  let output = perceptron(&image_input);

  // Define the loss to me minimized
  let label_input = Tensor::zeros(&[32, 10]).tracked();
  let loss = (&label_input - &output).sqr().mean(0);

  // Train with some labeled samples
  let learning_rate = 0.01;
  for _ in 0..100 {
    // Insert real training data here
    let images = Tensor::ones(&[32, 28 * 28]).tracked();
    let labels = (Tensor::rand(&[32]) * 10.0).cast::<u8>().one_hot(10);

    // Feed existing computation graph with new inputs
    image_input.feed(&images);
    label_input.feed(&labels);

    // Recompute output and loss
    loss.forward();

    // Compute gradients
    loss.backward();

    // Minimize loss by updating model parameters
    for mut param in loss.parameters() {
      param -= param.grad().unwrap() * learning_rate
    }

    // Reset gradients
    loss.reset();
  }
}

pub fn unary_op(&self, op: impl UnaryOp<T> + 'static) -> Self

pub fn binary_op(&self, op: impl BinaryOp<T> + 'static, rhs: &Self) -> Self

pub fn forward(&self)

Reevaluate this Variable’s graph to produce a new output.

Examples found in repository

examples/perceptron_graph.rs (line 50)

fn main() {
  // Define model by performing all computations on a placeholder once
  let image_input = Tensor::zeros(&[32, 28 * 28]).tracked();
  let output = perceptron(&image_input);

  // Define the loss to me minimized
  let label_input = Tensor::zeros(&[32, 10]).tracked();
  let loss = (&label_input - &output).sqr().mean(0);

  // Train with some labeled samples
  let learning_rate = 0.01;
  for _ in 0..100 {
    // Insert real training data here
    let images = Tensor::ones(&[32, 28 * 28]).tracked();
    let labels = (Tensor::rand(&[32]) * 10.0).cast::<u8>().one_hot(10);

    // Feed existing computation graph with new inputs
    image_input.feed(&images);
    label_input.feed(&labels);

    // Recompute output and loss
    loss.forward();

    // Compute gradients
    loss.backward();

    // Minimize loss by updating model parameters
    for mut param in loss.parameters() {
      param -= param.grad().unwrap() * learning_rate
    }

    // Reset gradients
    loss.reset();
  }
}

pub fn backward(&self)

Compute gradients across this Variable’s entire graph.

Examples found in repository

examples/basic.rs (line 13)

fn main() {
  // Define some tensors
  let x = Tensor::vec(&[1.0, 2.0]);
  let w = Tensor::randn(&[2, 8]).trained();
  let b = Tensor::zeros(&[8]).trained();

  // Do some computation
  let z = (x.tracked().mm(&w) + b - 0.5).sqr().mean(0);

  // Compute gradients
  z.backward();

  println!("Gradient of z with respect to w: {}", w.grad().unwrap());

  // Nudge w and b in order to minimize z
  for mut param in z.parameters() {
    param -= param.grad().unwrap() * 0.01
  }
}

examples/graph.rs (line 54)

fn load_model(filename: &str) {
  let graph = Graph::load(filename).unwrap();

  // Feed new data using #run.
  // Updating the entire graph in this way is more efficient
  // than calling #forward on each individual output.
  graph.run(&[
    &Tensor::vec(&[5.0, 6.0]).tracked(),
    &Tensor::randn(&[16]).tracked(),
  ]);

  // Get new output..
  let z = &graph.outputs[1];
  println!("z is now {}", z.item());

  // ..or train the model further
  let z = &graph.outputs[1];
  z.backward();
  for mut param in z.parameters() {
    param -= param.grad().unwrap() * 0.01
  }
}

examples/perceptron_eager.rs (line 73)

fn main() {
  // Construct model that stores all trainable tensors explicitly
  let model = Perceptron::new(28 * 28);

  // Train with labeled samples
  let learning_rate = 0.01;
  for _ in 0..100 {
    // Insert real training data here
    let images = Tensor::ones(&[32, 28 * 28]);
    let labels = (Tensor::rand(&[32]) * 10.0).cast::<u8>().one_hot(10);

    // Run the model, creating a fresh computation graph in the process
    let output = model.run(&images.tracked());

    // Compute loss
    let loss = (&labels.tracked() - &output).sqr().mean(0);

    // Compute gradients
    loss.backward();

    // Minimize loss by updating model parameters
    for mut param in loss.parameters() {
      param -= param.grad().unwrap() * learning_rate
    }

    // Reset gradients
    loss.reset();
  }
}

examples/perceptron_graph.rs (line 53)

fn main() {
  // Define model by performing all computations on a placeholder once
  let image_input = Tensor::zeros(&[32, 28 * 28]).tracked();
  let output = perceptron(&image_input);

  // Define the loss to me minimized
  let label_input = Tensor::zeros(&[32, 10]).tracked();
  let loss = (&label_input - &output).sqr().mean(0);

  // Train with some labeled samples
  let learning_rate = 0.01;
  for _ in 0..100 {
    // Insert real training data here
    let images = Tensor::ones(&[32, 28 * 28]).tracked();
    let labels = (Tensor::rand(&[32]) * 10.0).cast::<u8>().one_hot(10);

    // Feed existing computation graph with new inputs
    image_input.feed(&images);
    label_input.feed(&labels);

    // Recompute output and loss
    loss.forward();

    // Compute gradients
    loss.backward();

    // Minimize loss by updating model parameters
    for mut param in loss.parameters() {
      param -= param.grad().unwrap() * learning_rate
    }

    // Reset gradients
    loss.reset();
  }
}

pub fn parameters(&self) -> Vec<Self>

List all trainable parameters in this Variable’s graph.

Examples found in repository

examples/basic.rs (line 18)

fn main() {
  // Define some tensors
  let x = Tensor::vec(&[1.0, 2.0]);
  let w = Tensor::randn(&[2, 8]).trained();
  let b = Tensor::zeros(&[8]).trained();

  // Do some computation
  let z = (x.tracked().mm(&w) + b - 0.5).sqr().mean(0);

  // Compute gradients
  z.backward();

  println!("Gradient of z with respect to w: {}", w.grad().unwrap());

  // Nudge w and b in order to minimize z
  for mut param in z.parameters() {
    param -= param.grad().unwrap() * 0.01
  }
}

examples/graph.rs (line 55)

fn load_model(filename: &str) {
  let graph = Graph::load(filename).unwrap();

  // Feed new data using #run.
  // Updating the entire graph in this way is more efficient
  // than calling #forward on each individual output.
  graph.run(&[
    &Tensor::vec(&[5.0, 6.0]).tracked(),
    &Tensor::randn(&[16]).tracked(),
  ]);

  // Get new output..
  let z = &graph.outputs[1];
  println!("z is now {}", z.item());

  // ..or train the model further
  let z = &graph.outputs[1];
  z.backward();
  for mut param in z.parameters() {
    param -= param.grad().unwrap() * 0.01
  }
}

examples/perceptron_eager.rs (line 76)

fn main() {
  // Construct model that stores all trainable tensors explicitly
  let model = Perceptron::new(28 * 28);

  // Train with labeled samples
  let learning_rate = 0.01;
  for _ in 0..100 {
    // Insert real training data here
    let images = Tensor::ones(&[32, 28 * 28]);
    let labels = (Tensor::rand(&[32]) * 10.0).cast::<u8>().one_hot(10);

    // Run the model, creating a fresh computation graph in the process
    let output = model.run(&images.tracked());

    // Compute loss
    let loss = (&labels.tracked() - &output).sqr().mean(0);

    // Compute gradients
    loss.backward();

    // Minimize loss by updating model parameters
    for mut param in loss.parameters() {
      param -= param.grad().unwrap() * learning_rate
    }

    // Reset gradients
    loss.reset();
  }
}

examples/perceptron_graph.rs (line 56)

fn main() {
  // Define model by performing all computations on a placeholder once
  let image_input = Tensor::zeros(&[32, 28 * 28]).tracked();
  let output = perceptron(&image_input);

  // Define the loss to me minimized
  let label_input = Tensor::zeros(&[32, 10]).tracked();
  let loss = (&label_input - &output).sqr().mean(0);

  // Train with some labeled samples
  let learning_rate = 0.01;
  for _ in 0..100 {
    // Insert real training data here
    let images = Tensor::ones(&[32, 28 * 28]).tracked();
    let labels = (Tensor::rand(&[32]) * 10.0).cast::<u8>().one_hot(10);

    // Feed existing computation graph with new inputs
    image_input.feed(&images);
    label_input.feed(&labels);

    // Recompute output and loss
    loss.forward();

    // Compute gradients
    loss.backward();

    // Minimize loss by updating model parameters
    for mut param in loss.parameters() {
      param -= param.grad().unwrap() * learning_rate
    }

    // Reset gradients
    loss.reset();
  }
}

pub fn inputs(&self) -> Vec<Self>

pub fn reset(&self)

Set gradients to zero for this Variable’s entire graph.

Examples found in repository

examples/perceptron_eager.rs (line 81)

fn main() {
  // Construct model that stores all trainable tensors explicitly
  let model = Perceptron::new(28 * 28);

  // Train with labeled samples
  let learning_rate = 0.01;
  for _ in 0..100 {
    // Insert real training data here
    let images = Tensor::ones(&[32, 28 * 28]);
    let labels = (Tensor::rand(&[32]) * 10.0).cast::<u8>().one_hot(10);

    // Run the model, creating a fresh computation graph in the process
    let output = model.run(&images.tracked());

    // Compute loss
    let loss = (&labels.tracked() - &output).sqr().mean(0);

    // Compute gradients
    loss.backward();

    // Minimize loss by updating model parameters
    for mut param in loss.parameters() {
      param -= param.grad().unwrap() * learning_rate
    }

    // Reset gradients
    loss.reset();
  }
}

examples/perceptron_graph.rs (line 61)

fn main() {
  // Define model by performing all computations on a placeholder once
  let image_input = Tensor::zeros(&[32, 28 * 28]).tracked();
  let output = perceptron(&image_input);

  // Define the loss to me minimized
  let label_input = Tensor::zeros(&[32, 10]).tracked();
  let loss = (&label_input - &output).sqr().mean(0);

  // Train with some labeled samples
  let learning_rate = 0.01;
  for _ in 0..100 {
    // Insert real training data here
    let images = Tensor::ones(&[32, 28 * 28]).tracked();
    let labels = (Tensor::rand(&[32]) * 10.0).cast::<u8>().one_hot(10);

    // Feed existing computation graph with new inputs
    image_input.feed(&images);
    label_input.feed(&labels);

    // Recompute output and loss
    loss.forward();

    // Compute gradients
    loss.backward();

    // Minimize loss by updating model parameters
    for mut param in loss.parameters() {
      param -= param.grad().unwrap() * learning_rate
    }

    // Reset gradients
    loss.reset();
  }
}

pub fn check_gradients<F>(shape: &[usize], generator: F) -> Twhere F: Fn(&Self) -> Self,

Compute a function’s gradient with respect to a generated input numerically and compare it to the automatically derived solution.

Supply any function to check that it gets differentiated correctly.

pub fn statistics(&self) -> (usize, usize, usize, usize, usize)

Methods from Deref<Target = Tensor<T>>

pub fn raw(&self) -> RwLockReadGuard<'_, Vec<T>>

pub fn raw_mut(&self) -> RwLockWriteGuard<'_, Vec<T>>

pub fn size(&self) -> usize

pub fn rank(&self) -> usize

pub fn contiguous(&self) -> Self

pub fn detach(&self) -> Self

pub fn zip<O, F>(&self, rhs: &Self, cb: F) -> Tensor<O>where O: Inner, F: Fn((T, T)) -> O,

pub fn vectorize<O, F>(&self, cb: F) -> Tensor<O>where O: Inner, F: FnMut(T) -> O,

pub fn reduce<F>(&self, cb: F) -> Option<Self>where F: Fn(T, T) -> T,

pub fn collapse<O, F>(&self, dim: isize, cb: F) -> Tensor<O>where O: Inner, F: Fn(Self) -> O,

pub fn collapse_only<F>(&self, dim: isize, cb: F) -> Selfwhere F: Fn(Self) -> Self,

pub fn expand<O, F>(&self, cb: F) -> Tensor<O>where O: Inner, F: Fn(T) -> Vec<O>,

pub fn map<O, F>(&self, dim: isize, cb: F) -> Tensor<O>where O: Inner, F: Fn(Self) -> Tensor<O>,

pub fn iter(&self, dim: isize) -> TensorSliceIterator<'_, T>

pub fn param_iter(&self) -> TensorIterator<'_, T>

pub fn item(&self) -> T

Examples found in repository

examples/graph.rs (line 50)

fn load_model(filename: &str) {
  let graph = Graph::load(filename).unwrap();

  // Feed new data using #run.
  // Updating the entire graph in this way is more efficient
  // than calling #forward on each individual output.
  graph.run(&[
    &Tensor::vec(&[5.0, 6.0]).tracked(),
    &Tensor::randn(&[16]).tracked(),
  ]);

  // Get new output..
  let z = &graph.outputs[1];
  println!("z is now {}", z.item());

  // ..or train the model further
  let z = &graph.outputs[1];
  z.backward();
  for mut param in z.parameters() {
    param -= param.grad().unwrap() * 0.01
  }
}

pub fn view(&self, shape: &[usize]) -> Self

pub fn extend_front(&self, size: usize) -> Self

pub fn transpose_vec(&self, extend_front: bool) -> Self

pub fn equal(&self, rhs: &Self) -> Tensor<bool>

pub fn split(&self, size: usize, dim: isize) -> Vec<Self>

pub fn chunks(&self, n: usize, dim: isize) -> Vec<Self>

pub fn to_vec(&self, dim: isize) -> Vec<Self>

pub fn shuffle(&self, dim: isize) -> Self

pub fn feed(&self, other: &Self)

Examples found in repository

examples/perceptron_graph.rs (line 46)

fn main() {
  // Define model by performing all computations on a placeholder once
  let image_input = Tensor::zeros(&[32, 28 * 28]).tracked();
  let output = perceptron(&image_input);

  // Define the loss to me minimized
  let label_input = Tensor::zeros(&[32, 10]).tracked();
  let loss = (&label_input - &output).sqr().mean(0);

  // Train with some labeled samples
  let learning_rate = 0.01;
  for _ in 0..100 {
    // Insert real training data here
    let images = Tensor::ones(&[32, 28 * 28]).tracked();
    let labels = (Tensor::rand(&[32]) * 10.0).cast::<u8>().one_hot(10);

    // Feed existing computation graph with new inputs
    image_input.feed(&images);
    label_input.feed(&labels);

    // Recompute output and loss
    loss.forward();

    // Compute gradients
    loss.backward();

    // Minimize loss by updating model parameters
    for mut param in loss.parameters() {
      param -= param.grad().unwrap() * learning_rate
    }

    // Reset gradients
    loss.reset();
  }
}

pub fn add(&self, rhs: &Self) -> Self

pub fn sub(&self, rhs: &Self) -> Self

pub fn mul(&self, rhs: &Self) -> Self

pub fn div(&self, rhs: &Self) -> Self

pub fn rem(&self, rhs: &Self) -> Self

pub fn sum_over(&self, dim: isize) -> Self

pub fn gt(&self, rhs: &Self) -> Tensor<bool>

pub fn lt(&self, rhs: &Self) -> Tensor<bool>

pub fn top_k(&self, k: usize, dim: isize) -> Self

pub fn argmax<O: Integer + Unsigned>(&self, dim: isize) -> Tensor<O>

Collapse dimension using index of its greatest value

pub fn clamp(&self, min: T, max: T) -> Self

pub fn cast<I: Numeric>(&self) -> Tensor<I>

Examples found in repository

examples/perceptron_eager.rs (line 64)

fn main() {
  // Construct model that stores all trainable tensors explicitly
  let model = Perceptron::new(28 * 28);

  // Train with labeled samples
  let learning_rate = 0.01;
  for _ in 0..100 {
    // Insert real training data here
    let images = Tensor::ones(&[32, 28 * 28]);
    let labels = (Tensor::rand(&[32]) * 10.0).cast::<u8>().one_hot(10);

    // Run the model, creating a fresh computation graph in the process
    let output = model.run(&images.tracked());

    // Compute loss
    let loss = (&labels.tracked() - &output).sqr().mean(0);

    // Compute gradients
    loss.backward();

    // Minimize loss by updating model parameters
    for mut param in loss.parameters() {
      param -= param.grad().unwrap() * learning_rate
    }

    // Reset gradients
    loss.reset();
  }
}

examples/perceptron_graph.rs (line 43)

fn main() {
  // Define model by performing all computations on a placeholder once
  let image_input = Tensor::zeros(&[32, 28 * 28]).tracked();
  let output = perceptron(&image_input);

  // Define the loss to me minimized
  let label_input = Tensor::zeros(&[32, 10]).tracked();
  let loss = (&label_input - &output).sqr().mean(0);

  // Train with some labeled samples
  let learning_rate = 0.01;
  for _ in 0..100 {
    // Insert real training data here
    let images = Tensor::ones(&[32, 28 * 28]).tracked();
    let labels = (Tensor::rand(&[32]) * 10.0).cast::<u8>().one_hot(10);

    // Feed existing computation graph with new inputs
    image_input.feed(&images);
    label_input.feed(&labels);

    // Recompute output and loss
    loss.forward();

    // Compute gradients
    loss.backward();

    // Minimize loss by updating model parameters
    for mut param in loss.parameters() {
      param -= param.grad().unwrap() * learning_rate
    }

    // Reset gradients
    loss.reset();
  }
}

pub fn bernoulli<O: Numeric>(&self) -> Tensor<O>

pub fn sample(&self) -> usize

pub fn trained(&self) -> Variable<T>

Examples found in repository

examples/perceptron_eager.rs (line 26)

  pub fn new(input_size: usize, size: usize) -> Self {
    Self {
      weights: (Tensor::randn(&[input_size, size]) / size as f32).trained(),
      bias: Tensor::zeros(&[size]).trained(),
    }
  }

examples/perceptron_graph.rs (line 19)

fn dense_layer(input: &Variable<f32>, size: usize) -> Variable<f32> {
  let weights = (Tensor::randn(&[input.shape()[-1], size]) / size as f32).trained();
  let bias = Tensor::zeros(&[size]).trained();
  input.mm(&weights) + bias
}

examples/basic.rs (line 6)

fn main() {
  // Define some tensors
  let x = Tensor::vec(&[1.0, 2.0]);
  let w = Tensor::randn(&[2, 8]).trained();
  let b = Tensor::zeros(&[8]).trained();

  // Do some computation
  let z = (x.tracked().mm(&w) + b - 0.5).sqr().mean(0);

  // Compute gradients
  z.backward();

  println!("Gradient of z with respect to w: {}", w.grad().unwrap());

  // Nudge w and b in order to minimize z
  for mut param in z.parameters() {
    param -= param.grad().unwrap() * 0.01
  }
}

examples/graph.rs (line 23)

fn build_model(filename: &str) {
  // Have some inputs
  let x1 = Tensor::vec(&[1.0, 2.0]).tracked();
  let x2 = Tensor::ones(&[16]).tracked();
  let w = Tensor::randn(&[2, 16]).trained();

  // Do some computations
  let y = x1.mm(&w);
  let z = (&y * &x2).sum(0);

  // Pack the resulting graph into a Graph structure to make its inputs
  // and outputs explicit and arrange them in an order of your liking.
  let graph = Graph::new(&[x1, x2], &[y, z]);

  // Save entire computation graph to disc
  graph.save(filename).unwrap();
}

pub fn tracked(&self) -> Variable<T>

Examples found in repository

examples/basic.rs (line 10)

fn main() {
  // Define some tensors
  let x = Tensor::vec(&[1.0, 2.0]);
  let w = Tensor::randn(&[2, 8]).trained();
  let b = Tensor::zeros(&[8]).trained();

  // Do some computation
  let z = (x.tracked().mm(&w) + b - 0.5).sqr().mean(0);

  // Compute gradients
  z.backward();

  println!("Gradient of z with respect to w: {}", w.grad().unwrap());

  // Nudge w and b in order to minimize z
  for mut param in z.parameters() {
    param -= param.grad().unwrap() * 0.01
  }
}

examples/graph.rs (line 21)

fn build_model(filename: &str) {
  // Have some inputs
  let x1 = Tensor::vec(&[1.0, 2.0]).tracked();
  let x2 = Tensor::ones(&[16]).tracked();
  let w = Tensor::randn(&[2, 16]).trained();

  // Do some computations
  let y = x1.mm(&w);
  let z = (&y * &x2).sum(0);

  // Pack the resulting graph into a Graph structure to make its inputs
  // and outputs explicit and arrange them in an order of your liking.
  let graph = Graph::new(&[x1, x2], &[y, z]);

  // Save entire computation graph to disc
  graph.save(filename).unwrap();
}

fn load_model(filename: &str) {
  let graph = Graph::load(filename).unwrap();

  // Feed new data using #run.
  // Updating the entire graph in this way is more efficient
  // than calling #forward on each individual output.
  graph.run(&[
    &Tensor::vec(&[5.0, 6.0]).tracked(),
    &Tensor::randn(&[16]).tracked(),
  ]);

  // Get new output..
  let z = &graph.outputs[1];
  println!("z is now {}", z.item());

  // ..or train the model further
  let z = &graph.outputs[1];
  z.backward();
  for mut param in z.parameters() {
    param -= param.grad().unwrap() * 0.01
  }
}

examples/perceptron_eager.rs (line 67)

fn main() {
  // Construct model that stores all trainable tensors explicitly
  let model = Perceptron::new(28 * 28);

  // Train with labeled samples
  let learning_rate = 0.01;
  for _ in 0..100 {
    // Insert real training data here
    let images = Tensor::ones(&[32, 28 * 28]);
    let labels = (Tensor::rand(&[32]) * 10.0).cast::<u8>().one_hot(10);

    // Run the model, creating a fresh computation graph in the process
    let output = model.run(&images.tracked());

    // Compute loss
    let loss = (&labels.tracked() - &output).sqr().mean(0);

    // Compute gradients
    loss.backward();

    // Minimize loss by updating model parameters
    for mut param in loss.parameters() {
      param -= param.grad().unwrap() * learning_rate
    }

    // Reset gradients
    loss.reset();
  }
}

examples/perceptron_graph.rs (line 31)

fn main() {
  // Define model by performing all computations on a placeholder once
  let image_input = Tensor::zeros(&[32, 28 * 28]).tracked();
  let output = perceptron(&image_input);

  // Define the loss to me minimized
  let label_input = Tensor::zeros(&[32, 10]).tracked();
  let loss = (&label_input - &output).sqr().mean(0);

  // Train with some labeled samples
  let learning_rate = 0.01;
  for _ in 0..100 {
    // Insert real training data here
    let images = Tensor::ones(&[32, 28 * 28]).tracked();
    let labels = (Tensor::rand(&[32]) * 10.0).cast::<u8>().one_hot(10);

    // Feed existing computation graph with new inputs
    image_input.feed(&images);
    label_input.feed(&labels);

    // Recompute output and loss
    loss.forward();

    // Compute gradients
    loss.backward();

    // Minimize loss by updating model parameters
    for mut param in loss.parameters() {
      param -= param.grad().unwrap() * learning_rate
    }

    // Reset gradients
    loss.reset();
  }
}

pub fn accuracy<O: Real>(&self, labels: &Self) -> O

pub fn one_hot<O: Numeric>(&self, size: usize) -> Tensor<O>

Examples found in repository

examples/perceptron_eager.rs (line 64)

fn main() {
  // Construct model that stores all trainable tensors explicitly
  let model = Perceptron::new(28 * 28);

  // Train with labeled samples
  let learning_rate = 0.01;
  for _ in 0..100 {
    // Insert real training data here
    let images = Tensor::ones(&[32, 28 * 28]);
    let labels = (Tensor::rand(&[32]) * 10.0).cast::<u8>().one_hot(10);

    // Run the model, creating a fresh computation graph in the process
    let output = model.run(&images.tracked());

    // Compute loss
    let loss = (&labels.tracked() - &output).sqr().mean(0);

    // Compute gradients
    loss.backward();

    // Minimize loss by updating model parameters
    for mut param in loss.parameters() {
      param -= param.grad().unwrap() * learning_rate
    }

    // Reset gradients
    loss.reset();
  }
}

examples/perceptron_graph.rs (line 43)

fn main() {
  // Define model by performing all computations on a placeholder once
  let image_input = Tensor::zeros(&[32, 28 * 28]).tracked();
  let output = perceptron(&image_input);

  // Define the loss to me minimized
  let label_input = Tensor::zeros(&[32, 10]).tracked();
  let loss = (&label_input - &output).sqr().mean(0);

  // Train with some labeled samples
  let learning_rate = 0.01;
  for _ in 0..100 {
    // Insert real training data here
    let images = Tensor::ones(&[32, 28 * 28]).tracked();
    let labels = (Tensor::rand(&[32]) * 10.0).cast::<u8>().one_hot(10);

    // Feed existing computation graph with new inputs
    image_input.feed(&images);
    label_input.feed(&labels);

    // Recompute output and loss
    loss.forward();

    // Compute gradients
    loss.backward();

    // Minimize loss by updating model parameters
    for mut param in loss.parameters() {
      param -= param.grad().unwrap() * learning_rate
    }

    // Reset gradients
    loss.reset();
  }
}

pub fn confusion(&self, labels: &Self) -> Self

pub fn signum(&self) -> Self

pub fn numeric<O: Numeric>(&self) -> Tensor<O>

pub fn and(&self, rhs: &Self) -> Self

pub fn or(&self, rhs: &Self) -> Self

pub fn all(&self) -> Option<bool>

pub fn any(&self) -> Option<bool>

pub fn when<O: Inner>(&self, either: Tensor<O>, or: Tensor<O>) -> Tensor<O>

Trait Implementations

impl<T: Real> Add<&Variable<T>> for &Variable<T>

type Output = Variable<T>

The resulting type after applying the + operator.

fn add(self, rhs: Self) -> Variable<T>

Performs the + operation.

impl<T: Real> Add<&Variable<T>> for Variable<T>

type Output = Variable<T>

The resulting type after applying the + operator.

fn add(self, rhs: &Variable<T>) -> Variable<T>

Performs the + operation.

impl Add<&Variable<f32>> for f32

type Output = Variable<f32>

The resulting type after applying the + operator.

fn add(self, rhs: &Variable<f32>) -> Variable<f32>

Performs the + operation.

impl<T: Real> Add<T> for &Variable<T>

type Output = Variable<T>

The resulting type after applying the + operator.

fn add(self, rhs: T) -> Variable<T>

Performs the + operation.

impl<T: Real> Add<T> for Variable<T>

type Output = Variable<T>

The resulting type after applying the + operator.

fn add(self, rhs: T) -> Variable<T>

Performs the + operation.

impl<T: Real> Add<Variable<T>> for &Variable<T>

type Output = Variable<T>

The resulting type after applying the + operator.

fn add(self, rhs: Variable<T>) -> Variable<T>

Performs the + operation.

impl<T: Real> Add<Variable<T>> for Variable<T>

type Output = Variable<T>

The resulting type after applying the + operator.

fn add(self, rhs: Self) -> Variable<T>

Performs the + operation.

impl Add<Variable<f32>> for f32

type Output = Variable<f32>

The resulting type after applying the + operator.

fn add(self, rhs: Variable<f32>) -> Variable<f32>

Performs the + operation.

impl<T: Real> AddAssign<Tensor<T>> for Variable<T>

fn add_assign(&mut self, rhs: Tensor<T>)

Performs the += operation.

impl<T: Real> BaseHops<T> for Variable<T>

fn at(&self, indices: &[isize]) -> Self

fn squeeze_only(&self, dim: isize) -> Self

fn squeeze_but(&self, dim: isize) -> Self

fn squeeze_first(&self, n: usize) -> Self

fn squeeze_all(&self) -> Self

fn unsqueeze_n(&self, n: usize, dim: isize) -> Self

fn extend(&self, rank: usize) -> Self

fn stack(rows: &[Self], dim: isize) -> Self

fn rows(rows: &[Self]) -> Self

impl<T: Real> BaseOps<T> for Variable<T>

fn scalar(item: T) -> Self

fn shape(&self) -> &Shape

fn range(&self, ranges: &[Range<isize>]) -> Self

fn broadcast(&self, shape: &Shape, _ignore_from: Option<isize>) -> Self

fn reshape(&self, dims: &[usize]) -> Self

fn squeeze(&self, squeezed: &[isize]) -> Self

fn unsqueeze(&self, dim: isize) -> Self

fn transpose(&self, dim1: isize, dim2: isize) -> Self

fn concat(&self, rhs: &Self, dim: isize) -> Self

impl<T: Clone + Real + 'static> Clone for Variable<T>

fn clone(&self) -> Variable<T>

Returns a copy of the value.

fn clone_from(&mut self, source: &Self)

Performs copy-assignment from source.

impl<T: Debug + Real + 'static> Debug for Variable<T>

fn fmt(&self, f: &mut Formatter<'_>) -> Result

Formats the value using the given formatter.

impl<T: Real> Deref for Variable<T>

type Target = Tensor<T>

The resulting type after dereferencing.

fn deref(&self) -> &Self::Target

Dereferences the value.

impl<T: Real> Display for Variable<T>

fn fmt(&self, f: &mut Formatter<'_>) -> Result

Formats the value using the given formatter.

impl<T: Real> Div<&Variable<T>> for &Variable<T>

type Output = Variable<T>

The resulting type after applying the / operator.

fn div(self, rhs: Self) -> Variable<T>

Performs the / operation.

impl<T: Real> Div<&Variable<T>> for Variable<T>

type Output = Variable<T>

The resulting type after applying the / operator.

fn div(self, rhs: &Variable<T>) -> Variable<T>

Performs the / operation.

impl Div<&Variable<f32>> for f32

type Output = Variable<f32>

The resulting type after applying the / operator.

fn div(self, rhs: &Variable<f32>) -> Variable<f32>

Performs the / operation.

impl<T: Real> Div<T> for &Variable<T>

type Output = Variable<T>

The resulting type after applying the / operator.

fn div(self, rhs: T) -> Variable<T>

Performs the / operation.

impl<T: Real> Div<T> for Variable<T>

type Output = Variable<T>

The resulting type after applying the / operator.

fn div(self, rhs: T) -> Variable<T>

Performs the / operation.

impl<T: Real> Div<Variable<T>> for &Variable<T>

type Output = Variable<T>

The resulting type after applying the / operator.

fn div(self, rhs: Variable<T>) -> Variable<T>

Performs the / operation.

impl<T: Real> Div<Variable<T>> for Variable<T>

type Output = Variable<T>

The resulting type after applying the / operator.

fn div(self, rhs: Self) -> Variable<T>

Performs the / operation.

impl Div<Variable<f32>> for f32

type Output = Variable<f32>

The resulting type after applying the / operator.

fn div(self, rhs: Variable<f32>) -> Variable<f32>

Performs the / operation.

impl<T: Real> DivAssign<Tensor<T>> for Variable<T>

fn div_assign(&mut self, rhs: Tensor<T>)

Performs the /= operation.

impl<T: Real> Mul<&Variable<T>> for &Variable<T>

type Output = Variable<T>

The resulting type after applying the * operator.

fn mul(self, rhs: Self) -> Variable<T>

Performs the * operation.

impl<T: Real> Mul<&Variable<T>> for Variable<T>

type Output = Variable<T>

The resulting type after applying the * operator.

fn mul(self, rhs: &Variable<T>) -> Variable<T>

Performs the * operation.

impl Mul<&Variable<f32>> for f32

type Output = Variable<f32>

The resulting type after applying the * operator.

fn mul(self, rhs: &Variable<f32>) -> Variable<f32>

Performs the * operation.

impl<T: Real> Mul<T> for &Variable<T>

type Output = Variable<T>

The resulting type after applying the * operator.

fn mul(self, rhs: T) -> Variable<T>

Performs the * operation.

impl<T: Real> Mul<T> for Variable<T>

type Output = Variable<T>

The resulting type after applying the * operator.

fn mul(self, rhs: T) -> Variable<T>

Performs the * operation.

impl<T: Real> Mul<Variable<T>> for &Variable<T>

type Output = Variable<T>

The resulting type after applying the * operator.

fn mul(self, rhs: Variable<T>) -> Variable<T>

Performs the * operation.

impl<T: Real> Mul<Variable<T>> for Variable<T>

type Output = Variable<T>

The resulting type after applying the * operator.

fn mul(self, rhs: Self) -> Variable<T>

Performs the * operation.

impl Mul<Variable<f32>> for f32

type Output = Variable<f32>

The resulting type after applying the * operator.

fn mul(self, rhs: Variable<f32>) -> Variable<f32>

Performs the * operation.

impl<T: Real> MulAssign<Tensor<T>> for Variable<T>

fn mul_assign(&mut self, rhs: Tensor<T>)

Performs the *= operation.

impl<T: Real> Neg for &Variable<T>

type Output = Variable<T>

The resulting type after applying the - operator.

fn neg(self) -> Self::Output

Performs the unary - operation.

impl<T: Real> Neg for Variable<T>

type Output = Variable<T>

The resulting type after applying the - operator.

fn neg(self) -> Self::Output

Performs the unary - operation.

impl<T: Real> NumericOps<T> for Variable<T>

fn sum(&self, dim: isize) -> Variable<T>

fn mm(&self, rhs: &Self) -> Self

fn min(&self, dim: isize) -> Self

fn max(&self, dim: isize) -> Self

fn max_over(&self, _dim: isize) -> Self

impl<T: Real> PartialEq<Variable<T>> for Variable<T>

fn eq(&self, rhs: &Self) -> bool

This method tests for self and other values to be equal, and is used by ==.

fn ne(&self, other: &Rhs) -> bool

This method tests for !=. The default implementation is almost always sufficient, and should not be overridden without very good reason.

impl<T: Real> RealHops<T> for Variable<T>

fn powf(&self, exp: I) -> Self

fn sqr(&self) -> Self

fn sqrt(&self) -> Self

fn exp(&self) -> Self

fn norm(&self, dim: isize) -> Self

fn dot(&self, rhs: &Self, dim: isize) -> Self

fn mean(&self, dim: isize) -> Self

fn variance(&self, dim: isize) -> Self

fn softmax(&self, dim: isize) -> Self

fn max_with(&self, rhs: &Self) -> Self

impl<T: Real> RealOps<T> for Variable<T>

fn pow(&self, rhs: &Self) -> Variable<T>

fn sin(&self) -> Self

fn cos(&self) -> Self

fn log(&self) -> Self

fn relu(&self) -> Variable<T>

fn sigmoid(&self) -> Variable<T>

impl<T: Real> Rem<&Variable<T>> for &Variable<T>

type Output = Variable<T>

The resulting type after applying the % operator.

fn rem(self, rhs: Self) -> Variable<T>

Performs the % operation.

impl<T: Real> Rem<&Variable<T>> for Variable<T>

type Output = Variable<T>

The resulting type after applying the % operator.

fn rem(self, rhs: &Variable<T>) -> Variable<T>

Performs the % operation.

impl Rem<&Variable<f32>> for f32

type Output = Variable<f32>

The resulting type after applying the % operator.

fn rem(self, rhs: &Variable<f32>) -> Variable<f32>

Performs the % operation.

impl<T: Real> Rem<T> for &Variable<T>

type Output = Variable<T>

The resulting type after applying the % operator.

fn rem(self, rhs: T) -> Variable<T>

Performs the % operation.

impl<T: Real> Rem<T> for Variable<T>

type Output = Variable<T>

The resulting type after applying the % operator.

fn rem(self, rhs: T) -> Variable<T>

Performs the % operation.

impl<T: Real> Rem<Variable<T>> for &Variable<T>

type Output = Variable<T>

The resulting type after applying the % operator.

fn rem(self, rhs: Variable<T>) -> Variable<T>

Performs the % operation.

impl<T: Real> Rem<Variable<T>> for Variable<T>

type Output = Variable<T>

The resulting type after applying the % operator.

fn rem(self, rhs: Self) -> Variable<T>

Performs the % operation.

impl Rem<Variable<f32>> for f32

type Output = Variable<f32>

The resulting type after applying the % operator.

fn rem(self, rhs: Variable<f32>) -> Variable<f32>

Performs the % operation.

impl<T: Real> SignedOps<T> for Variable<T>

fn abs(&self) -> Variable<T>

impl<T: Real> Sub<&Variable<T>> for &Variable<T>

type Output = Variable<T>

The resulting type after applying the - operator.

fn sub(self, rhs: Self) -> Variable<T>

Performs the - operation.

impl<T: Real> Sub<&Variable<T>> for Variable<T>

type Output = Variable<T>

The resulting type after applying the - operator.

fn sub(self, rhs: &Variable<T>) -> Variable<T>

Performs the - operation.

impl Sub<&Variable<f32>> for f32

type Output = Variable<f32>

The resulting type after applying the - operator.

fn sub(self, rhs: &Variable<f32>) -> Variable<f32>

Performs the - operation.

impl<T: Real> Sub<T> for &Variable<T>

type Output = Variable<T>

The resulting type after applying the - operator.

fn sub(self, rhs: T) -> Variable<T>

Performs the - operation.

impl<T: Real> Sub<T> for Variable<T>

type Output = Variable<T>

The resulting type after applying the - operator.

fn sub(self, rhs: T) -> Variable<T>

Performs the - operation.

impl<T: Real> Sub<Variable<T>> for &Variable<T>

type Output = Variable<T>

The resulting type after applying the - operator.

fn sub(self, rhs: Variable<T>) -> Variable<T>

Performs the - operation.

impl<T: Real> Sub<Variable<T>> for Variable<T>

type Output = Variable<T>

The resulting type after applying the - operator.

fn sub(self, rhs: Self) -> Variable<T>

Performs the - operation.

impl Sub<Variable<f32>> for f32

type Output = Variable<f32>

The resulting type after applying the - operator.

fn sub(self, rhs: Variable<f32>) -> Variable<f32>

Performs the - operation.

impl<T: Real> SubAssign<Tensor<T>> for Variable<T>

fn sub_assign(&mut self, rhs: Tensor<T>)

Performs the -= operation.