godl

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

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

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

type AvgPool2DOpts struct {
	Kernel  tensor.Shape
	Padding []int
	Stride  []int
}

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

type BatchNormOpts struct {
	Momentum            float64
	Epsilon             float64
	ScaleInit, BiasInit gorgonia.InitWFn

	ScaleName, BiasName string

	InputSize int
}

type ConfusionMatrix map[MatchType]int

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

type Conv2dOpts struct {
	InputDimension  int
	OutputDimension int

	KernelSize tensor.Shape
	Pad        []int
	Stride     []int
	Dilation   []int

	WithBias bool

	WeightsInit, BiasInit gorgonia.InitWFn
	WeightsName, BiasName string
	FixedWeights          bool
}

type CostFn func(output Nodes, target *Node) *Node

type CrossEntropyLossOpt struct {
	Reduction Reduction
}

type DataLoader struct {
	FeaturesShape tensor.Shape
	Rows          int
	Batches       int
	CurrentBatch  int
	// contains filtered or unexported fields
}

type DataLoaderOpts struct {
	Shuffle   bool
	BatchSize int
	Drop      bool
}

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

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

type EmbeddingOpts struct {
	WeightsInit gorgonia.InitWFn
}

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

type GLUOpts struct {
	InputDimension   int
	OutputDimension  int
	VirtualBatchSize int
	Activation       activation.Function
	Linear           *LinearModule
	WeightsInit      gorgonia.InitWFn
	WithBias         bool
	Momentum         float64
}

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

type GhostBatchNormOpts struct {
	Momentum         float64
	Epsilon          float64
	VirtualBatchSize int
	OutputDimension  int

	ScaleInit, BiasInit gorgonia.InitWFn
}

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

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

type LayerType string

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

type LinearOpts struct {
	Activation      activation.Function
	Dropout         float64
	OutputDimension int
	InputDimension  int

	WeightsInit           gorgonia.InitWFn
	BiasInit              gorgonia.InitWFn
	WithBias              bool
	WeightsName, BiasName string
	FixedWeights          bool
}

type MSELossOpts struct {
	Reduction Reduction
}

type MatchType int

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

type MaxPool2DOpts struct {
	Kernel  tensor.Shape
	Padding []int
	Stride  []int
}

type Model struct {
	Logger  *log.Logger
	Storage *storage.Storage
	// contains filtered or unexported fields
}

type Module interface {
	Forward(inputs ...*Node) Nodes
	Name() string
}

type ModuleList []Module

type NewWeightsOpts struct {
	UniqueName string
	Value      gorgonia.Value
	InitFN     gorgonia.InitWFn

	// Fixed indicates that the weights won't be learnable. By default the weights are learnable
	Fixed bool
}

type Node = gorgonia.Node

type Nodes = gorgonia.Nodes

type PredictOpts struct {
	InputShape tensor.Shape
	DevMode    bool
}

type Predictor func(x tensor.Tensor) (gorgonia.Value, error)

type Reduction string

type TrainOpts struct {
	Epochs    int
	BatchSize int

	// DevMode detects common issues like exploding and vanishing gradients at the cost of performance
	DevMode bool

	WriteGraphFileTo string

	// WithLearnablesHeatmap writes images representing heatmaps for the weights. Use it to debug.
	WithLearnablesHeatmap bool

	// Solver defines the solver to use. It uses gorgonia.AdamSolver by default if none is passed
	Solver gorgonia.Solver

	// ValidateEvery indicates the number of epochs to run before running a validation. Defaults 1 (every epoch)
	ValidateEvery int

	CostObserver       func(epoch int, totalEpoch, batch int, totalBatch int, cost float32)
	ValidationObserver func(confMat ConfusionMatrix, cost float32)
	MatchTypeFor       func(predVal, targetVal []float32) MatchType
	CostFn             CostFn
}