nn.internal

fn avgpool2d_backward[T](grad_out &vtl.Tensor[T], kernel []int, padding []int, stride []int) !&vtl.Tensor[T]

avgpool2d_backward exposes this operation as part of the public API.

fn avgpool2d_forward[T](input &vtl.Tensor[T], kernel []int, padding []int, stride []int) !&vtl.Tensor[T]

avgpool2d_forward exposes this operation as part of the public API.

fn batchnorm1d_backward[T](gradient &vtl.Tensor[T], input &vtl.Tensor[T], gamma &vtl.Tensor[T], beta &vtl.Tensor[T], mean &vtl.Tensor[T], var_ &vtl.Tensor[T], eps f64) ![]&vtl.Tensor[T]

batchnorm1d_backward computes gradients w.r.t. input, gamma, beta.

fn batchnorm1d_forward[T](input &vtl.Tensor[T], gamma &vtl.Tensor[T], beta &vtl.Tensor[T], running_mean &vtl.Tensor[T], running_var &vtl.Tensor[T], eps f64) !&vtl.Tensor[T]

batchnorm1d_forward computes batch norm using running mean/var (inference path).

fn batchnorm1d_training[T](input &vtl.Tensor[T], gamma &vtl.Tensor[T], beta &vtl.Tensor[T], eps f64) !(&vtl.Tensor[T], &vtl.Tensor[T], &vtl.Tensor[T])

batchnorm1d_training computes batch norm using batch stats (training path).

fn bce[T](input &vtl.Tensor[T], target &vtl.Tensor[T]) !&vtl.Tensor[T]

bce exposes this operation as part of the public API.

fn bce_backward[T](gradient &vtl.Tensor[T], input &vtl.Tensor[T], target &vtl.Tensor[T], from_logits bool) !&vtl.Tensor[T]

bce_backward computes the gradient of BCE w.r.t. the raw logits (before sigmoid). If from_logits=true, the upstream gradient is multiplied by the sigmoid derivative.

fn compute_fans(shape []int) (int, int)

compute_fans exposes this operation as part of the public API.

fn conv2d_backward[T](grad_out &vtl.Tensor[T],
	input &vtl.Tensor[T],
	weight &vtl.Tensor[T],
	bias &vtl.Tensor[T],
	kernel_size []int,
	config Conv2DConfig) ![]&vtl.Tensor[T]

conv2d_backward computes gradients for input, weight, bias. Returns [d_input, d_weight, d_bias].

fn conv2d_backward_cpu_f32(grad_out &vtl.Tensor[f32], input &vtl.Tensor[f32], weight &vtl.Tensor[f32],
	bias &vtl.Tensor[f32], kernel_size []int, config Conv2DConfig) ![]&vtl.Tensor[f32]

conv2d_backward_cpu_f32 computes Conv2D gradients on CPU (reference).

fn conv2d_backward_cpu_f64(grad_out &vtl.Tensor[f64], input &vtl.Tensor[f64], weight &vtl.Tensor[f64],
	bias &vtl.Tensor[f64], kernel_size []int, config Conv2DConfig) ![]&vtl.Tensor[f64]

conv2d_backward_cpu_f64 computes Conv2D gradients on CPU (reference).

fn conv2d_backward_f32(grad_out &vtl.Tensor[f32], input &vtl.Tensor[f32], weight &vtl.Tensor[f32],
	bias &vtl.Tensor[f32], kernel_size []int, config Conv2DConfig) ![]&vtl.Tensor[f32]

conv2d_backward_f32 uses Vulkan GEMM for d_weight when eligible, else full CPU.

fn conv2d_backward_f64(grad_out &vtl.Tensor[f64], input &vtl.Tensor[f64], weight &vtl.Tensor[f64],
	bias &vtl.Tensor[f64], kernel_size []int, config Conv2DConfig) ![]&vtl.Tensor[f64]

conv2d_backward_f64 exposes this operation as part of the public API.

