tensor

package
v0.3.0 Latest Latest
Warning

This package is not in the latest version of its module.

 Go to latest Published: Oct 29, 2025 License: BSD-3-Clause Imports: 14 Imported by: 0

Documentation

Index

Examples

Constants

This section is empty.

Variables

This section is empty.

Functions

func Backward 

func Backward[T candy.D](root *Tensor[T], store *GradStore[T]) error

Backward computes gradients for all variable tensors contributing to the root tensor.

func MustReadNPZ 

func MustReadNPZ(path string) map[string]*Tensor[float32]

func MustWriteNPZ 

func MustWriteNPZ[T candy.D](path string, items map[string]*Tensor[T])

func ReadNPZ 

func ReadNPZ[T candy.D](path string) (map[string]*Tensor[T], error)

func WriteNPZ 

func WriteNPZ[T candy.D](path string, items map[string]*Tensor[T]) error

Types

type BackwardFunc 

type BackwardFunc[T candy.D] func(*Tensor[T], []*Tensor[T]) ([]*Tensor[T], error)

BackwardFunc defines a backward pass function for computing gradients.

func AbsBackward 

func AbsBackward[T candy.D]() BackwardFunc[T]

AbsBackward returns a BackwardFunc for absolute value gradients: ∂|x|/∂x = sign(x).

func AddBackward 

func AddBackward[T candy.D]() BackwardFunc[T]

AddBackward returns a BackwardFunc for addition gradients: ∂z/∂x = 1, ∂z/∂y = 1.

func AffineBackward 

func AffineBackward[T candy.D](scale, bias float64) BackwardFunc[T]

AffineBackward returns a BackwardFunc for affine transformation gradients: ∂y/∂x = scale.

func AvgPool2dBackward 

func AvgPool2dBackward[T candy.D](kH, kW, sH, sW int) BackwardFunc[T]

AvgPool2dBackward returns a BackwardFunc for 2D average pooling gradients.

func BroadcastAddBackward 

func BroadcastAddBackward[T candy.D]() BackwardFunc[T]

BroadcastAddBackward returns a BackwardFunc for broadcasted addition gradients: ∂z/∂x = 1, ∂z/∂y = 1.

func BroadcastAsBackward 

func BroadcastAsBackward[T candy.D](s *candy.Shape) BackwardFunc[T]

BroadcastAsBackward returns a BackwardFunc for broadcasting gradients.

func BroadcastDivBackward 

func BroadcastDivBackward[T candy.D]() BackwardFunc[T]

BroadcastDivBackward returns a BackwardFunc for broadcasted division gradients: ∂z/∂x = 1/y, ∂z/∂y = -x/y².

func BroadcastEqBackward 

func BroadcastEqBackward[T candy.D]() BackwardFunc[T]

BroadcastEqBackward returns a BackwardFunc for broadcasted equality gradients: ∂z/∂x = 0, ∂z/∂y = 0.

func BroadcastGeBackward 

func BroadcastGeBackward[T candy.D]() BackwardFunc[T]

BroadcastGeBackward returns a BackwardFunc for broadcasted greater-than-or-equal gradients: ∂z/∂x = 0, ∂z/∂y = 0.

func BroadcastGtBackward 

func BroadcastGtBackward[T candy.D]() BackwardFunc[T]

BroadcastGtBackward returns a BackwardFunc for broadcasted greater-than gradients: ∂z/∂x = 0, ∂z/∂y = 0.

func BroadcastLeBackward 

func BroadcastLeBackward[T candy.D]() BackwardFunc[T]

BroadcastLeBackward returns a BackwardFunc for broadcasted less-than-or-equal gradients: ∂z/∂x = 0, ∂z/∂y = 0.

func BroadcastLtBackward 

func BroadcastLtBackward[T candy.D]() BackwardFunc[T]

BroadcastLtBackward returns a BackwardFunc for broadcasted less-than gradients: ∂z/∂x = 0, ∂z/∂y = 0.

func BroadcastMaximumBackward 

func BroadcastMaximumBackward[T candy.D]() BackwardFunc[T]

BroadcastMaximumBackward returns a BackwardFunc for broadcasted maximum gradients.

func BroadcastMinimumBackward 

func BroadcastMinimumBackward[T candy.D]() BackwardFunc[T]

BroadcastMinimumBackward returns a BackwardFunc for broadcasted minimum gradients.

func BroadcastMulBackward 

func BroadcastMulBackward[T candy.D]() BackwardFunc[T]

BroadcastMulBackward returns a BackwardFunc for broadcasted multiplication gradients: ∂z/∂x = y, ∂z/∂y = x.

func BroadcastNeBackward 

func BroadcastNeBackward[T candy.D]() BackwardFunc[T]

BroadcastNeBackward returns a BackwardFunc for broadcasted inequality gradients: ∂z/∂x = 0, ∂z/∂y = 0.

func BroadcastSubBackward 

func BroadcastSubBackward[T candy.D]() BackwardFunc[T]

BroadcastSubBackward returns a BackwardFunc for broadcasted subtraction gradients: ∂z/∂x = 1, ∂z/∂y = -1.

func CeilBackward 

func CeilBackward[T candy.D]() BackwardFunc[T]

CeilBackward returns a BackwardFunc for ceiling gradients: ∂ceil(x)/∂x = 0.

func Conv1dBackward 

func Conv1dBackward[T candy.D](p *candy.Conv1DParams) BackwardFunc[T]

Conv1dBackward returns a BackwardFunc for 1D convolution gradients.

func Conv2dBackward 

func Conv2dBackward[T candy.D](p *candy.Conv2DParams) BackwardFunc[T]

Conv2dBackward returns a BackwardFunc for 2D convolution gradients.

func ConvTranspose1dBackward 

func ConvTranspose1dBackward[T candy.D](p *candy.ConvT1DParams) BackwardFunc[T]

ConvTranspose1dBackward returns a BackwardFunc for 1D transposed convolution gradients.

func ConvTranspose2dBackward 

func ConvTranspose2dBackward[T candy.D](p *candy.ConvT2DParams) BackwardFunc[T]

ConvTranspose2dBackward returns a BackwardFunc for 2D transposed convolution gradients.

func CopyBackward 

func CopyBackward[T candy.D]() BackwardFunc[T]

CopyBackward returns a BackwardFunc for clone gradients: ∂y/∂x = 1.

func CosBackward 

func CosBackward[T candy.D]() BackwardFunc[T]

CosBackward returns a BackwardFunc for cosine gradients: ∂cos(x)/∂x = -sin(x).

func DivBackward 

func DivBackward[T candy.D]() BackwardFunc[T]

DivBackward returns a BackwardFunc for division gradients: ∂z/∂x = 1/y, ∂z/∂y = -x/y².

func DropoutBackward 

func DropoutBackward[T candy.D](mask **Tensor[T]) BackwardFunc[T]

DropoutBackward returns a BackwardFunc for dropout gradients.

func EluBackward 

func EluBackward[T candy.D](alpha float64) BackwardFunc[T]

EluBackward returns a BackwardFunc for ELU gradients: ∂elu(x)/∂x = 1 if x >= 0, alpha*exp(x) if x < 0.

func EqBackward 

func EqBackward[T candy.D]() BackwardFunc[T]

EqBackward returns a BackwardFunc for equality gradients: ∂z/∂x = 0, ∂z/∂y = 0.

func ErfBackward 

func ErfBackward[T candy.D]() BackwardFunc[T]

ErfBackward returns a BackwardFunc for error function gradients: ∂erf(x)/∂x = (2/√π)exp(-x²).

func ExpBackward 

func ExpBackward[T candy.D]() BackwardFunc[T]

ExpBackward returns a BackwardFunc for exponential gradients: ∂exp(x)/∂x = exp(x).

func FastMaxBackward 

func FastMaxBackward[T candy.D]() BackwardFunc[T]

FastMaxBackward returns a BackwardFunc for maximum gradients over the last dimension.

func FastMinBackward 

func FastMinBackward[T candy.D]() BackwardFunc[T]

FastMinBackward returns a BackwardFunc for minimum gradients over the last dimension.

func FastSoftmaxBackward 

func FastSoftmaxBackward[T candy.D]() BackwardFunc[T]

FastSoftmaxBackward returns a BackwardFunc for softmax gradients.

func FlattenBackward 

func FlattenBackward[T candy.D](s *candy.Shape) BackwardFunc[T]

FlattenBackward returns a BackwardFunc for flatten gradients.

func FloorBackward 

func FloorBackward[T candy.D]() BackwardFunc[T]

FloorBackward returns a BackwardFunc for floor gradients: ∂floor(x)/∂x = 0.

func GatherBackward 

func GatherBackward[T candy.D](dim int) BackwardFunc[T]

GatherBackward returns a BackwardFunc for gather gradients.

func GeBackward 

func GeBackward[T candy.D]() BackwardFunc[T]

GeBackward returns a BackwardFunc for greater-than-or-equal gradients: ∂z/∂x = 0, ∂z/∂y = 0.

func GeluBackward 

func GeluBackward[T candy.D]() BackwardFunc[T]

GeluBackward returns a BackwardFunc for GELU gradients.

func GeluErfBackward 

func GeluErfBackward[T candy.D]() BackwardFunc[T]

GeluErfBackward returns a BackwardFunc for GELU (erf-based) gradients.

func GtBackward 

func GtBackward[T candy.D]() BackwardFunc[T]

GtBackward returns a BackwardFunc for greater-than gradients: ∂z/∂x = 0, ∂z/∂y = 0.

func LeBackward 

func LeBackward[T candy.D]() BackwardFunc[T]

LeBackward returns a BackwardFunc for less-than-or-equal gradients: ∂z/∂x = 0, ∂z/∂y = 0.

func LogBackward 

func LogBackward[T candy.D]() BackwardFunc[T]

LogBackward returns a BackwardFunc for logarithm gradients: ∂log(x)/∂x = 1/x.

func LtBackward 

func LtBackward[T candy.D]() BackwardFunc[T]

LtBackward returns a BackwardFunc for less-than gradients: ∂z/∂x = 0, ∂z/∂y = 0.

func MatMulBackward 

func MatMulBackward[T candy.D]() BackwardFunc[T]

MatMulBackward returns a BackwardFunc for matrix multiplication gradients: ∂z/∂x = g @ yᵀ, ∂z/∂y = xᵀ @ g.

func MaxPool2dBackward 

