Struct microtensor::Tensor

pub struct Tensor<T: Inner> { /* private fields */ }

Multidimensional array.

Tensors may contain any type that satisfies Inner, but additional methods are available for Numeric, Real and boolean inner types.

Real tensor types can be wrapped in a Variable by calling tracked or trained.

Implementations

impl<T: Inner> Tensor<T>

pub fn from_shape(shape: Shape, data: Vec<T>) -> Self

pub fn new(shape: &[usize], data: Vec<T>) -> Self

pub fn vec(vec: &[T]) -> Self

Examples found in repository

examples/basic.rs (line 5)

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
  }
}

pub fn from_vec(vec: Vec<T>) -> Self

pub fn fill(shape: &[usize], filler: T) -> Self

pub fn init(shape: &[usize], cb: impl FnMut(Vec<usize>) -> T) -> Self

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

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

pub fn into_raw(self) -> 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

impl<T: Numeric> Tensor<T>

pub fn ones(shape: &[usize]) -> Self

Examples found in repository

examples/graph.rs (line 22)

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();
}

examples/perceptron_eager.rs (line 63)

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 42)

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 zeros(shape: &[usize]) -> Self

Examples found in repository

examples/perceptron_eager.rs (line 27)

  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 20)

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
}

fn perceptron(input: &Variable<f32>) -> Variable<f32> {
  let output = dense_layer(input, 16).relu();
  dense_layer(&output, 10).sigmoid()
}

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();
  }
}

examples/basic.rs (line 7)

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
  }
}

pub fn arrange(shape: &[usize], start: T, step: T) -> Self

pub fn hot_encode(idx: usize, size: usize) -> Self

pub fn band(dims: &[usize], num_lower: isize, num_upper: 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();
  }
}

impl<T: Real> Tensor<T>

pub fn rand(shape: &[usize]) -> Self

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 randn(shape: &[usize]) -> Self

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();
}

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 linspace(shape: &[usize], start: T, end: T) -> Self

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();
  }
}

impl<T: Integer> Tensor<T>

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

impl<T: Integer + Unsigned> Tensor<T>

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

impl<T: Signed> Tensor<T>

pub fn signum(&self) -> Self

impl Tensor<bool>

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: Numeric> Add<&Tensor<T>> for &Tensor<T>

type Output = Tensor<T>

The resulting type after applying the + operator.

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

Performs the + operation.

impl<T: Numeric> Add<&Tensor<T>> for Tensor<T>

type Output = Tensor<T>

The resulting type after applying the + operator.

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

Performs the + operation.

impl Add<&Tensor<f32>> for f32

type Output = Tensor<f32>

The resulting type after applying the + operator.

fn add(self, tensor: &Tensor<f32>) -> Tensor<f32>

Performs the + operation.

impl<T: Numeric> Add<T> for &Tensor<T>

type Output = Tensor<T>

The resulting type after applying the + operator.

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

Performs the + operation.

impl<T: Numeric> Add<T> for Tensor<T>

type Output = Tensor<T>

The resulting type after applying the + operator.

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

Performs the + operation.

impl<T: Numeric> Add<Tensor<T>> for &Tensor<T>

type Output = Tensor<T>

The resulting type after applying the + operator.

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

Performs the + operation.

impl<T: Numeric> Add<Tensor<T>> for Tensor<T>

type Output = Tensor<T>

The resulting type after applying the + operator.

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

Performs the + operation.

impl Add<Tensor<f32>> for f32

type Output = Tensor<f32>

The resulting type after applying the + operator.

fn add(self, tensor: Tensor<f32>) -> Tensor<f32>

Performs the + operation.

impl<T: Numeric> AddAssign<Tensor<T>> for Tensor<T>