fn conv2d_backward_vulkan_f32(grad_out &vtl.Tensor[f32], input &vtl.Tensor[f32], weight &vtl.Tensor[f32],
	bias &vtl.Tensor[f32], kernel_size []int, config Conv2DConfig) ![]&vtl.Tensor[f32]

conv2d_backward_vulkan_f32 exposes this operation as part of the public API.

fn conv2d_cuda_eligible(kernel_size []int, config Conv2DConfig) bool

conv2d_cuda_eligible is false without -d cuda.

fn conv2d_forward[T](input &vtl.Tensor[T],
	weight &vtl.Tensor[T],
	bias &vtl.Tensor[T],
	kernel_size []int,
	config Conv2DConfig) !&vtl.Tensor[T]

conv2d_forward implements the forward pass of 2D convolution. input: [batch, in_ch, H, W] weight: [out_ch, in_ch/groups, k_h, k_w] bias: [1, out_ch] config: padding, stride, dilation, groups returns: [batch, out_ch, out_H, out_W]

fn conv2d_forward_cpu_f32(input &vtl.Tensor[f32],
	weight &vtl.Tensor[f32],
	bias &vtl.Tensor[f32],
	kernel_size []int,
	config Conv2DConfig) !&vtl.Tensor[f32]

conv2d_forward_cpu_f32 is the reference CPU implementation (nested loops).

fn conv2d_forward_cpu_f64(input &vtl.Tensor[f64],
	weight &vtl.Tensor[f64],
	bias &vtl.Tensor[f64],
	kernel_size []int,
	config Conv2DConfig) !&vtl.Tensor[f64]

conv2d_forward_cpu_f64 is the reference CPU implementation (nested loops).

fn conv2d_forward_cuda_f64(input &vtl.Tensor[f64],
	weight &vtl.Tensor[f64],
	bias &vtl.Tensor[f64],
	kernel_size []int,
	config Conv2DConfig) !&vtl.Tensor[f64]

conv2d_forward_cuda_f64 stub when not built with -d cuda.

fn conv2d_forward_f32(input &vtl.Tensor[f32],
	weight &vtl.Tensor[f32],
	bias &vtl.Tensor[f32],
	kernel_size []int,
	config Conv2DConfig) !&vtl.Tensor[f32]

conv2d_forward_f32 uses Vulkan im2col+GEMM when eligible (VTL_USE_VULKAN=1, -d vulkan), else CPU.

fn conv2d_forward_f64(input &vtl.Tensor[f64],
	weight &vtl.Tensor[f64],
	bias &vtl.Tensor[f64],
	kernel_size []int,
	config Conv2DConfig) !&vtl.Tensor[f64]

conv2d_forward_f64 uses cuDNN when eligible (VTL_USE_CUDA=1, -d cuda), else CPU loops.

fn conv2d_forward_vulkan_f32(input &vtl.Tensor[f32],
	weight &vtl.Tensor[f32],
	bias &vtl.Tensor[f32],
	kernel_size []int,
	config Conv2DConfig) !&vtl.Tensor[f32]

conv2d_forward_vulkan_f32 stub when not built with -d vulkan.

fn conv2d_vulkan_backward_eligible(kernel_size []int, config Conv2DConfig) bool

conv2d_vulkan_backward_eligible exposes this operation as part of the public API.

fn conv2d_vulkan_eligible(kernel_size []int, config Conv2DConfig) bool

conv2d_vulkan_eligible is false without -d vulkan.

fn cross_entropy[T](input &vtl.Tensor[T], target &vtl.Tensor[T]) !&vtl.Tensor[T]

cross_entropy computes CrossEntropyLoss (LogSoftmax + NLL combined). This is the standard cross-entropy for multi-class classification. input: [batch, n_classes] raw logits target: [batch, n_classes] one-hot targets

fn cross_entropy_backward[T](gradient &vtl.Tensor[T], input &vtl.Tensor[T], target &vtl.Tensor[T]) !&vtl.Tensor[T]