func MaxPool2dBackward[T candy.D](kH, kW, sH, sW int) BackwardFunc[T]

MaxPool2dBackward returns a BackwardFunc for 2D max pooling gradients.

func MaximumBackward 

func MaximumBackward[T candy.D]() BackwardFunc[T]

MaximumBackward returns a BackwardFunc for maximum gradients: ∂z/∂x = (x >= y) ? g : 0, ∂z/∂y = (y > x) ? g : 0.

func MinimumBackward 

func MinimumBackward[T candy.D]() BackwardFunc[T]

MinimumBackward returns a BackwardFunc for minimum gradients: ∂z/∂x = (x <= y) ? g : 0, ∂z/∂y = (y < x) ? g : 0.

func MulBackward 

func MulBackward[T candy.D]() BackwardFunc[T]

MulBackward returns a BackwardFunc for multiplication gradients: ∂z/∂x = y, ∂z/∂y = x.

func NeBackward 

func NeBackward[T candy.D]() BackwardFunc[T]

NeBackward returns a BackwardFunc for inequality gradients: ∂z/∂x = 0, ∂z/∂y = 0.

func NegBackward 

func NegBackward[T candy.D]() BackwardFunc[T]

NegBackward returns a BackwardFunc for negation gradients: ∂(-x)/∂x = -1.

func NormcdfBackward 

func NormcdfBackward[T candy.D]() BackwardFunc[T]

NormcdfBackward returns a BackwardFunc for normal CDF gradients: ∂Φ(x)/∂x = φ(x) = (1/√(2π))exp(-x²/2).

func PowfBackward 

func PowfBackward[T candy.D](p float64) BackwardFunc[T]

PowfBackward returns a BackwardFunc for power gradients: ∂(x^param)/∂x = param*x^(param-1).

func RecipBackward 

func RecipBackward[T candy.D]() BackwardFunc[T]

RecipBackward returns a BackwardFunc for reciprocal gradients: ∂(1/x)/∂x = -1/x².

func ReduceMaxBackward 

func ReduceMaxBackward[T candy.D](dim int, keepdim bool) BackwardFunc[T]

ReduceMaxBackward returns a BackwardFunc for maximum gradients along a specified dimension.

func ReduceMeanBackward 

func ReduceMeanBackward[T candy.D](dims []int, keepdim bool) BackwardFunc[T]

ReduceMeanBackward returns a BackwardFunc for mean gradients along specified dimensions.

func ReduceMinBackward 

func ReduceMinBackward[T candy.D](dim int, keepdim bool) BackwardFunc[T]

ReduceMinBackward returns a BackwardFunc for minimum gradients along a specified dimension.

func ReduceSumBackward 

func ReduceSumBackward[T candy.D](dims []int, keepdim bool) BackwardFunc[T]

ReduceSumBackward returns a BackwardFunc for sum gradients.

func ReluBackward 

func ReluBackward[T candy.D]() BackwardFunc[T]

ReluBackward returns a BackwardFunc for ReLU gradients: ∂relu(x)/∂x = x > 0 ? 1 : 0.

func ReshapeBackward 

func ReshapeBackward[T candy.D](s *candy.Shape) BackwardFunc[T]

ReshapeBackward returns a BackwardFunc for reshape gradients.

func RoundBackward 

func RoundBackward[T candy.D]() BackwardFunc[T]

RoundBackward returns a BackwardFunc for rounding gradients: ∂round(x)/∂x = 0.

func ScatterAddBackward 

func ScatterAddBackward[T candy.D](dim int) BackwardFunc[T]

ScatterAddBackward returns a BackwardFunc for scatter-add gradients.

func ScatterBackward 

func ScatterBackward[T candy.D](dim int) BackwardFunc[T]

ScatterBackward returns a BackwardFunc for scatter gradients.

func SigmoidBackward 

func SigmoidBackward[T candy.D]() BackwardFunc[T]

SigmoidBackward returns a BackwardFunc for sigmoid gradients: ∂σ(x)/∂x = σ(x)*(1-σ(x)).

func SignBackward 

func SignBackward[T candy.D]() BackwardFunc[T]

SignBackward returns a BackwardFunc for sign gradients: ∂sign(x)/∂x = 0.

func SiluBackward 

func SiluBackward[T candy.D]() BackwardFunc[T]

SiluBackward returns a BackwardFunc for SiLU gradients: ∂silu(x)/∂x = sigmoid(x) + x*sigmoid(x)*(1-sigmoid(x)).

func SinBackward 

func SinBackward[T candy.D]() BackwardFunc[T]

SinBackward returns a BackwardFunc for sine gradients: ∂sin(x)/∂x = cos(x).

func SqrBackward 

func SqrBackward[T candy.D]() BackwardFunc[T]

SqrBackward returns a BackwardFunc for square gradients: ∂(x²)/∂x = 2x.

func SqrtBackward 

func SqrtBackward[T candy.D]() BackwardFunc[T]

SqrtBackward returns a BackwardFunc for square root gradients: ∂√x/∂x = 1/(2√x).

func SqueezeBackward 

func SqueezeBackward[T candy.D](dim int) BackwardFunc[T]

SqueezeBackward returns a BackwardFunc for squeeze gradients.

func SubBackward 

func SubBackward[T candy.D]() BackwardFunc[T]

SubBackward returns a BackwardFunc for subtraction gradients: ∂z/∂x = 1, ∂z/∂y = -1.

func TanhBackward 

func TanhBackward[T candy.D]() BackwardFunc[T]

TanhBackward returns a BackwardFunc for hyperbolic tangent gradients: ∂tanh(x)/∂x = 1 - tanh²(x).

func TransposeBackward 

func TransposeBackward[T candy.D](dim1, dim2 int) BackwardFunc[T]

TransposeBackward returns a BackwardFunc for transpose gradients.

func UnsqueezeBackward 

func UnsqueezeBackward[T candy.D](dim int) BackwardFunc[T]

UnsqueezeBackward returns a BackwardFunc for unsqueeze gradients.

func UpsampleNearest2dBackward 

func UpsampleNearest2dBackward[T candy.D](h, w int) BackwardFunc[T]

UpsampleNearest2dBackward returns a BackwardFunc for 2D nearest neighbor upsampling gradients.

func WhereCondBackward 

func WhereCondBackward[T candy.D](c *Tensor[T]) BackwardFunc[T]

WhereCondBackward returns a BackwardFunc for conditional selection gradients.

type ForwardFunc 

type ForwardFunc[T candy.D] func([]*Tensor[T]) (*Tensor[T], error)

ForwardFunc defines a forward pass function for tensor operations.

func AbsForward 

func AbsForward[T candy.D]() ForwardFunc[T]

AbsForward returns a ForwardFunc for element-wise absolute value: |x|.

func AddForward 

func AddForward[T candy.D]() ForwardFunc[T]

AddForward returns a ForwardFunc for element-wise addition: x + y.

func AffineForward 

func AffineForward[T candy.D](scale, bias float64) ForwardFunc[T]

AffineForward returns a ForwardFunc for affine transformation: y = scale * x + bias.

func AvgPool2dForward 

func AvgPool2dForward[T candy.D](kH, kW, sH, sW int) ForwardFunc[T]

AvgPool2dForward returns a ForwardFunc for 2D average pooling.

func BroadcastAddForward 

func BroadcastAddForward[T candy.D]() ForwardFunc[T]

BroadcastAddForward returns a ForwardFunc for broadcasted addition: x + y.

func BroadcastAsForward 

func BroadcastAsForward[T candy.D](s *candy.Shape) ForwardFunc[T]

BroadcastAsForward returns a ForwardFunc for broadcasting to a target shape.

func BroadcastDivForward 

func BroadcastDivForward[T candy.D]() ForwardFunc[T]

BroadcastDivForward returns a ForwardFunc for broadcasted division: x / y.

func BroadcastEqForward 

func BroadcastEqForward[T candy.D]() ForwardFunc[T]

BroadcastEqForward returns a ForwardFunc for broadcasted equality: x == y.

func BroadcastGeForward 

func BroadcastGeForward[T candy.D]() ForwardFunc[T]

BroadcastGeForward returns a ForwardFunc for broadcasted greater-than-or-equal: x >= y.

func BroadcastGtForward 

func BroadcastGtForward[T candy.D]() ForwardFunc[T]

BroadcastGtForward returns a ForwardFunc for broadcasted greater-than: x > y.

func BroadcastLeForward 

func BroadcastLeForward[T candy.D]() ForwardFunc[T]

BroadcastLeForward returns a ForwardFunc for broadcasted less-than-or-equal: x <= y.

func BroadcastLtForward 

func BroadcastLtForward[T candy.D]() ForwardFunc[T]

BroadcastLtForward returns a ForwardFunc for broadcasted less-than: x < y.

func BroadcastMaximumForward 

func BroadcastMaximumForward[T candy.D]() ForwardFunc[T]

BroadcastMaximumForward returns a ForwardFunc for broadcasted maximum: max(x, y).

func BroadcastMinimumForward 

func BroadcastMinimumForward[T candy.D]() ForwardFunc[T]

BroadcastMinimumForward returns a ForwardFunc for broadcasted minimum: min(x, y).

func BroadcastMulForward 

func BroadcastMulForward[T candy.D]() ForwardFunc[T]

BroadcastMulForward returns a ForwardFunc for broadcasted multiplication: x * y.

func BroadcastNeForward 

func BroadcastNeForward[T candy.D]() ForwardFunc[T]

BroadcastNeForward returns a ForwardFunc for broadcasted inequality: x != y.

func BroadcastSubForward 

func BroadcastSubForward[T candy.D]() ForwardFunc[T]

BroadcastSubForward returns a ForwardFunc for broadcasted subtraction: x - y.

func CeilForward 

func CeilForward[T candy.D]() ForwardFunc[T]

CeilForward returns a ForwardFunc for element-wise ceiling: ceil(x).

func Conv1dForward 

func Conv1dForward[T candy.D](p *candy.Conv1DParams) ForwardFunc[T]

Conv1dForward returns a ForwardFunc for 1D convolution.

func Conv2dForward 

func Conv2dForward[T candy.D](p *candy.Conv2DParams) ForwardFunc[T]

Conv2dForward returns a ForwardFunc for 2D convolution.

func ConvTranspose1dForward 

func ConvTranspose1dForward[T candy.D](p *candy.ConvT1DParams) ForwardFunc[T]

ConvTranspose1dForward returns a ForwardFunc for 1D transposed convolution.

