tensai

Sep 1, 2026

Changes in this version

+ func GeluMul(gate, up []Float)

Sep 1, 2026

Changes in this version

+ const DefaultAcceleratorThreshold

+ func AddInto(out, a, b *Tensor) error

+ func DivInto(out, a, b *Tensor) error

+ func DotTBInto(out, a, b *Matrix) error

+ func MatMulInto(out, a, b *Tensor) error

+ func MatMulNTInto(out, a, b *Tensor) error

+ func MatMulTNInto(out, a, b *Tensor) error

+ func MulInto(out, a, b *Tensor) error

+ func SubInto(out, a, b *Tensor) error

+ type Accelerator interface

+ MatMul func(a, b *Tensor) (*Tensor, error)

+ MatMulNT func(a, b *Tensor) (*Tensor, error)

+ MatMulTN func(a, b *Tensor) (*Tensor, error)

+ func Acceleration() Accelerator

+ func UseAccelerator(acc Accelerator) Accelerator

+ func UseAcceleratorThreshold(acc Accelerator, minMACs int64) Accelerator

type Tensor

+ func MatMulNT(a, b *Tensor) (*Tensor, error)

+ func MatMulTN(a, b *Tensor) (*Tensor, error)

+ func (t *Tensor) Clone() *Tensor

+ func (t *Tensor) ZerosLike() *Tensor

Aug 27, 2026

Changes in this version

type Matrix

+ func (m *Matrix) ArgmaxRow(r int) int

Aug 27, 2026

Changes in this version

type Matrix

+ func EnsureMatrix(m *Matrix, rows, cols int) *Matrix

+ func NewMatrixFromInts(rows, cols int, data []int) (*Matrix, error)

Aug 27, 2026

Changes in this version

+ func Axpy(a Float, x, y []Float)

+ func Axpys(ws []Float, v, outs []Float)

+ func DotVecs(qs, k []Float, out []Float)

+ func MXFP4Value(code uint8) int8

+ func PackScaleMin(scale, min Float) uint32

+ func SiluMul(gate, up []Float)

+ type Dataset struct

+ Inputs *Matrix

+ Targets *Matrix

+ func NewDataset(inputs, targets *Matrix) (*Dataset, error)

+ func (d *Dataset) Batches(size int, rng *rand.Rand, fn func(inputs, targets *Matrix) error) error

+ func (d *Dataset) Len() int

+ func (d *Dataset) Shuffle(rng *rand.Rand)

+ func (d *Dataset) Split(testFraction float64) (train, test *Dataset, err error)

+ func (d *Dataset) Standardize() (mean, std []Float)

+ func (d *Dataset) StandardizeWith(mean, std []Float)

type Float

+ func DotVec(a, b []Float) Float

+ func MXFP4Scale(e uint8) Float

+ func UnpackScaleMin(u uint32) (scale, min Float)

+ type GPU struct

+ func OpenGPU(power ...GPUPower) (*GPU, error)

+ func (g *GPU) BeginBatch() error

+ func (g *GPU) Close()

+ func (g *GPU) Flush() error

+ func (g *GPU) HasF16() bool

+ func (g *GPU) MatMul(a, b *Tensor) (*Tensor, error)

+ func (g *GPU) Name() string

+ func (g *GPU) NewF16Tensor(shape ...int) (*GPUTensor, error)

+ func (g *GPU) StorageLimit() uint64

+ func (g *GPU) Upload(t *Tensor) (*GPUTensor, error)

+ func (g *GPU) UploadQ4(q *Q4Matrix) (*GPUQ4Matrix, error)

+ func (g *GPU) UploadQ8(q *QMatrix) (*GPUQMatrix, error)

+ type GPUPower uint32

+ const GPUDefault

+ const GPUHighPerformance

+ const GPULowPower

+ type GPUQ4Matrix struct

+ func (q *GPUQ4Matrix) Free()

+ func (q *GPUQ4Matrix) MatMul(x *GPUTensor) (*GPUTensor, error)

+ func (q *GPUQ4Matrix) MatMulOpts(x, bias, dst *GPUTensor) (*GPUTensor, error)

