Enum Value 

pub enum Value<B: Backend> {
    B1(Tensor<B, 1, Bool>),
    B2(Tensor<B, 2, Bool>),
    B3(Tensor<B, 3, Bool>),
    B4(Tensor<B, 4, Bool>),
    B5(Tensor<B, 5, Bool>),
    B6(Tensor<B, 6, Bool>),
    B7(Tensor<B, 7, Bool>),
    B8(Tensor<B, 8, Bool>),
    F1(Tensor<B, 1, Float>),
    F2(Tensor<B, 2, Float>),
    F3(Tensor<B, 3, Float>),
    F4(Tensor<B, 4, Float>),
    F5(Tensor<B, 5, Float>),
    F6(Tensor<B, 6, Float>),
    F7(Tensor<B, 7, Float>),
    F8(Tensor<B, 8, Float>),
    I1(Tensor<B, 1, Int>),
    I2(Tensor<B, 2, Int>),
    I3(Tensor<B, 3, Int>),
    I4(Tensor<B, 4, Int>),
    I5(Tensor<B, 5, Int>),
    I6(Tensor<B, 6, Int>),
    I7(Tensor<B, 7, Int>),
    I8(Tensor<B, 8, Int>),
    Incompatible(String),
    Multi(Vec<Self>),
}

enumerates burn tensors up to 8 dimensions, along with a variant to represent operation compatibility errors, and a variant for multiple tensors. An empty multi variant can be used to represent a lack of data. Once a the depth of a multi variant is enough for an operation to take full effect, further nesting should result in the same as applying separately

Variants

B1(Tensor<B, 1, Bool>)

B2(Tensor<B, 2, Bool>)

B3(Tensor<B, 3, Bool>)

B4(Tensor<B, 4, Bool>)

B5(Tensor<B, 5, Bool>)

B6(Tensor<B, 6, Bool>)

B7(Tensor<B, 7, Bool>)

B8(Tensor<B, 8, Bool>)

F1(Tensor<B, 1, Float>)

F2(Tensor<B, 2, Float>)

F3(Tensor<B, 3, Float>)

F4(Tensor<B, 4, Float>)

F5(Tensor<B, 5, Float>)

F6(Tensor<B, 6, Float>)

F7(Tensor<B, 7, Float>)

F8(Tensor<B, 8, Float>)

I1(Tensor<B, 1, Int>)

I2(Tensor<B, 2, Int>)

I3(Tensor<B, 3, Int>)

I4(Tensor<B, 4, Int>)

I5(Tensor<B, 5, Int>)

I6(Tensor<B, 6, Int>)

I7(Tensor<B, 7, Int>)

I8(Tensor<B, 8, Int>)

Incompatible(String)

Multi(Vec<Self>)

Implementations

impl<B: Backend> Value<B>

pub fn all(self) -> Value<B>

tests if all values are true

pub fn all_dim(self, d: i32) -> Value<B>

tests if all values are true along the dim

pub fn any(self) -> Value<B>

tests if any values are true

pub fn any_dim(self, d: i32) -> Value<B>

tests if any values are true along the dim

pub fn bool(self) -> Value<B>

casts to a bool tensor if not one

pub fn count(&self) -> usize

counts the number of components in the tensor

pub fn empty() -> Self

creates a new empty value

pub fn flatten_values(self) -> Self

flattens depth first into a list of tensors

pub fn float(self) -> Value<B>

casts to a float tensor if not one

pub fn from_values<I: IntoIterator<Item = Self>, S: Into<Shape>>( inner: I, shape: S, ) -> Self

creates a value from the inner values and recursive shape. Doesn’t check actual dimension values, the shape is just used for recursion data

pub fn gather(self, dim: i32, indices: Value<B>) -> Self

gather

pub fn int(self) -> Value<B>

casts to a int tensor if not one

pub fn into_float_vec(self) -> Vec<f32>

converts to a flattened vector of floats, ignoring incompatibility errors

pub fn into_int_vec(self) -> Vec<i32>

converts to a flattened vector of ints, ignoring incompatibility errors

pub fn height(&self) -> usize

returns the maximum recursive depth of the value tree (its height). Returns 0 for empty or single

pub fn is_empty(&self) -> bool

tests if the tensor is empty. incompatible isn’t considered empty for the purposes of this function

pub fn is_incompatible(&self) -> bool

tests if the tensor represents the result of an incompatible input and operation

pub fn into_multi(self) -> Vec<Value<B>>

converts to a multiple tensor, then unwraps to a vec of values

pub fn is_multi(&self) -> bool

tests if this is a multiple tensor. also returns true for empty and multi that only have one value

pub fn iter(&self) -> SliceIter<'_, Self>

shallow iteration over the contained values

pub fn kind(&self) -> Kind

returns the kind of value

pub fn len(&self) -> usize