func ConvTranspose2dForward 

func ConvTranspose2dForward[T candy.D](p *candy.ConvT2DParams) ForwardFunc[T]

ConvTranspose2dForward returns a ForwardFunc for 2D transposed convolution.

func CopyForward 

func CopyForward[T candy.D]() ForwardFunc[T]

CopyForward returns a ForwardFunc for tensor cloning: y = x.

func CosForward 

func CosForward[T candy.D]() ForwardFunc[T]

CosForward returns a ForwardFunc for element-wise cosine: cos(x).

func DivForward 

func DivForward[T candy.D]() ForwardFunc[T]

DivForward returns a ForwardFunc for element-wise division: x / y.

func DropoutForward 

func DropoutForward[T candy.D](dropProb float64, mask **Tensor[T]) ForwardFunc[T]

DropoutForward returns a ForwardFunc for dropout.

func EluForward 

func EluForward[T candy.D](alpha float64) ForwardFunc[T]

EluForward returns a ForwardFunc for element-wise ELU: x if x >= 0, alpha*(exp(x)-1) if x < 0.

func EqForward 

func EqForward[T candy.D]() ForwardFunc[T]

EqForward returns a ForwardFunc for element-wise equality: x == y.

func ErfForward 

func ErfForward[T candy.D]() ForwardFunc[T]

ErfForward returns a ForwardFunc for element-wise error function: erf(x).

func ExpForward 

func ExpForward[T candy.D]() ForwardFunc[T]

ExpForward returns a ForwardFunc for element-wise exponential: exp(x).

func FastMaxForward 

func FastMaxForward[T candy.D]() ForwardFunc[T]

FastMaxForward returns a ForwardFunc for maximum over the last dimension.

func FastMinForward 

func FastMinForward[T candy.D]() ForwardFunc[T]

FastMinForward returns a ForwardFunc for minimum over the last dimension.

func FastSoftmaxForward 

func FastSoftmaxForward[T candy.D]() ForwardFunc[T]

FastSoftmaxForward returns a ForwardFunc for softmax along the last dimension.

func FlattenForward 

func FlattenForward[T candy.D](s, e int) ForwardFunc[T]

FlattenForward returns a ForwardFunc for flattening from start to end dimension.

func FloorForward 

func FloorForward[T candy.D]() ForwardFunc[T]

FloorForward returns a ForwardFunc for element-wise floor: floor(x).

func GatherForward 

func GatherForward[T candy.D](dim int) ForwardFunc[T]

GatherForward returns a ForwardFunc for gathering elements along a dimension.

func GeForward 

func GeForward[T candy.D]() ForwardFunc[T]

GeForward returns a ForwardFunc for element-wise greater-than-or-equal: x >= y.

func GeluErfForward 

func GeluErfForward[T candy.D]() ForwardFunc[T]

GeluErfForward returns a ForwardFunc for element-wise GELU (erf-based): gelu_erf(x).

func GeluForward 

func GeluForward[T candy.D]() ForwardFunc[T]

GeluForward returns a ForwardFunc for element-wise GELU: gelu(x).

func GtForward 

func GtForward[T candy.D]() ForwardFunc[T]

GtForward returns a ForwardFunc for element-wise greater-than: x > y.

func LeForward 

func LeForward[T candy.D]() ForwardFunc[T]

LeForward returns a ForwardFunc for element-wise less-than-or-equal: x <= y.

func LogForward 

func LogForward[T candy.D]() ForwardFunc[T]

LogForward returns a ForwardFunc for element-wise natural logarithm: log(x).

func LtForward 

func LtForward[T candy.D]() ForwardFunc[T]

LtForward returns a ForwardFunc for element-wise less-than: x < y.

func MatMulForward 

func MatMulForward[T candy.D]() ForwardFunc[T]

MatMulForward returns a ForwardFunc for matrix multiplication: x @ y.

func MaxPool2dForward 

func MaxPool2dForward[T candy.D](kH, kW, sH, sW int) ForwardFunc[T]

MaxPool2dForward returns a ForwardFunc for 2D max pooling.

func MaximumForward 

func MaximumForward[T candy.D]() ForwardFunc[T]

MaximumForward returns a ForwardFunc for element-wise maximum: max(x, y).

func MinimumForward 

func MinimumForward[T candy.D]() ForwardFunc[T]

MinimumForward returns a ForwardFunc for element-wise minimum: min(x, y).

func MulForward 

func MulForward[T candy.D]() ForwardFunc[T]

MulForward returns a ForwardFunc for element-wise multiplication: x * y.

func NeForward 

func NeForward[T candy.D]() ForwardFunc[T]

NeForward returns a ForwardFunc for element-wise inequality: x != y.

func NegForward 

func NegForward[T candy.D]() ForwardFunc[T]

NegForward returns a ForwardFunc for element-wise negation: -x.

func NormcdfForward 

func NormcdfForward[T candy.D]() ForwardFunc[T]

NormcdfForward returns a ForwardFunc for element-wise normal CDF: Φ(x).

func PowfForward 

func PowfForward[T candy.D](p float64) ForwardFunc[T]

PowfForward returns a ForwardFunc for element-wise power: x^param.

func RecipForward 

func RecipForward[T candy.D]() ForwardFunc[T]

RecipForward returns a ForwardFunc for element-wise reciprocal: 1/x.

func ReduceMaxForward 

func ReduceMaxForward[T candy.D](dim int, keepdim bool) ForwardFunc[T]

ReduceMaxForward returns a ForwardFunc for computing the maximum along a specified dimension.

func ReduceMeanForward 

func ReduceMeanForward[T candy.D](dims []int, keepdim bool) ForwardFunc[T]

ReduceMeanForward returns a ForwardFunc for computing the mean along specified dimensions.

func ReduceMinForward 

func ReduceMinForward[T candy.D](dim int, keepdim bool) ForwardFunc[T]

ReduceMinForward returns a ForwardFunc for computing the minimum along a specified dimension.

func ReduceSumForward 

func ReduceSumForward[T candy.D](dims []int, keepdim bool) ForwardFunc[T]

ReduceSumForward returns a ForwardFunc for summing along specified dimensions.

func ReluForward 

func ReluForward[T candy.D]() ForwardFunc[T]

ReluForward returns a ForwardFunc for element-wise ReLU: max(0, x).

func ReshapeForward 

func ReshapeForward[T candy.D](s *candy.Shape) ForwardFunc[T]

ReshapeForward returns a ForwardFunc for reshaping to a new shape.

func RoundForward 

func RoundForward[T candy.D]() ForwardFunc[T]

RoundForward returns a ForwardFunc for element-wise rounding: round(x).

func ScatterAddForward 

func ScatterAddForward[T candy.D](dim int) ForwardFunc[T]

func ScatterForward 

func ScatterForward[T candy.D](dim int) ForwardFunc[T]

ScatterForward returns a ForwardFunc for scattering source elements into a destination tensor along a dimension.

func SigmoidForward 

func SigmoidForward[T candy.D]() ForwardFunc[T]

SigmoidForward returns a ForwardFunc for element-wise sigmoid: σ(x) = 1/(1+exp(-x)).

func SignForward 

func SignForward[T candy.D]() ForwardFunc[T]

SignForward returns a ForwardFunc for element-wise sign: sign(x).

func SiluForward 

func SiluForward[T candy.D]() ForwardFunc[T]

SiluForward returns a ForwardFunc for element-wise SiLU: x * sigmoid(x).

func SinForward 

func SinForward[T candy.D]() ForwardFunc[T]

SinForward returns a ForwardFunc for element-wise sine: sin(x).

func SqrForward 

func SqrForward[T candy.D]() ForwardFunc[T]

SqrForward returns a ForwardFunc for element-wise square: x².

func SqrtForward 

func SqrtForward[T candy.D]() ForwardFunc[T]

SqrtForward returns a ForwardFunc for element-wise square root: √x.

func SqueezeForward 

func SqueezeForward[T candy.D](dim int) ForwardFunc[T]

SqueezeForward returns a ForwardFunc for squeezing a dimension.

func SubForward 

func SubForward[T candy.D]() ForwardFunc[T]

SubForward returns a ForwardFunc for element-wise subtraction: x - y.

func TanhForward 

func TanhForward[T candy.D]() ForwardFunc[T]

TanhForward returns a ForwardFunc for element-wise hyperbolic tangent: tanh(x).

func TransposeForward 

func TransposeForward[T candy.D](dim1, dim2 int) ForwardFunc[T]

TransposeForward returns a ForwardFunc for transposing dimensions.

func UnsqueezeForward 

func UnsqueezeForward[T candy.D](dim int) ForwardFunc[T]

UnsqueezeForward returns a ForwardFunc for unsqueezing a dimension.

func UpsampleNearest2dForward 

func UpsampleNearest2dForward[T candy.D](h, w int) ForwardFunc[T]

UpsampleNearest2dForward returns a ForwardFunc for 2D nearest neighbor upsampling.

func WhereCondForward 

func WhereCondForward[T candy.D](c *Tensor[T]) ForwardFunc[T]

WhereCondForward returns a ForwardFunc for conditional selection: c ? t : f.

type GradStore 

type GradStore[T candy.D] struct {
	// contains filtered or unexported fields
}

GradStore maps tensor IDs to their gradient tensors for backpropagation.

func NewGradStore 

func NewGradStore[T candy.D]() *GradStore[T]

NewGradStore returns a new gradient store.

func (*GradStore[T]) Clear 

func (s *GradStore[T]) Clear()

Clear removes all gradient tensors from the store.

func (*GradStore[T]) Delete 

func (s *GradStore[T]) Delete(t *Tensor[T]) (*Tensor[T], bool)

Delete deletes the gradient tensor for the given tensor, returning it and whether it existed.

func (*GradStore[T]) DeleteByID 

func (s *GradStore[T]) DeleteByID(id TensorID) (*Tensor[T], bool)

DeleteByID deletes the gradient tensor for the given ID, returning it and whether it existed.

func (*GradStore[T]) Get 

func (s *GradStore[T]) Get(t *Tensor[T]) *Tensor[T]

Get returns the gradient tensor for the given tensor, or nil if not found.

func (*GradStore[T]) GetByID 

func (s *GradStore[T]) GetByID(id TensorID) *Tensor[T]

GetByID returns the gradient tensor for the given ID, or nil if not found.

func (*GradStore[T]) GetOrCreate 

func (s *GradStore[T]) GetOrCreate(t *Tensor[T]) (*Tensor[T], error)

