solidity/test/yulPhaser/GeneticAlgorithms.cpp

414 lines
16 KiB
C++

/*
This file is part of solidity.
solidity is free software: you can redistribute it and/or modify
it under the terms of the GNU General Public License as published by
the Free Software Foundation, either version 3 of the License, or
(at your option) any later version.
solidity is distributed in the hope that it will be useful,
but WITHOUT ANY WARRANTY; without even the implied warranty of
MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
GNU General Public License for more details.
You should have received a copy of the GNU General Public License
along with solidity. If not, see <http://www.gnu.org/licenses/>.
*/
// SPDX-License-Identifier: GPL-3.0
#include <test/yulPhaser/TestHelpers.h>
#include <tools/yulPhaser/FitnessMetrics.h>
#include <tools/yulPhaser/GeneticAlgorithms.h>
#include <tools/yulPhaser/Population.h>
#include <libsolutil/CommonIO.h>
#include <boost/test/unit_test.hpp>
#include <algorithm>
#include <vector>
using namespace std;
using namespace boost::unit_test::framework;
using namespace boost::test_tools;
using namespace solidity::util;
namespace solidity::phaser::test
{
class GeneticAlgorithmFixture
{
protected:
shared_ptr<FitnessMetric> m_fitnessMetric = make_shared<ChromosomeLengthMetric>();
};
class ClassicGeneticAlgorithmFixture: public GeneticAlgorithmFixture
{
protected:
ClassicGeneticAlgorithm::Options m_options = {
/* elitePoolSize = */ 0.0,
/* crossoverChance = */ 0.0,
/* mutationChance = */ 0.0,
/* deletionChance = */ 0.0,
/* additionChance = */ 0.0,
/* CrossoverChoice = */ CrossoverChoice::SinglePoint,
/* uniformCrossoverSwapChance= */ 0.5,
};
};
BOOST_AUTO_TEST_SUITE(Phaser, *boost::unit_test::label("nooptions"))
BOOST_AUTO_TEST_SUITE(GeneticAlgorithmsTest)
BOOST_AUTO_TEST_SUITE(RandomAlgorithmTest)
BOOST_FIXTURE_TEST_CASE(runNextRound_should_preserve_elite_and_randomise_rest_of_population, GeneticAlgorithmFixture)
{
auto population = Population::makeRandom(m_fitnessMetric, 4, 3, 3) + Population::makeRandom(m_fitnessMetric, 4, 5, 5);
assert((chromosomeLengths(population) == vector<size_t>{3, 3, 3, 3, 5, 5, 5, 5}));
RandomAlgorithm algorithm({0.5, 1, 1});
Population newPopulation = algorithm.runNextRound(population);
BOOST_TEST((chromosomeLengths(newPopulation) == vector<size_t>{1, 1, 1, 1, 3, 3, 3, 3}));
}
BOOST_FIXTURE_TEST_CASE(runNextRound_should_not_replace_elite_with_worse_individuals, GeneticAlgorithmFixture)
{
auto population = Population::makeRandom(m_fitnessMetric, 4, 3, 3) + Population::makeRandom(m_fitnessMetric, 4, 5, 5);
assert((chromosomeLengths(population) == vector<size_t>{3, 3, 3, 3, 5, 5, 5, 5}));
RandomAlgorithm algorithm({0.5, 7, 7});
Population newPopulation = algorithm.runNextRound(population);
BOOST_TEST((chromosomeLengths(newPopulation) == vector<size_t>{3, 3, 3, 3, 7, 7, 7, 7}));
}
BOOST_FIXTURE_TEST_CASE(runNextRound_should_replace_all_chromosomes_if_zero_size_elite, GeneticAlgorithmFixture)
{
auto population = Population::makeRandom(m_fitnessMetric, 4, 3, 3) + Population::makeRandom(m_fitnessMetric, 4, 5, 5);
assert((chromosomeLengths(population) == vector<size_t>{3, 3, 3, 3, 5, 5, 5, 5}));
RandomAlgorithm algorithm({0.0, 1, 1});
Population newPopulation = algorithm.runNextRound(population);
BOOST_TEST((chromosomeLengths(newPopulation) == vector<size_t>{1, 1, 1, 1, 1, 1, 1, 1}));
}
BOOST_FIXTURE_TEST_CASE(runNextRound_should_not_replace_any_chromosomes_if_whole_population_is_the_elite, GeneticAlgorithmFixture)
{
auto population = Population::makeRandom(m_fitnessMetric, 4, 3, 3) + Population::makeRandom(m_fitnessMetric, 4, 5, 5);
assert((chromosomeLengths(population) == vector<size_t>{3, 3, 3, 3, 5, 5, 5, 5}));
RandomAlgorithm algorithm({1.0, 1, 1});
Population newPopulation = algorithm.runNextRound(population);
BOOST_TEST((chromosomeLengths(newPopulation) == vector<size_t>{3, 3, 3, 3, 5, 5, 5, 5}));
}
BOOST_AUTO_TEST_SUITE_END()
BOOST_AUTO_TEST_SUITE(GenerationalElitistWithExclusivePoolsTest)
BOOST_FIXTURE_TEST_CASE(runNextRound_should_preserve_elite_and_regenerate_rest_of_population, GeneticAlgorithmFixture)
{
auto population = Population::makeRandom(m_fitnessMetric, 6, 3, 3) + Population::makeRandom(m_fitnessMetric, 4, 5, 5);
assert((chromosomeLengths(population) == vector<size_t>{3, 3, 3, 3, 3, 3, 5, 5, 5, 5}));
GenerationalElitistWithExclusivePools::Options options = {
/* mutationPoolSize = */ 0.2,
/* crossoverPoolSize = */ 0.2,
/* randomisationChance = */ 0.0,
/* deletionVsAdditionChance = */ 1.0,
/* percentGenesToRandomise = */ 0.0,
/* percentGenesToAddOrDelete = */ 1.0,
/* CrossoverChoice = */ CrossoverChoice::SinglePoint,
/* uniformCrossoverSwapChance= */ 0.5,
};
GenerationalElitistWithExclusivePools algorithm(options);
Population newPopulation = algorithm.runNextRound(population);
BOOST_TEST((chromosomeLengths(newPopulation) == vector<size_t>{0, 0, 3, 3, 3, 3, 3, 3, 3, 3}));
}
BOOST_FIXTURE_TEST_CASE(runNextRound_should_not_replace_elite_with_worse_individuals, GeneticAlgorithmFixture)
{
auto population = Population::makeRandom(m_fitnessMetric, 6, 3, 3) + Population::makeRandom(m_fitnessMetric, 4, 5, 5);
assert(chromosomeLengths(population) == (vector<size_t>{3, 3, 3, 3, 3, 3, 5, 5, 5, 5}));
GenerationalElitistWithExclusivePools::Options options = {
/* mutationPoolSize = */ 0.2,
/* crossoverPoolSize = */ 0.2,
/* randomisationChance = */ 0.0,
/* deletionVsAdditionChance = */ 0.0,
/* percentGenesToRandomise = */ 0.0,
/* percentGenesToAddOrDelete = */ 1.0,
/* CrossoverChoice = */ CrossoverChoice::SinglePoint,
/* uniformCrossoverSwapChance= */ 0.5,
};
GenerationalElitistWithExclusivePools algorithm(options);
Population newPopulation = algorithm.runNextRound(population);
BOOST_TEST((chromosomeLengths(newPopulation) == vector<size_t>{3, 3, 3, 3, 3, 3, 3, 3, 7, 7}));
}
BOOST_FIXTURE_TEST_CASE(runNextRound_should_generate_individuals_in_the_crossover_pool_by_mutating_the_elite, GeneticAlgorithmFixture)
{
auto population = Population::makeRandom(m_fitnessMetric, 20, 5, 5);
GenerationalElitistWithExclusivePools::Options options = {
/* mutationPoolSize = */ 0.8,
/* crossoverPoolSize = */ 0.0,
/* randomisationChance = */ 0.5,
/* deletionVsAdditionChance = */ 0.5,
/* percentGenesToRandomise = */ 1.0,
/* percentGenesToAddOrDelete = */ 1.0,
/* CrossoverChoice = */ CrossoverChoice::SinglePoint,
/* uniformCrossoverSwapChance= */ 0.5,
};
GenerationalElitistWithExclusivePools algorithm(options);
SimulationRNG::reset(1);
Population newPopulation = algorithm.runNextRound(population);
BOOST_TEST((
chromosomeLengths(newPopulation) ==
vector<size_t>{0, 0, 0, 0, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 11, 11, 11}
));
}
BOOST_FIXTURE_TEST_CASE(runNextRound_should_generate_individuals_in_the_crossover_pool_by_crossing_over_the_elite, GeneticAlgorithmFixture)
{
auto population = (
Population(m_fitnessMetric, {Chromosome("aa"), Chromosome("ff")}) +
Population::makeRandom(m_fitnessMetric, 8, 6, 6)
);
assert((chromosomeLengths(population) == vector<size_t>{2, 2, 6, 6, 6, 6, 6, 6, 6, 6}));
GenerationalElitistWithExclusivePools::Options options = {
/* mutationPoolSize = */ 0.0,
/* crossoverPoolSize = */ 0.8,
/* randomisationChance = */ 0.0,
/* deletionVsAdditionChance = */ 0.0,
/* percentGenesToRandomise = */ 0.0,
/* percentGenesToAddOrDelete = */ 0.0,
/* CrossoverChoice = */ CrossoverChoice::SinglePoint,
/* uniformCrossoverSwapChance= */ 0.5,
};
GenerationalElitistWithExclusivePools algorithm(options);
SimulationRNG::reset(1);
Population newPopulation = algorithm.runNextRound(population);
vector<Individual> const& newIndividuals = newPopulation.individuals();
BOOST_TEST((chromosomeLengths(newPopulation) == vector<size_t>{2, 2, 2, 2, 2, 2, 2, 2, 2, 2}));
for (auto& individual: newIndividuals)
BOOST_TEST((
individual.chromosome == Chromosome("aa") ||
individual.chromosome == Chromosome("af") ||
individual.chromosome == Chromosome("fa") ||
individual.chromosome == Chromosome("ff")
));
BOOST_TEST(any_of(newIndividuals.begin() + 2, newIndividuals.end(), [](auto& individual){
return individual.chromosome != Chromosome("aa") && individual.chromosome != Chromosome("ff");
}));
}
BOOST_AUTO_TEST_SUITE_END()
BOOST_AUTO_TEST_SUITE(ClassicGeneticAlgorithmTest)
// FIXME: This test runs *very* slowly (tens of seconds). Investigate, fix and re-enable.
BOOST_FIXTURE_TEST_CASE(runNextRound_should_select_individuals_with_probability_proportional_to_fitness, ClassicGeneticAlgorithmFixture, *boost::unit_test::disabled())
{
constexpr double relativeTolerance = 0.1;
constexpr size_t populationSize = 1000;
assert(populationSize % 4 == 0 && "Choose a number divisible by 4 for this test");
auto population =
Population::makeRandom(m_fitnessMetric, populationSize / 4, 0, 0) +
Population::makeRandom(m_fitnessMetric, populationSize / 4, 1, 1) +
Population::makeRandom(m_fitnessMetric, populationSize / 4, 2, 2) +
Population::makeRandom(m_fitnessMetric, populationSize / 4, 3, 3);
map<size_t, double> expectedProbabilities = {
{0, 4.0 / (4 + 3 + 2 + 1)},
{1, 3.0 / (4 + 3 + 2 + 1)},
{2, 2.0 / (4 + 3 + 2 + 1)},
{3, 1.0 / (4 + 3 + 2 + 1)},
};
double const expectedValue = (
0.0 * expectedProbabilities[0] +
1.0 * expectedProbabilities[1] +
2.0 * expectedProbabilities[2] +
3.0 * expectedProbabilities[3]
);
double const variance = (
(0.0 - expectedValue) * (0.0 - expectedValue) * expectedProbabilities[0] +
(1.0 - expectedValue) * (1.0 - expectedValue) * expectedProbabilities[1] +
(2.0 - expectedValue) * (2.0 - expectedValue) * expectedProbabilities[2] +
(3.0 - expectedValue) * (3.0 - expectedValue) * expectedProbabilities[3]
);
ClassicGeneticAlgorithm algorithm(m_options);
Population newPopulation = algorithm.runNextRound(population);
BOOST_TEST(newPopulation.individuals().size() == population.individuals().size());
vector<size_t> newFitness = chromosomeLengths(newPopulation);
BOOST_TEST(abs(mean(newFitness) - expectedValue) < expectedValue * relativeTolerance);
BOOST_TEST(abs(meanSquaredError(newFitness, expectedValue) - variance) < variance * relativeTolerance);
}
// FIXME: This test runs *very* slowly (tens of seconds). Investigate, fix and re-enable.
BOOST_FIXTURE_TEST_CASE(runNextRound_should_select_only_individuals_existing_in_the_original_population, ClassicGeneticAlgorithmFixture, *boost::unit_test::disabled())
{
constexpr size_t populationSize = 1000;
auto population = Population::makeRandom(m_fitnessMetric, populationSize, 1, 10);
set<string> originalSteps;
for (auto const& individual: population.individuals())
originalSteps.insert(toString(individual.chromosome));
ClassicGeneticAlgorithm algorithm(m_options);
Population newPopulation = algorithm.runNextRound(population);
for (auto const& individual: newPopulation.individuals())
BOOST_TEST(originalSteps.count(toString(individual.chromosome)) == 1);
}
BOOST_FIXTURE_TEST_CASE(runNextRound_should_do_crossover, ClassicGeneticAlgorithmFixture)
{
auto population = Population(m_fitnessMetric, {
Chromosome("aa"), Chromosome("aa"), Chromosome("aa"),
Chromosome("ff"), Chromosome("ff"), Chromosome("ff"),
Chromosome("gg"), Chromosome("gg"), Chromosome("gg"),
});
set<string> originalSteps{"aa", "ff", "gg"};
set<string> crossedSteps{"af", "fa", "fg", "gf", "ga", "ag"};
m_options.crossoverChance = 0.8;
ClassicGeneticAlgorithm algorithm(m_options);
SimulationRNG::reset(1);
Population newPopulation = algorithm.runNextRound(population);
size_t totalCrossed = 0;
size_t totalUnchanged = 0;
for (auto const& individual: newPopulation.individuals())
{
totalCrossed += crossedSteps.count(toString(individual.chromosome));
totalUnchanged += originalSteps.count(toString(individual.chromosome));
}
BOOST_TEST(totalCrossed + totalUnchanged == newPopulation.individuals().size());
BOOST_TEST(totalCrossed >= 2);
}
// FIXME: This test runs *very* slowly (tens of seconds). Investigate, fix and re-enable.
BOOST_FIXTURE_TEST_CASE(runNextRound_should_do_mutation, ClassicGeneticAlgorithmFixture, *boost::unit_test::disabled())
{
m_options.mutationChance = 0.6;
ClassicGeneticAlgorithm algorithm(m_options);
constexpr size_t populationSize = 1000;
constexpr double relativeTolerance = 0.05;
double const expectedValue = m_options.mutationChance;
double const variance = m_options.mutationChance * (1 - m_options.mutationChance);
Chromosome chromosome("aaaaaaaaaa");
vector<Chromosome> chromosomes(populationSize, chromosome);
Population population(m_fitnessMetric, chromosomes);
SimulationRNG::reset(1);
Population newPopulation = algorithm.runNextRound(population);
vector<size_t> bernoulliTrials;
for (auto const& individual: newPopulation.individuals())
{
string steps = toString(individual.chromosome);
for (char step: steps)
bernoulliTrials.push_back(static_cast<size_t>(step != 'a'));
}
BOOST_TEST(abs(mean(bernoulliTrials) - expectedValue) < expectedValue * relativeTolerance);
BOOST_TEST(abs(meanSquaredError(bernoulliTrials, expectedValue) - variance) < variance * relativeTolerance);
}
// FIXME: This test runs *very* slowly (tens of seconds). Investigate, fix and re-enable.
BOOST_FIXTURE_TEST_CASE(runNextRound_should_do_deletion, ClassicGeneticAlgorithmFixture, *boost::unit_test::disabled())
{
m_options.deletionChance = 0.6;
ClassicGeneticAlgorithm algorithm(m_options);
constexpr size_t populationSize = 1000;
constexpr double relativeTolerance = 0.05;
double const expectedValue = m_options.deletionChance;
double const variance = m_options.deletionChance * (1 - m_options.deletionChance);
Chromosome chromosome("aaaaaaaaaa");
vector<Chromosome> chromosomes(populationSize, chromosome);
Population population(m_fitnessMetric, chromosomes);
SimulationRNG::reset(1);
Population newPopulation = algorithm.runNextRound(population);
vector<size_t> bernoulliTrials;
for (auto const& individual: newPopulation.individuals())
{
string steps = toString(individual.chromosome);
for (size_t i = 0; i < chromosome.length(); ++i)
bernoulliTrials.push_back(static_cast<size_t>(i >= steps.size()));
}
BOOST_TEST(abs(mean(bernoulliTrials) - expectedValue) < expectedValue * relativeTolerance);
BOOST_TEST(abs(meanSquaredError(bernoulliTrials, expectedValue) - variance) < variance * relativeTolerance);
}
// FIXME: This test runs *very* slowly (tens of seconds). Investigate, fix and re-enable.
BOOST_FIXTURE_TEST_CASE(runNextRound_should_do_addition, ClassicGeneticAlgorithmFixture, *boost::unit_test::disabled())
{
m_options.additionChance = 0.6;
ClassicGeneticAlgorithm algorithm(m_options);
constexpr size_t populationSize = 1000;
constexpr double relativeTolerance = 0.05;
double const expectedValue = m_options.additionChance;
double const variance = m_options.additionChance * (1 - m_options.additionChance);
Chromosome chromosome("aaaaaaaaaa");
vector<Chromosome> chromosomes(populationSize, chromosome);
Population population(m_fitnessMetric, chromosomes);
SimulationRNG::reset(1);
Population newPopulation = algorithm.runNextRound(population);
vector<size_t> bernoulliTrials;
for (auto const& individual: newPopulation.individuals())
{
string steps = toString(individual.chromosome);
for (size_t i = 0; i < chromosome.length() + 1; ++i)
{
BOOST_REQUIRE(chromosome.length() <= steps.size() && steps.size() <= 2 * chromosome.length() + 1);
bernoulliTrials.push_back(static_cast<size_t>(i < steps.size() - chromosome.length()));
}
}
BOOST_TEST(abs(mean(bernoulliTrials) - expectedValue) < expectedValue * relativeTolerance);
BOOST_TEST(abs(meanSquaredError(bernoulliTrials, expectedValue) - variance) < variance * relativeTolerance);
}
BOOST_FIXTURE_TEST_CASE(runNextRound_should_preserve_elite, ClassicGeneticAlgorithmFixture)
{
auto population = Population::makeRandom(m_fitnessMetric, 4, 3, 3) + Population::makeRandom(m_fitnessMetric, 6, 5, 5);
assert((chromosomeLengths(population) == vector<size_t>{3, 3, 3, 3, 5, 5, 5, 5, 5, 5}));
m_options.elitePoolSize = 0.5;
m_options.deletionChance = 1.0;
ClassicGeneticAlgorithm algorithm(m_options);
Population newPopulation = algorithm.runNextRound(population);
BOOST_TEST((chromosomeLengths(newPopulation) == vector<size_t>{0, 0, 0, 0, 0, 3, 3, 3, 3, 5}));
}
BOOST_AUTO_TEST_SUITE_END()
BOOST_AUTO_TEST_SUITE_END()
BOOST_AUTO_TEST_SUITE_END()
}