returns a shallow count the number of values directly within this one. 1 if not multi, otherwise the len of the vec inside.

pub fn len_recursive(&self) -> usize

recursively counts the number of tensors within this value, including multi tensors within multi tensors

pub fn map_multi<F: FnMut(Value<B>) -> Value<B>>( self, depth: usize, f: F, ) -> Self

applies a function to each multi tensor value whose maximum distance to a leaf is depth. The depth for empty or single is 0, multi containing only empty or single is 1, etc

pub fn map_values<F: FnMut(Value<B>) -> Value<B>>(self, f: F) -> Self

applies a function to each single tensor value

pub fn mask_fill(self, mask: Value<B>, v: f32) -> Self

mask filling

pub fn multi(self) -> Self

casts to a multiple tensor if not one

pub fn new<S: Into<Shape>>(data: &[f32], device: &B::Device, shape: S) -> Self

creates a new multi tensor from the data and shape // TODO make work for bool and int too

pub fn promote(self, rhs: Value<B>) -> (Value<B>, Value<B>)

promotes the values to make them compatible if possible. bools can become floats or ints, ints can become floats, any can become multi, and lower ranks can be unsqueezed to higher ranks. This is a shallow operation, so tensors inside multi will be unaffected. incompatible with non multi will return the input

pub fn promote_kind(self, rhs: Value<B>) -> (Value<B>, Value<B>)

promotes the values to make them match if possible. bools can become floats or ints, ints can become floats, any can become multi. This is a shallow operation, so tensors inside multi will be unaffected. incompatible with non multi will return the input

pub fn promote_rank(self, rhs: Value<B>) -> (Value<B>, Value<B>)

promotes the values to make them match if possible. lower ranks can be unsqueezed to higher ranks. This is a shallow operation, so tensors inside multi will be unaffected. incompatible with non multi will return the input

pub fn rank(&self) -> Option<usize>

returns the number of axes of the tensor, or none if incompatible or multi

pub fn scatter(self, dim: i32, indices: Value<B>, values: Value<B>) -> Self

scatter

pub fn shape(&self) -> Shape

gets the shape of the tensor. Use the recursive version to recursively get the multi shape

pub fn shape_recursive(&self) -> Shape

gets the shape of the tensor. Use the non recusive function if deep shape structure of multi is not required

pub fn shift(self, d: i32, n: i32, v: f32) -> Self

shifts the components right n places, maintaining the current dimensions, filling the left spot with v cast to the appropriate type

pub fn slice<A: AsRef<[R]>, R: RangeBounds<usize>>(self, ranges: A) -> Self

returns a value containing the elements selected from the given ranges. If this is a multi tensor the slice will be applied to each sub tensor

pub fn split<I: Into<Option<i32>>>(self, chunksize: usize, dim: I) -> Self

splits into chunks along the dimension, or the multi vector if dim is None

pub fn squeeze(self) -> Self

squeeze 0

pub fn squeeze_dim(self, d: i32) -> Self

removes a dimension of size 1 at position d. incompatible if dimension at position d is not 1

pub fn try_incompatible(self) -> Result<String, Self>

attempts to unwrap the inner incompatible value

pub fn try_multi(self) -> Result<Vec<Value<B>>, Self>

attempts to unwrap the inner multi value

pub fn unsqueeze(self) -> Self

unsqueeze 0

pub fn unsqueeze_dim(self, d: i32) -> Self

inserts a dimension of size 1 at position d, or N+d+1 if d is negative

pub fn unwrap_incompatible(self) -> String

attempts to unwrap the inner incompatible value

pub fn unwrap_multi(self) -> Vec<Value<B>>

attempts to unwrap the inner multi value

pub fn zeros_like(&self) -> Value<B>

zeros like

pub fn zip(self) -> Self

takes in a multi value and zips the leaves of each inner value together. If this input is empty or single it is returned unchanged. Mistmatch between single and multi substructures will cause the multi to be interpreted as a leaf. Mismatch between multi lengths will cause the shorter to be extended with empty

pub fn try_b1(self) -> Result<Tensor<B, 1, Bool>, Self>

attempts to unwrap the inner value

pub fn unwrap_b1(self) -> Tensor<B, 1, Bool>

attempts to unwrap the inner value

pub fn try_b2(self) -> Result<Tensor<B, 2, Bool>, Self>

attempts to unwrap the inner value

pub fn unwrap_b2(self) -> Tensor<B, 2, Bool>

attempts to unwrap the inner value

pub fn try_b3(self) -> Result<Tensor<B, 3, Bool>, Self>

attempts to unwrap the inner value

pub fn unwrap_b3(self) -> Tensor<B, 3, Bool>

attempts to unwrap the inner value

pub fn try_b4(self) -> Result<Tensor<B, 4, Bool>, Self>

attempts to unwrap the inner value

