viva_tensor - v2.1.0

viva_tensor

viva_tensor - NumPy for the BEAM.

Born from the frustration of “why can’t I do tensor math in Erlang/Elixir without calling Python?” Now you can.

The name: “viva” = alive in Portuguese/Spanish. Tensors that live on the BEAM. Also, “viva” sounds better than “gleam_tensor” (sorry, marketing decision).

Architecture:

Performance tip: for matrices > 100x100, make sure the NIF is compiled. The difference is ~100-1000x. No, that’s not a typo.

import viva_tensor as t

let a = t.zeros([2, 3])
let b = t.ones([2, 3])
let assert Ok(c) = t.add(a, b)  // [2.0, 2.0, 2.0, 2.0, 2.0, 2.0]

Types

Conv2dConfig

</> 
pub type Conv2dConfig =
  tensor.Conv2dConfig

Tensor

</> 
pub type Tensor =
  tensor.Tensor

TensorError

</> 
pub type TensorError =
  error.TensorError

TflopsBackend

</> 
pub type TflopsBackend =
  tflops.Backend

TflopsResult

</> 
pub type TflopsResult =
  tflops.TflopsResult

Values

add

</> 
pub fn add(
  a: tensor.Tensor,
  b: tensor.Tensor,
) -> Result(tensor.Tensor, error.TensorError)

Add element-wise

add_broadcast

</> 
pub fn add_broadcast(
  a: tensor.Tensor,
  b: tensor.Tensor,
) -> Result(tensor.Tensor, error.TensorError)

Add with broadcasting

argmax

</> 
pub fn argmax(t: tensor.Tensor) -> Int

Index of maximum value

argmin

</> 
pub fn argmin(t: tensor.Tensor) -> Int

Index of minimum value

avg_pool2d

</> 
pub fn avg_pool2d(
  input: tensor.Tensor,
  pool_h: Int,
  pool_w: Int,
  stride_h: Int,
  stride_w: Int,
) -> Result(tensor.Tensor, error.TensorError)

Average pooling 2D

can_broadcast

</> 
pub fn can_broadcast(a: List(Int), b: List(Int)) -> Bool

Can these shapes broadcast together?

clamp

</> 
pub fn clamp(
  t: tensor.Tensor,
  min_val: Float,
  max_val: Float,
) -> tensor.Tensor

Clamp values

conv2d

</> 
pub fn conv2d(
  input: tensor.Tensor,
  kernel: tensor.Tensor,
  config: tensor.Conv2dConfig,
) -> Result(tensor.Tensor, error.TensorError)

2D Convolution

conv2d_config

</> 
pub fn conv2d_config() -> tensor.Conv2dConfig

Default conv2d config (3x3 kernel, stride 1, no padding)

conv2d_same

</> 
pub fn conv2d_same(
  kernel_h: Int,
  kernel_w: Int,
) -> tensor.Conv2dConfig

Conv2d config with “same” padding

detect_backends

</> 
pub fn detect_backends() -> List(tflops.Backend)

Detect available compute backends

div

</> 
pub fn div(
  a: tensor.Tensor,
  b: tensor.Tensor,
) -> Result(tensor.Tensor, error.TensorError)

Element-wise division

dot

</> 
pub fn dot(
  a: tensor.Tensor,
  b: tensor.Tensor,
) -> Result(Float, error.TensorError)

Dot product (vectors only)

fill

</> 
pub fn fill(shape: List(Int), value: Float) -> tensor.Tensor

Create tensor filled with value

flatten

</> 
pub fn flatten(t: tensor.Tensor) -> tensor.Tensor

Flatten to 1D

from_list

</> 
pub fn from_list(data: List(Float)) -> tensor.Tensor

Create tensor from list (1D)

from_list2d

</> 
pub fn from_list2d(
  rows: List(List(Float)),
) -> Result(tensor.Tensor, error.TensorError)

Create 2D tensor from list of lists

global_avg_pool2d

</> 
pub fn global_avg_pool2d(
  input: tensor.Tensor,
) -> Result(tensor.Tensor, error.TensorError)

Global average pooling

he_init

</> 
pub fn he_init(fan_in: Int, fan_out: Int) -> tensor.Tensor

He initialization (for ReLU networks)

is_contiguous

</> 
pub fn is_contiguous(t: tensor.Tensor) -> Bool

Check if contiguous

map

</> 
pub fn map(
  t: tensor.Tensor,
  f: fn(Float) -> Float,
) -> tensor.Tensor

Apply function to each element

matmul

</> 
pub fn matmul(
  a: tensor.Tensor,
  b: tensor.Tensor,
) -> Result(tensor.Tensor, error.TensorError)

Matrix-matrix multiplication

matmul_vec

</> 
pub fn matmul_vec(
  mat: tensor.Tensor,
  vec: tensor.Tensor,
) -> Result(tensor.Tensor, error.TensorError)

Matrix-vector multiplication

matrix

</> 
pub fn matrix(
  rows: Int,
  cols: Int,
  data: List(Float),
) -> Result(tensor.Tensor, error.TensorError)

Create matrix (2D tensor)

max