cross_entropy_backward computes gradient of CrossEntropyLoss w.r.t. input logits. dL/dx_i = (softmax(x)_i - target_i) / batch_size

fn deriv_elu[T](gradient &vtl.Tensor[T], cached &vtl.Tensor[T], alpha T) !&vtl.Tensor[T]

deriv_elu exposes this operation as part of the public API.

fn deriv_gelu[T](gradient &vtl.Tensor[T], cached &vtl.Tensor[T]) !&vtl.Tensor[T]

deriv_gelu exposes this operation as part of the public API.

fn deriv_leaky_relu[T](gradient &vtl.Tensor[T], cached &vtl.Tensor[T], alpha T) !&vtl.Tensor[T]

deriv_leaky_relu exposes this operation as part of the public API.

fn deriv_mish[T](gradient &vtl.Tensor[T], cached &vtl.Tensor[T]) !&vtl.Tensor[T]

deriv_mish exposes this operation as part of the public API.

fn deriv_relu[T](gradient &vtl.Tensor[T], cached &vtl.Tensor[T]) !&vtl.Tensor[T]

deriv_relu exposes this operation as part of the public API.

fn deriv_sigmoid[T](gradient &vtl.Tensor[T], cached &vtl.Tensor[T]) !&vtl.Tensor[T]

deriv_sigmoid exposes this operation as part of the public API.

fn deriv_softmax[T](gradient &vtl.Tensor[T], input &vtl.Tensor[T], dim int) !&vtl.Tensor[T]

deriv_softmax exposes this operation as part of the public API.

fn deriv_swish[T](gradient &vtl.Tensor[T], cached &vtl.Tensor[T]) !&vtl.Tensor[T]

deriv_swish exposes this operation as part of the public API.

fn deriv_tanh[T](gradient &vtl.Tensor[T], cached &vtl.Tensor[T]) !&vtl.Tensor[T]

deriv_tanh exposes this operation as part of the public API.

fn dropout[T](input &vtl.Tensor[T], mask &vtl.Tensor[T], prob f64) !&vtl.Tensor[T]

dropout exposes this operation as part of the public API.

fn dropout_backwards[T](gradient &vtl.Tensor[T], mask &vtl.Tensor[T], prob f64) !&vtl.Tensor[T]

dropout_backwards exposes this operation as part of the public API.

fn elu[T](x &vtl.Tensor[T], alpha T) &vtl.Tensor[T]

elu exposes this operation as part of the public API.

fn embedding_backward[T](grad_out &vtl.Tensor[T], input &vtl.Tensor[T], weight &vtl.Tensor[T]) ![]&vtl.Tensor[T]

embedding_backward computes gradient w.r.t. weight. Gradients are accumulated into the weight rows corresponding to the input indices.

fn embedding_forward[T](input &vtl.Tensor[T], weight &vtl.Tensor[T]) !&vtl.Tensor[T]

embedding_forward looks up each integer index in the weight matrix. input: [batch, seq_len] integer indices weight: [vocab_size, embedding_dim] returns: [batch, seq_len, embedding_dim]

fn gelu[T](x &vtl.Tensor[T]) &vtl.Tensor[T]

gelu exposes this operation as part of the public API.

fn global_avgpool2d_backward[T](grad_out &vtl.Tensor[T], input &vtl.Tensor[T]) !&vtl.Tensor[T]

global_avgpool2d_backward exposes this operation as part of the public API.

fn global_avgpool2d_forward[T](input &vtl.Tensor[T]) !&vtl.Tensor[T]

global_avgpool2d_forward exposes this operation as part of the public API.

fn huber[T](input &vtl.Tensor[T], target &vtl.Tensor[T], delta T) !&vtl.Tensor[T]

huber computes the Huber loss (smooth L1)

fn huber_backward[T](gradient &vtl.Tensor[T], input &vtl.Tensor[T], target &vtl.Tensor[T], delta T) !&vtl.Tensor[T]

