Struct Tensor 

pub struct Tensor { /* private fields */ }

Tensor is a concrete tensor in tract.

Implementations

impl Tensor

pub fn storage_as<T: TensorStorage>(&self) -> Option<&T>

pub fn try_storage_as<T: TensorStorage>(&self) -> TractResult<&T>

pub fn from_storage( dt: DatumType, shape: &[usize], storage: impl TensorStorage + 'static, ) -> Tensor

pub fn as_plain_ram(&self) -> Option<PlainView<'_>>

Returns an immutable PlainView if this tensor has plain storage.

pub fn try_as_plain_ram(&self) -> TractResult<PlainView<'_>>

Returns an immutable PlainView, or an error if storage is not plain.

Unlike as_plain_ram, this materializes storage that holds its bytes elsewhere, so it is the way to read a tensor whose storage may be lazily host-backed.

pub fn as_plain_ram_storage(&self) -> Option<&PlainStorage>

Plain storage this tensor already holds in ram, if any. Never materializes: the two axes at once, and the accessor to reach for before a plain read.

pub fn as_plain_ram_storage_mut(&mut self) -> Option<&mut PlainStorage>

Mutable plain storage this tensor already holds in ram, if any. Never materializes.

pub fn is_plain(&self) -> bool

Returns true if datum type and shape describe this tensor’s layout on their own.

The layout axis, orthogonal to placement: a dense tensor is plain wherever its bytes sit, block-quant weights are exotic wherever theirs sit. Matches TypedFact::is_plain.

pub fn is_exotic(&self) -> bool

Returns true if datum type and shape do not describe this tensor’s layout on their own, so a fact over it carries an ExoticFact.

pub fn is_plain_ram(&self) -> bool

Returns true if this tensor’s bytes can be read as plain host memory right now: both axes at once, and what a caller gating an eager read or an evaluation on cost is really asking.

pub fn in_ram(&self) -> bool

Returns true if this tensor’s bytes are in host memory, readable without a transfer.

The placement axis, and a transient one: storage that leaves its bytes on a device answers false until something materializes them, true afterwards. It answers for the bytes in whatever layout the storage keeps them, so it takes both axes – as_plain_ram_storage – for a plain read to be sure to work.

pub fn exotic_fact(&self) -> TractResult<Option<Box<dyn ExoticFact>>>

Build the ExoticFact matching this tensor’s storage, or None for plain tensors.

pub fn as_plain_ram_mut(&mut self) -> Option<PlainViewMut<'_>>

Returns a mutable PlainViewMut if this tensor has plain storage.

pub fn try_as_plain_ram_mut(&mut self) -> TractResult<PlainViewMut<'_>>

Returns a mutable PlainViewMut, or an error if storage is not plain.

pub unsafe fn uninitialized<T: Datum>(shape: &[usize]) -> TractResult<Tensor>

Create an uninitialized tensor (dt as type paramater).

pub unsafe fn uninitialized_dt( dt: DatumType, shape: &[usize], ) -> TractResult<Tensor>

Create an uninitialized tensor (dt as regular parameter).

pub unsafe fn uninitialized_aligned<T: Datum>( shape: &[usize], alignment: usize, ) -> TractResult<Tensor>

Create an uninitialized tensor with a given alignment (in bytes).

pub unsafe fn uninitialized_aligned_dt( dt: DatumType, shape: &[usize], alignment: usize, ) -> TractResult<Tensor>

Create an uninitialized tensor with a given alignment (in bytes).

pub fn stack_tensors( axis: usize, tensors: &[impl Borrow<Tensor>], ) -> TractResult<Tensor>

pub fn clear<T: Datum + Zero + Clone>(&mut self) -> TractResult<()>

pub fn zero<T: Datum + Zero>(shape: &[usize]) -> TractResult<Tensor>

pub fn zero_scalar<T: Datum + Zero>() -> TractResult<Tensor>

pub fn zero_scalar_dt(dt: DatumType) -> TractResult<Tensor>

pub fn zero_dt(dt: DatumType, shape: &[usize]) -> TractResult<Tensor>

pub fn fill_t<T: Datum + Clone>(&mut self, value: T) -> TractResult<()>

pub fn zero_aligned_dt( dt: DatumType, shape: &[usize], alignment: usize, ) -> TractResult<Tensor>

pub fn zero_aligned<T: Datum + Zero>( shape: &[usize], alignment: usize, ) -> TractResult<Tensor>

pub fn from_shape<T: Datum + Copy>( shape: &[usize], data: &[T], ) -> TractResult<Tensor>

Create a tensor with a given shape and a slice of elements. The data is copied and aligned to size of T.

pub fn from_shape_align<T: Datum + Copy>( shape: &[usize], data: &[T], align: usize, ) -> TractResult<Tensor>

Create a tensor with a given shape and a slice of elements. The data is copied and aligned to given alignment.

pub unsafe fn from_raw<T: Datum>( shape: &[usize], content: &[u8], ) -> TractResult<Tensor>

Create a tensor from raw data.

It copies the data, aligning it to the size of T.

pub unsafe fn from_raw_aligned<T: Datum>( shape: &[usize], content: &[u8], align: usize, ) -> TractResult<Tensor>

pub unsafe fn from_raw_dt( dt: DatumType, shape: &[usize], content: &[u8], ) -> TractResult<Tensor>

pub unsafe fn from_raw_dt_align( dt: DatumType, shape: &[usize], content: &[u8], align: usize, ) -> TractResult<Tensor>

pub unsafe fn from_slice_align<T: Datum>( content: &[T], align: usize, ) -> TractResult<Tensor>

pub fn rank(&self) -> usize

Get the number of dimensions (or axes) of the tensor.

pub fn shape(&self) -> &[usize]

Get the shape of the tensor.

pub fn len(&self) -> usize

Get the number of values in the tensor.

pub fn volume(&self) -> usize

Get the number of valeus in the tensor.

pub fn strides(&self) -> &[isize]

Get the shape of the tensor.

pub unsafe fn set_shape_unchecked(&mut self, shape: &[usize])

Force the tensor shape, no consistency check.

pub unsafe fn set_geometry_unchecked( &mut self, shape: &[usize], strides: &[isize], )

Force the tensor shape and strides, no consistency check.

pub fn set_shape(&mut self, shape: &[usize]) -> TractResult<()>

Force the tensor shape.

pub fn permute_axes(self, axes: &[usize]) -> TractResult<Tensor>

pub fn move_axis(self, from: usize, to: usize) -> TractResult<Tensor>

pub fn collapse_axis_with_next(self, axis: usize) -> Tensor

pub fn split_axis(self, axis: usize, outer_dim: usize) -> TractResult<Tensor>

pub fn into_shape(self, shape: &[usize]) -> TractResult<Tensor>

Reshape the tensor to shape.

pub fn insert_axis(&mut self, axis: usize) -> TractResult<()>

pub fn remove_axis(&mut self, axis: usize) -> TractResult<()>

pub fn broadcast_into_rank(self, rank: usize) -> TractResult<Tensor>

pub fn broadcast_to_rank(&mut self, rank: usize) -> TractResult<()>

pub fn broadcast_scalar_to_shape(&self, shape: &[usize]) -> TractResult<Tensor>

pub fn broadcast_to_shape(&self, shape: &[usize]) -> TractResult<Tensor>

pub fn broadcast_vector_to_shape( &self, shape: &[usize], axis: usize, ) -> TractResult<Tensor>

pub fn assign_slice( &mut self, range: impl RangeBounds<usize>, src: &Tensor, src_range: impl RangeBounds<usize>, axis: usize, ) -> TractResult<()>

pub fn assign_slice_at_prefix( &mut self, prefix: &[usize], range: impl RangeBounds<usize>, src: &Tensor, src_prefix: &[usize], src_range: impl RangeBounds<usize>, axis: usize, ) -> TractResult<()>

Assign src’s src_range along axis into range along axis, each taken in the sub-tensor at its prefix. A prefix indexes the leading axes as Tensor::view_at_prefix does, and both prefixes cover the same axes, whose extents may then differ. axis stays an axis of the whole tensors, so it has to sit past the prefixes.

pub unsafe fn assign_slice_unchecked( &mut self, range: impl RangeBounds<usize>, src: &Tensor, src_range: impl RangeBounds<usize>, axis: usize, )

pub fn fill_slice( &mut self, range: impl RangeBounds<usize>, value: &Tensor, axis: usize, ) -> TractResult<()>

Fill range along axis with value, a one-element tensor of this tensor’s datum type.

pub fn fill_slice_at_prefix( &mut self, prefix: &[usize], range: impl RangeBounds<usize>, value: &Tensor, axis: usize, ) -> TractResult<()>

Fill range along axis of the sub-tensor at prefix, which indexes the leading axes as Tensor::view_at_prefix does, with value, a one-element tensor of this tensor’s datum type. axis stays an axis of the whole tensor, so it has to sit past prefix.

pub fn datum_type(&self) -> DatumType

Get the datum type of the tensor.

pub unsafe fn set_datum_type(&mut self, dt: DatumType)

Set the datum type of the tensor.

pub fn dump(&self, force_full: bool) -> TractResult<String>

Dump the tensor in a human readable form.

force_full will force the tensor to be dump in full even if it is big.

pub fn close_enough( &self, other: &Self, approx: impl Into<Approximation> + Debug, ) -> TractResult<()>

Compare two tensors, allowing for rounding errors.

pub fn ulp_comparison_dt(&self) -> DatumType

The float type ULP distances against this tensor are measured in.

Float tensors are compared in their own type, so an f16 comparison stays an f16 comparison. Anything else falls back to f32, matching what close_enough does for its tolerance check.

pub fn max_ulp_distance( &self, other: &Self, ) -> TractResult<(u64, Option<usize>)>

Largest integer ULP distance between self and other, and the flat index where it occurs.

Comparison happens in Self::ulp_comparison_dt. See crate::ulp for the exact convention around signed zeros, infinities and NaN.

pub fn into_plain_array<D: Datum>(self) -> TractResult<ArrayD<D>>

Transform the tensor into a ndarray::Array.

pub unsafe fn into_array_unchecked<D: Datum>(self) -> ArrayD<D>

Transform the tensor into a ndarray::Array.

pub fn to_plain_array_view<D: Datum>(&self) -> TractResult<ArrayViewD<'_, D>>

Returns a plain array view of the tensor.

Errors if the storage is not plain or the datum type does not match D.

pub fn to_plain_array_view_mut<D: Datum>( &mut self, ) -> TractResult<ArrayViewMutD<'_, D>>

Returns a mutable plain array view of the tensor.

Errors if the storage is not plain or the datum type does not match D.

pub unsafe fn to_array_view_unchecked<D: Datum>(&self) -> ArrayViewD<'_, D>

Transform the data as a ndarray::Array.

pub unsafe fn to_array_view_mut_unchecked<D: Datum>( &mut self, ) -> ArrayViewMutD<'_, D>

Transform the data as a mutable ndarray::Array.

pub fn as_ptr<D: Datum>(&self) -> TractResult<*const D>

Access the data as a pointer.

pub unsafe fn as_ptr_unchecked<D: Datum>(&self) -> *const D

Access the data as a pointer.

pub unsafe fn as_ptr_mut_unchecked<D: Datum>(&mut self) -> *mut D

Access the data as a pointer.

pub fn as_ptr_mut<D: Datum>(&mut self) -> TractResult<*mut D>

Access the data as a mutable pointer.

pub unsafe fn as_slice_unchecked<D: Datum>(&self) -> &[D]

Access the data as a slice.

pub unsafe fn as_slice_mut_unchecked<D: Datum>(&mut self) -> &mut [D]

Access the data as a mutable slice.

pub fn to_scalar_tensor(&self) -> TractResult<Tensor>

Make the tensor a scalar tensor (assumes it contains a single value).

pub unsafe fn to_scalar_unchecked<D: Datum>(&self) -> &D

Access the data as a scalar.

pub fn to_scalar_mut<D: Datum>(&mut self) -> TractResult<&mut D>

Mutable access the data as a scalar.

pub unsafe fn to_scalar_mut_unchecked<D: Datum>(&mut self) -> &mut D

Mutable access the data as a scalar.

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

pub fn as_bytes_mut(&mut self) -> &mut [u8]

pub fn is_uniform(&self) -> bool

pub fn as_uniform(&self) -> Option<Tensor>

pub fn is_all_zero(&self) -> TractResult<bool>

pub fn is_zero(&self) -> TractResult<bool>

pub fn cast_to<D: Datum>(&self) -> TractResult<Cow<'_, Tensor>>

Optionnaly convert data to a tensor for a new DatumType.

pub fn cast_to_dt(&self, dst_dt: DatumType) -> TractResult<Cow<'_, Tensor>>

Optionnaly convert data to a tensor for a new DatumType.

pub fn cast_to_scalar<D: Datum + Copy>(&self) -> TractResult<D>

Access the data as a scalar, after a cast.

pub fn nth(&self, nth: usize) -> TractResult<Tensor>

Access the nth element of the tensor, returned as a 0-rank Tensor

pub fn deep_clone(&self) -> Tensor

pub fn slice( &self, axis: usize, start: usize, end: usize, ) -> TractResult<Tensor>

pub fn view(&self) -> TensorView<'_>

pub fn view_at_prefix(&self, prefix: &[usize]) -> TractResult<TensorView<'_>>

pub fn view_offsetting(&self, coords: &[usize]) -> TractResult<TensorView<'_>>

pub unsafe fn view_offsetting_unchecked( &self, coords: &[usize], ) -> TensorView<'_>

pub fn view_mut(&mut self) -> TensorView<'_>

pub fn view_at_prefix_mut( &mut self, prefix: &[usize], ) -> TractResult<TensorView<'_>>

pub fn view_offsetting_mut( &mut self, coords: &[usize], ) -> TractResult<TensorView<'_>>

pub fn offset_u8_as_i8(self: &Arc<Self>) -> Arc<Self>

Offsets the tensor as an i8 type if it’s an u8 type, otherwise passes it unchanged.

pub fn offset_i8_as_u8(self: &Arc<Self>) -> Arc<Self>

Offsets the tensor as an u8 type if it’s an i8 type, otherwise passes it unchanged.

pub fn to_aligned_default(&self) -> TractResult<Self>

pub fn natural_strides(shape: &[usize]) -> TVec<isize>

pub fn has_plain_ram_storage(&self) -> bool

Returns true if this tensor owns plain ram storage outright, rather than storage that produces or holds some – a device readback that has come back still keeps its device tensor.

pub fn into_plain_ram(self) -> TractResult<Tensor>

This tensor backed by plain ram storage of its own: bytes left on a device come back here, and exotic storage, which has no plain form, errors.

pub fn into_blob(self) -> TractResult<Blob>

Trait Implementations

impl Clone for Tensor

fn clone(&self) -> Tensor

Returns a duplicate of the value.

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

Performs copy-assignment from source.

impl Debug for Tensor

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

Formats the value using the given formatter.

impl Default for Tensor

fn default() -> Tensor

Returns the “default value” for a type.

impl Drop for Tensor

fn drop(&mut self)

Executes the destructor for this type.

fn pin_drop(self: Pin<&mut Self>)

🔬This is a nightly-only experimental API. (pin_ergonomics)

Execute the destructor for this type, but different to Drop::drop, it requires self to be pinned.

impl Eq for Tensor

impl<D: Dimension, T: Datum> From<ArrayBase<OwnedRepr<T>, D>> for Tensor

fn from(it: Array<T, D>) -> Tensor

Converts to this type from the input type.

impl From<Blob> for Tensor

fn from(it: Blob) -> Tensor

Converts to this type from the input type.

impl From<String> for Tensor

fn from(it: String) -> Tensor

Converts to this type from the input type.

impl From<TDim> for Tensor

fn from(it: TDim) -> Tensor

Converts to this type from the input type.

impl From<bool> for Tensor

fn from(it: bool) -> Tensor

Converts to this type from the input type.

impl From<f16> for Tensor

fn from(it: f16) -> Tensor

Converts to this type from the input type.

impl From<f32> for Tensor

fn from(it: f32) -> Tensor

Converts to this type from the input type.

impl From<f64> for Tensor

fn from(it: f64) -> Tensor

Converts to this type from the input type.

impl From<i8> for Tensor

fn from(it: i8) -> Tensor

Converts to this type from the input type.

impl From<i16> for Tensor

fn from(it: i16) -> Tensor

Converts to this type from the input type.

impl From<i32> for Tensor

fn from(it: i32) -> Tensor

Converts to this type from the input type.

impl From<i64> for Tensor

fn from(it: i64) -> Tensor

Converts to this type from the input type.

impl From<u8> for Tensor

fn from(it: u8) -> Tensor

Converts to this type from the input type.

impl From<u16> for Tensor

fn from(it: u16) -> Tensor

Converts to this type from the input type.

impl From<u32> for Tensor

fn from(it: u32) -> Tensor

Converts to this type from the input type.

impl From<u64> for Tensor

fn from(it: u64) -> Tensor

Converts to this type from the input type.

impl Hash for Tensor

fn hash<H: Hasher>(&self, state: &mut H)

Feeds this value into the given Hasher.

fn hash_slice<H>(data: &[Self], state: &mut H)

where H: Hasher, Self: Sized,

Feeds a slice of this type into the given Hasher.

impl IntoArcTensor for Tensor

fn into_arc_tensor(self) -> Arc<Tensor>

Convert Self to a Arc.

impl IntoTensor for Tensor

fn into_tensor(self) -> Tensor

Convert Self to a Tensor.

impl PartialEq for Tensor

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

Equality operator ==.

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

Inequality operator !=.

impl Send for Tensor

impl Sync for Tensor