+ func (q *GPUQ4Matrix) Shape() (int, int)

+ type GPUQMatrix struct

+ func (q *GPUQMatrix) Free()

+ func (q *GPUQMatrix) MatMul(x *GPUTensor) (*GPUTensor, error)

+ func (q *GPUQMatrix) MatMulOpts(x, bias, dst *GPUTensor) (*GPUTensor, error)

+ func (q *GPUQMatrix) Shape() (int, int)

+ type GPUTensor struct

+ func (q *GPUTensor) Attention(k, v *GPUTensor) (*GPUTensor, error)

+ func (q *GPUTensor) CausalAttention(k, v *GPUTensor) (*GPUTensor, error)

+ func (q *GPUTensor) CausalMultiHeadAttention(k, v *GPUTensor, heads int) (*GPUTensor, error)

+ func (q *GPUTensor) GroupedCausalAttention(k, v *GPUTensor, heads, kvHeads, seqKV, window int) (*GPUTensor, error)

+ func (q *GPUTensor) MultiHeadAttention(k, v *GPUTensor, heads int) (*GPUTensor, error)

+ func (t *GPUTensor) Add(o *GPUTensor) error

+ func (t *GPUTensor) CopyRowsInto(dst *GPUTensor, off int) error

+ func (t *GPUTensor) Download() (*Tensor, error)

+ func (t *GPUTensor) DownloadRange(off, n int) (*Tensor, error)

+ func (t *GPUTensor) Free()

+ func (t *GPUTensor) GeluMul(o *GPUTensor) error

+ func (t *GPUTensor) MatMul(o *GPUTensor) (*GPUTensor, error)

+ func (t *GPUTensor) MatMulT(o *GPUTensor) (*GPUTensor, error)

+ func (t *GPUTensor) RMSNorm(w *GPUTensor, eps float64) (*GPUTensor, error)

+ func (t *GPUTensor) RMSNormEach(w *GPUTensor, eps float64) (*GPUTensor, error)

+ func (t *GPUTensor) RoPE(headSz, pos0 int, theta float64) error

+ func (t *GPUTensor) Scale(s Float) error

+ func (t *GPUTensor) Shape() []int

+ func (t *GPUTensor) SiluMul(o *GPUTensor) error

+ func (t *GPUTensor) Size() int

+ func (t *GPUTensor) Softmax() (*GPUTensor, error)

+ type MXFP4Matrix struct

+ ColSum64 []int32

+ Cols int

+ Q []uint8

+ Rows int

+ Scale []Float

+ func NewMXFP4Matrix(rows, cols int) *MXFP4Matrix

+ func (q *MXFP4Matrix) Index(i, j int) int

+ func (q *MXFP4Matrix) MatMul(x, out *Matrix) error

+ func (q *MXFP4Matrix) MatVec(x, out []Float) error

+ func (q *MXFP4Matrix) TableIndex(g, j int) int

type Matrix

+ func (m *Matrix) Tensor() *Tensor

+ type Q4Matrix struct

+ Cols int

+ Group int

+ Q []uint8

+ Rows int

+ Scale []Float

+ ScaleMin []uint32

+ func NewQ4Matrix(rows, cols, group int, minForm bool) *Q4Matrix

+ func QuantizeMatrix4(m *Matrix) (*Q4Matrix, error)

+ func (q *Q4Matrix) Index(i, j int) int

+ func (q *Q4Matrix) MatMul(x, out *Matrix) error

+ func (q *Q4Matrix) MatVec(x, out []Float) error

+ func (q *Q4Matrix) TableIndex(g, j int) int

+ type Q8GMatrix struct

+ ColSum64 []int32

+ Cols int

+ Group int

+ Q []int8

+ Rows int

+ Scale []Float

+ func NewQ8GMatrix(rows, cols, group int) *Q8GMatrix

+ func (q *Q8GMatrix) Index(i, j int) int

+ func (q *Q8GMatrix) MatMul(x, out *Matrix) error

+ func (q *Q8GMatrix) MatVec(x, out []Float) error

+ func (q *Q8GMatrix) TableIndex(g, j int) int

