Genetic.cpp

#include "pch.h"
#include "Network.hpp"
#include <random>

// Initialize the seed
std::random_device rd;
// Initialize the random distribution
std::uniform_real_distribution<float> urd(-1.f, 1.f);
// Initialize the random generator
std::default_random_engine dre(rd());

namespace NeuralNetwork {
// Opérateurs génétiques
// ---------------------

void Network::mutation(float mutation_rate)
{
	for (auto& layer : m_layers_)
	{
		for (auto& weights : layer)
		{
			for (auto& weight : weights)
			{
				if (abs(urd(dre)) < mutation_rate * 1000)
				{
					weight = urd(dre);
				}
			}
		}
	}
}

Network Network::operator*(const Network& other) const
{
	vector<vector<vector<float>>> new_network(m_layers_.size());
	for (size_t i = 0; i < m_layers_.size(); ++i)
	{
		new_network[i] = vector<vector<float>>(m_layers_[i].size());
		for (size_t j = 0; j < m_layers_[i].size(); ++j)
		{
			new_network[i][j] = vector<float>(m_layers_[i][j].size());
			for (size_t k = 0; k < m_layers_[i][j].size(); ++k)
			{
				new_network[i][j][k] = (urd(dre) < 0.f) ? m_layers_[i][j][k] : other.m_layers_[i][j][k];
			}
		}
	}
	Network network(new_network, m_rec_);
	return network;
}

Network Network::reproduce(const Network& parent1, const Network& parent2, float mutation_rate)
{
	Network child = parent1 * parent2;
	child.mutation(mutation_rate);
	return child;
}
}