pub fn unwrap_b4(self) -> Tensor<B, 4, Bool>

attempts to unwrap the inner value

pub fn try_b5(self) -> Result<Tensor<B, 5, Bool>, Self>

attempts to unwrap the inner value

pub fn unwrap_b5(self) -> Tensor<B, 5, Bool>

attempts to unwrap the inner value

pub fn try_b6(self) -> Result<Tensor<B, 6, Bool>, Self>

attempts to unwrap the inner value

pub fn unwrap_b6(self) -> Tensor<B, 6, Bool>

attempts to unwrap the inner value

pub fn try_b7(self) -> Result<Tensor<B, 7, Bool>, Self>

attempts to unwrap the inner value

pub fn unwrap_b7(self) -> Tensor<B, 7, Bool>

attempts to unwrap the inner value

pub fn try_b8(self) -> Result<Tensor<B, 8, Bool>, Self>

attempts to unwrap the inner value

pub fn unwrap_b8(self) -> Tensor<B, 8, Bool>

attempts to unwrap the inner value

pub fn try_f1(self) -> Result<Tensor<B, 1, Float>, Self>

attempts to unwrap the inner value

pub fn unwrap_f1(self) -> Tensor<B, 1, Float>

attempts to unwrap the inner value

pub fn try_f2(self) -> Result<Tensor<B, 2, Float>, Self>

attempts to unwrap the inner value

pub fn unwrap_f2(self) -> Tensor<B, 2, Float>

attempts to unwrap the inner value

pub fn try_f3(self) -> Result<Tensor<B, 3, Float>, Self>

attempts to unwrap the inner value

pub fn unwrap_f3(self) -> Tensor<B, 3, Float>

attempts to unwrap the inner value

pub fn try_f4(self) -> Result<Tensor<B, 4, Float>, Self>

attempts to unwrap the inner value

pub fn unwrap_f4(self) -> Tensor<B, 4, Float>

attempts to unwrap the inner value

pub fn try_f5(self) -> Result<Tensor<B, 5, Float>, Self>

attempts to unwrap the inner value

pub fn unwrap_f5(self) -> Tensor<B, 5, Float>

attempts to unwrap the inner value

pub fn try_f6(self) -> Result<Tensor<B, 6, Float>, Self>

attempts to unwrap the inner value

pub fn unwrap_f6(self) -> Tensor<B, 6, Float>

attempts to unwrap the inner value

pub fn try_f7(self) -> Result<Tensor<B, 7, Float>, Self>

attempts to unwrap the inner value

pub fn unwrap_f7(self) -> Tensor<B, 7, Float>

attempts to unwrap the inner value

pub fn try_f8(self) -> Result<Tensor<B, 8, Float>, Self>

attempts to unwrap the inner value

pub fn unwrap_f8(self) -> Tensor<B, 8, Float>

attempts to unwrap the inner value

pub fn try_i1(self) -> Result<Tensor<B, 1, Int>, Self>

attempts to unwrap the inner value

pub fn unwrap_i1(self) -> Tensor<B, 1, Int>

attempts to unwrap the inner value

pub fn try_i2(self) -> Result<Tensor<B, 2, Int>, Self>

attempts to unwrap the inner value

pub fn unwrap_i2(self) -> Tensor<B, 2, Int>

attempts to unwrap the inner value

pub fn try_i3(self) -> Result<Tensor<B, 3, Int>, Self>

attempts to unwrap the inner value

pub fn unwrap_i3(self) -> Tensor<B, 3, Int>

attempts to unwrap the inner value

pub fn try_i4(self) -> Result<Tensor<B, 4, Int>, Self>

attempts to unwrap the inner value

pub fn unwrap_i4(self) -> Tensor<B, 4, Int>

attempts to unwrap the inner value

pub fn try_i5(self) -> Result<Tensor<B, 5, Int>, Self>

attempts to unwrap the inner value

pub fn unwrap_i5(self) -> Tensor<B, 5, Int>

attempts to unwrap the inner value

pub fn try_i6(self) -> Result<Tensor<B, 6, Int>, Self>

attempts to unwrap the inner value

pub fn unwrap_i6(self) -> Tensor<B, 6, Int>

attempts to unwrap the inner value

pub fn try_i7(self) -> Result<Tensor<B, 7, Int>, Self>

attempts to unwrap the inner value

pub fn unwrap_i7(self) -> Tensor<B, 7, Int>

attempts to unwrap the inner value

pub fn try_i8(self) -> Result<Tensor<B, 8, Int>, Self>

attempts to unwrap the inner value

pub fn unwrap_i8(self) -> Tensor<B, 8, Int>

attempts to unwrap the inner value

Trait Implementations

impl<B: Backend> AI<(Value<B>, Value<B>), Value<B>> for CrossEntropyLayer