+ type QMatrix struct

+ ColSum64 []int32

+ Cols int

+ Q []int8

+ Rows int

+ Scale []Float

+ func QuantizeMatrix(m *Matrix) *QMatrix

+ func (q *QMatrix) Index(i, j int) int

+ func (q *QMatrix) MatMul(x, out *Matrix) error

+ func (q *QMatrix) MatVec(x, out []Float) error

+ type Tensor struct

+ Data []Float

+ Shape []int

+ func MatMul(a, b *Tensor) (*Tensor, error)

+ func NewTensor(shape ...int) *Tensor

+ func NewTensorFromSlice(data []Float, shape ...int) (*Tensor, error)

+ func (t *Tensor) Add(o *Tensor) (*Tensor, error)

+ func (t *Tensor) At(idx ...int) Float

+ func (t *Tensor) Div(o *Tensor) (*Tensor, error)

+ func (t *Tensor) Matrix() (*Matrix, error)

+ func (t *Tensor) Mul(o *Tensor) (*Tensor, error)

+ func (t *Tensor) Reshape(shape ...int) (*Tensor, error)

+ func (t *Tensor) Scale(s Float)

+ func (t *Tensor) Set(v Float, idx ...int)

+ func (t *Tensor) Size() int

+ func (t *Tensor) Sub(o *Tensor) (*Tensor, error)

+ func (t *Tensor) Transpose(perm ...int) (*Tensor, error)

+ func (t *Tensor) Validate() error

Aug 20, 2026

Changes in this version

+ func DotInto(out, a, b *Matrix) error

+ func DotTAInto(out, a, b *Matrix) error

+ func LoadParams(r io.Reader, params ...*Node) error

+ func LoadParamsFile(path string, params ...*Node) error

+ func SaveParams(w io.Writer, params ...*Node) error

+ func SaveParamsFile(path string, params ...*Node) error

+ func TInto(dst, src *Matrix) error

+ func ZeroGrads(nodes ...*Node)

+ type Adam struct

+ Beta1 Float

+ Beta2 Float

+ Eps Float

+ LR Float

+ WeightDecay Float

+ func NewAdam(lr Float) *Adam

+ func NewAdamW(lr, weightDecay Float) *Adam

+ func (a *Adam) Name() string

+ func (a *Adam) NewLayer() int

+ func (a *Adam) Step(idx int, weights, gradW *Matrix, bias, gradB []Float)

+ func (a *Adam) String() string

+ type BatchNorm struct

+ Eps Float

+ Momentum Float

+ func NewBatchNorm() *BatchNorm

+ func (b *BatchNorm) Backward(gradOutput *Matrix) (*Matrix, error)

+ func (b *BatchNorm) Forward(input *Matrix) (*Matrix, error)

+ func (b *BatchNorm) Grads() (*Matrix, []Float)

+ func (b *BatchNorm) Init(inputCols int, _ *rand.Rand) (int, error)

+ func (b *BatchNorm) Params() (*Matrix, []Float)

+ func (b *BatchNorm) RunningStats() (mean, variance []Float)

+ func (b *BatchNorm) SetParams(weights *Matrix, bias []Float) error

+ type BinaryCrossEntropy struct

+ func (BinaryCrossEntropy) Loss(pred, target *Matrix) (Float, *Matrix, error)

+ func (BinaryCrossEntropy) LossInto(pred, target, grad *Matrix) (Float, error)

+ func (BinaryCrossEntropy) Name() string

+ type Conv2D struct

+ func NewConv2D(inH, inW, inC, outC, kernel, stride, pad int) *Conv2D

+ func (c *Conv2D) Backward(gradOutput *Matrix) (*Matrix, error)

+ func (c *Conv2D) Forward(input *Matrix) (*Matrix, error)

+ func (c *Conv2D) Grads() (*Matrix, []Float)

+ func (c *Conv2D) Init(inputCols int, rng *rand.Rand) (int, error)

+ func (c *Conv2D) Params() (*Matrix, []Float)

+ func (c *Conv2D) SetParams(weights *Matrix, bias []Float) error

