eaopt

eaopt is an evolutionary optimization library for Go. It provides implementations for various evolutionary optimization algorithms, including Genetic Algorithms (GA), Particle Swarm Optimization (PSO), Differential Evolution (DE), OpenAI Evolution Strategy (OES), Hill Climbing, and Simulated Annealing.

The library is designed around a highly flexible GA struct, which allows users to customize mutation, crossover, selection, and replacement procedures. This flexibility means most other algorithms in the library are implemented as special cases of a genetic algorithm, and users can also implement their own custom operators.

Speciation (or clustering) partitions individuals into smaller groups (species) of similar individuals based on a metric (e.g., fitness). This encourages genetic operators to be applied to similar individuals, preventing new evolutionary traits from being immediately lost during selection (a common issue in neural network topology optimization).

To use speciation, you must specify a Speciator in the Speciator field of the GA struct.

The Mutate and Crossover methods must modify the Genome values in-place.

• For slices (e.g., []float64): Since slices are references to underlying data in Go, modifying the slice inside the method will affect the original genome.
• For structs: You must use a pointer receiver (e.g., *Name) to ensure the method modifies the actual instance rather than a copy.

// Example 1: Using a slice (works because slices are references)
type Vector []float64

func (X Vector) Mutate(rng *rand.Rand) {
    eaopt.MutNormal(X, rng, 0.5)
}

// Example 2: Using a struct (requires a pointer receiver)
type Name string

func (n *Name) Mutate(rng *rand.Rand) {
    *n = randomName() // Use pointer to modify the value
}

eaopt allows running multiple independent populations in parallel to increase diversity.

• Multi-populations: Controlled by the Populations field in the GA struct. The number of populations is defined in GAConfig.NPops.
• Migration: If a Migrator and MigFrequency are provided, individuals are exchanged between populations at every generation divisible by MigFrequency (e.g., if frequency is 5, migration occurs at generations 5, 10, 15, etc.).
• Independence: If Migrator and MigFrequency are omitted, populations run independently.

By default, eaopt evolves populations in parallel. You can further optimize performance by enabling parallelism for specific heavy operations using the GA struct fields:

• ParallelEval: Set to true to evaluate individuals in parallel. This is beneficial if your Evaluate method is computationally expensive.
• ParallelInit: Set to true to initialize individuals in parallel. This is beneficial if your genome initialization method is computationally expensive.

Note that these settings can be used regardless of whether you are using a single or multiple populations.

OpenAI's evolution strategy uses natural gradients to optimize a center point mu by sampling points around it using a normal distribution.

You can use eaopt.NewDefaultOES() for a quick setup or eaopt.NewOES() for fine-grained control over the evolution parameters.

To use it, provide a fitness function (a function that takes a slice of float64 and returns a float64) to the Minimize method of the OES instance.

// Instantiate OES with custom parameters
nPoints := uint(10)
nSteps := uint(100)
sigma := 0.05
lr := 0.01
parallel := true
var rng *rand.Rand = nil

var oes, err = eaopt.NewOES(nPoints, nSteps, sigma, lr, parallel, rng)

// Run minimization on a function
_, y, err := oes.Minimize(Rastrigin, 2)

When using the eaopt library, follow these guidelines to ensure correct initialization and performance:

• Use Constructor Functions: Always use the provided constructor functions (e.g., NewPSO instead of instantiating a PSO struct directly). These functions perform necessary parameter validation and error checking.
• Leverage Built-in Operators: If using the GA struct, check if evolutionary operators are already implemented in eaopt before writing your own.
• Understand Algorithm Abstractions: Many algorithms in the library are implemented as special cases of Genetic Algorithms (GAs). This design allows for more efficient underlying processing even if you only need a specific optimization method.
• Check Minimize signatures: To understand what type of function a specific method can optimize, inspect its Minimize function signature.

If your specific problem does not require crossover, you must still satisfy the Genome interface. You can do this by providing a blank implementation of the Crossover method.

type Vector []float64

// Provide a blank implementation to satisfy the interface
func (X Vector) Crossover(Y eaopt.Genome, rng *rand.Rand) {}

Hill climbing can be implemented in eaopt by configuring a Genetic Algorithm (GA) with the ModMutationOnly model and setting Strict: true.

To implement this, your genome must satisfy the eaopt.Genome interface, which requires implementing Evaluate(), Mutate(), Crossover(), and Clone(). For hill climbing, Crossover should do nothing.

cfg := eaopt.NewDefaultGAConfig()
cfg.Model = eaopt.ModMutationOnly{Strict: true}
cfg.NGenerations = 9999

ga, err := cfg.NewGA()
err = ga.Minimize(func(rng *rand.Rand) eaopt.Genome {
    // Return a new random genome instance
    return &Coord2D{X: rng.Float64(), Y: rng.Float64()}
})