tensor

class tinychain.collection.tensor.Tensor(form)

Bases: Collection, NDArray, Trigonometric, Boolean, Numeric, Compare, Generic[DType]

An n-dimensional array of numbers.

abs()

Absolute value

acos()

Arccosine

acosh()

Hyperbolic arccosine

add(other)

Addition

asin()

Arcsine

asinh()

Hyperbolic arcsine

atan()

Arctangent

atanh()

Hyperbolic arctangent

broadcast(shape)

Broadcast this NDArray into the given shape.

cast(dtype)

Attempt to cast this State into the given dtype.

cond(then, or_else)

Return a view of then and or_else depending on whether the corresponding element of this tensor is True.

self, then, and or_else must support broadcasting to the same shape.

copy()

Return a copy of this NDArray

cos()

Cosine

cosh()

Hyperbolic cosine

div(other)

Division

eq(other)

Return a boolean Tensor with element-wise equality values.

exp()

Raise e to the power of this Numeric.

expand_dims(axes=None)

Return a view of this Tensor with extra dimensions of size 1 at the given axes.

gt(other)

Return a boolean Tensor with element-wise greater-than values.

gte(other)

Return a boolean Tensor with element-wise greater-or-equal values.

log(base=None)

Calculate the logarithm of this Numeric with respect to the given base.

If no base is given, this will return the natural logarithm (base e).

lt(other)

Return a boolean Tensor with element-wise less-than values.

lte(other)

Return a boolean Tensor with element-wise less-or-equal values.

max(axes=None, keepdims=False)

Return the maximum value of this Tensor along the given axes, or the overall maximum if no axes are given.

min(axes=None, keepdims=False)

Return the minimum value of this Tensor along the given axes, or the overal minimum if no axes are given.

mul(other)

Multiplication

property ndim

Return the number of dimensions of this Tensor.

ne(other)

Return a boolean Tensor with element-wise not-equal values.

norm(axis=None, keepdims=False)

With no axis, computes the Frobenius norm (aka Euclidean norm) of a matrix or batch of matrices.

For a vector norm, specify the axis of the vector.

pow(other)

Raise this Numeric to the given power.

product(axes=None, keepdims=False)

Calculate the product of this Tensor along the given axes, or the total product if no axes are given.

reshape(shape, copy=True)

Return a view of this Tensor with the given shape.

property schema

Return the schema of this Collection.

property shape

Return the shape of this Tensor.

sin()

Sine

sinh()

Hyperbolic sine

slice(bounds)

Return the sub-array of this NDArray within the given bounds.

sub(other)

Subtraction

sum(axes=None, keepdims=False)

Calculate the sum of this Tensor along the given axes, or the total sum if no axes are given.

tan()

Tangent

tanh()

Hyperbolic tangent

transpose(permutation=None)

Return a view of this Tensor with its axes transposed according to the given permutation.

If no permutation is given, the axes will be inverted (e.g. (0, 1, 2) inverts to (2, 1, 0)).

class tinychain.collection.tensor.Dense(form)

Bases: Tensor, Generic[DType]

An n-dimensional array of numbers stored as sequential blocks.

IMPORTANT: for efficiency reasons, serialization of a Dense tensor will stop if a non-numeric value (NaN or +/- infinity) is encountered. If you receive a Dense tensor without enough elements for its shape, you can safely treat this response as a divide-by-zero error.

add(other)

Addition

classmethod arange(shape, start, stop)

Return a Dense tensor with the given shape containing a range of numbers evenly distributed between start and stop.

argsort()

Return the coordinates needed to sort this Tensor.

as_sparse()

Return a Sparse view of this Dense tensor.

cast(dtype)

Attempt to cast this State into the given dtype.

classmethod concatenate(tensors, axis=0)

Create a new Dense tensor by concatenating the given tensors along the given axis.

classmethod constant(shape, value)

Return a Dense tensor of the given shape filled with the given value.

classmethod create(shape, dtype=<class 'tinychain.scalar.number.F32'>)

Create a new, empty Dense tensor.

Call this method to initialize a persistent Tensor in a Chain.

