Browse Source

First commit - Seems to pass "all 1's" evolution test

remotes/origin/HEAD
Mike 2 years ago
parent
commit
854ad5a1a3
13 changed files with 1231 additions and 0 deletions
  1. +152
    -0
      Breeder.cpp
  2. +41
    -0
      Breeder.h
  3. +184
    -0
      Chromosome.cpp
  4. +71
    -0
      Chromosome.h
  5. +13
    -0
      Defines.h
  6. +9
    -0
      Enums.h
  7. +14
    -0
      ForwardDeclarations.h
  8. +13
    -0
      Includes.h
  9. +122
    -0
      Makefile
  10. +389
    -0
      Population.cpp
  11. +96
    -0
      Population.h
  12. +86
    -0
      Random.cpp
  13. +41
    -0
      Random.h

+ 152
- 0
Breeder.cpp View File

@@ -0,0 +1,152 @@


//
#include "BitEvolver/Random.h"
#include "BitEvolver/Chromosome.h"
#include "BitEvolver/Breeder.h"


//
#include <iostream>


//
namespace BitEvolver
{
//
using std::cout;
using std::endl;
//
Breeder::Breeder(std::shared_ptr<Random> _random)
{
//
this->random = _random;
}
//
std::shared_ptr<Chromosome> Breeder::Breed(
std::shared_ptr<Chromosome> mama,
std::shared_ptr<Chromosome> papa,
double crossover_rate,
double mutation_rate
)
{
//
std::shared_ptr<Chromosome> kiddo;
int bit_length;
// For now, don't crossover unless the bit lengths are identical
bit_length = mama->GetBitCount();
if ( papa->GetBitCount() != bit_length ) {
throw std::runtime_error("Breeder::Breed() - Incompatible parents");
}
// Directly copy the mama
kiddo = std::shared_ptr<Chromosome>(new Chromosome(this->random, bit_length));
*kiddo = *mama;
// Apply crossover
this->ApplyCrossover(kiddo, papa, crossover_rate);
// Apply mutation
this->Mutate(kiddo, mutation_rate);
return kiddo;
}
//
void Breeder::Mutate(std::shared_ptr<Chromosome> chromosome, double mutation_rate)
{
//
int i, size;
//
#warning "For efficiency, let's instead roll the number of bits to flip in advance, and loop that many times (faster than rolling for every bit)"
//
size = chromosome->GetBitCount();
for ( i=0; i<size; i++ ) {
//
if ( this->random->RollBool(mutation_rate) ) {
chromosome->FlipBit(i);
}
}
//
chromosome->ResetFitness();
}
//
int Breeder::PickRandomCrossoverPoint(std::shared_ptr<Chromosome> chromosome, double crossover_rate)
{
//
double crossover_point_double;
int crossover_point;
int bit_count;
//
bit_count = chromosome->GetBitCount();
/**
Choose a double between [0.0,1.0] for the crossover point.
Use normal distribution, with the mean to the default point,
and 1.0 as the std.
That way, there is still randomness to the crossover point,
but it still generally sticks near the default
*/
crossover_point_double = this->random->GetNormal(crossover_rate, 1.0);
// Apply to the actual int length
crossover_point = crossover_point_double * bit_count;
// Loop around to keep in bounds
while ( crossover_point < 0 )
{
crossover_point += bit_count;
}
while ( crossover_point >= bit_count)
{
crossover_point -= bit_count;
}
return crossover_point;
}
//
void Breeder::ApplyCrossover(std::shared_ptr<Chromosome> kiddo, std::shared_ptr<Chromosome> parent, double crossover_rate)
{
//
int
bits_count,
crossover_point,
i
;
//
bits_count = kiddo->GetBitCount();
if ( parent->GetBitCount() != bits_count ) {
throw std::runtime_error("Breeder::ApplyCrossover() - Parent incompatible with Kiddo (bit lengths don't match)");
}
// Pick random crossover point
crossover_point = this->PickRandomCrossoverPoint(kiddo, crossover_rate);
// Begin copying the parent at the crossover point and beyond
// (not before)
for ( i=crossover_point; i<bits_count; i++) {
kiddo->SetBit( i, parent->GetBit(i) );
}
//
kiddo->ResetFitness();
}
};








