Struct burn_tensor::Tensor

pub struct Tensor<B: Backend, const D: usize> { /* private fields */ }

Implementations

impl<const D: usize, B> Tensor<B, D>where
    B: Backend,

pub fn new(tensor: B::TensorPrimitive<D>) -> Self

pub fn reshape<const D2: usize>(&self, shape: Shape<D2>) -> Tensor<B, D2>

pub fn to_device(&self, device: B::Device) -> Self

pub fn exp(&self) -> Self

pub fn log(&self) -> Self

pub fn device(&self) -> B::Device

pub fn shape(&self) -> &Shape<D>

pub fn into_data(self) -> Data<B::Elem, D>

pub fn to_data(&self) -> Data<B::Elem, D>

pub fn zeros_like(&self) -> Self

pub fn one_hot(index: usize, num_classes: usize) -> Self

pub fn ones_like(&self) -> Self

pub fn random_like(&self, distribution: Distribution<B::Elem>) -> Self

pub fn add(&self, other: &Self) -> Self

pub fn add_scalar(&self, other: &B::Elem) -> Self

pub fn sub(&self, other: &Self) -> Self

pub fn sub_scalar(&self, other: &B::Elem) -> Self

pub fn transpose(&self) -> Self

pub fn matmul(&self, other: &Self) -> Self

pub fn neg(&self) -> Self

pub fn mul(&self, other: &Self) -> Self

pub fn mul_scalar(&self, other: &B::Elem) -> Self

pub fn div(&self, other: &Self) -> Self

pub fn div_scalar(&self, other: &B::Elem) -> Self

pub fn random(shape: Shape<D>, distribution: Distribution<B::Elem>) -> Self

pub fn mean(&self) -> Tensor<B, 1>

pub fn sum(&self) -> Tensor<B, 1>

pub fn mean_dim(&self, dim: usize) -> Self

pub fn sum_dim(&self, dim: usize) -> Self

pub fn equal(&self, other: &Self) -> BoolTensor<B, D>

pub fn equal_scalar(&self, other: &B::Elem) -> BoolTensor<B, D>

pub fn greater(&self, other: &Self) -> BoolTensor<B, D>

pub fn greater_equal(&self, other: &Self) -> BoolTensor<B, D>

pub fn greater_scalar(&self, other: &B::Elem) -> BoolTensor<B, D>

pub fn greater_equal_scalar(&self, other: &B::Elem) -> BoolTensor<B, D>

pub fn lower(&self, other: &Self) -> BoolTensor<B, D>

pub fn lower_equal(&self, other: &Self) -> BoolTensor<B, D>

pub fn lower_scalar(&self, other: &B::Elem) -> BoolTensor<B, D>

pub fn lower_equal_scalar(&self, other: &B::Elem) -> BoolTensor<B, D>

pub fn zeros(shape: Shape<D>) -> Self

pub fn ones(shape: Shape<D>) -> Self

pub fn from_data(data: Data<B::Elem, D>) -> Self

pub fn from_data_device(data: Data<B::Elem, D>, device: B::Device) -> Self

pub fn index<const D2: usize>(&self, indexes: [Range<usize>; D2]) -> Self

pub fn index_assign<const D2: usize>(
    &self,
    indexes: [Range<usize>; D2],
    values: &Self
) -> Self

pub fn mask_fill(&self, mask: &BoolTensor<B, D>, value: B::Elem) -> Self

pub fn to_full_precision(&self) -> Tensor<B::FullPrecisionBackend, D>

pub fn from_full_precision(tensor: Tensor<B::FullPrecisionBackend, D>) -> Self

pub fn argmax(&self, dim: usize) -> Tensor<B::IntegerBackend, D>

pub fn argmin(&self, dim: usize) -> Tensor<B::IntegerBackend, D>

pub fn cat(tensors: Vec<Self>, dim: usize) -> Self

pub fn unsqueeze<const D2: usize>(&self) -> Tensor<B, D2>

impl<const D: usize, B: ADBackend> Tensor<B, D>

pub fn backward(&self) -> Gradients

pub fn grad(&self, grads: &Gradients) -> Option<Tensor<B::InnerBackend, D>>

pub fn inner(&self) -> Tensor<B::InnerBackend, D>

pub fn update(&mut self, other_inner: Tensor<B::InnerBackend, D>)

pub fn from_inner(inner: Tensor<B::InnerBackend, D>) -> Self

pub fn detach(&self) -> Self

Trait Implementations

impl<E, const D: usize, B> Add<E> for Tensor<B, D>where
    E: Element,
    B: Backend<Elem = E>,

type Output = Tensor<B, D>

The resulting type after applying the + operator.

fn add(self, other: E) -> Self

Performs the + operation.

impl<const D: usize, B> Add<Tensor<B, D>> for Tensor<B, D>where
    B: Backend,

type Output = Tensor<B, D>

The resulting type after applying the + operator.

fn add(self, other: Self) -> Self

Performs the + operation.

impl<B: Clone + Backend, const D: usize> Clone for Tensor<B, D>where
    B::TensorPrimitive<D>: Clone,

fn clone(&self) -> Tensor<B, D>

Returns a copy of the value.

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

Performs copy-assignment from source.

impl<B: Debug + Backend, const D: usize> Debug for Tensor<B, D>where
    B::TensorPrimitive<D>: Debug,

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

Formats the value using the given formatter.

impl<E, const D: usize, B> Div<E> for Tensor<B, D>where
    E: Element,
    B: Backend<Elem = E>,

type Output = Tensor<B, D>

The resulting type after applying the / operator.

fn div(self, other: E) -> Self

Performs the / operation.

impl<const D: usize, B> Div<Tensor<B, D>> for Tensor<B, D>where
    B: Backend,

type Output = Tensor<B, D>

The resulting type after applying the / operator.

fn div(self, other: Self) -> Self

Performs the / operation.

impl<E, const D: usize, B> Mul<E> for Tensor<B, D>where
    E: Element,
    B: Backend<Elem = E>,

type Output = Tensor<B, D>

The resulting type after applying the * operator.

fn mul(self, other: E) -> Self

Performs the * operation.

impl<const D: usize, B> Mul<Tensor<B, D>> for Tensor<B, D>where
    B: Backend,

type Output = Tensor<B, D>

The resulting type after applying the * operator.

fn mul(self, other: Self) -> Self

Performs the * operation.

impl<E, const D: usize, B> Sub<E> for Tensor<B, D>where
    E: Element,
    B: Backend<Elem = E>,

type Output = Tensor<B, D>

The resulting type after applying the - operator.

fn sub(self, other: E) -> Self

Performs the - operation.

impl<const D: usize, B> Sub<Tensor<B, D>> for Tensor<B, D>where
    B: Backend,

type Output = Tensor<B, D>

The resulting type after applying the - operator.

fn sub(self, other: Self) -> Self

Performs the - operation.