Struct TensorData

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

Data structure for tensors.

Fields

bytes: Bytes

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, S>(value: Vec<E>, shape: S) -> TensorData

where E: Element, S: Into<Vec<usize>>,

Creates a new tensor data structure.

pub fn quantized<E, S>( value: Vec<E>, shape: S, strategy: QuantizationStrategy, ) -> TensorData

where E: Element, S: Into<Vec<usize>>,

Creates a new quantized tensor data structure.

pub fn from_bytes<S>(bytes: Vec<u8>, shape: S, dtype: DType) -> TensorData

where S: Into<Vec<usize>>,

Creates a new tensor data structure from raw bytes.

Prefer TensorData::new or TensorData::quantized over this method unless you are certain that the bytes representation is valid.

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

where E: Element,

Returns the immutable slice view of the tensor data.

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

where E: Element,

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>(&self) -> Result<Vec<E>, DataError>

where E: Element,

Returns the tensor data as a vector of scalar values.

pub fn into_vec<E>(self) -> Result<Vec<E>, DataError>

where E: Element,

Returns the tensor data as a vector of scalar values.

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

where E: Element,

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, R, S>( shape: S, distribution: Distribution, rng: &mut R, ) -> TensorData

where E: Element, R: RngCore, S: Into<Vec<usize>>,

Populates the data with random values.

pub fn zeros<E, S>(shape: S) -> TensorData

where E: Element, S: Into<Vec<usize>>,

Populates the data with zeros.

pub fn ones<E, S>(shape: S) -> TensorData

where E: Element, S: Into<Vec<usize>>,

Populates the data with ones.

pub fn full<E, S>(shape: S, fill_value: E) -> TensorData

where E: Element, S: Into<Vec<usize>>,

Populates the data with the given value

pub fn convert<E>(self) -> TensorData

where E: Element,

Converts the data to a different element type.

pub fn convert_dtype(self, dtype: DType) -> TensorData

Converts the data to a different element type.

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

Returns the data as a slice of bytes.

pub fn into_bytes(self) -> Bytes

Returns the bytes representation of the data.

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

Applies the data quantization strategy.

Panics

Panics if the data type is not supported for quantization.

pub fn dequantize(self) -> Result<TensorData, DataError>

Dequantizes the data according to its quantization scheme.

pub fn assert_eq(&self, other: &TensorData, 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<F>(&self, other: &TensorData, tolerance: Tolerance<F>)

where F: Float + Element,

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>(&self, range: Range<E>)

where E: Element,

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

pub fn assert_within_range_inclusive<E>(&self, range: RangeInclusive<E>)

where E: Element,

Asserts each value is within a given inclusive range.

Arguments

• range - The range.

Panics

If any value is not within the half-open range bounded inclusively (start..=end).

Trait Implementations

impl Clone for TensorData

fn clone(&self) -> TensorData

Returns a duplicate 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<(), Error>

Formats the value using the given formatter.

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

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

where __D: Deserializer<'de>,

Deserialize this value from the given Serde deserializer.

impl Display for TensorData

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

Formats the value using the given formatter.

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

where E: Element,

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

Converts to this type from the input type.

impl From<&[usize]> for TensorData

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

Converts to this type from the input type.

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

where Elem: Element,

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

Converts to this type from the input type.

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

where E: Element,

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

Converts to this type from the input type.

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

where E: Element,

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

Converts to this type from the input type.

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

where E: Element,

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

Converts to this type from the input type.

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

where E: Element,

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

Converts to this type from the input type.

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

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

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 as Serializer>::Ok, <__S as Serializer>::Error>

where __S: Serializer,

Serialize this value into the given Serde serializer.

impl Eq for TensorData

impl StructuralPartialEq for TensorData