+ 41
- 0
Breeder.h View File

@@ -0,0 +1,41 @@


//
#pragma once


//
namespace BitEvolver
{
//
class Breeder
{
//
public:
//
Breeder(std::shared_ptr<class Random> _random);
//
std::shared_ptr<class Chromosome> Breed(
std::shared_ptr<class Chromosome> mama,
std::shared_ptr<class Chromosome> papa,
double crossover_rate,
double mutation_rate
);
//
void Mutate(std::shared_ptr<class Chromosome> chromosome, double mutation_rate);
//
private:
//
std::shared_ptr<class Random> random;
//
int PickRandomCrossoverPoint(std::shared_ptr<class Chromosome> chromosome, double crossover_rate);
void ApplyCrossover(std::shared_ptr<class Chromosome> kiddo, std::shared_ptr<class Chromosome> parent, double crossover_rate);
};
};


+ 184
- 0
Chromosome.cpp View File

@@ -0,0 +1,184 @@


//
#include "BitEvolver/Chromosome.h"
#include "BitEvolver/Random.h"


//
#include <memory>
#include <string>
#include <sstream>
#include <vector>


//
namespace BitEvolver
{
//
using std::string;
using std::to_string;
using std::stringstream;
//
Chromosome::Chromosome(std::shared_ptr<Random> _random, int _bits)
{
//
this->random = _random;
this->SetBitCount(_bits);
//
this->Reset();
}
//
void Chromosome::Reset()
{
//
this->Randomize();
}
//
void Chromosome::Randomize()
{
//
int i;
//
this->bits.clear();
//
for ( i=0; i<this->bits_count_desired; i++ ) {
this->bits.push_back(this->random->GetInt(0, 1));
}
}
//
void Chromosome::SetBitCount(int count)
{
//
this->bits_count_desired = count;
this->Randomize();
}
//
int Chromosome::GetBitCount()
{
return (int)this->bits.size();
}
//
void Chromosome::FlipBit(int index)
{
//
if ( index >= (int)this->bits.size() ) {
throw std::runtime_error("Chromosome::FlipBit() - Tried to flip out of range bit index: " + to_string(index));
}
//
if ( this->bits[index] ) {
this->bits[index] = false;
}
else{
this->bits[index] = true;
}
}
//
bool Chromosome::GetBit(int index)
{
//
if ( index >= (int)this->bits.size() ) {
throw std::runtime_error("Chromosome::GetBit() - Tried to access out of bounds bit");
}
//
return this->bits[index];
}
//
void Chromosome::SetBit(int index, bool b)
{
//
if ( index >= (int)this->bits.size() ) {
throw std::runtime_error("Chromosome::GetBit() - Tried to access out of bounds bit");
}
//
this->bits[index] = b;
}
//
void Chromosome::ResetFitness()
{
//
this->SetFitness(0.0);
}
//
void Chromosome::SetFitness(double d)
{
//
this->fitness = d;
}
//
void Chromosome::AdjustFitness(double d)
{
//
this->fitness += d;
}
//
double Chromosome::GetFitness()
{
//
return this->fitness;
}
//
string Chromosome::ToString()
{
//
stringstream s;
//
for ( bool b : this->bits ) {
//
if ( b ) {
s << "1";
}
else{
s << "0";
}
}
//
return s.str();
}
//
const Chromosome& Chromosome::operator=(const Chromosome& other)
{
//
int i;
//
this->random = other.random;
this->bits = other.bits;
this->bits_count_desired = other.bits_count_desired;
this->fitness = other.fitness;
// Copy the bits!
this->bits.clear();
for ( i=0; i<(int)other.bits.size(); i++ ) {
this->bits.push_back(other.bits[i]);
}
return *this;
}
};




+ 71
- 0
Chromosome.h View File

@@ -0,0 +1,71 @@


//
#pragma once


//
#include "BitEvolver/Includes.h"


//
#include <memory>
#include <string>
#include <sstream>
#include <vector>


