nn.types

fn layer[T](ptr voidptr, output_shape_fn LayerOutputShapeFn, variables_fn LayerVariablesFn, forward_fn LayerForwardFn) Layer[T]

layer creates a typed wrapper around a concrete neural network layer.

fn loss[T](ptr voidptr, loss_fn LossFn) Loss[T]

loss creates a typed loss wrapper.

fn variable_ptrs_to_voidptrs[T](vars []&autograd.Variable[T]) []voidptr

variable_ptrs_to_voidptrs converts typed variable pointers at wrapper edges.

interface Optimizer[T] {
mut:
	params        []&autograd.Variable[T]
	learning_rate f64
	update() !
	build_params(layers Layer[T])
}

Optimizer is a generic interface for all optimizers.

type LayerForwardFn = fn (layer voidptr, input voidptr) !voidptr

LayerForwardFn forwards a layer using opaque wrapper pointers.

type LayerOutputShapeFn = fn (layer voidptr) []int

LayerOutputShapeFn returns a layer output shape from an opaque wrapper pointer.

type LayerVariablesFn = fn (layer voidptr) []voidptr

LayerVariablesFn returns trainable variable pointers from an opaque wrapper pointer.

fn (layer Layer[T]) output_shape() []int

output_shape returns the layer output shape.

fn (layer Layer[T]) variables() []&autograd.Variable[T]

variables returns the trainable variables owned by the layer.

fn (layer Layer[T]) forward(input &autograd.Variable[T]) !&autograd.Variable[T]

forward runs a forward pass through the wrapped layer.

type LossFn = fn (loss voidptr, input voidptr, target voidptr) !voidptr

LossFn computes a loss value using opaque wrapper pointers.

fn (loss Loss[T]) loss(input &autograd.Variable[T], target &vtl.Tensor[T]) !&autograd.Variable[T]

loss computes a scalar loss variable for model output and target tensors.

struct Layer[T] {
	ptr             voidptr
	output_shape_fn LayerOutputShapeFn = unsafe { nil }
	variables_fn    LayerVariablesFn   = unsafe { nil }
	forward_fn      LayerForwardFn     = unsafe { nil }
}

Layer is an opaque wrapper for a neural network layer.

struct Loss[T] {
	ptr     voidptr
	loss_fn LossFn = unsafe { nil }
}

Loss wraps a concrete loss implementation without storing a generic interface.