</> 
pub fn max(t: tensor.Tensor) -> Float

Maximum value

max_pool2d

</> 
pub fn max_pool2d(
  input: tensor.Tensor,
  pool_h: Int,
  pool_w: Int,
  stride_h: Int,
  stride_w: Int,
) -> Result(tensor.Tensor, error.TensorError)

Max pooling 2D

mean

</> 
pub fn mean(t: tensor.Tensor) -> Float

Mean of all elements

measure_tflops

</> 
pub fn measure_tflops(
  backend: tflops.Backend,
  m: Int,
  n: Int,
  k: Int,
) -> tflops.TflopsResult

Measure TFLOPS for a single matmul operation

measure_tflops_averaged

</> 
pub fn measure_tflops_averaged(
  backend: tflops.Backend,
  m: Int,
  n: Int,
  k: Int,
  iterations: Int,
) -> tflops.TflopsResult

Measure averaged TFLOPS (warmup + iterations)

min

</> 
pub fn min(t: tensor.Tensor) -> Float

Minimum value

mul

</> 
pub fn mul(
  a: tensor.Tensor,
  b: tensor.Tensor,
) -> Result(tensor.Tensor, error.TensorError)

Element-wise multiplication

mul_broadcast

</> 
pub fn mul_broadcast(
  a: tensor.Tensor,
  b: tensor.Tensor,
) -> Result(tensor.Tensor, error.TensorError)

Multiply with broadcasting

norm

</> 
pub fn norm(t: tensor.Tensor) -> Float

L2 norm (Euclidean length)

normalize

</> 
pub fn normalize(t: tensor.Tensor) -> tensor.Tensor

Normalize to unit length

ones

</> 
pub fn ones(shape: List(Int)) -> tensor.Tensor

Create tensor of ones

outer

</> 
pub fn outer(
  a: tensor.Tensor,
  b: tensor.Tensor,
) -> Result(tensor.Tensor, error.TensorError)

Outer product

pad2d

</> 
pub fn pad2d(
  t: tensor.Tensor,
  pad_h: Int,
  pad_w: Int,
) -> Result(tensor.Tensor, error.TensorError)

Pad 2D tensor with zeros

pad4d

</> 
pub fn pad4d(
  t: tensor.Tensor,
  pad_h: Int,
  pad_w: Int,
) -> Result(tensor.Tensor, error.TensorError)

Pad 4D tensor with zeros

random_normal

</> 
pub fn random_normal(
  shape: List(Int),
  mean: Float,
  std: Float,
) -> tensor.Tensor

Tensor with normal random values

random_uniform

</> 
pub fn random_uniform(shape: List(Int)) -> tensor.Tensor

Random uniform [0, 1)

rank

</> 
pub fn rank(t: tensor.Tensor) -> Int

Get rank (number of dimensions)

reshape

</> 
pub fn reshape(
  t: tensor.Tensor,
  new_shape: List(Int),
) -> Result(tensor.Tensor, error.TensorError)

Reshape (total size must match)

scale

</> 
pub fn scale(t: tensor.Tensor, s: Float) -> tensor.Tensor

Scale by constant

shape

</> 
pub fn shape(t: tensor.Tensor) -> List(Int)

Shape as list of dimensions

size

</> 
pub fn size(t: tensor.Tensor) -> Int

Get total size

squeeze

</> 
pub fn squeeze(t: tensor.Tensor) -> tensor.Tensor

Remove dimensions of size 1

std

</> 
pub fn std(t: tensor.Tensor) -> Float

Standard deviation

sub

</> 
pub fn sub(
  a: tensor.Tensor,
  b: tensor.Tensor,
) -> Result(tensor.Tensor, error.TensorError)

Element-wise subtraction

sum

</> 
pub fn sum(t: tensor.Tensor) -> Float

Sum everything

to_contiguous

</> 
pub fn to_contiguous(t: tensor.Tensor) -> tensor.Tensor

Convert to contiguous tensor

to_list

</> 
pub fn to_list(t: tensor.Tensor) -> List(Float)

Convert to list

to_strided

</> 
pub fn to_strided(t: tensor.Tensor) -> tensor.Tensor

Convert to strided representation for O(1) element access

transpose

</> 
pub fn transpose(
  t: tensor.Tensor,
) -> Result(tensor.Tensor, error.TensorError)

Matrix transpose

transpose_strided

</> 
pub fn transpose_strided(
  t: tensor.Tensor,
) -> Result(tensor.Tensor, error.TensorError)

Zero-copy transpose

unsqueeze

</> 
pub fn unsqueeze(t: tensor.Tensor, axis: Int) -> tensor.Tensor

Add dimension of size 1

variance

</> 
pub fn variance(t: tensor.Tensor) -> Float

Variance

vector

</> 
pub fn vector(data: List(Float)) -> tensor.Tensor

Create vector (1D tensor)

xavier_init

</> 
pub fn xavier_init(fan_in: Int, fan_out: Int) -> tensor.Tensor

Xavier initialization for neural network weights

zeros

</> 
pub fn zeros(shape: List(Int)) -> tensor.Tensor

All zeros. The tensor equivalent of a blank canvas.

✨ Search Document