//
namespace BitEvolver
{
//
class Chromosome
{
//
public:
//
Chromosome(std::shared_ptr<class Random> _random, int _bits);
//
void Reset();
void Randomize();
//
void SetBitCount(int count);
int GetBitCount();
//
void FlipBit(int index);
//
bool GetBit(int index);
void SetBit(int index, bool b);
//
void ResetFitness();
void SetFitness(double d);
void AdjustFitness(double d);
double GetFitness();
//
std::string ToString();
//
const Chromosome& operator=(const Chromosome& other);
//
private:
// Random number generator
std::shared_ptr<class Random> random;
//
std::vector<bool> bits;
int bits_count_desired;
// Fitness
double fitness;
};
};


+ 13
- 0
Defines.h View File

@@ -0,0 +1,13 @@
#ifndef BITEVOLVER_DEFINES_H
#define BITEVOLVER_DEFINES_H



//
#define BIT_EVOLVER_POPULATION_DEFAULT_POPULATION_SIZE 100
#define BIT_EVOLVER_POPULATION_DEFAULT_MUTATE_RATE 0.01
#define BIT_EVOLVER_POPULATION_DEFAULT_CROSSOVER 0.7



#endif

+ 9
- 0
Enums.h View File

@@ -0,0 +1,9 @@
#ifndef BITEVOLVER_ENUMS_H
#define BITEVOLVER_ENUMS_H


//



#endif

+ 14
- 0
ForwardDeclarations.h View File

@@ -0,0 +1,14 @@
#ifndef BITEVOLVER_FORWARD_DECLARATIONS_H
#define BITEVOLVER_FORWARD_DECLARATIONS_H

//
namespace BitEvolver
{
//
class Population;
class Breeder;
class Chromosome;
};


#endif

+ 13
- 0
Includes.h View File

@@ -0,0 +1,13 @@
#ifndef BITEVOLVER_INCLUDES_H
#define BITEVOLVER_INCLUDES_H


//
#include "BitEvolver/Defines.h"
#include "BitEvolver/Enums.h"





#endif

+ 122
- 0
Makefile View File

@@ -1 +1,123 @@

# Custom functions
define say
$(info [BitEvolver] $1)
endef
define error
$(error [BitEvolver] $1)
endef
define die
$(call error,$1)
$(exit 1)
endef


# Demand BUILD_DIR and BIN_DIR
ifeq ($(BUILD_DIR),)
$(call die,Please provide BUILD_DIR)
endif
ifeq ($(BIN_DIR),)
$(call die,Please provide BIN_DIR)
endif


#
CC=g++
CFLAGS= -c -std=c++11 -Wall -I..


#
OBJECT_PREFIX=BitEvolver_


#
default: default-say
default: release
default:
$(call say,Default target finished)
default-say:
$(call say,Using default target: release)


#
release: release-say
release: CFLAGS+= -O2
release: build-objects
release:
$(call say,Done building RELEASE)
release-say:
$(call say,Building RELEASE)

#
debug: debug-say
debug: CFLAGS+= -g -g3
debug: build-objects
debug:
$(call say,Done building DEBUG)
debug-say:
$(call say,Building DEBUG)


#
build-objects: \
$(BUILD_DIR)/$(OBJECT_PREFIX)Random.o \
$(BUILD_DIR)/$(OBJECT_PREFIX)Population.o \
$(BUILD_DIR)/$(OBJECT_PREFIX)Breeder.o \
$(BUILD_DIR)/$(OBJECT_PREFIX)Chromosome.o
$(call say,Done building objects)


# Population.o
$(BUILD_DIR)/$(OBJECT_PREFIX)Population.o: \
Population.h \
Population.cpp \
Defines.h Enums.h Includes.h \
Random.h \
Chromosome.h
$(CC) -o $@ \
Population.cpp \
$(CFLAGS)
$(call say,Built $@)


# Breeder.o
$(BUILD_DIR)/$(OBJECT_PREFIX)Breeder.o: \
Breeder.h \
Breeder.cpp \
Defines.h Enums.h Includes.h \
Random.h \
Chromosome.h
$(CC) -o $@ \
Breeder.cpp \
$(CFLAGS)
$(call say,Built $@)