fn forward(&self, (output, target): (Value<B>, Value<B>)) -> Value<B>

applies to the input

fn forward_mut(&mut self, input: X) -> Y

applies to the input, possibly updating internal caches

impl<B: Backend> AI<(Value<B>, Value<B>), Value<B>> for CrossEntropyLoss<B>

fn forward(&self, (output, target): (Value<B>, Value<B>)) -> Value<B>

applies to the input

fn forward_mut(&mut self, input: X) -> Y

applies to the input, possibly updating internal caches

impl<B: Backend> AI<(Value<B>, Value<B>), Value<B>> for SquaredErrorLayer

fn forward(&self, (output, target): (Value<B>, Value<B>)) -> Value<B>

applies to the input

fn forward_mut(&mut self, input: X) -> Y

applies to the input, possibly updating internal caches

impl<B: Backend> AI<(Value<B>, Value<B>, Value<B>), Value<B>> for Attention<B>

fn forward(&self, (k, q, v): (Value<B>, Value<B>, Value<B>)) -> Value<B>

applies to the input

fn forward_mut(&mut self, input: X) -> Y

applies to the input, possibly updating internal caches

impl<B: Backend> AI<Value<B>, (Value<B>, Value<B>, Value<B>)> for KQV<B>

fn forward(&self, input: Value<B>) -> (Value<B>, Value<B>, Value<B>)

applies to the input

fn forward_mut(&mut self, input: X) -> Y

applies to the input, possibly updating internal caches

impl<B: Backend> AI<Value<B>, Tensor<B, 1>> for MeanLayer

fn forward(&self, input: Value<B>) -> Tensor<B, 1>

applies to the input

fn forward_mut(&mut self, input: X) -> Y

applies to the input, possibly updating internal caches

impl<B: Backend> AI<Value<B>, Tensor<B, 1>> for SumLayer

fn forward(&self, input: Value<B>) -> Tensor<B, 1>

applies to the input

fn forward_mut(&mut self, input: X) -> Y

applies to the input, possibly updating internal caches

impl<B: Backend> AI<Value<B>, Value<B>> for AccQLayer

fn forward(&self, input: Value<B>) -> Value<B>

applies to the input

fn forward_mut(&mut self, input: X) -> Y

applies to the input, possibly updating internal caches

impl<B: Backend> AI<Value<B>, Value<B>> for Attention<B>

fn forward(&self, input: Value<B>) -> Value<B>

applies to the input

fn forward_mut(&mut self, input: X) -> Y

applies to the input, possibly updating internal caches

impl<B: Backend> AI<Value<B>, Value<B>> for BatchNorm<B>

fn forward(&self, input: Value<B>) -> Value<B>

applies to the input

fn forward_mut(&mut self, input: X) -> Y

applies to the input, possibly updating internal caches

impl<B: Backend> AI<Value<B>, Value<B>> for Cache<B>

fn forward(&self, input: Value<B>) -> Value<B>

applies to the input

fn forward_mut(&mut self, input: Value<B>) -> Value<B>

applies to the input, possibly updating internal caches

impl<B: Backend> AI<Value<B>, Value<B>> for ChooseLayer

fn forward(&self, input: Value<B>) -> Value<B>

applies to the input

fn forward_mut(&mut self, input: X) -> Y

applies to the input, possibly updating internal caches

impl<B: Backend> AI<Value<B>, Value<B>> for Conv2d<B>

fn forward(&self, input: Value<B>) -> Value<B>

applies to the input

fn forward_mut(&mut self, input: X) -> Y

applies to the input, possibly updating internal caches

impl<B: Backend> AI<Value<B>, Value<B>> for CrossEntropyLayer

fn forward(&self, input: Value<B>) -> Value<B>

applies to the input

fn forward_mut(&mut self, input: X) -> Y

applies to the input, possibly updating internal caches

impl<B: Backend> AI<Value<B>, Value<B>> for CrossEntropyLoss<B>

fn forward(&self, input: Value<B>) -> Value<B>

applies to the input

fn forward_mut(&mut self, input: X) -> Y

applies to the input, possibly updating internal caches

impl<B: Backend> AI<Value<B>, Value<B>> for Dropout

fn forward(&self, input: Value<B>) -> Value<B>

applies to the input

fn forward_mut(&mut self, input: X) -> Y

applies to the input, possibly updating internal caches

impl<B: Backend> AI<Value<B>, Value<B>> for Embedding<B>

fn forward(&self, input: Value<B>) -> Value<B>

applies to the input

fn forward_mut(&mut self, input: X) -> Y

applies to the input, possibly updating internal caches

impl<B: Backend> AI<Value<B>, Value<B>> for KQV<B>

fn forward(&self, input: Value<B>) -> Value<B>

applies to the input

fn forward_mut(&mut self, input: X) -> Y

applies to the input, possibly updating internal caches

