blt-gp/examples/symbolic_regression.cpp

151 lines
5.6 KiB
C++
Raw Normal View History

2024-07-11 04:11:24 -04:00
/*
* <Short Description>
* Copyright (C) 2024 Brett Terpstra
*
* This program 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.
*
* This program 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 this program. If not, see <https://www.gnu.org/licenses/>.
*/
#include <blt/gp/program.h>
2024-07-11 21:14:23 -04:00
#include <blt/profiling/profiler_v2.h>
2024-07-11 04:11:24 -04:00
#include <blt/gp/tree.h>
#include <blt/std/logging.h>
#include <iostream>
2024-08-06 13:45:24 -04:00
//static constexpr long SEED = 41912;
static const unsigned long SEED = std::random_device()();
2024-07-11 04:11:24 -04:00
struct context
{
float x, y;
};
std::array<context, 200> fitness_cases;
blt::gp::prog_config_t config = blt::gp::prog_config_t()
.set_initial_min_tree_size(2)
.set_initial_max_tree_size(6)
2024-07-22 21:59:05 -04:00
.set_elite_count(2)
2024-07-16 23:45:02 -04:00
.set_crossover_chance(0.9)
.set_mutation_chance(0.1)
.set_reproduction_chance(0)
2024-07-11 04:11:24 -04:00
.set_max_generations(50)
.set_pop_size(500)
2024-08-18 01:28:23 -04:00
.set_thread_count(0);
2024-07-11 04:11:24 -04:00
blt::gp::type_provider type_system;
2024-07-11 21:14:23 -04:00
blt::gp::gp_program program{type_system, SEED, config};
2024-07-11 04:11:24 -04:00
blt::gp::operation_t add([](float a, float b) { return a + b; }, "add");
blt::gp::operation_t sub([](float a, float b) { return a - b; }, "sub");
blt::gp::operation_t mul([](float a, float b) { return a * b; }, "mul");
blt::gp::operation_t pro_div([](float a, float b) { return b == 0.0f ? 1.0f : a / b; }, "div");
blt::gp::operation_t op_sin([](float a) { return std::sin(a); }, "sin");
blt::gp::operation_t op_cos([](float a) { return std::cos(a); }, "cos");
blt::gp::operation_t op_exp([](float a) { return std::exp(a); }, "exp");
blt::gp::operation_t op_log([](float a) { return a == 0.0f ? 0.0f : std::log(a); }, "log");
2024-08-20 13:07:33 -04:00
auto lit = blt::gp::operation_t([]() {
2024-07-11 04:11:24 -04:00
return program.get_random().get_float(-320.0f, 320.0f);
2024-08-20 13:07:33 -04:00
}, "lit").set_ephemeral();
2024-07-11 04:11:24 -04:00
blt::gp::operation_t op_x([](const context& context) {
return context.x;
}, "x");
2024-07-11 21:14:23 -04:00
constexpr auto fitness_function = [](blt::gp::tree_t& current_tree, blt::gp::fitness_t& fitness, blt::size_t) {
2024-07-11 04:11:24 -04:00
constexpr double value_cutoff = 1.e15;
for (auto& fitness_case : fitness_cases)
{
2024-08-20 13:07:33 -04:00
auto diff = std::abs(fitness_case.y - current_tree.get_evaluation_value<float>(&fitness_case, program.get_eval_func()));
2024-07-11 04:11:24 -04:00
if (diff < value_cutoff)
{
fitness.raw_fitness += diff;
if (diff < 0.01)
fitness.hits++;
} else
fitness.raw_fitness += value_cutoff;
}
fitness.standardized_fitness = fitness.raw_fitness;
fitness.adjusted_fitness = (1.0 / (1.0 + fitness.standardized_fitness));
2024-08-11 13:33:24 -04:00
return static_cast<blt::size_t>(fitness.hits) == fitness_cases.size();
2024-07-11 04:11:24 -04:00
};
float example_function(float x)
{
return x * x * x * x + x * x * x + x * x + x;
}
int main()
{
2024-07-13 15:36:49 -04:00
BLT_INFO("Starting BLT-GP Symbolic Regression Example");
2024-07-11 21:14:23 -04:00
BLT_START_INTERVAL("Symbolic Regression", "Main");
2024-07-13 15:36:49 -04:00
BLT_DEBUG("Setup Fitness cases");
2024-07-11 04:11:24 -04:00
for (auto& fitness_case : fitness_cases)
{
constexpr float range = 10;
constexpr float half_range = range / 2.0;
auto x = program.get_random().get_float(-half_range, half_range);
auto y = example_function(x);
fitness_case = {x, y};
}
2024-07-13 15:36:49 -04:00
BLT_DEBUG("Setup Types and Operators");
2024-07-11 04:11:24 -04:00
type_system.register_type<float>();
blt::gp::operator_builder<context> builder{type_system};
2024-08-20 13:07:33 -04:00
program.set_operations(builder.build(add, sub, mul, pro_div, op_sin, op_cos, op_exp, op_log, lit, op_x));
2024-07-11 04:11:24 -04:00
2024-07-13 15:36:49 -04:00
BLT_DEBUG("Generate Initial Population");
auto sel = blt::gp::select_fitness_proportionate_t{};
program.generate_population(type_system.get_type<float>().id(), fitness_function, sel, sel, sel);
2024-07-11 04:11:24 -04:00
2024-07-13 15:36:49 -04:00
BLT_DEBUG("Begin Generation Loop");
2024-07-11 04:11:24 -04:00
while (!program.should_terminate())
{
2024-07-13 15:36:49 -04:00
BLT_TRACE("------------{Begin Generation %ld}------------", program.get_current_generation());
2024-07-11 21:14:23 -04:00
BLT_START_INTERVAL("Symbolic Regression", "Gen");
program.create_next_generation();
2024-07-11 21:14:23 -04:00
BLT_END_INTERVAL("Symbolic Regression", "Gen");
2024-07-13 15:36:49 -04:00
BLT_TRACE("Move to next generation");
2024-07-11 21:14:23 -04:00
BLT_START_INTERVAL("Symbolic Regression", "Fitness");
2024-07-11 04:11:24 -04:00
program.next_generation();
2024-07-13 15:36:49 -04:00
BLT_TRACE("Evaluate Fitness");
2024-07-11 04:11:24 -04:00
program.evaluate_fitness();
2024-07-11 21:14:23 -04:00
BLT_END_INTERVAL("Symbolic Regression", "Fitness");
2024-07-13 15:36:49 -04:00
BLT_TRACE("----------------------------------------------");
std::cout << std::endl;
2024-07-11 04:11:24 -04:00
}
2024-07-11 21:14:23 -04:00
BLT_END_INTERVAL("Symbolic Regression", "Main");
2024-07-11 04:11:24 -04:00
auto best = program.get_best_individuals<3>();
BLT_INFO("Best approximations:");
for (auto& i_ref : best)
{
auto& i = i_ref.get();
BLT_DEBUG("Fitness: %lf, stand: %lf, raw: %lf", i.fitness.adjusted_fitness, i.fitness.standardized_fitness, i.fitness.raw_fitness);
i.tree.print(program, std::cout);
std::cout << "\n";
}
2024-07-11 21:14:23 -04:00
auto& stats = program.get_population_stats();
BLT_INFO("Stats:");
BLT_INFO("Average fitness: %lf", stats.average_fitness.load());
BLT_INFO("Best fitness: %lf", stats.best_fitness.load());
BLT_INFO("Worst fitness: %lf", stats.worst_fitness.load());
BLT_INFO("Overall fitness: %lf", stats.overall_fitness.load());
2024-07-11 13:51:14 -04:00
// TODO: make stats helper
2024-07-11 04:11:24 -04:00
2024-07-11 21:14:23 -04:00
BLT_PRINT_PROFILE("Symbolic Regression", blt::PRINT_CYCLES | blt::PRINT_THREAD | blt::PRINT_WALL);
2024-07-11 04:11:24 -04:00
return 0;
}