# Chromosome.o
$(BUILD_DIR)/$(OBJECT_PREFIX)Chromosome.o: \
Chromosome.h \
Chromosome.cpp \
Defines.h Enums.h Includes.h \
Random.h
$(CC) -o $@ \
Chromosome.cpp \
$(CFLAGS)
$(call say,Built $@)


# Random.o
$(BUILD_DIR)/$(OBJECT_PREFIX)Random.o: \
Random.h \
Random.cpp \
Defines.h Enums.h Includes.h
$(CC) -o $@ \
Random.cpp \
$(CFLAGS)
$(call say,Built $@)








+ 389
- 0
Population.cpp View File

@@ -0,0 +1,389 @@


//
#include "BitEvolver/Includes.h"
#include "BitEvolver/Random.h"
#include "BitEvolver/Population.h"
#include "BitEvolver/Breeder.h"
#include "BitEvolver/Chromosome.h"


//
#include <memory>
#include <vector>
#include <mutex>
#include <iostream>
#include <algorithm>
#include <thread>


//
namespace BitEvolver
{
//
using std::cout;
using std::endl;
//
Population::Population()
{
//
this->InitRandomGenerator();
this->InitBreeder();
//
this->Reset();
}
//
void Population::Reset()
{
//
this->population_size = BIT_EVOLVER_POPULATION_DEFAULT_POPULATION_SIZE;
this->SetMutationRate(BIT_EVOLVER_POPULATION_DEFAULT_MUTATE_RATE);
this->evolution_number = 0;
//
this->RandomizePopulation(this->population_size);
}
//
void Population::ClearPopulation()
{
//
this->chromosomes.clear();
this->evolution_number = 0;
}
//
void Population::InitRandomPopulation(int _population_size, int _bit_length)
{
//
this->population_size = _population_size;
//
this->RandomizePopulation(_bit_length);
}
//
void Population::RandomizePopulation(int _bit_length)
{
//
std::shared_ptr<Chromosome> chromosome;
int i;
//
this->ClearPopulation();
for ( i=0; i<this->population_size; i++ ) {
//
chromosome = std::shared_ptr<Chromosome>(
new Chromosome( this->random, _bit_length )
);
this->chromosomes.push_back(chromosome);
}
}
//
void Population::PopulationChanged()
{
//
this->population_needs_sorting = true;
}
//
std::vector<std::shared_ptr<Chromosome>> Population::GetChromosomes()
{
return this->chromosomes;
}
//
void Population::GetChromosomes(std::shared_ptr<std::vector<std::shared_ptr<Chromosome>>> _chromosomes)
{
//
_chromosomes->clear();
for ( std::shared_ptr<Chromosome> chromosome : this->chromosomes) {
_chromosomes->push_back(chromosome);
}
}
//
std::shared_ptr<Chromosome> Population::GetChampion()
{
//
this->EnsureSortedPopulation();
//
if ( this->chromosomes.size() > 0 ) {
return this->chromosomes[0];
}
return nullptr;
}
//
double Population::GetAverageFitness()
{
return this->GetAverageFitness(this->chromosomes);
}
//
double Population::GetAverageFitness(std::vector<std::shared_ptr<Chromosome>> _chromosomes)
{
//
double fitness_sum;
double fitness_average;
//
fitness_sum = 0;
for ( std::shared_ptr<Chromosome> chromosome : _chromosomes ) {
fitness_sum += chromosome->GetFitness();
}
//
fitness_average = 0;
if ( _chromosomes.size() > 0 ) {
fitness_average = fitness_sum / _chromosomes.size();
}
return fitness_average;
}
//
void Population::SetMutationRate(double r)
{
//
this->mutation_rate = r;
}
//
void Population::Evolve()
{
//
std::shared_ptr<std::vector< std::shared_ptr<Chromosome> > > population_new;
//
if ( this->chromosomes.size() == 0 ) {
return;
}
//
this->EnsureSortedPopulation();
//
population_new = std::shared_ptr<
std::vector<
std::shared_ptr<Chromosome>
>
>(
new std::vector<std::shared_ptr<Chromosome>>()
);
// Start the new population off with our champion,
// so the best score always carries over (elitism = 1 unit)
#warning "Elitism is only 1 right now"
population_new->push_back(this->chromosomes[0]);
// Breed the new population
this->BreedNewPopulation(population_new, (int)this->chromosomes.size());
// Replace old population with the new
this->chromosomes = *population_new;
this->evolution_number++;
//
this->PopulationChanged();
}
//
int Population::GetEvolutionNumber()
{
return this->evolution_number;
}
//
void Population::PrintPopulation()
{
//
this->EnsureSortedPopulation();
this->PrintPopulation(this->chromosomes);
}
//
void Population::PrintPopulation(std::vector<std::shared_ptr<Chromosome>> _chromosomes)
{
//
for ( std::shared_ptr<Chromosome> chromosome : chromosomes ) {
cout << chromosome->ToString() << endl;
}
cout << "Average Fitness --> " << this->GetAverageFitness(_chromosomes) << endl;
}
//
void Population::InitRandomGenerator()
{
//
this->random = std::shared_ptr<Random>(
new Random()
);
}
//
void Population::InitBreeder()
{
//
if ( !this->random ) {
throw std::runtime_error("Population::InitBreeder() - Should come after InitRandomGenerator()");
}
//
this->breeder = std::shared_ptr<Breeder>(
new Breeder( this->random )
);
}
//
void Population::EnsureSortedPopulation()
{
//
if ( !this->population_needs_sorting ) {
return;
}
// Yay std::sort
std::sort(
this->chromosomes.begin(),
this->chromosomes.end(),
[]( std::shared_ptr<Chromosome>& left, std::shared_ptr<Chromosome>& right ) -> bool
{
//
if ( left->GetFitness() > right->GetFitness() ) {
return true;
}
return false;
}
);
//
this->population_needs_sorting = false;
}
//
void Population::BreedNewPopulation(std::shared_ptr<std::vector<std::shared_ptr<Chromosome>>> population_new, int size)
{
//
std::vector<std::shared_ptr<std::thread>> threads;
std::shared_ptr<std::thread> thread;
int
thread_count,
i
;
//
thread_count = std::thread::hardware_concurrency();
//
for ( i=0; i<thread_count; i++) {
thread = std::shared_ptr<std::thread>(
new std::thread(&Population::BreedNewPopulation_Thread, this, population_new, size)
);
threads.push_back(thread);
}
//
for ( i=0; i<(int)threads.size(); i++) {
threads[i]->join();
}
}
//
void Population::BreedNewPopulation_Thread(std::shared_ptr<std::vector<std::shared_ptr<Chromosome>>> population_new, int size)
{
//
std::shared_ptr<Chromosome> kiddo;
//
while ( (int)population_new->size() < size )
{
//
kiddo = this->BreedChild();
// Mutexed
this->breed_mutex.lock();
if ( (int)population_new->size() < size ) {
population_new->push_back(kiddo);
}
this->breed_mutex.unlock();
}
}
//
std::shared_ptr<Chromosome> Population::BreedChild()
{
//
std::shared_ptr<Chromosome>
mama, papa, kiddo
;
// Pick two parents
mama = this->PickChromosomeForBreeding();
papa = this->PickChromosomeForBreeding();
//
kiddo = this->breeder->Breed(mama, papa, BIT_EVOLVER_POPULATION_DEFAULT_CROSSOVER, this->mutation_rate);
return kiddo;
}
/**
(1) We want to pick the best chromosomes to repopulate
(2) [not in lecture] We want to add a bit of randomness
to the selection process, such that the worst chromosomes
can still possibly be picked, and the best can still
possibly be not-picked; Their fitness only increases
the probability they're picked.
*/
std::shared_ptr<Chromosome> Population::PickChromosomeForBreeding()
{
//
double normal;
int chromosome_index;
//
this->EnsureSortedPopulation();
/**
Grab normal with 0 at the mean, and the standard deviation equal
to 1/2 of the population size. Then make that an absolute value.
This will make top/best chromosomes more likely to be picked,
with the far/low end being much less likely
*/
#warning "Need to upgrade this to Roulette Wheel"
// Repeat as needed, since the normal generator might actually
// give us an out-of-bounds result sometimes
while ( true )
{
//
normal = this->random->GetNormal(0, 0.5);
chromosome_index = abs( normal * this->chromosomes.size()
);
if ( chromosome_index >= 0 && chromosome_index < (int)this->chromosomes.size() ) {
break;
}
}
//
return this->chromosomes[chromosome_index];
}
};