GetOrCreate returns the gradient tensor for the given tensor, creating a zero-filled tensor if none exists.

func (*GradStore[T]) IDs 

func (s *GradStore[T]) IDs() []TensorID

IDs returns all stored gradient tensor IDs.

func (*GradStore[T]) Len 

func (s *GradStore[T]) Len() int

Len returns the number of gradient tensors currently stored.

func (*GradStore[T]) Set 

func (s *GradStore[T]) Set(t *Tensor[T], grad *Tensor[T]) (*Tensor[T], bool)

Set sets the gradient tensor for the given tensor, returning the previous gradient and whether it existed.

func (*GradStore[T]) SetByID 

func (s *GradStore[T]) SetByID(id TensorID, grad *Tensor[T]) (*Tensor[T], bool)

SetByID sets the gradient tensor for the given ID, returning the previous gradient and whether it existed.

type Op 

type Op[T candy.D] struct {
	// contains filtered or unexported fields
}

Op holds the computation graph node for automatic differentiation.

func (*Op[T]) Backward 

func (op *Op[T]) Backward(grad *Tensor[T], inputs []*Tensor[T]) ([]*Tensor[T], error)

Backward computes the gradients for the operation.

func (*Op[T]) Inputs 

func (op *Op[T]) Inputs() []*Tensor[T]

Inputs returns the input tensors of the operation.

type Tensor 

type Tensor[T candy.D] struct {
	// contains filtered or unexported fields
}

Tensor is a multi-dimensional array supporting autograd.

func ApplyOp 

func ApplyOp[T candy.D](inputs []*Tensor[T], forward ForwardFunc[T], backward BackwardFunc[T]) (*Tensor[T], error)

ApplyOp applies a forward function and builds the computation graph if needed.

func Full 

func Full[T candy.D](value float64, shape *candy.Shape, dev candy.Device) (*Tensor[T], error)

Full creates a tensor filled with value.

func MustFull 

func MustFull[T candy.D](value float64, shape *candy.Shape, dev candy.Device) *Tensor[T]

MustFull creates tensor filled with value, panics on error.

func MustNew 

func MustNew[T candy.D](data []T, shape *candy.Shape, dev candy.Device) *Tensor[T]

MustNew creates tensor from data and shape, panics on error.

func MustOnes 

func MustOnes[T candy.D](shape *candy.Shape, dev candy.Device) *Tensor[T]

MustOnes creates tensor filled with ones, panics on error.

func MustRand 

func MustRand[T candy.D](lo, up float64, shape *candy.Shape, dev candy.Device) *Tensor[T]

MustRand creates tensor with uniform samples, panics on error.

func MustRandN 

func MustRandN[T candy.D](mean, std float64, shape *candy.Shape, dev candy.Device) *Tensor[T]

MustRandN creates tensor with normal samples, panics on error.

func MustReadNPY 

func MustReadNPY[T candy.D](path string) *Tensor[T]

func MustReadNPZByName 

func MustReadNPZByName(path string, names []string) []*Tensor[float32]

func MustZeros 

func MustZeros[T candy.D](shape *candy.Shape, dev candy.Device) *Tensor[T]

MustZeros creates tensor filled with zeros, panics on error.

func New 

func New[T candy.D](data []T, shape *candy.Shape, dev candy.Device) (*Tensor[T], error)

New creates a tensor from data and shape on device.

func NewFrom 

func NewFrom[T candy.D](storage candy.BackendStorage[T], layout *candy.Layout, dtype candy.DType, dev candy.Device) *Tensor[T]

NewFrom creates a tensor from storage and layout.

func Ones 

func Ones[T candy.D](shape *candy.Shape, dev candy.Device) (*Tensor[T], error)

Ones creates a tensor filled with ones.

func Rand 

func Rand[T candy.D](lo, up float64, shape *candy.Shape, dev candy.Device) (*Tensor[T], error)

Rand creates a tensor with uniform samples in [lo, up).

func RandN 

func RandN[T candy.D](mean, std float64, shape *candy.Shape, dev candy.Device) (*Tensor[T], error)

RandN creates a tensor with normal distribution samples.

func ReadNPY 

func ReadNPY[T candy.D](path string) (*Tensor[T], error)

func ReadNPZByName 

func ReadNPZByName[T candy.D](path string, names []string) ([]*Tensor[T], error)

func ReduceBroadcastGrad 

func ReduceBroadcastGrad[T candy.D](g *Tensor[T], dims []int) (*Tensor[T], error)

ReduceBroadcastGrad reduces a broadcasted gradient to the target shape.

func ToDtype 

func ToDtype[T, U candy.D](t *Tensor[T], dtype candy.DType) (*Tensor[U], error)

ToDtype converts to new dtype.

func Zeros 

func Zeros[T candy.D](shape *candy.Shape, dev candy.Device) (*Tensor[T], error)

Zeros creates a tensor filled with zeros.

func (*Tensor[T]) Abs 

func (t *Tensor[T]) Abs() (*Tensor[T], error)

Abs absolutes element-wise.

func (*Tensor[T]) AdaptiveAvgPool2d 

func (t *Tensor[T]) AdaptiveAvgPool2d(outH, outW int) (*Tensor[T], error)

AdaptiveAvgPool2d computes kernel and stride to produce exact outH×outW output, then calls AvgPool2d.

func (*Tensor[T]) Add 

func (t *Tensor[T]) Add(other *Tensor[T]) (*Tensor[T], error)

Add adds element-wise.

func (*Tensor[T]) AddScalar 

func (t *Tensor[T]) AddScalar(s float64) (*Tensor[T], error)

AddScalar adds scalar using affine.

func (*Tensor[T]) Affine 

func (t *Tensor[T]) Affine(scale, bias float64) (*Tensor[T], error)

Affine applies y = scale * x + bias.

func (*Tensor[T]) AvgPool2d 

func (t *Tensor[T]) AvgPool2d(kH, kW, sH, sW int) (*Tensor[T], error)

AvgPool2d applies 2D average pooling.

func (*Tensor[T]) Backward 

func (t *Tensor[T]) Backward() (*GradStore[T], error)

Backward computes gradients.

func (*Tensor[T]) BroadcastAdd 

func (t *Tensor[T]) BroadcastAdd(other *Tensor[T]) (*Tensor[T], error)

BroadcastAdd adds with broadcast.

func (*Tensor[T]) BroadcastAs 

func (t *Tensor[T]) BroadcastAs(s *candy.Shape) (*Tensor[T], error)

BroadcastAs broadcasts to shape.

func (*Tensor[T]) BroadcastClamp 

func (t *Tensor[T]) BroadcastClamp(minT, maxT *Tensor[T]) (*Tensor[T], error)

BroadcastClamp clamps values between broadcastable tensor bounds.

func (*Tensor[T]) BroadcastDiv 

func (t *Tensor[T]) BroadcastDiv(other *Tensor[T]) (*Tensor[T], error)

BroadcastDiv divides with broadcast.

func (*Tensor[T]) BroadcastEq 

func (t *Tensor[T]) BroadcastEq(other *Tensor[T]) (*Tensor[T], error)

BroadcastEq equals with broadcast.

func (*Tensor[T]) BroadcastGe 

func (t *Tensor[T]) BroadcastGe(other *Tensor[T]) (*Tensor[T], error)

BroadcastGe greater-equal with broadcast.

func (*Tensor[T]) BroadcastGt 

func (t *Tensor[T]) BroadcastGt(other *Tensor[T]) (*Tensor[T], error)

BroadcastGt greater-than with broadcast.

func (*Tensor[T]) BroadcastLe 

func (t *Tensor[T]) BroadcastLe(other *Tensor[T]) (*Tensor[T], error)

BroadcastLe less-equal with broadcast.

func (*Tensor[T]) BroadcastLeft 

func (t *Tensor[T]) BroadcastLeft(ld ...int) (*Tensor[T], error)

BroadcastLeft adds left dims for broadcast.

func (*Tensor[T]) BroadcastLt 

func (t *Tensor[T]) BroadcastLt(other *Tensor[T]) (*Tensor[T], error)

BroadcastLt less-than with broadcast.

func (*Tensor[T]) BroadcastMaximum 

func (t *Tensor[T]) BroadcastMaximum(other *Tensor[T]) (*Tensor[T], error)

BroadcastMaximum takes max with broadcast.

func (*Tensor[T]) BroadcastMinimum 

func (t *Tensor[T]) BroadcastMinimum(other *Tensor[T]) (*Tensor[T], error)

BroadcastMinimum takes min with broadcast.

func (*Tensor[T]) BroadcastMul 

func (t *Tensor[T]) BroadcastMul(other *Tensor[T]) (*Tensor[T], error)

BroadcastMul multiplies with broadcast.

func (*Tensor[T]) BroadcastNe 

func (t *Tensor[T]) BroadcastNe(other *Tensor[T]) (*Tensor[T], error)

BroadcastNe not equals with broadcast.

func (*Tensor[T]) BroadcastSub 

func (t *Tensor[T]) BroadcastSub(other *Tensor[T]) (*Tensor[T], error)

BroadcastSub subtracts with broadcast.

func (*Tensor[T]) Ceil 

func (t *Tensor[T]) Ceil() (*Tensor[T], error)

Ceil ceilings element-wise.

func (*Tensor[T]) Clamp 

func (t *Tensor[T]) Clamp(minT, maxT *Tensor[T]) (*Tensor[T], error)

Clamp clamps values between tensor bounds.

func (*Tensor[T]) Clone 

func (t *Tensor[T]) Clone() (*Tensor[T], error)

Clone clones the tensor.

func (*Tensor[T]) Conv1d 

func (t *Tensor[T]) Conv1d(kernel *Tensor[T], params *candy.Conv1DParams) (*Tensor[T], error)

Conv1d applies 1D convolution.

func (*Tensor[T]) Conv2d 

func (t *Tensor[T]) Conv2d(kernel *Tensor[T], params *candy.Conv2DParams) (*Tensor[T], error)

Conv2d applies 2D convolution.

func (*Tensor[T]) ConvTranspose1d 

func (t *Tensor[T]) ConvTranspose1d(kernel *Tensor[T], params *candy.ConvT1DParams) (*Tensor[T], error)

ConvTranspose1d applies 1D transposed convolution.

func (*Tensor[T]) ConvTranspose2d 

func (t *Tensor[T]) ConvTranspose2d(kernel *Tensor[T], params *candy.ConvT2DParams) (*Tensor[T], error)