+ func (c *Conv2D) Shape() (inH, inW, inC, outC, kernel, stride, pad int)

+ type Dense struct

+ func NewDense(outCols int) *Dense

+ func (d *Dense) Backward(gradOutput *Matrix) (*Matrix, error)

+ func (d *Dense) Forward(input *Matrix) (*Matrix, error)

+ func (d *Dense) Grads() (*Matrix, []Float)

+ func (d *Dense) Init(inputCols int, rng *rand.Rand) (int, error)

+ func (d *Dense) Params() (*Matrix, []Float)

+ func (d *Dense) SetParams(weights *Matrix, bias []Float) error

+ type Dropout struct

+ Rate Float

+ func NewDropout(rate Float) *Dropout

+ func (d *Dropout) Backward(gradOutput *Matrix) (*Matrix, error)

+ func (d *Dropout) Forward(input *Matrix) (*Matrix, error)

+ func (d *Dropout) Grads() (*Matrix, []Float)

+ func (d *Dropout) Init(inputCols int, rng *rand.Rand) (int, error)

+ func (d *Dropout) Params() (*Matrix, []Float)

+ func (d *Dropout) SetParams(*Matrix, []Float) error

+ type Embedding struct

+ func NewEmbedding(vocabSize, dim int) *Embedding

+ func (e *Embedding) Backward(gradOutput *Matrix) (*Matrix, error)

+ func (e *Embedding) Forward(input *Matrix) (*Matrix, error)

+ func (e *Embedding) Grads() (*Matrix, []Float)

+ func (e *Embedding) Init(inputCols int, rng *rand.Rand) (int, error)

+ func (e *Embedding) Params() (*Matrix, []Float)

+ func (e *Embedding) SetParams(weights *Matrix, bias []Float) error

+ type Float = float32

+ type GELU struct

+ func (a *GELU) Grads() (*Matrix, []Float)

+ func (a *GELU) Params() (*Matrix, []Float)

+ func (a *GELU) SetParams(*Matrix, []Float) error

+ func (g *GELU) Backward(gradOutput *Matrix) (*Matrix, error)

+ func (g *GELU) Forward(input *Matrix) (*Matrix, error)

+ func (g *GELU) Init(inputCols int, _ *rand.Rand) (int, error)

+ type KNN struct

+ K int

+ func NewKNN(k int) *KNN

+ func (k *KNN) Fit(inputs, targets *Matrix) error

+ func (k *KNN) Predict(inputs *Matrix) (*Matrix, error)

+ type LSTMCell struct

+ Bf *Node

+ Bg *Node

+ Bi *Node

+ Bo *Node

+ Whf *Node

+ Whg *Node

+ Whi *Node

+ Who *Node

+ Wxf *Node

+ Wxg *Node

+ Wxi *Node

+ Wxo *Node

+ func NewLSTMCell(inSize, hidden int, rng *rand.Rand) *LSTMCell

+ func (c *LSTMCell) InitState(batch int) (*Node, *Node)

+ func (c *LSTMCell) Params() []*Node

+ func (c *LSTMCell) Step(x, h, cell *Node) (*Node, *Node)

+ type Layer interface

+ Backward func(gradOutput *Matrix) (*Matrix, error)

+ Forward func(input *Matrix) (*Matrix, error)

+ Grads func() (*Matrix, []Float)

+ Init func(inputCols int, rng *rand.Rand) (outputCols int, err error)

+ Params func() (*Matrix, []Float)

+ SetParams func(weights *Matrix, bias []Float) error

+ type LayerNorm struct

+ func NewLayerNorm() *LayerNorm

+ func (l *LayerNorm) Backward(gradOutput *Matrix) (*Matrix, error)

+ func (l *LayerNorm) Forward(input *Matrix) (*Matrix, error)

+ func (l *LayerNorm) Grads() (*Matrix, []Float)

+ func (l *LayerNorm) Init(inputCols int, _ *rand.Rand) (int, error)

+ func (l *LayerNorm) Params() (*Matrix, []Float)

+ func (l *LayerNorm) SetParams(weights *Matrix, bias []Float) error

+ type LeakyReLU struct

+ Alpha Float