impl<B: Backend> AI<Value<B>, Value<B>> for Layer<B>

fn forward(&self, input: Value<B>) -> Value<B>

applies to the input

fn forward_mut(&mut self, input: Value<B>) -> Value<B>

applies to the input, possibly updating internal caches

impl<B: Backend> AI<Value<B>, Value<B>> for LayerNorm<B>

fn forward(&self, input: Value<B>) -> Value<B>

applies to the input

fn forward_mut(&mut self, input: X) -> Y

applies to the input, possibly updating internal caches

impl<B: Backend> AI<Value<B>, Value<B>> for Linear<B>

fn forward(&self, input: Value<B>) -> Value<B>

applies to the input

fn forward_mut(&mut self, input: X) -> Y

applies to the input, possibly updating internal caches

impl<B: Backend> AI<Value<B>, Value<B>> for MaxPool2d

fn forward(&self, input: Value<B>) -> Value<B>

applies to the input

fn forward_mut(&mut self, input: X) -> Y

applies to the input, possibly updating internal caches

impl<B: Backend> AI<Value<B>, Value<B>> for MeanLayer

fn forward(&self, input: Value<B>) -> Value<B>

applies to the input

fn forward_mut(&mut self, input: X) -> Y

applies to the input, possibly updating internal caches

impl<B: Backend> AI<Value<B>, Value<B>> for MseLoss

fn forward(&self, input: Value<B>) -> Value<B>

applies to the input

fn forward_mut(&mut self, input: X) -> Y

applies to the input, possibly updating internal caches

impl<B: Backend> AI<Value<B>, Value<B>> for Relu

fn forward(&self, input: Value<B>) -> Value<B>

applies to the input

fn forward_mut(&mut self, input: X) -> Y

applies to the input, possibly updating internal caches

impl<B: Backend> AI<Value<B>, Value<B>> for RotaryEncoding<B>

fn forward(&self, input: Value<B>) -> Value<B>

applies to the input

fn forward_mut(&mut self, input: X) -> Y

applies to the input, possibly updating internal caches

impl<B: Backend> AI<Value<B>, Value<B>> for SoftmaxLayer

fn forward(&self, input: Value<B>) -> Value<B>

applies to the input

fn forward_mut(&mut self, input: X) -> Y

applies to the input, possibly updating internal caches

impl<B: Backend> AI<Value<B>, Value<B>> for SquaredErrorLayer

fn forward(&self, input: Value<B>) -> Value<B>

applies to the input

fn forward_mut(&mut self, input: X) -> Y

applies to the input, possibly updating internal caches

impl<B: Backend> AI<Value<B>, Value<B>> for SumLayer

fn forward(&self, input: Value<B>) -> Value<B>

applies to the input

fn forward_mut(&mut self, input: X) -> Y

applies to the input, possibly updating internal caches

impl<B: Backend> AI<Value<B>, Value<B>> for Tanh

fn forward(&self, input: Value<B>) -> Value<B>

applies to the input

fn forward_mut(&mut self, input: X) -> Y

applies to the input, possibly updating internal caches

impl<B: Backend> AI<Value<B>, Vec<u32>> for ChooseLayer

fn forward(&self, input: Value<B>) -> Vec<u32>

applies to the input

fn forward_mut(&mut self, input: X) -> Y

applies to the input, possibly updating internal caches

impl<B: Backend> AI<Value<B>, f32> for MeanLayer

fn forward(&self, input: Value<B>) -> f32

applies to the input

fn forward_mut(&mut self, input: X) -> Y

applies to the input, possibly updating internal caches

impl<B: Backend> AI<Value<B>, f32> for SumLayer

fn forward(&self, input: Value<B>) -> f32

applies to the input

fn forward_mut(&mut self, input: X) -> Y

applies to the input, possibly updating internal caches

impl<B: Backend> AI<Value<B>, u32> for ChooseLayer

fn forward(&self, input: Value<B>) -> u32

applies to the input

fn forward_mut(&mut self, input: X) -> Y

applies to the input, possibly updating internal caches

impl<B: Backend> Abs for Value<B>

type Output = Value<B>

the output type

fn abs(self) -> Self::Output

computes the operation

fn _apply(self) -> Self::Output

where Self: Sized,

macro convenience version of the primary method

impl<B: Backend> Add<&Value<B>> for &Value<B>

type Output = Value<B>

The resulting type after applying the + operator.

fn add(self, rhs: &Value<B>) -> Value<B>

Performs the + operation.

impl<B: Backend> Add<&Value<B>> for Value<B>

type Output = Value<B>

The resulting type after applying the + operator.

fn add(self, rhs: &Value<B>) -> Value<B>

Performs the + operation.

impl<B: Backend, E: Copy + ElementConversion> Add<E> for &Value<B>

type Output = Value<B>

The resulting type after applying the + operator.

