neat

Documentation

Overview

Package neat implements NeuroEvolution of Augmenting Topologies (NEAT) method which can be used to evolve Artificial Neural Networks to perform specific task using genetic algorithms.

Index

• Constants
• Variables
• type LoggerLevel
• type NeatContext
  • func LoadContext(r io.Reader) *NeatContext
  • func NewNeatContext() *NeatContext
  • func (c *NeatContext) LoadContext(r io.Reader) error
  • func (c *NeatContext) RandomNodeActivationType() (utils.NodeActivationType, error)
• type Trait
  • func NewTrait() *Trait
  • func NewTraitAvrg(t1, t2 *Trait) (*Trait, error)
  • func NewTraitCopy(t *Trait) *Trait
  • func (t *Trait) Mutate(trait_mutation_power, trait_param_mut_prob float64)
  • func (t *Trait) String() string

Constants

const Num_trait_params = 8

The number of parameters used in neurons that learn through habituation, sensitization, or Hebbian-type processes

Variables

var (
	// The current log level of the context
	LogLevel LoggerLevel

	// The logger to output all messages
	DebugLog = func(message string) {
		if LogLevel <= LogLevelDebug {
			loggerDebug.Output(2, message)
		}
	}
	// The logger to output messages with Info and up level
	InfoLog = func(message string) {
		if LogLevel <= LogLevelInfo {
			loggerInfo.Output(2, message)
		}
	}
	// The logger to output messages with Warn and up level
	WarnLog = func(message string) {
		if LogLevel <= LogLevelWarning {
			loggerWarn.Output(2, message)
		}
	}
	// The logger to output messages with Error and up level
	ErrorLog = func(message string) {
		if LogLevel <= LogLevelError {
			loggerError.Output(2, message)
		}
	}
)

var (
	ErrTraitsParametersCountMismatch = errors.New("traits parameters number mismatch")
)

Types

type LoggerLevel

type LoggerLevel byte

LoggerLevel type to specify logger output level

const (
	// The Debug log level
	LogLevelDebug LoggerLevel = iota
	// The Info log level
	LogLevelInfo
	// The Warning log level
	LogLevelWarning
	// The Error log level
	LogLevelError
)

type NeatContext

type NeatContext struct {
	// Probability of mutating a single trait param
	TraitParamMutProb float64
	// Power of mutation on a single trait param
	TraitMutationPower float64
	// The power of a link weight mutation
	WeightMutPower float64

	// These 3 global coefficients are used to determine the formula for
	// computing the compatibility between 2 genomes.  The formula is:
	// disjoint_coeff * pdg + excess_coeff * peg + mutdiff_coeff * mdmg.
	// See the compatibility method in the Genome class for more info
	// They can be thought of as the importance of disjoint Genes,
	// excess Genes, and parametric difference between Genes of the
	// same function, respectively.
	DisjointCoeff float64
	ExcessCoeff   float64
	MutdiffCoeff  float64

	// This global tells compatibility threshold under which
	// two Genomes are considered the same species
	CompatThreshold float64

	// How much does age matter? Gives a fitness boost up to some young age (niching).
	// If it is 1, then young species get no fitness boost.
	AgeSignificance float64
	// Percent of average fitness for survival, how many get to reproduce based on survival_thresh * pop_size
	SurvivalThresh float64

	// Probabilities of a non-mating reproduction
	MutateOnlyProb         float64
	MutateRandomTraitProb  float64
	MutateLinkTraitProb    float64
	MutateNodeTraitProb    float64
	MutateLinkWeightsProb  float64
	MutateToggleEnableProb float64
	MutateGeneReenableProb float64
	MutateAddNodeProb      float64
	MutateAddLinkProb      float64
	MutateConnectSensors   float64 // probability of mutation involving disconnected inputs connection

	// Probabilities of a mate being outside species
	InterspeciesMateRate  float64
	MateMultipointProb    float64
	MateMultipointAvgProb float64
	MateSinglepointProb   float64

	// Prob. of mating without mutation
	MateOnlyProb float64
	// Probability of forcing selection of ONLY links that are naturally recurrent
	RecurOnlyProb float64

	// Size of population
	PopSize int
	// Age when Species starts to be penalized
	DropOffAge int
	// Number of tries mutate_add_link will attempt to find an open link
	NewLinkTries int

	// Tells to print population to file every n generations
	PrintEvery int

	// The number of babies to stolen off to the champions
	BabiesStolen int

	// The number of runs to average over in an experiment
	NumRuns int

	// The number of epochs (generations) to execute training
	NumGenerations int
	// The epoch's executor type to apply
	EpochExecutorType int
	// The genome compatibility testing method to use (0 - linear, 1 - fast (make sense for large genomes))
	GenCompatMethod int

	// The neuron nodes activation functions list to choose from
	NodeActivators []utils.NodeActivationType
	// The probabilities of selection of the specific node activator function
	NodeActivatorsProb []float64
}

The NEAT execution context holding common configuration parameters, etc.

func LoadContext

func LoadContext(r io.Reader) *NeatContext

Loads context configuration from provided reader

func NewNeatContext

func NewNeatContext() *NeatContext

Creates new empty NEAT context

func (*NeatContext) LoadContext

func (c *NeatContext) LoadContext(r io.Reader) error

Loads context configuration from provided reader as YAML

func (*NeatContext) RandomNodeActivationType

func (c *NeatContext) RandomNodeActivationType() (utils.NodeActivationType, error)

Returns next random node activation type among registered with this context

type Trait

type Trait struct {
	// The trait ID
	Id int
	// The learned trait parameters
	Params []float64
}

TRAIT: A Trait is a group of parameters that can be expressed as a group more than one time. Traits save a genetic algorithm from having to search vast parameter landscapes on every node. Instead, each node can simply point to a trait and those traits can evolve on their own.

func NewTrait

func NewTrait() *Trait

func NewTraitAvrg

func NewTraitAvrg(t1, t2 *Trait) (*Trait, error)

Special Constructor creates a new Trait which is the average of two existing traits passed in

func NewTraitCopy

func NewTraitCopy(t *Trait) *Trait

The copy constructor

func (*Trait) Mutate

func (t *Trait) Mutate(trait_mutation_power, trait_param_mut_prob float64)

Perturb the trait parameters slightly

func (*Trait) String

func (t *Trait) String() string