ConvTranspose2d applies 2D transposed convolution.

func (*Tensor[T]) Copy 

func (t *Tensor[T]) Copy() (*Tensor[T], error)

Copy copies the tensor.

func (*Tensor[T]) Cos 

func (t *Tensor[T]) Cos() (*Tensor[T], error)

Cos cosines element-wise.

func (*Tensor[T]) DType 

func (t *Tensor[T]) DType() candy.DType

DType returns the data type.

func (*Tensor[T]) Data 

func (t *Tensor[T]) Data() []T

Data returns CPU data slice, panics if not CPU.

func (*Tensor[T]) Detach 

func (t *Tensor[T]) Detach() *Tensor[T]

Detach detaches from graph.

func (*Tensor[T]) Device 

func (t *Tensor[T]) Device() candy.Device

Device returns the device.

func (*Tensor[T]) Dim 

func (t *Tensor[T]) Dim(dim int) int

Dim returns size of dimension.

func (*Tensor[T]) Dims 

func (t *Tensor[T]) Dims() []int

Dims returns dimensions.

func (*Tensor[T]) Dims0 

func (t *Tensor[T]) Dims0() error

Dims0 validates scalar (0 dims).

func (*Tensor[T]) Dims1 

func (t *Tensor[T]) Dims1() (int, error)

Dims1 extracts 1D dimension.

func (*Tensor[T]) Dims2 

func (t *Tensor[T]) Dims2() (int, int, error)

Dims2 extracts 2D dimensions.

func (*Tensor[T]) Dims3 

func (t *Tensor[T]) Dims3() (int, int, int, error)

Dims3 extracts 3D dimensions.

func (*Tensor[T]) Dims4 

func (t *Tensor[T]) Dims4() (int, int, int, int, error)

Dims4 extracts 4D dimensions.

func (*Tensor[T]) Dims5 

func (t *Tensor[T]) Dims5() (int, int, int, int, int, error)

Dims5 extracts 5D dimensions.

func (*Tensor[T]) Div 

func (t *Tensor[T]) Div(other *Tensor[T]) (*Tensor[T], error)

Div divides element-wise.

func (*Tensor[T]) DivScalar 

func (t *Tensor[T]) DivScalar(s float64) (*Tensor[T], error)

DivScalar divides by scalar using affine.

func (*Tensor[T]) Dropout 

func (x *Tensor[T]) Dropout(dropProb float64) (*Tensor[T], error)

Dropout randomly zeroes elements with probability dropProb and rescales the remainder.

func (*Tensor[T]) Elu 

func (t *Tensor[T]) Elu(alpha float64) (*Tensor[T], error)

Elu applies ELU activation.

func (*Tensor[T]) Eq 

func (t *Tensor[T]) Eq(other *Tensor[T]) (*Tensor[T], error)

Eq compares equality element-wise.

func (*Tensor[T]) Erf 

func (t *Tensor[T]) Erf() (*Tensor[T], error)

Erf error functions element-wise.

func (*Tensor[T]) Exp 

func (t *Tensor[T]) Exp() (*Tensor[T], error)

Exp exponentiates element-wise.

func (*Tensor[T]) Expand 

func (t *Tensor[T]) Expand(s *candy.Shape) (*Tensor[T], error)

Expand expands to shape.

func (*Tensor[T]) FastMax 

func (t *Tensor[T]) FastMax() (*Tensor[T], error)

FastMax maxes over last dim.

func (*Tensor[T]) FastMin 

func (t *Tensor[T]) FastMin() (*Tensor[T], error)

FastMin mins over last dim.

func (*Tensor[T]) FastSoftmax 

func (t *Tensor[T]) FastSoftmax() (*Tensor[T], error)

FastSoftmax soft maxes over last dim.

func (*Tensor[T]) Flatten 

func (t *Tensor[T]) Flatten(start, end int) (*Tensor[T], error)

Flatten flattens from start to end dim.

func (*Tensor[T]) FlattenAll 

func (t *Tensor[T]) FlattenAll() (*Tensor[T], error)

FlattenAll flattens to 1D.

func (*Tensor[T]) Floor 

func (t *Tensor[T]) Floor() (*Tensor[T], error)

Floor floors element-wise.

func (*Tensor[T]) FullLike 

func (t *Tensor[T]) FullLike(value float64) (*Tensor[T], error)

FullLike creates like t, filled with value.

func (*Tensor[T]) Gather 

func (t *Tensor[T]) Gather(idx *Tensor[T], dim int) (*Tensor[T], error)

Gather gathers along dimension.

func (*Tensor[T]) Ge 

func (t *Tensor[T]) Ge(other *Tensor[T]) (*Tensor[T], error)

Ge compares greater-equal element-wise.

func (*Tensor[T]) Gelu 

func (t *Tensor[T]) Gelu() (*Tensor[T], error)

Gelu applies GELU activation.

func (*Tensor[T]) GeluErf 

func (t *Tensor[T]) GeluErf() (*Tensor[T], error)

GeluErf applies ERF-based GELU.

func (*Tensor[T]) Gt 

func (t *Tensor[T]) Gt(other *Tensor[T]) (*Tensor[T], error)

Gt compares greater-than element-wise.

func (*Tensor[T]) ID 

func (t *Tensor[T]) ID() TensorID

ID returns the unique identifier.

func (*Tensor[T]) IsVar 

func (t *Tensor[T]) IsVar() bool

IsVar checks if gradient is required.

func (*Tensor[T]) Layout 

func (t *Tensor[T]) Layout() *candy.Layout

Layout returns a cloned layout.

func (*Tensor[T]) Le 

func (t *Tensor[T]) Le(other *Tensor[T]) (*Tensor[T], error)

Le compares less-equal element-wise.

func (*Tensor[T]) Log 

func (t *Tensor[T]) Log() (*Tensor[T], error)

Log logs element-wise (natural).

func (*Tensor[T]) LogSoftmax 

func (x *Tensor[T]) LogSoftmax(dim int) (*Tensor[T], error)

LogSoftmax computes the log-softmax along the specified dimension.

func (*Tensor[T]) Lt 

func (t *Tensor[T]) Lt(other *Tensor[T]) (*Tensor[T], error)

Lt compares less-than element-wise.

func (*Tensor[T]) MatMul 

func (t *Tensor[T]) MatMul(rhs *Tensor[T]) (*Tensor[T], error)

MatMul multiplies matrices.

func (*Tensor[T]) Max 

func (t *Tensor[T]) Max(dim int) (*Tensor[T], error)

Max computes maximum along dims, removes dims.

func (*Tensor[T]) MaxKeep 

func (t *Tensor[T]) MaxKeep(dim int) (*Tensor[T], error)

MaxKeep computes maximum along dims, keeps size 1.

func (*Tensor[T]) MaxPool2d 

func (t *Tensor[T]) MaxPool2d(kH, kW, sH, sW int) (*Tensor[T], error)

MaxPool2d applies 2D max pooling.

func (*Tensor[T]) Maximum 

func (t *Tensor[T]) Maximum(other *Tensor[T]) (*Tensor[T], error)

Maximum takes element-wise max.

func (*Tensor[T]) Mean 

func (t *Tensor[T]) Mean(dims []int) (*Tensor[T], error)

Mean computes mean along dims, removes dims.

func (*Tensor[T]) MeanAll 

func (t *Tensor[T]) MeanAll() (*Tensor[T], error)

MeanAll computes mean of all elements.

func (*Tensor[T]) MeanKeep 

func (t *Tensor[T]) MeanKeep(dims []int) (*Tensor[T], error)

MeanKeep computes mean along dims, keeps size 1.

func (*Tensor[T]) Min 

func (t *Tensor[T]) Min(dim int) (*Tensor[T], error)

Min computes minimum along dims, removes dims.

func (*Tensor[T]) MinKeep 

func (t *Tensor[T]) MinKeep(dim int) (*Tensor[T], error)

MinKeep computes minimum along dims, keeps size 1.

func (*Tensor[T]) Minimum 

func (t *Tensor[T]) Minimum(other *Tensor[T]) (*Tensor[T], error)

Minimum takes element-wise min.

func (*Tensor[T]) Mul 

func (t *Tensor[T]) Mul(other *Tensor[T]) (*Tensor[T], error)

Mul multiplies element-wise.

func (*Tensor[T]) MulScalar 

func (t *Tensor[T]) MulScalar(s float64) (*Tensor[T], error)

MulScalar multiplies by scalar using affine.

func (*Tensor[T]) MustAbs 

func (t *Tensor[T]) MustAbs() *Tensor[T]

MustAbs absolutes, panics on error.

func (*Tensor[T]) MustAdaptiveAvgPool2d 

func (t *Tensor[T]) MustAdaptiveAvgPool2d(outH, outW int) *Tensor[T]

MustAdaptiveAvgPool2d applies AdaptiveAvgPool2d and panics on error.

func (*Tensor[T]) MustAdd 

func (t *Tensor[T]) MustAdd(other *Tensor[T]) *Tensor[T]

MustAdd adds element-wise, panics on error.

func (*Tensor[T]) MustAddScalar 

func (t *Tensor[T]) MustAddScalar(s float64) *Tensor[T]

MustAddScalar adds scalar, panics on error.

func (*Tensor[T]) MustAffine 

func (t *Tensor[T]) MustAffine(scale, bias float64) *Tensor[T]

MustAffine applies affine, panics on error.

func (*Tensor[T]) MustAvgPool2d 

func (t *Tensor[T]) MustAvgPool2d(kH, kW, sH, sW int) *Tensor[T]

MustAvgPool2d applies 2D average pooling, panics on error.

func (*Tensor[T]) MustBackward 

func (t *Tensor[T]) MustBackward() *GradStore[T]

MustBackward computes gradients, panics on error.

func (*Tensor[T]) MustBroadcastAdd 

func (t *Tensor[T]) MustBroadcastAdd(other *Tensor[T]) *Tensor[T]

MustBroadcastAdd adds with broadcast, panics on error.

func (*Tensor[T]) MustBroadcastAs 

func (t *Tensor[T]) MustBroadcastAs(s *candy.Shape) *Tensor[T]

MustBroadcastAs broadcasts to shape, panics on error.

func (*Tensor[T]) MustBroadcastClamp 

func (t *Tensor[T]) MustBroadcastClamp(minT, maxT *Tensor[T]) *Tensor[T]

