training

type Batch ¶ added in v0.3.0

type Batch[T tensor.Numeric] struct {
	Inputs  map[graph.Node[T]]*tensor.TensorNumeric[T]
	Targets *tensor.TensorNumeric[T]
}

Batch groups the stable inputs for a single training step.

Inputs are provided as a map keyed by the graph's input nodes. Targets are provided as a single tensor; strategies may interpret targets appropriately for the chosen loss.

type DefaultBackpropStrategy ¶ added in v0.3.0

type DefaultBackpropStrategy[T tensor.Numeric] struct{}

DefaultBackpropStrategy performs standard backpropagation through the loss and model graph.

func NewDefaultBackpropStrategy[T tensor.Numeric]() *DefaultBackpropStrategy[T]

func (s *DefaultBackpropStrategy[T]) ComputeGradients(
	ctx context.Context,
	g *graph.Graph[T],
	loss graph.Node[T],
	batch Batch[T],
) (T, error)

type DefaultTrainer ¶ added in v0.3.0

type DefaultTrainer[T tensor.Numeric] struct {
	// contains filtered or unexported fields
}

DefaultTrainer encapsulates stable training components and delegates gradient computation to a strategy.

func NewDefaultTrainer[T tensor.Numeric](
	g *graph.Graph[T],
	loss graph.Node[T],
	optimizer opt.Optimizer[T],
	strategy GradientStrategy[T],
) *DefaultTrainer[T]

func (t *DefaultTrainer[T]) TrainStep(
	ctx context.Context,
	g *graph.Graph[T],
	optimizer opt.Optimizer[T],
	inputs map[graph.Node[T]]*tensor.TensorNumeric[T],
	targets *tensor.TensorNumeric[T],
) (T, error)

type EraSequencer ¶ added in v0.3.0

type EraSequencer struct {
	// contains filtered or unexported fields
}

EraSequencer generates sequences of consecutive eras for curriculum learning.

func NewEraSequencer(maxSeqLen int) *EraSequencer

func (s *EraSequencer) GenerateSequences(dataset *data.Dataset, numSequences int) []*data.Dataset

func (s *EraSequencer) GenerateTrainValidationSplit(dataset *data.Dataset, validationEras int) (*data.Dataset, *data.Dataset)

func (s *EraSequencer) SetSeed(seed1, seed2 uint64)

type GradientStrategy ¶ added in v0.3.0

type GradientStrategy[T tensor.Numeric] interface {
	ComputeGradients(
		ctx context.Context,
		g *graph.Graph[T],
		loss graph.Node[T],
		batch Batch[T],
	) (lossValue T, err error)
}

GradientStrategy encapsulates how to compute gradients for a training step.

Implementations may perform standard backprop through the loss, use approximations, or incorporate auxiliary losses (e.g., deep supervision). The strategy must leave parameter gradients populated on the graph's parameters so that the optimizer can apply updates afterwards.

type Model ¶

type Model[T tensor.Numeric] interface {
	// Forward performs the forward pass of the model.
	Forward(ctx context.Context, inputs ...*tensor.TensorNumeric[T]) (*tensor.TensorNumeric[T], error)
	// Backward performs the backward pass of the model.
	Backward(ctx context.Context, grad *tensor.TensorNumeric[T], inputs ...*tensor.TensorNumeric[T]) ([]*tensor.TensorNumeric[T], error)
	// Parameters returns the parameters of the model.
	Parameters() []*graph.Parameter[T]
}

Model defines the interface for a trainable model.

type OneStepApproximationStrategy ¶ added in v0.3.0

type OneStepApproximationStrategy[T tensor.Numeric] struct{}

OneStepApproximationStrategy performs a one-step gradient approximation. It is designed for training recurrent models without full BPTT.

func NewOneStepApproximationStrategy[T tensor.Numeric]() *OneStepApproximationStrategy[T]

func (s *OneStepApproximationStrategy[T]) ComputeGradients(
	ctx context.Context,
	g *graph.Graph[T],
	loss graph.Node[T],
	batch Batch[T],
) (T, error)

type Trainer ¶

type Trainer[T tensor.Numeric] interface {
	// TrainStep performs a single training step for a model.
	// It takes the model's parameters, the optimizer, and the input/target data.
	// It is responsible for computing the loss, gradients, and updating the parameters.
	TrainStep(
		ctx context.Context,
		modelGraph *graph.Graph[T],
		optimizer optimizer.Optimizer[T],
		inputs map[graph.Node[T]]*tensor.TensorNumeric[T],
		targets *tensor.TensorNumeric[T],
	) (loss T, err error)
}

Trainer is an interface for model-specific training orchestration.