Struct burn_tensor::TensorData

pub struct TensorData {
    pub bytes: Vec<u8>,
    pub shape: Vec<usize>,
    pub dtype: DType,
}

Data structure for tensors.

Fields

bytes: Vec<u8>

The values of the tensor (as bytes).

shape: Vec<usize>

The shape of the tensor.

dtype: DType

The data type of the tensor.

Implementations

impl TensorData

pub fn new<E: Element, S: Into<Vec<usize>>>(value: Vec<E>, shape: S) -> Self

Creates a new tensor data structure.

pub fn quantized<E: Element, S: Into<Vec<usize>>>( value: Vec<E>, shape: S, strategy: QuantizationStrategy, ) -> Self

Creates a new quantized tensor data structure.

pub fn as_slice<E: Element>(&self) -> Result<&[E], DataError>

Returns the immutable slice view of the tensor data.

pub fn as_mut_slice<E: Element>(&mut self) -> Result<&mut [E], DataError>

Returns the mutable slice view of the tensor data.

Panics

If the target element type is different from the stored element type.

pub fn to_vec<E: Element>(&self) -> Result<Vec<E>, DataError>

Returns the tensor data as a vector of scalar values.

pub fn iter<E: Element>(&self) -> Box<dyn Iterator<Item = E> + '_>

Returns an iterator over the values of the tensor data.

pub fn num_elements(&self) -> usize

Returns the total number of elements of the tensor data.

pub fn random<E: Element, R: RngCore, S: Into<Vec<usize>>>( shape: S, distribution: Distribution, rng: &mut R, ) -> Self

Populates the data with random values.

pub fn zeros<E: Element, S: Into<Vec<usize>>>(shape: S) -> TensorData

Populates the data with zeros.

pub fn ones<E: Element, S: Into<Vec<usize>>>(shape: S) -> TensorData

Populates the data with ones.

pub fn full<E: Element, S: Into<Vec<usize>>>( shape: S, fill_value: E, ) -> TensorData

Populates the data with the given value

pub fn convert<E: Element>(self) -> Self

Converts the data to a different element type.

pub fn as_bytes(&self) -> &[u8]

Returns the data as a slice of bytes.

pub fn with_quantization(self, quantization: QuantizationStrategy) -> Self

Applies the data quantization strategy.

Panics

Panics if the data type is not supported for quantization.

pub fn assert_approx_eq(&self, other: &Self, precision: usize)

Asserts the data is approximately equal to another data.

Arguments

• other - The other data.
• precision - The precision of the comparison.

Panics

Panics if the data is not approximately equal.

pub fn assert_eq(&self, other: &Self, strict: bool)

Asserts the data is equal to another data.

Arguments

• other - The other data.
• strict - If true, the data types must the be same. Otherwise, the comparison is done in the current data type.

Panics

Panics if the data is not equal.

pub fn assert_approx_eq_diff(&self, other: &Self, tolerance: f64)

Asserts the data is approximately equal to another data.

Arguments

• other - The other data.
• tolerance - The tolerance of the comparison.

Panics

Panics if the data is not approximately equal.

pub fn assert_within_range<E: Element>(&self, range: Range<E>)

Asserts each value is within a given range.

Arguments

• range - The range.

Panics

If any value is not within the half-open range bounded inclusively below and exclusively above (start..end).

Trait Implementations

impl Clone for TensorData

fn clone(&self) -> TensorData

Returns a copy of the value.

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

Performs copy-assignment from source.

impl Debug for TensorData

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

Formats the value using the given formatter.

impl<'de> Deserialize<'de> for TensorData

fn deserialize<__D>(__deserializer: __D) -> Result<Self, __D::Error>

where __D: Deserializer<'de>,

Deserialize this value from the given Serde deserializer.

impl Display for TensorData

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

Formats the value using the given formatter.

impl<E: Element> From<&[E]> for TensorData

fn from(elems: &[E]) -> Self

Converts to this type from the input type.

impl From<&[usize]> for TensorData

fn from(elems: &[usize]) -> Self

Converts to this type from the input type.

impl<Elem: Element, const A: usize, const B: usize, const C: usize, const D: usize, const E: usize> From<[[[[[Elem; E]; D]; C]; B]; A]> for TensorData

fn from(elems: [[[[[Elem; E]; D]; C]; B]; A]) -> Self

Converts to this type from the input type.

impl<E: Element, const A: usize, const B: usize, const C: usize, const D: usize> From<[[[[E; D]; C]; B]; A]> for TensorData

fn from(elems: [[[[E; D]; C]; B]; A]) -> Self

Converts to this type from the input type.

impl<E: Element, const A: usize, const B: usize, const C: usize> From<[[[E; C]; B]; A]> for TensorData

fn from(elems: [[[E; C]; B]; A]) -> Self

Converts to this type from the input type.

impl<E: Element, const A: usize, const B: usize> From<[[E; B]; A]> for TensorData

fn from(elems: [[E; B]; A]) -> Self

Converts to this type from the input type.

impl<E: Element, const A: usize> From<[E; A]> for TensorData

fn from(elems: [E; A]) -> Self

Converts to this type from the input type.

impl<const A: usize> From<[usize; A]> for TensorData

fn from(elems: [usize; A]) -> Self

Converts to this type from the input type.

impl PartialEq for TensorData

fn eq(&self, other: &TensorData) -> bool

Tests for self and other values to be equal, and is used by ==.

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

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

impl Serialize for TensorData

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

where __S: Serializer,

Serialize this value into the given Serde serializer.

impl Eq for TensorData

impl StructuralPartialEq for TensorData