fn add(self, rhs: E) -> Value<B>

Performs the + operation.

impl<B: Backend, E: Copy + ElementConversion> Add<E> for Value<B>

type Output = Value<B>

The resulting type after applying the + operator.

fn add(self, rhs: E) -> Value<B>

Performs the + operation.

impl<B: Backend> Add<Value<B>> for &Value<B>

type Output = Value<B>

The resulting type after applying the + operator.

fn add(self, rhs: Value<B>) -> Value<B>

Performs the + operation.

impl<B: Backend> Add for Value<B>

type Output = Value<B>

The resulting type after applying the + operator.

fn add(self, rhs: Value<B>) -> Value<B>

Performs the + operation.

impl<B: Backend> AsRef<Value<B>> for Value<B>

fn as_ref(&self) -> &Self

Converts this type into a shared reference of the (usually inferred) input type.

impl<A: AutodiffBackend> AutodiffModule<A> for Value<A>

type InnerModule = Value<<A as AutodiffBackend>::InnerBackend>

Inner module without auto-differentiation.

fn valid(&self) -> Self::InnerModule

Get the same module, but on the inner backend without auto-differentiation.

impl<B: Backend> Cat for Value<B>

fn cat(self, d: i32) -> Self

concatenates the multi tensor along dimension d

type Output = Value<B>

the output type

fn _apply(self, dim: i32) -> Self::Output

where Self: Sized,

macro convenience version of the primary method

impl<B: Clone + Backend> Clone for Value<B>

fn clone(&self) -> Value<B>

Returns a duplicate of the value.

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

Performs copy-assignment from source.

impl<B: Debug + Backend> Debug for Value<B>

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

Formats the value using the given formatter.

impl<B: Backend> Decompose for Value<B>

type Decomposition = Value<B>

the decomposed type

fn compose(decomposition: Self::Decomposition) -> Self

recreates from the decomposition

fn decompose(self) -> Self::Decomposition

owned decomposition

fn decompose_cloned(&self) -> Self::Decomposition

decomposition that copies data

impl<B: Backend> Default for Value<B>

fn default() -> Self

Returns the “default value” for a type.

impl<'a, B: Backend> Deserialize<'a> for Value<B>

fn deserialize<D: Deserializer<'a>>(deserializer: D) -> Result<Self, D::Error>

Deserialize this value from the given Serde deserializer.

impl<B: Backend> Display for Value<B>

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

Formats the value using the given formatter.

impl<B: Backend> Div<&Value<B>> for &Value<B>

type Output = Value<B>

The resulting type after applying the / operator.

fn div(self, rhs: &Value<B>) -> Value<B>

Performs the / operation.

impl<B: Backend> Div<&Value<B>> for Value<B>

type Output = Value<B>

The resulting type after applying the / operator.

fn div(self, rhs: &Value<B>) -> Value<B>

Performs the / operation.

impl<B: Backend, E: Copy + ElementConversion> Div<E> for &Value<B>

type Output = Value<B>

The resulting type after applying the / operator.

fn div(self, rhs: E) -> Value<B>

Performs the / operation.

impl<B: Backend, E: Copy + ElementConversion> Div<E> for Value<B>

type Output = Value<B>

The resulting type after applying the / operator.

fn div(self, rhs: E) -> Value<B>

Performs the / operation.

impl<B: Backend> Div<Value<B>> for &Value<B>

type Output = Value<B>

The resulting type after applying the / operator.

fn div(self, rhs: Value<B>) -> Value<B>

Performs the / operation.

impl<B: Backend> Div for Value<B>

type Output = Value<B>

The resulting type after applying the / operator.

fn div(self, rhs: Value<B>) -> Value<B>

Performs the / operation.

impl<B: Backend, R: Clone + RangeBounds<isize>> Flatten<R> for Value<B>

type Output = Value<B>

the output type

fn flatten(self, args: R) -> Self::Output

flattens

fn _apply(self, args: R) -> Self::Output

where Self: Sized,

macro convenience version of the primary method

impl<B: Backend, S: ?Sized + AsRef<str>> From<&S> for Value<B>

fn from(value: &S) -> Self

Converts to this type from the input type.

impl<B: Backend, K: 'static + TensorKind<B>, const N: usize> From<Result<Tensor<B, N, K>, String>> for Value<B>

fn from(value: Result<Tensor<B, N, K>, String>) -> Self

Converts to this type from the input type.

impl<B: Backend> From<String> for Value<B>

fn from(value: String) -> Self

Converts to this type from the input type.

impl<B: Backend, K: 'static + TensorKind<B>, const N: usize> From<Tensor<B, N, K>> for Value<B>

fn from(value: Tensor<B, N, K>) -> Self

Converts to this type from the input type.

impl<B: Backend> From<Vec<Value<B>>> for Value<B>