huber_backward computes the gradient of Huber loss w.r.t. input

fn kaiming_normal[T](shape []int) &vtl.Tensor[T]

kaiming_normal exposes this operation as part of the public API.

fn kaiming_uniform[T](shape []int) &vtl.Tensor[T]

kaiming_uniform exposes this operation as part of the public API.

fn kl_div[T](input &vtl.Tensor[T], target &vtl.Tensor[T]) !&vtl.Tensor[T]

kl_div computes KL Divergence loss D_KL(P || Q) = sum(P * log(P/Q)) input: log-probs Q, target: probabilities P

fn kl_div_backward[T](gradient &vtl.Tensor[T], input &vtl.Tensor[T], target &vtl.Tensor[T]) !&vtl.Tensor[T]

kl_div_backward computes gradient of KL Divergence w.r.t. input (log-probs Q)

fn layer_norm_backward[T](gradient &vtl.Tensor[T], input &vtl.Tensor[T], gamma &vtl.Tensor[T], beta &vtl.Tensor[T], eps f64) ![]&vtl.Tensor[T]

layer_norm_backward computes gradient w.r.t. input, gamma, beta.

fn layer_norm_forward[T](input &vtl.Tensor[T], gamma &vtl.Tensor[T], beta &vtl.Tensor[T], eps f64) !&vtl.Tensor[T]

layer_norm_forward computes layer normalization over all elements of input. gamma, beta: same shape as input (optional affine params, pass nil to skip)

fn leaky_relu[T](x &vtl.Tensor[T], alpha T) &vtl.Tensor[T]

leaky_relu exposes this operation as part of the public API.

fn linear_backward_vulkan_f32(grad &vtl.Tensor[f32], input &vtl.Tensor[f32],
	weight &vtl.Tensor[f32], bias_needs_grad bool) ![]&vtl.Tensor[f32]

linear_backward_vulkan_f32 exposes this operation as part of the public API.

fn lstm_forward_multi[T](input_ &vtl.Tensor[T],
	h0 &vtl.Tensor[T],
	w_ih &vtl.Tensor[T],
	w_hh &vtl.Tensor[T],
	b_ih &vtl.Tensor[T],
	b_hh &vtl.Tensor[T]) !(&vtl.Tensor[T], &vtl.Tensor[T])

lstm_forward_multi stacks multiple LSTM layers.

fn lstm_forward_single[T](input &vtl.Tensor[T],
	hidden0 &vtl.Tensor[T],
	w_ih &vtl.Tensor[T],
	w_hh &vtl.Tensor[T],
	b_ih &vtl.Tensor[T],
	b_hh &vtl.Tensor[T]) !(&vtl.Tensor[T], &vtl.Tensor[T])

lstm_forward_single runs a single-layer LSTM. input: [seq_len, batch, input_size] hidden0: [batch, hidden_size] w_ih: [4hidden_size, input_size] (i, f, g, o gates) w_hh: [4hidden_size, hidden_size] b_ih, b_hh: [4*hidden_size] Returns (output [seq_len, batch, hidden_size], h_n [batch, hidden_size])

fn maxpool2d[T](input &vtl.Tensor[T], kernel []int, padding []int, stride []int) (&vtl.Tensor[int], &vtl.Tensor[T])

maxpool2d exposes this operation as part of the public API.

fn maxpool2d_backward[T](shape []int, max_indices &vtl.Tensor[int], grad_output &vtl.Tensor[T]) !&vtl.Tensor[T]

maxpool2d_backward exposes this operation as part of the public API.

fn mish[T](x &vtl.Tensor[T]) &vtl.Tensor[T]

mish exposes this operation as part of the public API.

fn mse[T](input &vtl.Tensor[T], target &vtl.Tensor[T]) !&vtl.Tensor[T]

mse exposes this operation as part of the public API.

