Pool operators Unit tests

Author: salvacorts

mlp-ea-decentralized/common/ga/tests/client_test.go renamed to mlp-ea-decentralized/common/ga/client_test.go

@@ -133,7 +133,7 @@ func (c *eventHandler) NotifyUpdate(node *memberlist.Node) {
 	meta := NodeMetadata{}
 	err := meta.Unmarshal(node.Meta)
 	if err != nil {
-		c.Logger.Errorf("Could not deserialize node metadata. $s", err.Error())
+		c.Logger.Errorf("Could not deserialize node metadata. %s", err.Error())
 	}
 
 	c.Logger.Infof("Node updated: %s:%d", node.Addr.String(), node.Port)

mlp-ea-decentralized/common/ga/cluster.go

@@ -13,7 +13,6 @@ import (
 	"sync"
 	"time"
 
-	"github.com/salvacorts/TFG-Parasitic-Metaheuristics/mlp-ea-decentralized/common/mlp"
 	"github.com/sirupsen/logrus"
 
 	"github.com/dennwc/dom/net/ws"
@@ -27,6 +26,9 @@ var Log = logrus.New()
 // SortFunction gets an array of individuals and sorts them with a given precission
 type SortFunction = func(slice []eaopt.Individual, precission int) []eaopt.Individual
 
+// GenomeGenerator is a function that creates genomes randomly initializaed
+type GenomeGenerator = func(*rand.Rand) eaopt.Genome
+
 // PoolModel is a pool-based evolutionary algorithm
 // 		TODO: Wrap configuration into ConfigTypes (e.g. ClientConfig, IslandConfig, ModelConfig...)
 type PoolModel struct {
@@ -79,7 +81,9 @@ type PoolModel struct {
 }
 
 // MakePool Creates a new pool with default configuration
-func MakePool(popSize int, grpcPort, clusterPort int, boostrapPeers []string, rnd *rand.Rand) *PoolModel {
+func MakePool(
+	popSize int, grpcPort, clusterPort int, boostrapPeers []string,
+	rnd *rand.Rand, generator GenomeGenerator) *PoolModel {
 	pool := &PoolModel{
 		Rnd:                   rnd,
 		PopSize:               popSize,
@@ -100,7 +104,7 @@ func MakePool(popSize int, grpcPort, clusterPort int, boostrapPeers []string, rn
 	pool.cluster.Logger.SetLevel(logrus.DebugLevel)
 
 	for i := 0; i < pool.PopSize; i++ {
-		indi := eaopt.NewIndividual(mlp.NewRandMLP(pool.Rnd), pool.Rnd)
+		indi := eaopt.NewIndividual(generator(pool.Rnd), pool.Rnd)
 		pool.population.Add(indi)
 	}
 
@@ -140,6 +144,10 @@ func (pool *PoolModel) Minimize() {
 	for pool.evaluations < pool.MaxEvaluations {
 		var offsprings []eaopt.Individual
 
+		// At least nOffsprings shold be available in the population
+		// tu run this operator
+		pool.popSemaphore.Acquire(4)
+
 		// take here randomly from population
 		offsprings = pool.selection(4, 4)
 		offsprings = pool.crossover(offsprings)
@@ -168,14 +176,10 @@ func (pool *PoolModel) Minimize() {
 	}
 }
 
-// Binary torunament
+// Selection selects nOffstrings on a tournamnet of nCandidates
 func (pool *PoolModel) selection(nOffstrings, nCandidates int) []eaopt.Individual {
 	offsprings := make([]eaopt.Individual, nOffstrings)
 
-	// At least nOffsprings shold be available in the population
-	// tu run this operator
-	pool.popSemaphore.Acquire(nOffstrings)
-
 	for i := range offsprings {
 		alreadySelected := make(map[string]int) // 0 means not selected
 		candidates := make([]eaopt.Individual, nCandidates)
@@ -209,6 +213,7 @@ func (pool *PoolModel) selection(nOffstrings, nCandidates int) []eaopt.Individua
 
 // TODO: Get rid of odd arrays here
 func (pool *PoolModel) crossover(in []eaopt.Individual) []eaopt.Individual {
+	offsprings := make([]eaopt.Individual, len(in))
 	for i := 0; i < len(in)-1; i += 2 {
 		if pool.Rnd.Float64() < pool.CrossRate {
 			o1, o2 := in[i].Clone(pool.Rnd), in[i+1].Clone(pool.Rnd)
@@ -218,12 +223,12 @@ func (pool *PoolModel) crossover(in []eaopt.Individual) []eaopt.Individual {
 			o2.Evaluated = false
 
 			// Add keep best here? No, since you would have to evaluate the offsprings
-			in[i] = o1
-			in[i+1] = o2
+			offsprings[i] = o1
+			offsprings[i+1] = o2
 		}
 	}
 
-	return in
+	return offsprings
 }
 
 func (pool *PoolModel) mutate(in []eaopt.Individual) []eaopt.Individual {

mlp-ea-decentralized/common/ga/poolModel.go

@@ -0,0 +1,114 @@
+package ga
+
+import (
+	"math"
+	"math/rand"
+	"testing"
+
+	"github.com/salvacorts/TFG-Parasitic-Metaheuristics/mlp-ea-decentralized/common/mlp"
+)
+
+func TestMakePool(t *testing.T) {
+	size := 100
+
+	mlp.Config.FactoryCfg.MinHiddenNeurons = 2
+	mlp.Config.FactoryCfg.MaxHiddenNeurons = 4
+	pool := MakePool(size, 9999, 9998, []string{}, rand.New(rand.NewSource(7)), mlp.NewRandMLP)
+
+	if pool.GetTotalEvaluations() != 0 {
+		t.Errorf("Evaluated individuals on initialization")
+	}
+
+	if pool.BestSolution.Fitness != math.Inf(1) {
+		t.Errorf("Best individual fitness is not +Inf")
+	}
+
+	if pool.PopSize != size {
+		t.Errorf("PopSize and size argument on costructor do noot match")
+	}
+
+	if pool.population.Length() != size {
+		t.Errorf("Population Length does not match the constructor size")
+	}
+
+	if len(pool.GetPopulationSnapshot()) != pool.PopSize {
+		t.Errorf("Population snapshot size is different form PopSize")
+	}
+}
+
+func TestSelection(t *testing.T) {
+	mlp.Config.FactoryCfg.MinHiddenNeurons = 2
+	mlp.Config.FactoryCfg.MaxHiddenNeurons = 4
+	pool := MakePool(20, 9999, 9998, []string{}, rand.New(rand.NewSource(7)), mlp.NewRandMLP)
+	pool.SortFunc = mlp.SortByFitnessAndNeurons
+
+	for i, in := range pool.GetPopulationSnapshot() {
+		in.Fitness = float64(i)
+		pool.population.Add(in)
+	}
+
+	if pool.population.Length() != 20 {
+		t.Errorf("Population Add operator do not overwrite existing individual")
+	}
+
+	selected := pool.selection(4, 4)
+
+	scores := make([]float64, len(selected))
+	for i, s := range selected {
+		scores[i] = s.Fitness
+	}
+
+	t.Logf("Selected individuals: %v", scores)
+	if len(selected) != 4 {
+		t.Errorf("Selection do not select the amount of offsprings specified")
+	}
+
+	// If selection selected one of the 4 worst individuals it is not working
+	// It can happen but it is very unlikely
+	for _, s := range selected {
+		for i := 20 - 4 - 1; i < 20; i++ {
+			if s.Fitness == float64(i) {
+				t.Log("[WARN] Selected one of the worst individuals. It is very unlikely")
+			}
+		}
+	}
+
+}
+
+func TestCrossover(t *testing.T) {
+	mlp.Config.FactoryCfg.MinHiddenNeurons = 2
+	mlp.Config.FactoryCfg.MaxHiddenNeurons = 4
+	pool := MakePool(20, 9999, 9998, []string{}, rand.New(rand.NewSource(7)), mlp.NewRandMLP)
+	pool.SortFunc = mlp.SortByFitnessAndNeurons
+	pool.CrossRate = 1
+
+	snap := pool.GetPopulationSnapshot()
+
+	offsprings := pool.crossover(snap[:4])
+
+	for i, o := range offsprings {
+		if o == snap[i] {
+			t.Errorf("Offspring is equal to parent")
+		}
+	}
+}
+
+func TestGetAverageFitness(t *testing.T) {
+	mlp.Config.FactoryCfg.MinHiddenNeurons = 2
+	mlp.Config.FactoryCfg.MaxHiddenNeurons = 4
+	pool := MakePool(20, 9999, 9998, []string{}, rand.New(rand.NewSource(7)), mlp.NewRandMLP)
+
+	sum := 0.0
+	for i, in := range pool.GetPopulationSnapshot() {
+		in.Fitness = float64(i)
+		pool.population.Add(in)
+
+		sum += in.Fitness
+	}
+
+	avg := pool.GetAverageFitness()
+	if avg != sum/20 {
+		t.Errorf("Average fitness is not correct. Expected %f, got %f", sum/20, avg)
+	}
+
+}

mlp-ea-decentralized/common/ga/poolOperators_test.go

@@ -4,20 +4,18 @@ import (
 	"testing"
 
 	"github.com/salvacorts/eaopt"
-
-	"github.com/salvacorts/TFG-Parasitic-Metaheuristics/mlp-ea-decentralized/common/ga"
 )
 
 func TestMake(t *testing.T) {
-	population := ga.MakePopulation()
+	population := MakePopulation()
 
 	if population.Length() > 0 {
 		t.Errorf("Population is not empty at initialization")
 	}
 }
 
 func TestAdd(t *testing.T) {
-	population := ga.MakePopulation()
+	population := MakePopulation()
 
 	indiv := eaopt.Individual{
 		ID:        "A",
@@ -60,7 +58,7 @@ func TestAdd(t *testing.T) {
 }
 
 func TestRemove(t *testing.T) {
-	population := ga.MakePopulation()
+	population := MakePopulation()
 
 	indiv := eaopt.Individual{
 		ID:        "A",
@@ -85,7 +83,7 @@ func TestRemove(t *testing.T) {
 }
 
 func TestFold(t *testing.T) {
-	population := ga.MakePopulation()
+	population := MakePopulation()
 
 	indiv1 := eaopt.Individual{
 		ID:        "A",