MustBroadcastClamp clamps between broadcastable bounds, panics on error.

func (*Tensor[T]) MustBroadcastDiv 

func (t *Tensor[T]) MustBroadcastDiv(other *Tensor[T]) *Tensor[T]

MustBroadcastDiv divides with broadcast, panics on error.

func (*Tensor[T]) MustBroadcastEq 

func (t *Tensor[T]) MustBroadcastEq(other *Tensor[T]) *Tensor[T]

MustBroadcastEq equals with broadcast, panics on error.

func (*Tensor[T]) MustBroadcastGe 

func (t *Tensor[T]) MustBroadcastGe(other *Tensor[T]) *Tensor[T]

MustBroadcastGe greater-equal with broadcast, panics on error.

func (*Tensor[T]) MustBroadcastGt 

func (t *Tensor[T]) MustBroadcastGt(other *Tensor[T]) *Tensor[T]

MustBroadcastGt greater-than with broadcast, panics on error.

func (*Tensor[T]) MustBroadcastLe 

func (t *Tensor[T]) MustBroadcastLe(other *Tensor[T]) *Tensor[T]

MustBroadcastLe less-equal with broadcast, panics on error.

func (*Tensor[T]) MustBroadcastLeft 

func (t *Tensor[T]) MustBroadcastLeft(ld ...int) *Tensor[T]

MustBroadcastLeft adds left dims, panics on error.

func (*Tensor[T]) MustBroadcastLt 

func (t *Tensor[T]) MustBroadcastLt(other *Tensor[T]) *Tensor[T]

MustBroadcastLt less-than with broadcast, panics on error.

func (*Tensor[T]) MustBroadcastMaximum 

func (t *Tensor[T]) MustBroadcastMaximum(other *Tensor[T]) *Tensor[T]

MustBroadcastMaximum takes max with broadcast, panics on error.

func (*Tensor[T]) MustBroadcastMinimum 

func (t *Tensor[T]) MustBroadcastMinimum(other *Tensor[T]) *Tensor[T]

MustBroadcastMinimum takes min with broadcast, panics on error.

func (*Tensor[T]) MustBroadcastMul 

func (t *Tensor[T]) MustBroadcastMul(other *Tensor[T]) *Tensor[T]

MustBroadcastMul multiplies with broadcast, panics on error.

func (*Tensor[T]) MustBroadcastNe 

func (t *Tensor[T]) MustBroadcastNe(other *Tensor[T]) *Tensor[T]

MustBroadcastNe not equals with broadcast, panics on error.

func (*Tensor[T]) MustBroadcastSub 

func (t *Tensor[T]) MustBroadcastSub(other *Tensor[T]) *Tensor[T]

MustBroadcastSub subtracts with broadcast, panics on error.

func (*Tensor[T]) MustCeil 

func (t *Tensor[T]) MustCeil() *Tensor[T]

MustCeil ceilings, panics on error.

func (*Tensor[T]) MustClamp 

func (t *Tensor[T]) MustClamp(minT, maxT *Tensor[T]) *Tensor[T]

MustClamp clamps between tensor bounds, panics on error.

func (*Tensor[T]) MustClone 

func (t *Tensor[T]) MustClone() *Tensor[T]

MustClone clones, panics on error.

func (*Tensor[T]) MustConv1d 

func (t *Tensor[T]) MustConv1d(kernel *Tensor[T], params *candy.Conv1DParams) *Tensor[T]

MustConv1d applies 1D convolution, panics on error.

func (*Tensor[T]) MustConv2d 

func (t *Tensor[T]) MustConv2d(kernel *Tensor[T], params *candy.Conv2DParams) *Tensor[T]

MustConv2d applies 2D convolution, panics on error.

func (*Tensor[T]) MustConvTranspose1d 

func (t *Tensor[T]) MustConvTranspose1d(kernel *Tensor[T], params *candy.ConvT1DParams) *Tensor[T]

MustConvTranspose1d applies 1D transposed convolution, panics on error.

func (*Tensor[T]) MustConvTranspose2d 

func (t *Tensor[T]) MustConvTranspose2d(kernel *Tensor[T], params *candy.ConvT2DParams) *Tensor[T]

MustConvTranspose2d applies 2D transposed convolution, panics on error.

func (*Tensor[T]) MustCopy 

func (t *Tensor[T]) MustCopy() *Tensor[T]

MustCopy copies, panics on error.

func (*Tensor[T]) MustCos 

func (t *Tensor[T]) MustCos() *Tensor[T]

MustCos cosines, panics on error.

func (*Tensor[T]) MustDiv 

func (t *Tensor[T]) MustDiv(other *Tensor[T]) *Tensor[T]

MustDiv divides element-wise, panics on error.

func (*Tensor[T]) MustDivScalar 

func (t *Tensor[T]) MustDivScalar(s float64) *Tensor[T]

MustDivScalar divides by scalar, panics on error.

func (*Tensor[T]) MustDropout 

func (t *Tensor[T]) MustDropout(dropProb float64) *Tensor[T]

MustDropout drops out values, panics on error.

func (*Tensor[T]) MustElu 

func (t *Tensor[T]) MustElu(alpha float64) *Tensor[T]

MustElu applies ELU, panics on error.

func (*Tensor[T]) MustEq 

func (t *Tensor[T]) MustEq(other *Tensor[T]) *Tensor[T]

MustEq compares equality, panics on error.

func (*Tensor[T]) MustErf 

func (t *Tensor[T]) MustErf() *Tensor[T]

MustErf error functions, panics on error.

func (*Tensor[T]) MustExp 

func (t *Tensor[T]) MustExp() *Tensor[T]

MustExp exponentiates, panics on error.

func (*Tensor[T]) MustExpand 

func (t *Tensor[T]) MustExpand(s *candy.Shape) *Tensor[T]

MustExpand expands to shape, panics on error.

func (*Tensor[T]) MustFastMax 

func (t *Tensor[T]) MustFastMax() *Tensor[T]

MustFastMax maxes over last dim, panics on error.

func (*Tensor[T]) MustFastMin 

func (t *Tensor[T]) MustFastMin() *Tensor[T]

MustFastMin mins over last dim, panics on error.

func (*Tensor[T]) MustFastSoftmax 

func (t *Tensor[T]) MustFastSoftmax() *Tensor[T]

MustFastSoftmax soft maxes, panics on error.

func (*Tensor[T]) MustFlatten 

func (t *Tensor[T]) MustFlatten(start, end int) *Tensor[T]

MustFlatten flattens range, panics on error.

func (*Tensor[T]) MustFlattenAll 

func (t *Tensor[T]) MustFlattenAll() *Tensor[T]

MustFlattenAll flattens to 1D, panics on error.

func (*Tensor[T]) MustFloor 

func (t *Tensor[T]) MustFloor() *Tensor[T]

MustFloor floors, panics on error.

func (*Tensor[T]) MustFullLike 

func (t *Tensor[T]) MustFullLike(value float64) *Tensor[T]

MustFullLike creates like t filled with value, panics on error.

func (*Tensor[T]) MustGather 

func (t *Tensor[T]) MustGather(idx *Tensor[T], dim int) *Tensor[T]

MustGather gathers along dimension, panics on error.

func (*Tensor[T]) MustGe 

func (t *Tensor[T]) MustGe(other *Tensor[T]) *Tensor[T]

MustGe compares greater-equal, panics on error.

func (*Tensor[T]) MustGelu 

func (t *Tensor[T]) MustGelu() *Tensor[T]

MustGelu applies GELU, panics on error.

func (*Tensor[T]) MustGeluErf 

func (t *Tensor[T]) MustGeluErf() *Tensor[T]

MustGeluErf applies ERF GELU, panics on error.

func (*Tensor[T]) MustGt 

func (t *Tensor[T]) MustGt(other *Tensor[T]) *Tensor[T]

MustGt compares greater-than, panics on error.

func (*Tensor[T]) MustLe 

func (t *Tensor[T]) MustLe(other *Tensor[T]) *Tensor[T]

MustLe compares less-equal, panics on error.

func (*Tensor[T]) MustLog 

func (t *Tensor[T]) MustLog() *Tensor[T]

MustLog logs, panics on error.

func (*Tensor[T]) MustLogSoftmax 

func (t *Tensor[T]) MustLogSoftmax(dim int) *Tensor[T]

MustLogSoftmax log soft maxes, panics on error.

func (*Tensor[T]) MustLt 

func (t *Tensor[T]) MustLt(other *Tensor[T]) *Tensor[T]

MustLt compares less-than, panics on error.

func (*Tensor[T]) MustMatMul 

func (t *Tensor[T]) MustMatMul(rhs *Tensor[T]) *Tensor[T]

MustMatMul multiplies matrices, panics on error.

func (*Tensor[T]) MustMax 

func (t *Tensor[T]) MustMax(dim int) *Tensor[T]

MustMax computes maximum along dims, panics on error.

func (*Tensor[T]) MustMaxKeep 

func (t *Tensor[T]) MustMaxKeep(dim int) *Tensor[T]

MustMaxKeep computes maximum along dims, panics on error.

func (*Tensor[T]) MustMaxPool2d 

func (t *Tensor[T]) MustMaxPool2d(kH, kW, sH, sW int) *Tensor[T]

MustMaxPool2d applies 2D max pooling, panics on error.

func (*Tensor[T]) MustMaximum 

func (t *Tensor[T]) MustMaximum(other *Tensor[T]) *Tensor[T]

MustMaximum takes element-wise max, panics on error.

func (*Tensor[T]) MustMean 

func (t *Tensor[T]) MustMean(dims []int) *Tensor[T]

MustMean computes mean along dims, panics on error.

func (*Tensor[T]) MustMeanAll 

func (t *Tensor[T]) MustMeanAll() *Tensor[T]

MustMeanAll computes mean of all elements, panics on error.

func (*Tensor[T]) MustMeanKeep 

func (t *Tensor[T]) MustMeanKeep(dims []int) *Tensor[T]

MustMeanKeep computes mean along dims, panics on error.

func (*Tensor[T]) MustMin 

func (t *Tensor[T]) MustMin(dim int) *Tensor[T]

MustMin computes minimum along dims, panics on error.

func (*Tensor[T]) MustMinKeep 

func (t *Tensor[T]) MustMinKeep(dim int) *Tensor[T]

MustMinKeep computes minimum along dims, panics on error.

func (*Tensor[T]) MustMinimum 

