evoli

Genetic Algorithm and Particle Swarm Optimization written in Go

Example

Problem

Given `f(x,y) = cos(x^2 * y^2) * 1/(x^2 * y^2 + 1)`

Find `(x,y)` such as `f(x,y)` reaches its maximum

Answer `f(0,0) = 1`

Particle Swarm Optimization

```package main

import (
"fmt"
"math"
"math/rand"

"github.com/khezen/evoli"
)

// 3d cosine that gets smaller as you move away from 0,0
func f(x, y float64) float64 {
d := x*x + y*y
return math.Cos(d) * (1 / (d/10 + 1))
}

type FIndividual struct {
v       []float64
x       []float64
fitness float64
}

func (i *FIndividual) Equal(other evoli.Individual) bool {
return i == other
}

func (i *FIndividual) Fitness() float64 {
return i.fitness
}

func (i *FIndividual) SetFitness(newFitness float64) {
i.fitness = newFitness
}

type FPositioner struct {
}

func (p *FPositioner) Position(indiv, pBest, gBest evoli.Individual, c1, c2 float64) (evoli.Individual, error) {
fIndiv, ok1 := indiv.(*FIndividual)
fPBest, ok2 := pBest.(*FIndividual)
fGBest, ok3 := gBest.(*FIndividual)
if !ok1 || !ok2 || !ok3 {
return nil, fmt.Errorf("invalid individual type")
}
newIndiv := FIndividual{
v: make([]float64, len(fIndiv.v)),
x: make([]float64, len(fIndiv.v)),
}
w := 0.9
for d := range fIndiv.v {
rp := rand.Float64()
rg := rand.Float64()
newIndiv.v[d] = w*fIndiv.v[d] +
c1*rp*(fPBest.x[d]-fIndiv.x[d]) +
c2*rg*(fGBest.x[d]-fIndiv.x[d])

newIndiv.x[d] = fIndiv.x[d] + newIndiv.v[d]
}
return &newIndiv, nil
}

type FEvaluater struct {
}

func (e *FEvaluater) Evaluate(indiv evoli.Individual) (Fitness float64, err error) {
fIndiv, ok := indiv.(*FIndividual)
if !ok {
return 0, fmt.Errorf("invalid individual type")
}
return f(fIndiv.x[0], fIndiv.x[1]), nil
}

func main() {
pop := evoli.NewPopulation(50)
for i := 0; i < pop.Cap(); i++ {
x := rand.Float64()*20 - 10
y := rand.Float64()*20 - 10
vx := rand.Float64()*20 - 10
vy := rand.Float64()*20 - 10
x: []float64{x, y},
v: []float64{vx, vy},
})
}
positioner := &FPositioner{}
evaluator := &FEvaluater{}

sw := evoli.NewSwarm(pop, positioner, .2, .2, evaluator)

for i := 0; i < 100; i++ {
err := sw.Next()
if err != nil {
panic(err)
}
}

// evaluate the latest population
for _, v := range sw.Population().Slice() {
f, err := evaluator.Evaluate(v)
if err != nil {
panic(err)
}
v.SetFitness(f)
}

fmt.Printf("Max Value: %.2f\n", sw.Alpha().Fitness())
}```
`Max Value: 1.00`

Gentic Algorithm