classmethod load(shape, data, dtype=<class 'tinychain.scalar.number.F32'>)

Load a Dense tensor from an existing data set.

Example:

values = [0, 1, 2]
dense = tc.tensor.Dense.load([1, 3], values, tc.I32)

classmethod ones(shape, dtype=<class 'tinychain.scalar.number.F32'>)

Construct a Dense tensor filled with ones.

classmethod ones_like(tensor)

Return a Dense tensor filled with ones, with the same shape as the given tensor.

classmethod random_normal(shape, mean=0.0, std=1.0)

Return a Dense tensor filled with a random normal distribution of F64 s.

classmethod random_uniform(shape, minval=0, maxval=1)

Return a Dense tensor filled with a uniform random distribution of F64 s.

sub(other)

Subtraction

classmethod truncated_normal(shape, mean=0.0, std=1.0, minval=None, maxval=None)

Return a Dense tensor filled with a random normal distribution of F64 s.

Any value x outside the range minval <= x <= maxval will be replaced by a value drawn from a new random normal distribution.

minval and maxval default to two standard deviations.

classmethod zeros(shape, dtype=<class 'tinychain.scalar.number.F32'>)

Construct a Dense tensor filled with zeros.

classmethod zeros_like(tensor)

Return a Dense tensor filled with zeros, with the same shape as the given tensor.

class tinychain.collection.tensor.Sparse(form)

Bases: Tensor, Generic[DType]

An n-dimensional array of numbers stored as a Table of coordinates and values.

IMPORTANT: be careful when broadcasting a Sparse tensor–the result may not be so sparse! For example, broadcasting a Sparse tensor with shape [2, 1] with exactly one element into shape [2, 1000] will result in a Sparse tensor with 1000 elements.

The and, div, and mul methods are optimized to avoid this issue by ignoring right-hand values at coordinates which are not filled in the left-hand Tensor.

as_dense()

Return a Dense view of this Sparse tensor.

cast(dtype)

Attempt to cast this State into the given dtype.

classmethod create(shape, dtype=<class 'tinychain.scalar.number.F32'>)

Create a new, empty Sparse tensor.

Call this method to initialize a persistent Tensor in a Chain.

div(other)

Division

classmethod eye(size, batch=[])

Create a boolean identity matrix of shape [size, size].

classmethod load(shape, data, dtype=<class 'tinychain.scalar.number.F32'>)

Load a Sparse tensor from an existing data set.

Example:

coords = [[0, 0, 1], [0, 1, 0]]
values = [1, 2]
sparse = tc.tensor.Sparse.load([2, 3, 4], zip(coords, values))

mul(other)

Multiplication

classmethod zeros(shape, dtype=<class 'tinychain.scalar.number.F32'>)

Create a Sparse tensor with the given shape and data type.

If dtype is not specified, the data type will be F32.

classmethod zeros_like(tensor)

Create a Sparse tensor with the same shape and data type as the given tensor.

tinychain.collection.tensor.einsum(f, tensors)

Return the Einstein summation of the given tensors according the the given format string.

Example: einsum(“ij,jk->ik”, [A, B]) # multiply matrices A and B

The tensor product is computed from left to right, so when using any Sparse tensors, it’s important to put the sparsest first in the list to avoid redundant broadcasting.

tinychain.collection.tensor.split(tensor, num_or_size_splits, axis=0)

Split the given tensor into multiple slices along the given axis.

This method requires a constant num_or_size_splits, axis, and self.shape[axis].

If num_or_size_splits is a Number, the tensor will be sliced along axis num_or_size_splits times; if self.shape[axis] % num_or_size_splits != 0 then a ValueError error will be raised.

If num_or_size_splits is a Tuple with length n then the tensor will be split into n slices each with shape[axis] == num_or_size_splits[axis]; if the sum of num_or_size_splits is not equal to self.shape[axis] then a ValueError error will be raised.

tinychain.collection.tensor.tile(tensor, multiples)

Construct a new Tensor by tiling the given tensor multiples times.

The values of tensor are repeated multiples[x] times along the x`th axis of the output. `multiples must be a positive integer or a Tuple of length tensor.ndim.