fn mse_backward[T](gradient &vtl.Tensor[T], cache &vtl.Tensor[T], target &vtl.Tensor[T]) ![]&vtl.Tensor[T]

mse_backward exposes this operation as part of the public API.

fn nll[T](input &vtl.Tensor[T], target &vtl.Tensor[T]) !&vtl.Tensor[T]

nll computes Negative Log Likelihood loss (assumes input is log-probs) Target is one-hot or class probabilities; we compute -sum(target * log(input))

fn nll_backward[T](gradient &vtl.Tensor[T], input &vtl.Tensor[T], target &vtl.Tensor[T]) !&vtl.Tensor[T]

nll_backward computes gradient of NLL w.r.t. input (log-probs)

fn relu[T](x &vtl.Tensor[T]) &vtl.Tensor[T]

relu exposes this operation as part of the public API.

fn sgd_optimize[T](mut value vtl.Tensor[T], gradient &vtl.Tensor[T], learning_rate f64) !

sgd_optimize exposes this operation as part of the public API.

fn sigmoid[T](x &vtl.Tensor[T]) &vtl.Tensor[T]

sigmoid exposes this operation as part of the public API.

fn sigmoid_cross_entropy[T](input &vtl.Tensor[T], target &vtl.Tensor[T]) !&vtl.Tensor[T]

sigmoid_cross_entropy exposes this operation as part of the public API.

fn sigmoid_cross_entropy_backward[T](gradient &vtl.Tensor[T], cache &vtl.Tensor[T], target &vtl.Tensor[T]) ![]&vtl.Tensor[T]

sigmoid_cross_entropy_backward exposes this operation as part of the public API.

fn softmax_cross_entropy[T](input &vtl.Tensor[T], target &vtl.Tensor[T]) !&vtl.Tensor[T]

softmax_cross_entropy exposes this operation as part of the public API.

fn softmax_cross_entropy_backward[T](gradient &vtl.Tensor[T], cache &vtl.Tensor[T], target &vtl.Tensor[T]) ![]&vtl.Tensor[T]

softmax_cross_entropy_backward computes the gradient of the SCE loss w.r.t. the logits. The gradient for each logit is: upstream * (softmax(logit_i) - target_i) / batch_size

This is the standard gradient derived from the log-softmax formulation (equivalent to Arraymancer's implementation).

fn softmax_forward[T](input &vtl.Tensor[T], dim int) !&vtl.Tensor[T]

softmax_forward computes softmax along a specified dimension.

fn swish[T](x &vtl.Tensor[T]) &vtl.Tensor[T]

swish exposes this operation as part of the public API.

fn tanh[T](x &vtl.Tensor[T]) &vtl.Tensor[T]

tanh exposes this operation as part of the public API.

fn variance_scaled[T](shape []int, scale T, fan_mode FanMode, distribution Distribution) &vtl.Tensor[T]

variance_scaled exposes this operation as part of the public API.

fn Distribution.from[W](input W) !Distribution

fn FanMode.from[W](input W) !FanMode

enum Distribution {
	uniform
	normal
}

Distribution lists the supported public values for this module.

enum FanMode {
	fan_avg
	fan_in
	fan_out
}

FanMode lists the supported public values for this module.

struct Conv2DConfig {
pub:
	padding  []int = [0, 0]
	stride   []int = [1, 1]
	dilation []int = [1, 1]
	groups   int   = 1
}

Conv2DConfig mirrors vtl.nn.layers.Conv2DConfig to avoid import cycle.

struct LSTMIntermediate[T] {
mut:
	zs      []&vtl.Tensor[T] // update gate per timestep
	rs      []&vtl.Tensor[T] // reset gate per timestep
	hs      []&vtl.Tensor[T] // candidate hidden per timestep
	gates_x []&vtl.Tensor[T] // gates from input per timestep
	gates_h []&vtl.Tensor[T] // gates from hidden per timestep
}

LSTMIntermediate stores per-timestep gate values for backprop.