```package main

import (
"fmt"
"math"
"math/rand"

"github.com/khezen/evoli"
)

// 3d cosine that gets smaller as you move away from 0,0
func h(x, y float64) float64 {
d := x*x + y*y
return math.Cos(d) * (1 / (d/10 + 1))
}

type HIndividual struct {
v       []float64
x       []float64
fitness float64
}

func (i *HIndividual) Equal(other evoli.Individual) bool {
return i == other
}

func (i *HIndividual) Fitness() float64 {
return i.fitness
}

func (i *HIndividual) SetFitness(newFitness float64) {
i.fitness = newFitness
}

type HMutater struct {
}

func (m HMutater) Mutate(indiv evoli.Individual) (evoli.Individual, error) {
x := rand.Float64()*20 - 10
y := rand.Float64()*20 - 10
vx := rand.Float64()*20 - 10
vy := rand.Float64()*20 - 10
return &FIndividual{
x: []float64{x, y},
v: []float64{vx, vy},
}, nil
}

type HCrosser struct {
}

func (h HCrosser) Cross(indiv1, indiv2 evoli.Individual) (evoli.Individual, error) {
fIndiv1, _ := indiv1.(*FIndividual)
fIndiv2, _ := indiv2.(*FIndividual)
return &FIndividual{
x: []float64{(fIndiv1.x[0] + fIndiv2.x[0]) / 2, (fIndiv1.x[1] + fIndiv2.x[1]) / 2},
v: []float64{(fIndiv1.v[0] + fIndiv2.v[0]) / 2, (fIndiv1.v[1] + fIndiv2.v[1]) / 2},
}, nil
}

type HEvaluater struct {
}

func (e HEvaluater) Evaluate(indiv evoli.Individual) (Fitness float64, err error) {
fIndiv, ok := indiv.(*FIndividual)
if !ok {
return 0, fmt.Errorf("invalid individual type")
}
return f(fIndiv.x[0], fIndiv.x[1]), nil
}

func main() {
pop := evoli.NewPopulation(50)
for i := 0; i < pop.Cap(); i++ {
x := rand.Float64()*20 - 10
y := rand.Float64()*20 - 10
vx := rand.Float64()*20 - 10
vy := rand.Float64()*20 - 10
x: []float64{x, y},
v: []float64{vx, vy},
})
}
crosser := HCrosser{}
mutater := HMutater{}
evaluator := HEvaluater{}
mutationProbability := .02
selecter := evoli.NewTruncationSelecter()
survivorSize := 30

ga := evoli.NewGenetic(pop, selecter, survivorSize, crosser, mutater, mutationProbability, evaluator)

for i := 0; i < 100; i++ {
err := ga.Next()
if err != nil {
panic(err)
}
}

// evaluate the latest population
for _, v := range ga.Population().Slice() {
f, err := evaluator.Evaluate(v)
if err != nil {
panic(err)
}
v.SetFitness(f)
}

fmt.Printf("Max Value: %.2f\n", ga.Alpha().Fitness())
}```
`Max Value: 1.00`

Issues

If you have any problems or questions, please ask for help through a GitHub issue.

Contributions

Help is always welcome! For example, documentation (like the text you are reading now) can always use improvement. There's always code that can be improved. If you ever see something you think should be fixed, you should own it. If you have no idea what to start on, you can browse the issues labeled with help wanted.

As a potential contributor, your changes and ideas are welcome at any hour of the day or night, weekdays, weekends, and holidays. Please do not ever hesitate to ask a question or send a pull request.

• Add an example test case for using PSO

Hello @khezen ,

I was looking to use evoli and needed a quick little example for using PSO. I'd love to have your input on the example I created.

I think an example might be useful to others who look to use evoli.

Thanks!

Jason

opened by jasonsurratt 3
• Example of Genetic Algo Implementation Does Not Compile

The example for implementing and running a Genetic Algorithm does not compile. This is due to two main issues:

1. There are several instances of trying to use "FIndividual" to identify the individual object when "HIndividual" was used as the variable name for the implementation of an individual object instead. This is easily fixed by changing the "FIndividual" references to "HIndividual".

2. The call to evoli.NewGenetic() fails because the supplied "crosser", "mutater", and "evaluator" are incorrect. This problem breaks down into 2 more problems: Litteralls are trying to a) First all the supplied variables are literals when they should be pointers. This is easily fixed by added an & when assigning the "crosser", "mutater", and "evaluator" variables. b) The implementations of "HCrosser" and "HMutater" are incomplete. HCrosser is missing the "MutationProbability" float64 input. HMutater is missing the child2 output. This is not easily fixable, but just to get it to compile the missing variables can be quickly added.

I made the above changes in this commit: https://github.com/khezen/evoli/commit/1694c1db6c6212fbc1cb0da8c9ed51b94e956b8b

At this point, I was able to compile and run the program. Unfortunately, I got the following results from 6 runs:

1. Max Value: 0.99
2. Max Value: 0.97
3. Max Value: 0.99
4. Max Value: 0.98
5. Max Value: 0.98
6. Max Value: 1.00

This lack of accuracy is due to the implementation of "crosser" and "mutater" not using those aforementioned missing variables. After implementing a proper mutater and crosser and adjusting the mutation probability up to 0.2 the output consistently finds the maximum of 1.00.

opened by Ashtacore 2

• v1.3.0(Mar 6, 2021)

• API change Crosser to return two children
``````type Crosser interface {
Cross(parent1, parent2 Individual) (child1, child2 Individual, err error)
}
``````
Source code(tar.gz)
Source code(zip)

Description

We encountered use cases where it was important to retrieve deads as well as survivors so we changed the PI to enable that.

API Change

~~Select(pop Population, survivorsSize int) (survivors Population, err error)~~ Select(pop Population, survivorsSize int) (survivors, deads Population, err error)