func (t *Tensor[T]) MustMinimum(other *Tensor[T]) *Tensor[T]

MustMinimum takes element-wise min, panics on error.

func (*Tensor[T]) MustMul 

func (t *Tensor[T]) MustMul(other *Tensor[T]) *Tensor[T]

MustMul multiplies element-wise, panics on error.

func (*Tensor[T]) MustMulScalar 

func (t *Tensor[T]) MustMulScalar(s float64) *Tensor[T]

MustMulScalar multiplies by scalar, panics on error.

func (*Tensor[T]) MustNe 

func (t *Tensor[T]) MustNe(other *Tensor[T]) *Tensor[T]

MustNe compares inequality, panics on error.

func (*Tensor[T]) MustNeg 

func (t *Tensor[T]) MustNeg() *Tensor[T]

MustNeg negates, panics on error.

func (*Tensor[T]) MustNormcdf 

func (t *Tensor[T]) MustNormcdf() *Tensor[T]

MustNormcdf normal CDFs, panics on error.

func (*Tensor[T]) MustOnesLike 

func (t *Tensor[T]) MustOnesLike() *Tensor[T]

MustOnesLike creates like t filled with ones, panics on error.

func (*Tensor[T]) MustPowf 

func (t *Tensor[T]) MustPowf(p float64) *Tensor[T]

MustPowf powers, panics on error.

func (*Tensor[T]) MustRandLike 

func (t *Tensor[T]) MustRandLike(lo, up float64) *Tensor[T]

MustRandLike creates like t with uniform samples, panics on error.

func (*Tensor[T]) MustRandNLike 

func (t *Tensor[T]) MustRandNLike(mean, std float64) *Tensor[T]

MustRandNLike creates like t with normal samples, panics on error.

func (*Tensor[T]) MustRecip 

func (t *Tensor[T]) MustRecip() *Tensor[T]

MustRecip reciprocates, panics on error.

func (*Tensor[T]) MustReduceMax 

func (t *Tensor[T]) MustReduceMax(dim int, keep bool) *Tensor[T]

MustReduceMax computes maximum along dims, panics on error.

func (*Tensor[T]) MustReduceMean 

func (t *Tensor[T]) MustReduceMean(dims []int, keep bool) *Tensor[T]

MustReduceMean computes mean along dims, panics on error.

func (*Tensor[T]) MustReduceMin 

func (t *Tensor[T]) MustReduceMin(dim int, keep bool) *Tensor[T]

MustReduceMin computes minimum along dims, panics on error.

func (*Tensor[T]) MustReduceSum 

func (t *Tensor[T]) MustReduceSum(dims []int, keep bool) *Tensor[T]

MustReduceSum computes sum along dims, panics on error.

func (*Tensor[T]) MustRelu 

func (t *Tensor[T]) MustRelu() *Tensor[T]

MustRelu applies ReLU, panics on error.

func (*Tensor[T]) MustReshape 

func (t *Tensor[T]) MustReshape(d ...int) *Tensor[T]

MustReshape reshapes, panics on error.

func (*Tensor[T]) MustRound 

func (t *Tensor[T]) MustRound() *Tensor[T]

MustRound rounds, panics on error.

func (*Tensor[T]) MustScatter 

func (t *Tensor[T]) MustScatter(idx *Tensor[T], src *Tensor[T], dim int) *Tensor[T]

MustScatter scatters along dimension, panics on error.

func (*Tensor[T]) MustScatterAdd 

func (t *Tensor[T]) MustScatterAdd(idx *Tensor[T], src *Tensor[T], dim int) *Tensor[T]

MustScatterAdd performs scatter-add operation, panics on error.

func (*Tensor[T]) MustSigmoid 

func (t *Tensor[T]) MustSigmoid() *Tensor[T]

MustSigmoid applies sigmoid, panics on error.

func (*Tensor[T]) MustSign 

func (t *Tensor[T]) MustSign() *Tensor[T]

MustSign signs, panics on error.

func (*Tensor[T]) MustSilu 

func (t *Tensor[T]) MustSilu() *Tensor[T]

MustSilu applies SiLU, panics on error.

func (*Tensor[T]) MustSin 

func (t *Tensor[T]) MustSin() *Tensor[T]

MustSin sines, panics on error.

func (*Tensor[T]) MustSoftmax 

func (t *Tensor[T]) MustSoftmax(dim int) *Tensor[T]

MustSoftmax soft maxes, panics on error.

func (*Tensor[T]) MustSqr 

func (t *Tensor[T]) MustSqr() *Tensor[T]

MustSqr squares, panics on error.

func (*Tensor[T]) MustSqrt 

func (t *Tensor[T]) MustSqrt() *Tensor[T]

MustSqrt square roots, panics on error.

func (*Tensor[T]) MustSqueeze 

func (t *Tensor[T]) MustSqueeze(dim int) *Tensor[T]

MustSqueeze squeezes dim, panics on error.

func (*Tensor[T]) MustSub 

func (t *Tensor[T]) MustSub(other *Tensor[T]) *Tensor[T]

MustSub subtracts element-wise, panics on error.

func (*Tensor[T]) MustSubScalar 

func (t *Tensor[T]) MustSubScalar(s float64) *Tensor[T]

MustSubScalar subtracts scalar, panics on error.

func (*Tensor[T]) MustSum 

func (t *Tensor[T]) MustSum(dims []int) *Tensor[T]

MustSum computes sum along dims, panics on error.

func (*Tensor[T]) MustSumAll 

func (t *Tensor[T]) MustSumAll() *Tensor[T]

MustSumAll computes sum of all elements, panics on error.

func (*Tensor[T]) MustSumKeep 

func (t *Tensor[T]) MustSumKeep(dims []int) *Tensor[T]

MustSumKeep computes sum along dims, panics on error.

func (*Tensor[T]) MustT 

func (t *Tensor[T]) MustT() *Tensor[T]

MustT transposes last two, panics on error.

func (*Tensor[T]) MustTanh 

func (t *Tensor[T]) MustTanh() *Tensor[T]

MustTanh tangents, panics on error.

func (*Tensor[T]) MustToFloat32 

func (t *Tensor[T]) MustToFloat32() *Tensor[float32]

MustToFloat32 converts to float32, panics on error.

func (*Tensor[T]) MustToFloat64 

func (t *Tensor[T]) MustToFloat64() *Tensor[float64]

MustToFloat64 converts to float64, panics on error.

func (*Tensor[T]) MustToInt64 

func (t *Tensor[T]) MustToInt64() *Tensor[int64]

MustToInt64 converts to int64, panics on error.

func (*Tensor[T]) MustToUint32 

func (t *Tensor[T]) MustToUint32() *Tensor[uint32]

MustToUint32 converts to uint32, panics on error.

func (*Tensor[T]) MustToUint8 

func (t *Tensor[T]) MustToUint8() *Tensor[uint8]

MustToUint8 converts to uint8, panics on error.

func (*Tensor[T]) MustTranspose 

func (t *Tensor[T]) MustTranspose(d1, d2 int) *Tensor[T]

MustTranspose transposes, panics on error.

func (*Tensor[T]) MustUnsqueeze 

func (t *Tensor[T]) MustUnsqueeze(dim int) *Tensor[T]

MustUnsqueeze inserts dim, panics on error.

func (*Tensor[T]) MustUpsampleNearest2d 

func (t *Tensor[T]) MustUpsampleNearest2d(h, w int) *Tensor[T]

MustUpsampleNearest2d upsamples 2D, panics on error.

func (*Tensor[T]) MustWhereCond 

func (t *Tensor[T]) MustWhereCond(trueV, falseV *Tensor[T]) *Tensor[T]

MustWhereCond selects, panics on error.

func (*Tensor[T]) MustWriteNPY 

func (t *Tensor[T]) MustWriteNPY(path string)

func (*Tensor[T]) MustZerosLike 

func (t *Tensor[T]) MustZerosLike() *Tensor[T]

MustZerosLike creates like t filled with zeros, panics on error.

func (*Tensor[T]) Ne 

func (t *Tensor[T]) Ne(other *Tensor[T]) (*Tensor[T], error)

Ne compares inequality element-wise.

func (*Tensor[T]) Neg 

func (t *Tensor[T]) Neg() (*Tensor[T], error)

Neg negates element-wise.

func (*Tensor[T]) Normcdf 

func (t *Tensor[T]) Normcdf() (*Tensor[T], error)

Normcdf normal CDFs element-wise.

func (*Tensor[T]) Numel 

func (t *Tensor[T]) Numel() int

Numel returns element count.

func (*Tensor[T]) OnesLike 

func (t *Tensor[T]) OnesLike() (*Tensor[T], error)

OnesLike creates like t, filled with ones.

func (*Tensor[T]) Op 

func (t *Tensor[T]) Op() *Op[T]

Op returns the creating operation.

func (*Tensor[T]) Powf 

func (t *Tensor[T]) Powf(p float64) (*Tensor[T], error)

Powf powers element-wise to param.

func (*Tensor[T]) RandLike 

func (t *Tensor[T]) RandLike(lo, up float64) (*Tensor[T], error)

RandLike creates like t, with uniform samples.

func (*Tensor[T]) RandNLike 

func (t *Tensor[T]) RandNLike(mean, std float64) (*Tensor[T], error)

RandNLike creates like t, with normal samples.

func (*Tensor[T]) Rank 

func (t *Tensor[T]) Rank() int

Rank returns number of dimensions.

func (*Tensor[T]) Recip 

func (t *Tensor[T]) Recip() (*Tensor[T], error)

Recip reciprocates element-wise.

func (*Tensor[T]) ReduceMax 

func (t *Tensor[T]) ReduceMax(dim int, keep bool) (*Tensor[T], error)

ReduceMax computes maximum along dims, keepdim retains size 1.

func (*Tensor[T]) ReduceMean 

func (t *Tensor[T]) ReduceMean(dims []int, keep bool) (*Tensor[T], error)

ReduceMean computes mean along dims, keepdim retains size 1.

func (*Tensor[T]) ReduceMin 

func (t *Tensor[T]) ReduceMin(dim int, keep bool) (*Tensor[T], error)

ReduceMin computes minimum along dims, keepdim retains size 1.

func (*Tensor[T]) ReduceSum 

func (t *Tensor[T]) ReduceSum(dims []int, keep bool) (*Tensor[T], error)

ReduceSum computes sum along dims, keepdim retains size 1.

func (*Tensor[T]) Relu 

func (t *Tensor[T]) Relu() (*Tensor[T], error)