fn from(value: Vec<Value<B>>) -> Self

Converts to this type from the input type.

impl<B: Backend> From<Vec<bool>> for Value<B>

fn from(value: Vec<bool>) -> Self

Converts to this type from the input type.

impl<B: Backend> From<Vec<f32>> for Value<B>

fn from(value: Vec<f32>) -> Self

Converts to this type from the input type.

impl<B: Backend> From<Vec<i32>> for Value<B>

fn from(value: Vec<i32>) -> Self

Converts to this type from the input type.

impl<B: Backend> From<Vec<u32>> for Value<B>

fn from(value: Vec<u32>) -> Self

Converts to this type from the input type.

impl<A: Into<Value<B>>, B: Backend> FromIterator<A> for Value<B>

fn from_iter<I: IntoIterator<Item = A>>(iter: I) -> Self

Creates a value from an iterator.

impl<B: Backend> IntoIterator for Value<B>

type IntoIter = IntoIter<Value<B>>

Which kind of iterator are we turning this into?

type Item = Value<B>

The type of the elements being iterated over.

fn into_iter(self) -> Self::IntoIter

Creates an iterator from a value.

impl<B: Backend> Merge for Value<B>

fn merge(&mut self, other: Self)

merges the other into self, taking out of other if convenient

impl<B: Backend> Module<B> for Value<B>

type Record = ConstantRecord

Type to save and load the module.

fn collect_devices( &self, devices: Vec<<B as Backend>::Device>, ) -> Vec<<B as Backend>::Device>

Return all the devices found in the underneath module tree added to the given vector without duplicates.

fn devices(&self) -> Vec<<B as Backend>::Device>

Return all the devices found in the underneath module tree without duplicates.

fn fork(self, device: &<B as Backend>::Device) -> Self

Fork the module and all of its sub-modules to the given device.

fn into_record(self) -> Self::Record

Convert the module into a record containing the state.

fn load_file<F: FileRecorder<B>, P: Into<PathBuf>>( self, _filepath: P, _recorder: &F, _device: &<B as Backend>::Device, ) -> Result<Self, RecorderError>

Load the module from a file using the provided file recorder.

fn load_record(self, _record: Self::Record) -> Self

Load the module state from a record.

fn map<Mapper: ModuleMapper<B>>(self, mapper: &mut Mapper) -> Self

Map each tensor parameter in the module with a mapper.

fn num_params(&self) -> usize

Get the number of parameters the module has, including all of its sub-modules.

fn quantize_weights(self, quantizer: &mut Quantizer) -> Self

Quantize the weights of the module.

fn save_file<F: FileRecorder<B>, P: Into<PathBuf>>( self, _filepath: P, _recorder: &F, ) -> Result<(), RecorderError>

Save the module to a file using the provided file recorder.

fn to_device(self, device: &<B as Backend>::Device) -> Self

Move the module and all of its sub-modules to the given device.

fn visit<Visitor: ModuleVisitor<B>>(&self, visitor: &mut Visitor)

Visit each tensor parameter in the module with a visitor.

fn no_grad(self) -> Self

Each tensor in the module tree will not require grad.

impl<B: Backend> ModuleDisplay for Value<B>

fn custom_content(&self, _content: Content) -> Option<Content>

Custom attributes for the module.

fn custom_settings(&self) -> Option<DisplaySettings>

Custom display settings for the module.

fn format(&self, s: DisplaySettings) -> String

Formats the module with provided display settings.

impl<B: Backend> ModuleDisplayDefault for Value<B>

fn content(&self, content: Content) -> Option<Content>

Attributes of the module used for display purposes.

fn num_params(&self) -> usize

Gets the number of the parameters of the module.

impl<B: Backend> Mul<&Value<B>> for &Value<B>

type Output = Value<B>

The resulting type after applying the * operator.

fn mul(self, rhs: &Value<B>) -> Value<B>

Performs the * operation.

impl<B: Backend> Mul<&Value<B>> for Value<B>

type Output = Value<B>

The resulting type after applying the * operator.

fn mul(self, rhs: &Value<B>) -> Value<B>

Performs the * operation.

impl<B: Backend, E: Copy + ElementConversion> Mul<E> for &Value<B>

type Output = Value<B>

The resulting type after applying the * operator.

fn mul(self, rhs: E) -> Value<B>

Performs the * operation.

impl<B: Backend, E: Copy + ElementConversion> Mul<E> for Value<B>

type Output = Value<B>

The resulting type after applying the * operator.

fn mul(self, rhs: E) -> Value<B>

Performs the * operation.

impl<B: Backend> Mul<Value<B>> for &Value<B>

type Output = Value<B>

The resulting type after applying the * operator.

fn mul(self, rhs: Value<B>) -> Value<B>

Performs the * operation.

impl<B: Backend> Mul for Value<B>

