automata

type BinaryCost ¶

type BinaryCost struct{}

BinaryCost implement the binary (Zero-One Loss) function

func (c *BinaryCost) Cost(target, output []float64) float64

type ConnID ¶

type ConnID int64

type Connection ¶

type Connection struct {
	ID     ConnID
	From   *Neuron
	To     *Neuron
	Gater  *Neuron
	Weight float64
	Gain   float64
}

Connection represents a connection between two neurons.

func NewConnection(from, to *Neuron, weight *float64) *Connection

type Coster ¶

type Coster interface {
	// Cost of the given output. The length of target and output will always be the same.
	Cost(target, output []float64) (cost float64)
}

Coster defines a cost function for use with the Trainer.

type CrossEntropyCost ¶

type CrossEntropyCost struct{}

CrossEntropyCost implement the cross entropy function (Eq. 9)

func (c *CrossEntropyCost) Cost(target, output []float64) (cost float64)

type GateType ¶

type GateType int

type Hopfield ¶

type Hopfield struct {
	Network
}

func NewHopfieldNetwork(table *LookupTable, size int) *Hopfield

func (h *Hopfield) Activate(input []float64) ([]float64, error)

type Layer ¶

type Layer struct {
	List        []*Neuron
	ConnectedTo []LayerConnection
	LookupTable *LookupTable
}

Layer represents a group of neurons which activate together.

func NewLayer(table *LookupTable, size int) Layer

func (l *Layer) Activate(inputs []float64) ([]float64, error)

func (l *Layer) Gate(conn *LayerConnection, gateType GateType) error

func (l *Layer) Project(toLayer *Layer, ltype LayerType) *LayerConnection

func (l *Layer) Propagate(rate float64, target []float64) error

func (l *Layer) SetBias(bias float64)

type LayerConnection ¶

type LayerConnection struct {
	From        *Layer
	To          *Layer
	Type        LayerType
	Connections map[ConnID]*Connection
	List        []*Connection
}

LayerConnection represents a connection between two layers.

func NewLayerConnection(from, to *Layer, ltype LayerType) LayerConnection

type LayerType ¶

type LayerType int

const (
	LayerTypeAuto LayerType = iota
	LayerTypeAllToAll
	LayerTypeOneToOne
	LayerTypeAllToElse
)

type LookupTable ¶

type LookupTable struct {
	Neurons     []*Neuron
	Connections []*Connection
}

LookupTable stores mappings of:

• Neuron IDs to Neurons
• Connection IDs to Connections

It can be thought of as a global hash map, but is implemented slightly differently for performance reasons.

Rationale: Neurons need references to other neurons/connections (e.g. neighbours). The simplest way to do this is to store a map[ID]*Thing in the Neuron struct itself. This ends up being slow because this is called a lot and each time incurs hashing overheads. It would be better if this was done as a slice, especially since network topologies don't tend to change at runtime so there are no resizing overheads. This means the IDs would be indexes. LookupTable is a massive global slice which provides Neurons/Layers/Connections access to each other via their ID. It's not a true global variable as it is dependency injected at the point of use, allowing the ability of running multiple disconnected networks without sharing the same ID space. Sharing the same LookupTable for all neurons in a network also lowers memory usage from O(n) to O(1), as each neuron is not having to store its own mini lookup table.

func (t *LookupTable) GetConnection(id ConnID) *Connection

func (t *LookupTable) GetNeuron(id NeuronID) *Neuron

func (t *LookupTable) SetConnection(conn *Connection) ConnID

func (t *LookupTable) SetConnectionWithID(id ConnID, conn *Connection)

func (t *LookupTable) SetNeuron(neuron *Neuron) NeuronID

type MeanSquaredErrorCost ¶

type MeanSquaredErrorCost struct{}

MeanSquaredErrorCost implements the MSE cost function.

func (c *MeanSquaredErrorCost) Cost(target, output []float64) (cost float64)

type Network ¶

type Network struct {
	Input  *Layer
	Hidden []Layer
	Output *Layer
}

