neat_speciation.hpp

Go to the documentation of this file.

 
#pragma once
 
#include <algorithm>
#include <stdexcept>
#include <vector>
 
#include "pulsatrix/neat_genome.hpp"
 
namespace pulsatrix {
 
inline double CompatibilityDistance(const NEATGenome& a, const NEATGenome& b, double c1, double c2, double c3) {
    const auto& conn_a = a.connections();
    const auto& conn_b = b.connections();
    if (conn_a.empty() || conn_b.empty()) {
        throw std::invalid_argument("CompatibilityDistance: both genomes must have at least one connection gene");
    }
 
    int max_innovation_a = 0;
    for (const auto& c : conn_a) {
        max_innovation_a = std::max(max_innovation_a, c.innovation);
    }
    int max_innovation_b = 0;
    for (const auto& c : conn_b) {
        max_innovation_b = std::max(max_innovation_b, c.innovation);
    }
    int overlap_bound = std::min(max_innovation_a, max_innovation_b);
 
    int excess = 0;
    int disjoint = 0;
    int matching = 0;
    double weight_diff_sum = 0.0;
 
    for (const auto& ca : conn_a) {
        const auto it = std::find_if(conn_b.begin(), conn_b.end(),
                                      [&](const ConnectionGene& cb) { return cb.innovation == ca.innovation; });
        if (it != conn_b.end()) {
            ++matching;
            weight_diff_sum += std::fabs(ca.weight - it->weight);
        } else if (ca.innovation > overlap_bound) {
            ++excess;
        } else {
            ++disjoint;
        }
    }
    for (const auto& cb : conn_b) {
        const bool in_a = std::any_of(conn_a.begin(), conn_a.end(),
                                       [&](const ConnectionGene& ca) { return ca.innovation == cb.innovation; });
        if (!in_a) {
            if (cb.innovation > overlap_bound) {
                ++excess;
            } else {
                ++disjoint;
            }
        }
    }
 
    size_t size_a = conn_a.size();
    size_t size_b = conn_b.size();
    size_t larger = std::max(size_a, size_b);
    double n = (larger < 20) ? 1.0 : static_cast<double>(larger);
    double w_bar = (matching > 0) ? weight_diff_sum / static_cast<double>(matching) : 0.0;
 
    return c1 * static_cast<double>(excess) / n + c2 * static_cast<double>(disjoint) / n + c3 * w_bar;
}
 
struct SpeciesAssignment {
    std::vector<std::vector<size_t>> species;
};
 
inline SpeciesAssignment SpeciatePopulation(const std::vector<NEATGenome>& population,
                                            double compatibility_threshold, double c1, double c2, double c3) {
    if (population.empty()) {
        throw std::invalid_argument("SpeciatePopulation: population must not be empty");
    }
    if (compatibility_threshold <= 0.0) {
        throw std::invalid_argument("SpeciatePopulation: compatibility_threshold must be positive");
    }
 
    std::vector<std::vector<size_t>> species;
    std::vector<size_t> representatives;
 
    for (size_t i = 0; i < population.size(); ++i) {
        bool placed = false;
        for (size_t s = 0; s < species.size(); ++s) {
            double distance = CompatibilityDistance(population[i], population[representatives[s]], c1, c2, c3);
            if (distance < compatibility_threshold) {
                species[s].push_back(i);
                placed = true;
                break;
            }
        }
        if (!placed) {
            species.push_back({i});
            representatives.push_back(i);
        }
    }
    return SpeciesAssignment{species};
}
 
inline std::vector<double> ComputeAdjustedFitness(const std::vector<double>& raw_fitness,
                                                   const std::vector<std::vector<size_t>>& species) {
    size_t total_members = 0;
    for (const auto& s : species) {
        total_members += s.size();
    }
    if (total_members != raw_fitness.size()) {
        throw std::invalid_argument(
            "ComputeAdjustedFitness: species must partition exactly raw_fitness.size() individuals");
    }
 
    std::vector<double> adjusted(raw_fitness.size(), 0.0);
    for (const auto& s : species) {
        for (size_t index : s) {
            adjusted[index] = raw_fitness[index] / static_cast<double>(s.size());
        }
    }
    return adjusted;
}
 
}  // namespace pulsatrix