+ 96
- 0
Population.h View File

@@ -0,0 +1,96 @@


//
#pragma once


//
#include "BitEvolver/Includes.h"


//
#include <memory>
#include <vector>
#include <mutex>


//
namespace BitEvolver
{
//
class Population
{
//
public:
//
Population();
//
void Reset();
//
void ClearPopulation();
void InitRandomPopulation(int _population_size, int _bit_length);
void RandomizePopulation(int _bit_length);
//
void PopulationChanged();
//
std::vector<std::shared_ptr<class Chromosome>> GetChromosomes();
void GetChromosomes(std::shared_ptr<std::vector<std::shared_ptr<class Chromosome>>> _chromosomes);
std::shared_ptr<class Chromosome> GetChampion();
//
double GetAverageFitness();
double GetAverageFitness(std::vector<std::shared_ptr<class Chromosome>> _chromosomes);
//
void SetMutationRate(double r);
//
void Evolve();
int GetEvolutionNumber();
//
void PrintPopulation();
void PrintPopulation(std::vector<std::shared_ptr<class Chromosome>> _chromosomes);
//
private:
//
std::shared_ptr<class Random> random;
std::shared_ptr<class Breeder> breeder;
//
std::vector<std::shared_ptr<class Chromosome>> chromosomes;
int population_size;
bool population_needs_sorting;
double mutation_rate;
int evolution_number;
//
std::mutex breed_mutex;
//
void InitRandomGenerator();
void InitBreeder();
//
void EnsureSortedPopulation();
//
void BreedNewPopulation(std::shared_ptr<std::vector<std::shared_ptr<Chromosome>>> population_new, int size);
void BreedNewPopulation_Thread(std::shared_ptr<std::vector<std::shared_ptr<Chromosome>>> population_new, int size);
//
std::shared_ptr<Chromosome> BreedChild();
std::shared_ptr<Chromosome> PickChromosomeForBreeding();
};
};