type Output = Value<B>

The resulting type after applying the * operator.

fn mul(self, rhs: Value<B>) -> Value<B>

Performs the * operation.

impl<B: Backend> Rem<&Value<B>> for &Value<B>

type Output = Value<B>

The resulting type after applying the % operator.

fn rem(self, rhs: &Value<B>) -> Value<B>

Performs the % operation.

impl<B: Backend> Rem<&Value<B>> for Value<B>

type Output = Value<B>

The resulting type after applying the % operator.

fn rem(self, rhs: &Value<B>) -> Value<B>

Performs the % operation.

impl<B: Backend, E: Copy + ElementConversion> Rem<E> for &Value<B>

type Output = Value<B>

The resulting type after applying the % operator.

fn rem(self, rhs: E) -> Value<B>

Performs the % operation.

impl<B: Backend, E: Copy + ElementConversion> Rem<E> for Value<B>

type Output = Value<B>

The resulting type after applying the % operator.

fn rem(self, rhs: E) -> Value<B>

Performs the % operation.

impl<B: Backend> Rem<Value<B>> for &Value<B>

type Output = Value<B>

The resulting type after applying the % operator.

fn rem(self, rhs: Value<B>) -> Value<B>

Performs the % operation.

impl<B: Backend> Rem for Value<B>

type Output = Value<B>

The resulting type after applying the % operator.

fn rem(self, rhs: Value<B>) -> Value<B>

Performs the % operation.

impl<B: Backend, R: Into<Reshape>> Reshape<R> for Value<B>

type Output = Value<B>

the output type

fn reshape(self, args: R) -> Self::Output

reshapes

fn _apply(self, args: R) -> Self::Output

where Self: Sized,

macro convenience version of the primary method

impl<B: Backend> Serialize for Value<B>

fn serialize<S: Serializer>(&self, serializer: S) -> Result<S::Ok, S::Error>

Serialize this value into the given Serde serializer.

impl<B: Backend> Squeeze for Value<B>

type Output = Value<B>

the output type

fn squeeze(self, d: i32) -> Self

computes the operation

fn _apply(self, dim: i32) -> Self::Output

where Self: Sized,

macro convenience version of the primary method

impl<B: Backend> Stack for Value<B>

fn stack(self, d: i32) -> Self

stacks the multi tensor, inserting a dimension at d, or N+d+1 if d is negative. for singular tensors this has an unsqueezing effect

type Output = Value<B>

the output type

fn _apply(self, dim: i32) -> Self::Output

where Self: Sized,

macro convenience version of the primary method

impl<B: Backend> Sub<&Value<B>> for &Value<B>

type Output = Value<B>

The resulting type after applying the - operator.

fn sub(self, rhs: &Value<B>) -> Value<B>

Performs the - operation.

impl<B: Backend> Sub<&Value<B>> for Value<B>

type Output = Value<B>

The resulting type after applying the - operator.

fn sub(self, rhs: &Value<B>) -> Value<B>

Performs the - operation.

impl<B: Backend, E: Copy + ElementConversion> Sub<E> for &Value<B>

type Output = Value<B>

The resulting type after applying the - operator.

fn sub(self, rhs: E) -> Value<B>

Performs the - operation.

impl<B: Backend, E: Copy + ElementConversion> Sub<E> for Value<B>

type Output = Value<B>

The resulting type after applying the - operator.

fn sub(self, rhs: E) -> Value<B>

Performs the - operation.

impl<B: Backend> Sub<Value<B>> for &Value<B>

type Output = Value<B>

The resulting type after applying the - operator.

fn sub(self, rhs: Value<B>) -> Value<B>

Performs the - operation.

impl<B: Backend> Sub for Value<B>

type Output = Value<B>

The resulting type after applying the - operator.

fn sub(self, rhs: Value<B>) -> Value<B>

Performs the - operation.

impl<B: Backend, C: Backend> ToBackend<C> for Value<B>

type OnBackend = Value<C>

the type on the new backend

fn to_backend_device(self, device: &C::Device) -> Self::OnBackend

moves the module to the backend with the device

fn to_backend(self) -> Self::OnBackend

moves the module to the backend with the device

impl<B: Backend, K: 'static + TensorKind<B>, const N: usize> TryFrom<Value<B>> for Tensor<B, N, K>

type Error = Value<B>

The type returned in the event of a conversion error.

fn try_from(value: Value<B>) -> Result<Self, Self::Error>

Performs the conversion.

impl<B: Backend> Unsqueeze for Value<B>

type Output = Value<B>

the output type

fn unsqueeze(self, d: i32) -> Self

computes the operation

fn _apply(self, dim: i32) -> Self::Output

where Self: Sized,

macro convenience version of the primary method

impl<B: Backend> Wrappable for Value<B>

type B = B

type With<C: Backend> = Value<C>