+ func NewLeakyReLU(alpha Float) *LeakyReLU

+ func (a *LeakyReLU) Grads() (*Matrix, []Float)

+ func (a *LeakyReLU) Params() (*Matrix, []Float)

+ func (a *LeakyReLU) SetParams(*Matrix, []Float) error

+ func (l *LeakyReLU) Backward(gradOutput *Matrix) (*Matrix, error)

+ func (l *LeakyReLU) Forward(input *Matrix) (*Matrix, error)

+ func (l *LeakyReLU) Init(inputCols int, _ *rand.Rand) (int, error)

+ type Loss interface

+ Loss func(pred, target *Matrix) (Float, *Matrix, error)

+ Name func() string

+ type Matrix struct

+ Cols int

+ Data []Float

+ Rows int

+ func Add(a, b *Matrix) (*Matrix, error)

+ func AddBias(a *Matrix, bias []Float) (*Matrix, error)

+ func Dot(a, b *Matrix) (*Matrix, error)

+ func NewMatrix(rows, cols int) *Matrix

+ func NewMatrixFromSlice(rows, cols int, data []Float) (*Matrix, error)

+ func RandomMatrix(rows, cols int, rng *rand.Rand) *Matrix

+ func (m *Matrix) At(r, c int) Float

+ func (m *Matrix) Row(r int) []Float

+ func (m *Matrix) Scale(s Float)

+ func (m *Matrix) Set(r, c int, v Float)

+ func (m *Matrix) SetRow(r int, vals []Float) error

+ func (m *Matrix) T() *Matrix

+ func (m *Matrix) Validate() error

+ type MaxPool2D struct

+ func NewMaxPool2D(inH, inW, channels, size int) *MaxPool2D

+ func (p *MaxPool2D) Backward(gradOutput *Matrix) (*Matrix, error)

+ func (p *MaxPool2D) Forward(input *Matrix) (*Matrix, error)

+ func (p *MaxPool2D) Grads() (*Matrix, []Float)

+ func (p *MaxPool2D) Init(inputCols int, _ *rand.Rand) (int, error)

+ func (p *MaxPool2D) Params() (*Matrix, []Float)

+ func (p *MaxPool2D) SetParams(*Matrix, []Float) error

+ func (p *MaxPool2D) Shape() (inH, inW, channels, size int)

+ type MeanSquaredError struct

+ func (MeanSquaredError) Loss(pred, target *Matrix) (Float, *Matrix, error)

+ func (MeanSquaredError) LossInto(pred, target, grad *Matrix) (Float, error)

+ func (MeanSquaredError) Name() string

+ type Model interface

+ Predict func(input *Matrix) (*Matrix, error)

+ type Node struct

+ Grad *Matrix

+ Value *Matrix

+ func Attention(q, k, v *Node) *Node

+ func Input(m *Matrix) *Node

+ func Param(m *Matrix) *Node

+ func (n *Node) Add(o *Node) *Node

+ func (n *Node) AddRow(row *Node) *Node

+ func (n *Node) Backward()

+ func (n *Node) MSELoss(target *Matrix) *Node

+ func (n *Node) MatMul(o *Node) *Node

+ func (n *Node) Mean() *Node

+ func (n *Node) MulElem(o *Node) *Node

+ func (n *Node) Named(name string) *Node

+ func (n *Node) ReLU() *Node

+ func (n *Node) Scalar() Float

+ func (n *Node) Scale(s Float) *Node

+ func (n *Node) Sigmoid() *Node

+ func (n *Node) Softmax() *Node

+ func (n *Node) SoftmaxCELoss(target *Matrix) *Node

+ func (n *Node) Sub(o *Node) *Node

+ func (n *Node) Sum() *Node

+ func (n *Node) T() *Node

+ func (n *Node) Tanh() *Node

+ func (n *Node) ToDot() string

+ type Optimizer interface

+ Name func() string

+ NewLayer func() int

+ Step func(idx int, weights, gradW *Matrix, bias, gradB []Float)

+ type RNNCell struct

+ B *Node

+ Wh *Node

+ Wx *Node