Network represents an arbitrary artificial neural network.

func NewLSTM(table *LookupTable, inputSize int, memoryBlocks []int, outputSize int) *Network

func NewPerceptronNetwork(table *LookupTable, sizesOfLayers []int) (*Network, error)

// create a network with:
//  - 2 neurons on the input layer
//  - 3 neurons on the first hidden layer
//  - 4 neurons on the second hidden layer
//  - 1 neuron on the output layer
perceptron := automata.NewPerceptron([]int{2,3,4,1})

func (n *Network) Activate(input []float64) ([]float64, error)

func (n *Network) Gate(conn *LayerConnection, gateType GateType)

func (n *Network) ProjectLayer(layer *Layer, ltype LayerType)

func (n *Network) ProjectNetwork(network *Network, ltype LayerType)

func (n *Network) Propagate(rate float64, target []float64) error

type Networker ¶

type Networker interface {
	Activate(input []float64) ([]float64, error)
	Propagate(rate float64, target []float64) error
}

Networker represents an abstraction of a Network, which is used primarily with the Trainer to accommodate different Network structs such as Hopfield.

type Neuron ¶

type Neuron struct {
	ID         NeuronID
	Old        float64
	State      float64
	Derivative float64
	Activation float64
	Self       *Connection
	Squash     Squasher
	Bias       float64
	Neighbours []NeuronID

	Inputs    []ConnID
	Projected []ConnID
	Gated     []ConnID

	ErrorResponsibility float64
	ErrorProjected      float64
	ErrorGated          float64

	TraceEligibility []float64 // Efficient form of map[ConnID]float64
	TraceExtended    map[NeuronID]map[ConnID]float64
	TraceInfluences  map[NeuronID][]ConnID

	LookupTable *LookupTable
}

Neuron represents a base unit of work in a neural network.

func NewNeuron(table *LookupTable) *Neuron

func (n *Neuron) Activate(input *float64) float64

func (n *Neuron) ConnectionForNeuron(target *Neuron) *Connection

func (n *Neuron) Gate(conn *Connection)

func (n *Neuron) Project(targetNeuron *Neuron, weight *float64) *Connection

func (n *Neuron) Propagate(rate float64, target *float64)

type NeuronID ¶

type NeuronID int64

type SquashIdentity ¶

type SquashIdentity struct{}

SquashIdentity implements the identity function.

func (s *SquashIdentity) Squash(x float64, derivate bool) float64

type SquashLogistic ¶

type SquashLogistic struct{}

SquashLogistic implements the logistic function.

func (s *SquashLogistic) Squash(x float64, derivate bool) float64

type SquashRelu ¶

type SquashRelu struct{}

SquashRelu implements the ReLU activation function, which is not subject to the Vanishing Gradient problem . https://en.wikipedia.org/wiki/Rectifier_(neural_networks)

func (s *SquashRelu) Squash(x float64, derivate bool) float64

type SquashTanh ¶

type SquashTanh struct{}

SquashTanh implements tanh function.

func (s *SquashTanh) Squash(x float64, derivate bool) float64

type Squasher ¶

type Squasher interface {
	// Squash an input x into a suitable output. If 'derivate' is true, the derivative should
	// be returned.
	Squash(x float64, derivate bool) float64
}

Squasher implements a squashing function which can be used as an activation function. Squashing functions modify inputs allowing neurons to model non-linear relationships. This typically involves clamping/bounding the output at one or both ends.

These functions can be very sensitive to the weights which are applied to them which can make training difficult because you need to discover the precise weightings which will squash the input in the way you want. Some functions can exacerbate the Vanishing Gradient problem.

Common squash functions are already implemented.

type TrainSet ¶

type TrainSet struct {
	Input  []float64
	Output []float64
}

type Trainer ¶

type Trainer struct {
	Network      Networker
	LearnRate    float64
	Iterations   int
	MaxErrorRate float64
	CostFunction Coster
}

func (t *Trainer) Train(trainingSet []TrainSet) error