Relu applies ReLU activation.

func (*Tensor[T]) RequiresGrad 

func (t *Tensor[T]) RequiresGrad() *Tensor[T]

RequiresGrad marks for gradient, returns self.

func (*Tensor[T]) Reshape 

func (t *Tensor[T]) Reshape(d ...int) (*Tensor[T], error)

Reshape reshapes preserving elements.

func (*Tensor[T]) Round 

func (t *Tensor[T]) Round() (*Tensor[T], error)

Round rounds element-wise.

func (*Tensor[T]) Scatter 

func (t *Tensor[T]) Scatter(idx *Tensor[T], src *Tensor[T], dim int) (*Tensor[T], error)

Scatter scatters src values along dimension using indices.

func (*Tensor[T]) ScatterAdd 

func (t *Tensor[T]) ScatterAdd(idx *Tensor[T], src *Tensor[T], dim int) (*Tensor[T], error)

ScatterAdd performs scatter-add operation: adds src values to dst at indices along dimension.

func (*Tensor[T]) SetDType 

func (t *Tensor[T]) SetDType(d candy.DType) *Tensor[T]

SetDType sets data type, returns self.

func (*Tensor[T]) SetDevice 

func (t *Tensor[T]) SetDevice(d candy.Device) *Tensor[T]

SetDevice sets device, returns self.

func (*Tensor[T]) SetIsVar 

func (t *Tensor[T]) SetIsVar(v bool) *Tensor[T]

SetIsVar sets gradient flag, returns self.

func (*Tensor[T]) SetLayout 

func (t *Tensor[T]) SetLayout(l *candy.Layout) *Tensor[T]

SetLayout sets layout, returns self.

func (*Tensor[T]) SetOp 

func (t *Tensor[T]) SetOp(o *Op[T]) *Tensor[T]

SetOp sets operation, returns self.

func (*Tensor[T]) SetStorage 

func (t *Tensor[T]) SetStorage(s candy.BackendStorage[T]) *Tensor[T]

SetStorage sets storage, returns self.

func (*Tensor[T]) Shape 

func (t *Tensor[T]) Shape() *candy.Shape

Shape returns shape.

func (*Tensor[T]) Sigmoid 

func (t *Tensor[T]) Sigmoid() (*Tensor[T], error)

Sigmoid applies sigmoid activation.

func (*Tensor[T]) Sign 

func (t *Tensor[T]) Sign() (*Tensor[T], error)

Sign signs element-wise.

func (*Tensor[T]) Silu 

func (t *Tensor[T]) Silu() (*Tensor[T], error)

Silu applies SiLU activation.

func (*Tensor[T]) Sin 

func (t *Tensor[T]) Sin() (*Tensor[T], error)

Sin sines element-wise.

func (*Tensor[T]) Softmax 

func (x *Tensor[T]) Softmax(dim int) (*Tensor[T], error)

Softmax computes the softmax along the specified dimension.

func (*Tensor[T]) Sqr 

func (t *Tensor[T]) Sqr() (*Tensor[T], error)

Sqr squares element-wise.

func (*Tensor[T]) Sqrt 

func (t *Tensor[T]) Sqrt() (*Tensor[T], error)

Sqrt square roots element-wise.

func (*Tensor[T]) Squeeze 

func (t *Tensor[T]) Squeeze(dim int) (*Tensor[T], error)

Squeeze squeezes dim if size 1.

func (*Tensor[T]) SqueezeDims 

func (t *Tensor[T]) SqueezeDims(dims []int) (*Tensor[T], error)

SqueezeDims squeezes multiple dims if size 1.

func (*Tensor[T]) Storage 

func (t *Tensor[T]) Storage() candy.BackendStorage[T]

Storage returns the backend storage.

func (*Tensor[T]) Stride 

func (t *Tensor[T]) Stride() []int

Stride returns strides.

func (*Tensor[T]) String 

func (t *Tensor[T]) String() string

String returns a compact, PyTorch-style string representation of the tensor.

Example (Empty)

ExampleTensor_String_empty demonstrates formatting an empty tensor. 

package main

import (
	"fmt"

	"github.com/gocnn/candy"
	"github.com/gocnn/candy/tensor"
)

func main() {
	t := tensor.MustZeros[float32](candy.NewShape(0), candy.CPU)
	fmt.Println("\n", t)
}

Output:

tensor([], shape=[0], dtype=float32, device=cpu)
Example (Matrix)

ExampleTensor_String_matrix demonstrates formatting a 2D tensor (matrix). 

package main

import (
	"fmt"

	"github.com/gocnn/candy"
	"github.com/gocnn/candy/tensor"
)

func main() {
	t := tensor.MustNew([]float32{
		1.0, 2.0, 3.0,
		4.0, 5.0, 6.0,
	}, candy.NewShape(2, 3), candy.CPU)
	fmt.Println("\n", t)
}

Output:

tensor([[1., 2., 3.],
        [4., 5., 6.]], shape=[2 3], dtype=float32, device=cpu)
Example (Scalar)

ExampleTensor_String_scalar demonstrates formatting a scalar tensor. 

package main

import (
	"fmt"

	"github.com/gocnn/candy"
	"github.com/gocnn/candy/tensor"
)

func main() {
	t := tensor.MustNew([]float32{3.14159}, candy.NewShape(), candy.CPU)
	fmt.Println("\n", t)
}

Output:

tensor(3.14159, shape=[], dtype=float32, device=cpu)
Example (Special)

ExampleTensor_String_special demonstrates formatting with NaN, infinity, and extreme values. 

package main

import (
	"fmt"
	"math"

	"github.com/gocnn/candy"
	"github.com/gocnn/candy/tensor"
)

func main() {
	data := []float64{
		math.NaN(), math.Inf(1), math.Inf(-1), math.MaxFloat64, // NaN, +Inf, -Inf, MaxFloat64
		-math.MaxFloat64, 2.2250738585072014e-308, 4.9406564584124654e-324, 0.0, // -MaxFloat64, MinNormalFloat64, SmallestNonzeroFloat64, Zero
		0.0, 42.0, -999999999999.999, 0.000000000000001, // Negative zero, normal, large negative, tiny positive
	}
	t := tensor.MustNew(data, candy.NewShape(3, 4), candy.CPU)
	fmt.Println("\n", t)
}

Output:

tensor([[         nan,          inf,         -inf,  1.7977e+308],
        [-1.7977e+308,  2.2251e-308,  4.9407e-324,           0.],
        [          0.,          42.,       -1e+12,        1e-15]], shape=[3 4], dtype=float64, device=cpu)
Example (Vector)

ExampleTensor_String_vector demonstrates formatting a 1D tensor (vector). 

package main

import (
	"fmt"

	"github.com/gocnn/candy"
	"github.com/gocnn/candy/tensor"
)

func main() {
	t := tensor.MustNew([]float32{1.0, 2.5, 3.0, 4.25, 5.0}, candy.NewShape(5), candy.CPU)
	fmt.Println("\n", t)
}

Output:

tensor([  1.,  2.5,   3., 4.25,   5.], shape=[5], dtype=float32, device=cpu)

func (*Tensor[T]) Sub 

func (t *Tensor[T]) Sub(other *Tensor[T]) (*Tensor[T], error)

Sub subtracts element-wise.

func (*Tensor[T]) SubScalar 

func (t *Tensor[T]) SubScalar(s float64) (*Tensor[T], error)

SubScalar subtracts scalar using affine.

func (*Tensor[T]) Sum 

func (t *Tensor[T]) Sum(dims []int) (*Tensor[T], error)

Sum computes sum along dims, removes dims.

func (*Tensor[T]) SumAll 

func (t *Tensor[T]) SumAll() (*Tensor[T], error)

SumAll computes sum of all elements.

func (*Tensor[T]) SumKeep 

func (t *Tensor[T]) SumKeep(dims []int) (*Tensor[T], error)

SumKeep computes sum along dims, keeps size 1.

func (*Tensor[T]) T 

func (t *Tensor[T]) T() (*Tensor[T], error)

T transposes last two dims.

func (*Tensor[T]) Tanh 

func (t *Tensor[T]) Tanh() (*Tensor[T], error)

Tanh hyperbolically tangents element-wise.

func (*Tensor[T]) ToFloat32 

func (t *Tensor[T]) ToFloat32() (*Tensor[float32], error)

ToFloat32 converts to float32.

func (*Tensor[T]) ToFloat64 

func (t *Tensor[T]) ToFloat64() (*Tensor[float64], error)

ToFloat64 converts to float64.

func (*Tensor[T]) ToInt64 

func (t *Tensor[T]) ToInt64() (*Tensor[int64], error)

ToInt64 converts to int64.

func (*Tensor[T]) ToUint32 

func (t *Tensor[T]) ToUint32() (*Tensor[uint32], error)

ToUint32 converts to uint32.

func (*Tensor[T]) ToUint8 

func (t *Tensor[T]) ToUint8() (*Tensor[uint8], error)

ToUint8 converts to uint8.

func (*Tensor[T]) Transpose 

func (t *Tensor[T]) Transpose(d1, d2 int) (*Tensor[T], error)

Transpose transposes dims.

func (*Tensor[T]) Unsqueeze 

func (t *Tensor[T]) Unsqueeze(dim int) (*Tensor[T], error)

Unsqueeze inserts size 1 dim.

func (*Tensor[T]) UpsampleNearest2d 

func (t *Tensor[T]) UpsampleNearest2d(h, w int) (*Tensor[T], error)

UpsampleNearest2d upsamples 2D with nearest neighbor.

func (*Tensor[T]) WhereCond 

func (t *Tensor[T]) WhereCond(trueV, falseV *Tensor[T]) (*Tensor[T], error)

WhereCond selects based on condition.

func (*Tensor[T]) WriteNPY 

func (t *Tensor[T]) WriteNPY(path string) error

func (*Tensor[T]) ZerosLike 

func (t *Tensor[T]) ZerosLike() (*Tensor[T], error)

ZerosLike creates like t, filled with zeros.

type TensorID 

type TensorID uint64

TensorID uniquely identifies a tensor.

func NewID 

func NewID() TensorID

NewID generates a unique TensorID safely.

Source Files

View all Source files

Jump to

Keyboard shortcuts

? : This menu
/ : Search site
f or F : Jump to
y or Y : Canonical URL
go.dev uses cookies from Google to deliver and enhance the quality of its services and to analyze traffic. Learn more.