+ 86
- 0
Random.cpp View File

@@ -0,0 +1,86 @@


//
#include "BitEvolver/Random.h"


//
#include <random>
#include <chrono>


//
namespace BitEvolver
{
//
Random::Random()
{
//
this->InitializeGenerators();
}
//
int Random::GetInt(int min, int max)
{
//
std::uniform_int_distribution<int> distribution(min, max);
//
int the_int = distribution(this->generator_mersenne_twister);
return the_int;
}
//
double Random::GetDouble(double min, double max)
{
//
std::uniform_real_distribution<double> distribution(min, max);
//
double the_double = distribution(this->generator_mersenne_twister);
return the_double;
}
//
double Random::GetNormal(double mean, double standard_deviation)
{
//
std::normal_distribution<double> distribution(mean, standard_deviation);
double d = distribution(this->generator_mersenne_twister);
return d;
}
//
bool Random::RollBool(double chance)
{
//
double d = this->GetDouble(0, 1);
if ( d <= chance ) {
return true;
}
return false;
}
//
void Random::InitializeGenerators()
{
// Mostly taken from
// http://www.cplusplus.com/reference/random/mersenne_twister_engine/seed/
typedef std::chrono::high_resolution_clock myclock;
//
myclock::time_point beginning = myclock::now();
myclock::duration d = myclock::now() - beginning;
unsigned seed = d.count();
// Seed our internal generator
this->generator_mersenne_twister.seed(seed);
}
};



+ 41
- 0
Random.h View File

@@ -0,0 +1,41 @@


//
#pragma once


//
#include <random>


//
namespace BitEvolver
{
//
class Random
{
//
public:
//
Random();
//
int GetInt(int min, int max);
double GetDouble(double min, double max);
double GetNormal(double mean, double standard_deviation);
//
bool RollBool(double chance);
//
private:
//
std::mt19937_64 generator_mersenne_twister;
//
void InitializeGenerators();
};
};

Loading…
Cancel
Save