Fixed GetFittestOrganism() actually always returning the least fittes…

…t. This commit is the first one completely solving the XOR Test!

JNF_NEAT/genome.cpp

@@ -55,7 +55,7 @@ double Genome::GetGeneticalDistanceFrom(const Genome& other) const {
 	return disjointGenesInfluence + averageWeightDifference;
 }
 
-bool Genome::DoesContainGene(const Gene & gene) const {
+bool Genome::DoesContainGene(const Gene& gene) const {
 	for (auto & g : genes) {
 		if (g.from == gene.from && g.to == gene.to && g.isRecursive == gene.isRecursive) {
 			return true;

JNF_NEAT/main.cpp

@@ -34,7 +34,7 @@ int main() {
 	*/
 	std::vector<std::vector<float>> trainingData = { { 0.0f, 0.0f },{ 0.0f, 1.0f },{ 1.0f, 0.0f },{ 1.0f, 1.0f } };
 	for (auto & t : trainingData) {
-		std::cout << (int)(champ.GetOutputs(t).front() >= 0.5f) << "\t" << ((t.front() >= 0.5f) ^ (t.back() >= 0.5f)) << std::endl;
+		std::cout << (int)(champ.GetOutputs(t).front() >= 0.0f) << "\t" << ((t.front() >= 0.0f) ^ (t.back() >= 0.0f)) << std::endl;
 	}
 	return 0;
 }

JNF_NEAT/neural_network_trainer.cpp

@@ -127,18 +127,18 @@ void NeuralNetworkTrainer::DeleteEmptySpecies() {
 void NeuralNetworkTrainer::Repopulate() {
     PrepareSpeciesForPopulation();
 	auto DidChanceOccure = [](float chance) {
-		auto num = rand() % 100;
-		return num < int(100.0f * chance);
+		auto num = rand() % 1000;
+		return num < int(1000.0f * chance);
 	};
 
 	for (auto& trainer : bodies) {
 		Species* sp = &SelectSpeciesToBreed();
-		auto & father = sp->GetOrganismToBreed();
+		auto& father = sp->GetOrganismToBreed();
 		if (DidChanceOccure(parameters.advanced.reproduction.chanceForInterspecialReproduction)){
 			sp = &SelectSpeciesToBreed();
 		}
 		auto& mother = sp->GetOrganismToBreed();
-		auto childNeuralNetwork(father.BreedWith(mother));
+		auto childNeuralNetwork(std::move(father.BreedWith(mother)));
 		Organism child(&*trainer, std::move(childNeuralNetwork));
         FillOrganismIntoSpecies(std::move(child));
 	}

JNF_NEAT/organism.cpp

@@ -21,11 +21,11 @@ double Organism::GetOrCalculateFitness()
 }
 
 double Organism::GetOrCalculateRawFitness() {
-    if (!isFitnessUpToDate) {
-        fitness = trainer->GetFitness();
-        isFitnessUpToDate = true;
-    }
-    return fitness;
+	if (!isFitnessUpToDate) {
+		fitness = trainer->GetFitness();
+		isFitnessUpToDate = true;
+	}
+	return fitness;
 }
 
 NeuralNetwork Organism::BreedWith(Organism& partner)

JNF_NEAT/species.cpp

@@ -60,6 +60,7 @@ void Species::SetPopulationsFitnessModifier() {
 void Species::ElectRepresentative() {
 	if (!population.empty()) {
 		SelectRandomRepresentative();
+		//SelectFittestOrganismAsRepresentative();
 	}
 }
 
@@ -72,6 +73,15 @@ void Species::SelectRandomRepresentative() {
     }
 }
 
+void Species::SelectFittestOrganismAsRepresentative() {
+	if (representative == nullptr) {
+		representative = std::make_unique<Organism>(GetFittestOrganism());
+	}
+	else {
+		*representative = GetFittestOrganism();
+	}
+}
+
 template <class T>
 constexpr bool Species::IsAboveCompatibilityThreshold(T t) const {
 	return t > representative->GetTrainingParameters().advanced.speciation.compatibilityThreshold;
@@ -96,7 +106,7 @@ Organism& Species::GetFittestOrganism() {
     }
 	if (!isSortedByFitness) {
 		auto CompareOrganisms = [&](Organism* lhs, Organism* rhs) {
-			return lhs->GetOrCalculateFitness() < rhs->GetOrCalculateFitness();
+			return lhs->GetOrCalculateFitness() > rhs->GetOrCalculateFitness();
 		};
 		std::sort(population.begin(), population.end(), CompareOrganisms);
 		isSortedByFitness = true;

JNF_NEAT/species.h

@@ -37,6 +37,7 @@ class Species {
 private:
 		void ElectRepresentative();
 		void SelectRandomRepresentative();
+		void SelectFittestOrganismAsRepresentative();
 
 		template<class T>
 		constexpr bool IsAboveCompatibilityThreshold(T t) const;

JNF_NEAT/training_parameters.h

@@ -25,6 +25,7 @@ struct TrainingParameters {
 		} speciation;
 		struct Reproduction {
 			float chanceForInterspecialReproduction = 0.001f;
+			size_t minSpeciesSizeForChampConservation = 5;
 		} reproduction;
         struct Structure {
             size_t numberOfBiasNeurons = 1;

JNF_NEAT/xor_solver.cpp

@@ -2,18 +2,16 @@
 
 void XORSolver::Reset()
 {
-    correctEvaluations = 0;
 	currTraining = trainingData.begin();
+	results.clear();
 }
 
 void XORSolver::Update(const std::vector<float>& networkOutputs)
 {    
 	int xorResult = currTraining->first ^ currTraining->second;
 	int networksXorResult = int(networkOutputs.front() >= 0.0f);
 
-	if (xorResult == networksXorResult) {
-        correctEvaluations++;
-	}
+	results.push_back(networksXorResult);
 	++currTraining;
 	if (currTraining == trainingData.end()) {
 		currTraining = trainingData.begin();
@@ -22,6 +20,21 @@ void XORSolver::Update(const std::vector<float>& networkOutputs)
 
 double XORSolver::GetFitness() const
 {
+	size_t correctEvaluations = 0;
+	auto firstResult = results.front();
+	bool areAllResultsSame = true;
+	for (size_t i = 0; i < trainingData.size(); ++i) {
+		auto correctResult = trainingData[i].first ^ trainingData[i].second;
+		if (results[i] == correctResult) {
+			correctEvaluations++;
+		}
+		if (results[i] != firstResult) {
+			areAllResultsSame = false;
+		}
+	}
+	if (areAllResultsSame) {
+		return 0.0;
+	}
 	return double(correctEvaluations * correctEvaluations);
 }
 

JNF_NEAT/xor_solver.h

@@ -9,7 +9,7 @@ class XORSolver : public IBody {
 		virtual std::vector<float> ProvideNetworkWithInputs() const override;
 
 	private:
-		int correctEvaluations = 0;
 		std::vector<std::pair<int,int>> trainingData = { {0, 0}, {0, 1}, {1, 0}, {1, 1} };
+		std::vector<int> results;
 		std::vector<std::pair<int,int>>::iterator currTraining = trainingData.begin();
 };