fn add_assign(&mut self, rhs: Self)

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: Inner> BaseHops<T> for Tensor<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: Inner> BaseOps<T> for Tensor<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, shape: &[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 + Inner> Clone for Tensor<T>

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

Returns a copy of the value.

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

Performs copy-assignment from source.

impl<T: Numeric> Cops<T> for Tensor<T>

default fn matmul(&self, rhs: &Self) -> Vec<T>

impl Cops<f32> for Tensor<f32>

fn matmul(&self, rhs: &Self) -> Vec<f32>

impl Cops<f64> for Tensor<f64>

fn matmul(&self, rhs: &Self) -> Vec<f64>

impl<T: Debug + Inner> Debug for Tensor<T>

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

Formats the value using the given formatter.

impl<'de, T> Deserialize<'de> for Tensor<T>where T: Deserialize<'de> + Inner,

fn deserialize<__D>(__deserializer: __D) -> Result<Self, __D::Error>where __D: Deserializer<'de>,

Deserialize this value from the given Serde deserializer.

impl<T: Inner> Display for Tensor<T>

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

Formats the value using the given formatter.

impl<T: Numeric> Div<&Tensor<T>> for &Tensor<T>

type Output = Tensor<T>

The resulting type after applying the / operator.

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

Performs the / operation.

impl<T: Numeric> Div<&Tensor<T>> for Tensor<T>

type Output = Tensor<T>

The resulting type after applying the / operator.

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

Performs the / operation.

impl Div<&Tensor<f32>> for f32

type Output = Tensor<f32>

The resulting type after applying the / operator.

fn div(self, tensor: &Tensor<f32>) -> Tensor<f32>

Performs the / operation.

impl<T: Numeric> Div<T> for &Tensor<T>

type Output = Tensor<T>

The resulting type after applying the / operator.

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

Performs the / operation.

impl<T: Numeric> Div<T> for Tensor<T>

type Output = Tensor<T>

The resulting type after applying the / operator.

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

Performs the / operation.

impl<T: Numeric> Div<Tensor<T>> for &Tensor<T>

type Output = Tensor<T>

The resulting type after applying the / operator.

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

Performs the / operation.

impl<T: Numeric> Div<Tensor<T>> for Tensor<T>

type Output = Tensor<T>

The resulting type after applying the / operator.

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

Performs the / operation.

impl Div<Tensor<f32>> for f32

type Output = Tensor<f32>

The resulting type after applying the / operator.

fn div(self, tensor: Tensor<f32>) -> Tensor<f32>

Performs the / operation.

impl<T: Numeric> DivAssign<Tensor<T>> for Tensor<T>

fn div_assign(&mut self, rhs: Self)

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: Numeric> Mul<&Tensor<T>> for &Tensor<T>

type Output = Tensor<T>

The resulting type after applying the * operator.

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

Performs the * operation.

impl<T: Numeric> Mul<&Tensor<T>> for Tensor<T>

type Output = Tensor<T>

The resulting type after applying the * operator.

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

Performs the * operation.

impl Mul<&Tensor<f32>> for f32

type Output = Tensor<f32>

The resulting type after applying the * operator.

fn mul(self, tensor: &Tensor<f32>) -> Tensor<f32>

Performs the * operation.

impl<T: Numeric> Mul<T> for &Tensor<T>

type Output = Tensor<T>

The resulting type after applying the * operator.

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

Performs the * operation.

impl<T: Numeric> Mul<T> for Tensor<T>

type Output = Tensor<T>

The resulting type after applying the * operator.

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

Performs the * operation.

impl<T: Numeric> Mul<Tensor<T>> for &Tensor<T>

type Output = Tensor<T>

The resulting type after applying the * operator.

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

Performs the * operation.

impl<T: Numeric> Mul<Tensor<T>> for Tensor<T>

type Output = Tensor<T>

The resulting type after applying the * operator.

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

Performs the * operation.

impl Mul<Tensor<f32>> for f32

type Output = Tensor<f32>

The resulting type after applying the * operator.

fn mul(self, tensor: Tensor<f32>) -> Tensor<f32>

Performs the * operation.

impl<T: Numeric> MulAssign<Tensor<T>> for Tensor<T>

fn mul_assign(&mut self, rhs: Self)

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: Signed> Neg for &Tensor<T>

type Output = Tensor<T>

The resulting type after applying the - operator.

fn neg(self) -> Self::Output

Performs the unary - operation.

impl<T: Signed> Neg for Tensor<T>

type Output = Tensor<T>

The resulting type after applying the - operator.

fn neg(self) -> Self::Output

Performs the unary - operation.

impl Not for Tensor<bool>

type Output = Tensor<bool>

The resulting type after applying the ! operator.

fn not(self) -> Self::Output

Performs the unary ! operation.

impl<T: Numeric> NumericOps<T> for Tensor<T>

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

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: Inner> PartialEq<Tensor<T>> for Tensor<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 Tensor<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 Tensor<T>

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

fn sin(&self) -> Self

fn cos(&self) -> Self

fn log(&self) -> Self

fn relu(&self) -> Self

fn sigmoid(&self) -> Self

impl<T: Numeric> Rem<&Tensor<T>> for &Tensor<T>

type Output = Tensor<T>

The resulting type after applying the % operator.

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

Performs the % operation.

impl<T: Numeric> Rem<&Tensor<T>> for Tensor<T>

type Output = Tensor<T>

The resulting type after applying the % operator.

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

Performs the % operation.

impl Rem<&Tensor<f32>> for f32

type Output = Tensor<f32>

The resulting type after applying the % operator.

fn rem(self, tensor: &Tensor<f32>) -> Tensor<f32>

Performs the % operation.

impl<T: Numeric> Rem<T> for &Tensor<T>

type Output = Tensor<T>

The resulting type after applying the % operator.

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

Performs the % operation.

impl<T: Numeric> Rem<T> for Tensor<T>

type Output = Tensor<T>

The resulting type after applying the % operator.

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

Performs the % operation.

impl<T: Numeric> Rem<Tensor<T>> for &Tensor<T>

type Output = Tensor<T>

The resulting type after applying the % operator.

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

Performs the % operation.

impl<T: Numeric> Rem<Tensor<T>> for Tensor<T>

type Output = Tensor<T>

The resulting type after applying the % operator.

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

Performs the % operation.

impl Rem<Tensor<f32>> for f32

type Output = Tensor<f32>

The resulting type after applying the % operator.

fn rem(self, tensor: Tensor<f32>) -> Tensor<f32>

Performs the % operation.

impl<T> Serialize for Tensor<T>where T: Serialize + Inner,

fn serialize<__S>(&self, __serializer: __S) -> Result<__S::Ok, __S::Error>where __S: Serializer,

Serialize this value into the given Serde serializer.

impl<T: Signed> SignedOps<T> for Tensor<T>

fn abs(&self) -> Self

impl<T: Numeric> Sub<&Tensor<T>> for &Tensor<T>

type Output = Tensor<T>

The resulting type after applying the - operator.

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

Performs the - operation.

impl<T: Numeric> Sub<&Tensor<T>> for Tensor<T>

type Output = Tensor<T>

The resulting type after applying the - operator.

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

Performs the - operation.

impl Sub<&Tensor<f32>> for f32

type Output = Tensor<f32>

The resulting type after applying the - operator.

fn sub(self, tensor: &Tensor<f32>) -> Tensor<f32>

Performs the - operation.

impl<T: Numeric> Sub<T> for &Tensor<T>

type Output = Tensor<T>

The resulting type after applying the - operator.

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

Performs the - operation.

impl<T: Numeric> Sub<T> for Tensor<T>

type Output = Tensor<T>

The resulting type after applying the - operator.

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

Performs the - operation.

impl<T: Numeric> Sub<Tensor<T>> for &Tensor<T>

type Output = Tensor<T>

The resulting type after applying the - operator.

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

Performs the - operation.

impl<T: Numeric> Sub<Tensor<T>> for Tensor<T>

type Output = Tensor<T>

The resulting type after applying the - operator.

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

Performs the - operation.

impl Sub<Tensor<f32>> for f32

type Output = Tensor<f32>

The resulting type after applying the - operator.

fn sub(self, tensor: Tensor<f32>) -> Tensor<f32>

Performs the - operation.

impl<T: Numeric> SubAssign<Tensor<T>> for Tensor<T>

fn sub_assign(&mut self, rhs: Self)

Performs the -= operation.

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

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

Performs the -= operation.

impl<T: Numeric> Sum<Tensor<T>> for Tensor<T>

fn sum<I>(iter: I) -> Selfwhere I: Iterator + Iterator<Item = Self>,

Method which takes an iterator and generates Self from the elements by “summing up” the items.