+ func NewRNNCell(inSize, hidden int, rng *rand.Rand) *RNNCell

+ func (c *RNNCell) InitState(batch int) *Node

+ func (c *RNNCell) Params() []*Node

+ func (c *RNNCell) Step(x, h *Node) *Node

+ type ReLU struct

+ func (a *ReLU) Grads() (*Matrix, []Float)

+ func (a *ReLU) Params() (*Matrix, []Float)

+ func (a *ReLU) SetParams(*Matrix, []Float) error

+ func (r *ReLU) Backward(gradOutput *Matrix) (*Matrix, error)

+ func (r *ReLU) Forward(input *Matrix) (*Matrix, error)

+ func (r *ReLU) Init(inputCols int, _ *rand.Rand) (int, error)

+ type SGD struct

+ LR Float

+ Momentum Float

+ func NewSGD(lr, momentum Float) *SGD

+ func (s *SGD) Name() string

+ func (s *SGD) NewLayer() int

+ func (s *SGD) Step(idx int, weights, gradW *Matrix, bias, gradB []Float)

+ func (s *SGD) String() string

+ type SelfAttention struct

+ Wk *Node

+ Wq *Node

+ Wv *Node

+ func NewSelfAttention(inSize, dModel int, rng *rand.Rand) *SelfAttention

+ func (a *SelfAttention) Forward(x *Node) *Node

+ func (a *SelfAttention) Params() []*Node

+ type Sequential struct

+ func NewSequential() *Sequential

+ func (s *Sequential) Add(layer Layer) *Sequential

+ func (s *Sequential) Compile(inputCols int, loss Loss, optimizer Optimizer) error

+ func (s *Sequential) Fit(input, target *Matrix, epochs int) error

+ func (s *Sequential) FitStep(input, target *Matrix) (Float, error)

+ func (s *Sequential) Layers() []Layer

+ func (s *Sequential) Load(r io.Reader) error

+ func (s *Sequential) LoadFile(path string) error

+ func (s *Sequential) Predict(input *Matrix) (*Matrix, error)

+ func (s *Sequential) Save(w io.Writer) error

+ func (s *Sequential) SaveFile(path string) error

+ type Sigmoid struct

+ func (a *Sigmoid) Grads() (*Matrix, []Float)

+ func (a *Sigmoid) Params() (*Matrix, []Float)

+ func (a *Sigmoid) SetParams(*Matrix, []Float) error

+ func (s *Sigmoid) Backward(gradOutput *Matrix) (*Matrix, error)

+ func (s *Sigmoid) Forward(input *Matrix) (*Matrix, error)

+ func (s *Sigmoid) Init(inputCols int, _ *rand.Rand) (int, error)

+ type Softmax struct

+ func (a *Softmax) Grads() (*Matrix, []Float)

+ func (a *Softmax) Params() (*Matrix, []Float)

+ func (a *Softmax) SetParams(*Matrix, []Float) error

+ func (s *Softmax) Backward(gradOutput *Matrix) (*Matrix, error)

+ func (s *Softmax) Forward(input *Matrix) (*Matrix, error)

+ func (s *Softmax) Init(inputCols int, _ *rand.Rand) (int, error)

+ type SoftmaxCrossEntropy struct

+ func (SoftmaxCrossEntropy) Loss(pred, target *Matrix) (Float, *Matrix, error)

+ func (SoftmaxCrossEntropy) LossInto(pred, target, grad *Matrix) (Float, error)

+ func (SoftmaxCrossEntropy) Name() string

+ type Tanh struct

+ func (a *Tanh) Grads() (*Matrix, []Float)

+ func (a *Tanh) Params() (*Matrix, []Float)

+ func (a *Tanh) SetParams(*Matrix, []Float) error

+ func (t *Tanh) Backward(gradOutput *Matrix) (*Matrix, error)

+ func (t *Tanh) Forward(input *Matrix) (*Matrix, error)

+ func (t *Tanh) Init(inputCols int, _ *rand.Rand) (int, error)

+ type Trainer struct

+ func NewTrainer(opt Optimizer, params ...*Node) *Trainer

+ func (t *Trainer) Step(loss *Node) Float