~~Abritrate(participants ...Individual) (winner Individual)~~ Abritrate(participants ...Individual) (winner Individual, loosers []Individual)

Source code(tar.gz)
Source code(zip)

• v1.1.0(Mar 21, 2020)

Guillaume Simonneau
Opensource & knowledge sharing enthusiast.
Distributed hyperparameter optimization framework, inspired by Optuna.

Goptuna Distributed hyperparameter optimization framework, inspired by Optuna [1]. This library is particularly designed for machine learning, but eve

214 Jun 28, 2022
SGPM: A coroutine scheduling model for wound-wait concurrency control optimization

Environment set up off the mod go env -w GO111MODULE=off change to GPATH to project directory go env -w GOPATH=\$HOME/sgpm Usage This project serves th

0 Dec 12, 2021
Genetic Algorithms library written in Go / golang

Description Genetic Algorithms for Go/Golang Install \$ go install git://github.com/thoj/go-galib.git Compiling examples: \$ git clone git://github.com

192 May 26, 2022
Genetic algorithms using Golang Generics

Package genetic Package genetic implements genetic algorithms using Golang's Gen

2 Jun 18, 2022
A native Go clean room implementation of the Porter Stemming algorithm.

Go Porter Stemmer A native Go clean room implementation of the Porter Stemming Algorithm. This algorithm is of interest to people doing Machine Learni

179 Oct 15, 2021
Golang implementation of the Paice/Husk Stemming Algorithm

##Golang Implementation of the Paice/Husk stemming algorithm This project was created for the QUT course INB344. Details on the algorithm can be found

28 Jan 23, 2022
Fast (linear time) implementation of the Gaussian Blur algorithm in Go.

Song2 Fast (linear time) implementation of the Gaussian Blur algorithm in Go.

49 Apr 24, 2022
An iterative algorithm to generate high-quality triangulated images.

An iterative algorithm to generate high quality triangulated images. Introduction Triangula uses a modified genetic algorithm to triangulate images. I

3.7k Jun 27, 2022
k-means clustering algorithm implementation written in Go

kmeans k-means clustering algorithm implementation written in Go What It Does k-means clustering partitions a multi-dimensional data set into k cluste

376 Jun 14, 2022
a* pathfinding algorithm written in go

astar a* (a-star) pathfinding algorithm written in go Wikipedia: EN: A* search algorithm DE: A*-Algorithmus Install go get github.com/jpierer/[email protected]

26 Mar 21, 2022
The open source, end-to-end computer vision platform. Label, build, train, tune, deploy and automate in a unified platform that runs on any cloud and on-premises.

End-to-end computer vision platform Label, build, train, tune, deploy and automate in a unified platform that runs on any cloud and on-premises. onepa

605 Jun 24, 2022
Go types, funcs, and utilities for working with cards, decks, and evaluating poker hands (Holdem, Omaha, Stud, more)

cardrank.io/cardrank Package cardrank.io/cardrank provides a library of types, funcs, and utilities for working with playing cards, decks, and evaluat

50 Jun 21, 2022
k-modes and k-prototypes clustering algorithms implementation in Go

go-cluster GO implementation of clustering algorithms: k-modes and k-prototypes. K-modes algorithm is very similar to well-known clustering algorithm

31 Mar 14, 2022
Probability distributions and associated methods in Go

godist godist provides some Go implementations of useful continuous and discrete probability distributions, as well as some handy methods for working

33 Apr 1, 2022
On-line Machine Learning in Go (and so much more)

goml Golang Machine Learning, On The Wire goml is a machine learning library written entirely in Golang which lets the average developer include machi

1.3k Jun 30, 2022
Bayesian text classifier with flexible tokenizers and storage backends for Go

Shield is a bayesian text classifier with flexible tokenizer and backend store support Currently implemented: Redis backend English tokenizer Example

152 Jun 23, 2022
Training materials and labs for a "Getting Started" level course on COBOL

COBOL Programming Course This project is a set of training materials and labs for COBOL on z/OS. The following books are available within this reposit

2.2k Jun 27, 2022
A curated list of Awesome Go performance libraries and tools

Awesome Go performance Collection of the Awesomeâ„˘ Go libraries, tools, project around performance. Contents Algorithm Assembly Benchmarks Compiling Co

271 Jun 29, 2022
Deploy, manage, and scale machine learning models in production

Deploy, manage, and scale machine learning models in production. Cortex is a cloud native model serving platform for machine learning engineering teams.

7.8k Jun 21, 2022