Compare commits
20 Commits
ea9721b4cc
...
89ed1bd116
| Author | SHA1 | Date |
|---|---|---|
Brett
|
89ed1bd116 | |
|
Brett
|
1789a9e474 | |
|
Brett
|
3572539b74 | |
|
Brett
|
2f3ea1b3bf | |
|
Brett
|
91bda10b0a | |
|
Brett
|
d4e6c40fe1 | |
 Brett
|
cc76f2791a | |
|
Brett
|
5f1a80c062 | |
|
Brett
|
3cf2d319b6 | |
|
Brett
|
bc903e0251 | |
|
Brett
|
144b3a4ceb | |
|
Brett
|
d30ba51820 | |
|
Brett
|
ac76b3c5df | |
|
Brett
|
68dc109dad | |
|
Brett
|
e5966789be | |
|
Brett
|
95b88aeebf | |
|
Brett
|
6ded725802 | |
|
Brett
|
d28577def2 | |
|
Brett
|
ec8153bef0 | |
|
Brett
|
95460e7bf1 |
|
|
@ -7,7 +7,5 @@ out/
|
|||
massif.*
|
||||
callgrind.*
|
||||
*.out.*
|
||||
<<<<<<< HEAD
|
||||
heaptrack.*
|
||||
=======
|
||||
>>>>>>> refs/remotes/origin/main
|
||||
Rice_Cammeo_Osmancik.arff
|
||||
|
|
|
|||
|
|
@ -1,5 +1,5 @@
|
|||
cmake_minimum_required(VERSION 3.25)
|
||||
project(blt-gp VERSION 0.1.20)
|
||||
project(blt-gp VERSION 0.1.36)
|
||||
|
||||
include(CTest)
|
||||
|
||||
|
|
@ -9,12 +9,15 @@ option(ENABLE_TSAN "Enable the thread data race sanitizer" OFF)
|
|||
option(BUILD_EXAMPLES "Build example programs. This will build with CTest" OFF)
|
||||
option(BUILD_GP_TESTS "Build test programs." OFF)
|
||||
option(DEBUG_LEVEL "Enable debug features which prints extra information to the console, might slow processing down. [0, 3)" 0)
|
||||
option(TRACK_ALLOCATIONS "Track total allocations. Can be accessed with blt::gp::tracker" OFF)
|
||||
|
||||
set(CMAKE_CXX_STANDARD 17)
|
||||
|
||||
set(THREADS_PREFER_PTHREAD_FLAG ON)
|
||||
find_package(Threads REQUIRED)
|
||||
|
||||
#SET(CMAKE_CXX_FLAGS_RELEASE "-O3 -g")
|
||||
|
||||
if (NOT TARGET BLT)
|
||||
add_subdirectory(lib/blt)
|
||||
endif ()
|
||||
|
|
@ -38,6 +41,10 @@ target_include_directories(blt-gp PUBLIC include/)
|
|||
target_link_libraries(blt-gp PRIVATE BLT Threads::Threads)
|
||||
target_compile_definitions(blt-gp PRIVATE BLT_DEBUG_LEVEL=${DEBUG_LEVEL})
|
||||
|
||||
if (${TRACK_ALLOCATIONS})
|
||||
target_compile_definitions(blt-gp PRIVATE BLT_TRACK_ALLOCATIONS=1)
|
||||
endif ()
|
||||
|
||||
if (${ENABLE_ADDRSAN} MATCHES ON)
|
||||
target_compile_options(blt-gp PRIVATE -fsanitize=address)
|
||||
target_link_options(blt-gp PRIVATE -fsanitize=address)
|
||||
|
|
@ -67,6 +74,10 @@ macro(blt_add_project name source type)
|
|||
target_link_options(${name}-${type} PRIVATE -Wall -Wextra -Wpedantic -Wno-comment)
|
||||
target_compile_definitions(${name}-${type} PRIVATE BLT_DEBUG_LEVEL=${DEBUG_LEVEL})
|
||||
|
||||
if (${TRACK_ALLOCATIONS})
|
||||
target_compile_definitions(${name}-${type} PRIVATE BLT_TRACK_ALLOCATIONS=1)
|
||||
endif ()
|
||||
|
||||
if (${ENABLE_ADDRSAN} MATCHES ON)
|
||||
target_compile_options(${name}-${type} PRIVATE -fsanitize=address)
|
||||
target_link_options(${name}-${type} PRIVATE -fsanitize=address)
|
||||
|
|
@ -97,6 +108,7 @@ endmacro()
|
|||
if (${BUILD_EXAMPLES})
|
||||
|
||||
blt_add_project(blt-symbolic-regression examples/symbolic_regression.cpp example)
|
||||
blt_add_project(blt-rice-classification examples/rice_classification.cpp example)
|
||||
|
||||
endif ()
|
||||
|
||||
|
|
|
|||
|
|
@ -1302,7 +1302,7 @@
|
|||
,"0x4845DA0: memalign (in /usr/libexec/valgrind/vgpreload_dhat-amd64-linux.so)"
|
||||
,"0x129674: std::_Function_handler<void (void*, blt::gp::stack_allocator&, blt::gp::stack_allocator&), blt::gp::operation_t<lit::{lambda()#1}, float ()>::make_callable<context>() const::{lambda(void*, blt::gp::stack_allocator&, blt::gp::stack_allocator&)#1}>::_M_invoke(std::_Any_data const&, void*&&, blt::gp::stack_allocator&, blt::gp::stack_allocator&) (in /home/brett/Documents/code/c++/blt-gp/cmake-build-release/blt-SR-playground-example)"
|
||||
,"0x158664: blt::gp::tree_t blt::gp::create_tree<blt::gp::grow_generator_t::generate(blt::gp::generator_arguments const&)::{lambda(blt::gp::gp_program&, std::stack<blt::gp::stack, std::deque<blt::gp::stack, std::allocator<blt::gp::stack> > >&, blt::gp::type_id, unsigned long)#1}>(blt::gp::grow_generator_t::generate(blt::gp::generator_arguments const&)::{lambda(blt::gp::gp_program&, std::stack<blt::gp::stack, std::deque<blt::gp::stack, std::allocator<blt::gp::stack> > >&, blt::gp::type_id, unsigned long)#1}&&, blt::gp::generator_arguments const&) (in /home/brett/Documents/code/c++/blt-gp/cmake-build-release/blt-SR-playground-example)"
|
||||
,"0x15D0C0: void std::vector<blt::gp::individual, std::allocator<blt::gp::individual> >::_M_realloc_insert<blt::gp::tree_t>(__gnu_cxx::__normal_iterator<blt::gp::individual*, std::vector<blt::gp::individual, std::allocator<blt::gp::individual> > >, blt::gp::tree_t&&) (in /home/brett/Documents/code/c++/blt-gp/cmake-build-release/blt-SR-playground-example)"
|
||||
,"0x15D0C0: void std::vector<blt::gp::individual_t, std::allocator<blt::gp::individual_t> >::_M_realloc_insert<blt::gp::tree_t>(__gnu_cxx::__normal_iterator<blt::gp::individual_t*, std::vector<blt::gp::individual_t, std::allocator<blt::gp::individual_t> > >, blt::gp::tree_t&&) (in /home/brett/Documents/code/c++/blt-gp/cmake-build-release/blt-SR-playground-example)"
|
||||
,"0x15CCFA: blt::gp::ramped_half_initializer_t::generate(blt::gp::initializer_arguments const&) (in /home/brett/Documents/code/c++/blt-gp/cmake-build-release/blt-SR-playground-example)"
|
||||
,"0x15A9F0: blt::gp::tree_t blt::gp::create_tree<blt::gp::full_generator_t::generate(blt::gp::generator_arguments const&)::{lambda(blt::gp::gp_program&, std::stack<blt::gp::stack, std::deque<blt::gp::stack, std::allocator<blt::gp::stack> > >&, blt::gp::type_id, unsigned long)#1}>(blt::gp::full_generator_t::generate(blt::gp::generator_arguments const&)::{lambda(blt::gp::gp_program&, std::stack<blt::gp::stack, std::deque<blt::gp::stack, std::allocator<blt::gp::stack> > >&, blt::gp::type_id, unsigned long)#1}&&, blt::gp::generator_arguments const&) (in /home/brett/Documents/code/c++/blt-gp/cmake-build-release/blt-SR-playground-example)"
|
||||
,"0x15C977: blt::gp::ramped_half_initializer_t::generate(blt::gp::initializer_arguments const&) (in /home/brett/Documents/code/c++/blt-gp/cmake-build-release/blt-SR-playground-example)"
|
||||
|
|
@ -1330,7 +1330,7 @@
|
|||
,"0x1548AB: blt::gp::crossover_t::apply(blt::gp::gp_program&, blt::gp::tree_t const&, blt::gp::tree_t const&) (in /home/brett/Documents/code/c++/blt-gp/cmake-build-release/blt-SR-playground-example)"
|
||||
,"0x1549A7: blt::gp::crossover_t::apply(blt::gp::gp_program&, blt::gp::tree_t const&, blt::gp::tree_t const&) (in /home/brett/Documents/code/c++/blt-gp/cmake-build-release/blt-SR-playground-example)"
|
||||
,"0x127C77: blt::gp::default_next_pop_creator<blt::gp::select_tournament_t, blt::gp::select_tournament_t, blt::gp::select_tournament_t>::{lambda(blt::gp::selector_args&&, blt::gp::select_tournament_t&&, blt::gp::select_tournament_t&&, blt::gp::select_tournament_t&&)#1}::operator()(blt::gp::selector_args&&, blt::gp::select_tournament_t&&, blt::gp::select_tournament_t&&, blt::gp::select_tournament_t&&) const [clone .isra.0] (in /home/brett/Documents/code/c++/blt-gp/cmake-build-release/blt-SR-playground-example)"
|
||||
,"0x1268EF: blt::gp::individual& std::vector<blt::gp::individual, std::allocator<blt::gp::individual> >::emplace_back<blt::gp::individual>(blt::gp::individual&&) [clone .isra.0] (in /home/brett/Documents/code/c++/blt-gp/cmake-build-release/blt-SR-playground-example)"
|
||||
,"0x1268EF: blt::gp::individual_t& std::vector<blt::gp::individual_t, std::allocator<blt::gp::individual_t> >::emplace_back<blt::gp::individual_t>(blt::gp::individual_t&&) [clone .isra.0] (in /home/brett/Documents/code/c++/blt-gp/cmake-build-release/blt-SR-playground-example)"
|
||||
,"0x127DDE: blt::gp::default_next_pop_creator<blt::gp::select_tournament_t, blt::gp::select_tournament_t, blt::gp::select_tournament_t>::{lambda(blt::gp::selector_args&&, blt::gp::select_tournament_t&&, blt::gp::select_tournament_t&&, blt::gp::select_tournament_t&&)#1}::operator()(blt::gp::selector_args&&, blt::gp::select_tournament_t&&, blt::gp::select_tournament_t&&, blt::gp::select_tournament_t&&) const [clone .isra.0] (in /home/brett/Documents/code/c++/blt-gp/cmake-build-release/blt-SR-playground-example)"
|
||||
,"0x127F26: blt::gp::default_next_pop_creator<blt::gp::select_tournament_t, blt::gp::select_tournament_t, blt::gp::select_tournament_t>::{lambda(blt::gp::selector_args&&, blt::gp::select_tournament_t&&, blt::gp::select_tournament_t&&, blt::gp::select_tournament_t&&)#1}::operator()(blt::gp::selector_args&&, blt::gp::select_tournament_t&&, blt::gp::select_tournament_t&&, blt::gp::select_tournament_t&&) const [clone .isra.0] (in /home/brett/Documents/code/c++/blt-gp/cmake-build-release/blt-SR-playground-example)"
|
||||
,"0x127FE6: blt::gp::default_next_pop_creator<blt::gp::select_tournament_t, blt::gp::select_tournament_t, blt::gp::select_tournament_t>::{lambda(blt::gp::selector_args&&, blt::gp::select_tournament_t&&, blt::gp::select_tournament_t&&, blt::gp::select_tournament_t&&)#1}::operator()(blt::gp::selector_args&&, blt::gp::select_tournament_t&&, blt::gp::select_tournament_t&&, blt::gp::select_tournament_t&&) const [clone .isra.0] (in /home/brett/Documents/code/c++/blt-gp/cmake-build-release/blt-SR-playground-example)"
|
||||
|
|
@ -1366,7 +1366,7 @@
|
|||
,"0x1247AC: main (in /home/brett/Documents/code/c++/blt-gp/cmake-build-release/blt-SR-playground-example)"
|
||||
,"0x12497D: main (in /home/brett/Documents/code/c++/blt-gp/cmake-build-release/blt-SR-playground-example)"
|
||||
,"0x124A4A: main (in /home/brett/Documents/code/c++/blt-gp/cmake-build-release/blt-SR-playground-example)"
|
||||
,"0x126AFC: blt::gp::individual& std::vector<blt::gp::individual, std::allocator<blt::gp::individual> >::emplace_back<blt::gp::tree_t>(blt::gp::tree_t&&) [clone .isra.0] (in /home/brett/Documents/code/c++/blt-gp/cmake-build-release/blt-SR-playground-example)"
|
||||
,"0x126AFC: blt::gp::individual_t& std::vector<blt::gp::individual_t, std::allocator<blt::gp::individual_t> >::emplace_back<blt::gp::tree_t>(blt::gp::tree_t&&) [clone .isra.0] (in /home/brett/Documents/code/c++/blt-gp/cmake-build-release/blt-SR-playground-example)"
|
||||
,"0x127AE9: blt::gp::default_next_pop_creator<blt::gp::select_tournament_t, blt::gp::select_tournament_t, blt::gp::select_tournament_t>::{lambda(blt::gp::selector_args&&, blt::gp::select_tournament_t&&, blt::gp::select_tournament_t&&, blt::gp::select_tournament_t&&)#1}::operator()(blt::gp::selector_args&&, blt::gp::select_tournament_t&&, blt::gp::select_tournament_t&&, blt::gp::select_tournament_t&&) const [clone .isra.0] (in /home/brett/Documents/code/c++/blt-gp/cmake-build-release/blt-SR-playground-example)"
|
||||
,"0x127E76: blt::gp::default_next_pop_creator<blt::gp::select_tournament_t, blt::gp::select_tournament_t, blt::gp::select_tournament_t>::{lambda(blt::gp::selector_args&&, blt::gp::select_tournament_t&&, blt::gp::select_tournament_t&&, blt::gp::select_tournament_t&&)#1}::operator()(blt::gp::selector_args&&, blt::gp::select_tournament_t&&, blt::gp::select_tournament_t&&, blt::gp::select_tournament_t&&) const [clone .isra.0] (in /home/brett/Documents/code/c++/blt-gp/cmake-build-release/blt-SR-playground-example)"
|
||||
,"0x127EAF: blt::gp::default_next_pop_creator<blt::gp::select_tournament_t, blt::gp::select_tournament_t, blt::gp::select_tournament_t>::{lambda(blt::gp::selector_args&&, blt::gp::select_tournament_t&&, blt::gp::select_tournament_t&&, blt::gp::select_tournament_t&&)#1}::operator()(blt::gp::selector_args&&, blt::gp::select_tournament_t&&, blt::gp::select_tournament_t&&, blt::gp::select_tournament_t&&) const [clone .isra.0] (in /home/brett/Documents/code/c++/blt-gp/cmake-build-release/blt-SR-playground-example)"
|
||||
|
|
|
|||
|
|
@ -0,0 +1,33 @@
|
|||
#pragma once
|
||||
/*
|
||||
* 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/>.
|
||||
*/
|
||||
|
||||
#ifndef BLT_GP_OPERATIONS_COMMON_H
|
||||
#define BLT_GP_OPERATIONS_COMMON_H
|
||||
|
||||
#include <blt/gp/program.h>
|
||||
|
||||
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");
|
||||
|
||||
#endif //BLT_GP_OPERATIONS_COMMON_H
|
||||
|
|
@ -0,0 +1,353 @@
|
|||
/*
|
||||
* This rice classification example uses data from the UC Irvine Machine Learning repository.
|
||||
* The data for this example can be found at:
|
||||
* https://archive.ics.uci.edu/dataset/545/rice+cammeo+and+osmancik
|
||||
*
|
||||
* 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>
|
||||
#include <blt/profiling/profiler_v2.h>
|
||||
#include <blt/gp/tree.h>
|
||||
#include <blt/std/logging.h>
|
||||
#include <blt/std/format.h>
|
||||
#include <blt/parse/argparse.h>
|
||||
#include <iostream>
|
||||
#include "operations_common.h"
|
||||
#include "blt/fs/loader.h"
|
||||
|
||||
static const auto SEED_FUNC = [] { return std::random_device()(); };
|
||||
|
||||
enum class rice_type_t
|
||||
{
|
||||
Cammeo,
|
||||
Osmancik
|
||||
};
|
||||
|
||||
struct rice_record
|
||||
{
|
||||
float area;
|
||||
float perimeter;
|
||||
float major_axis_length;
|
||||
float minor_axis_length;
|
||||
float eccentricity;
|
||||
float convex_area;
|
||||
float extent;
|
||||
rice_type_t type;
|
||||
};
|
||||
|
||||
std::vector<rice_record> training_cases;
|
||||
std::vector<rice_record> testing_cases;
|
||||
|
||||
blt::gp::prog_config_t config = blt::gp::prog_config_t()
|
||||
.set_initial_min_tree_size(2)
|
||||
.set_initial_max_tree_size(6)
|
||||
.set_elite_count(2)
|
||||
.set_crossover_chance(0.9)
|
||||
.set_mutation_chance(0.1)
|
||||
.set_reproduction_chance(0)
|
||||
.set_max_generations(50)
|
||||
.set_pop_size(5000)
|
||||
.set_thread_count(0);
|
||||
|
||||
blt::gp::gp_program program{SEED_FUNC, config};
|
||||
|
||||
auto lit = blt::gp::operation_t([]() {
|
||||
return program.get_random().get_float(-32000.0f, 32000.0f);
|
||||
}, "lit").set_ephemeral();
|
||||
|
||||
blt::gp::operation_t op_area([](const rice_record& rice_data) {
|
||||
return rice_data.area;
|
||||
}, "area");
|
||||
|
||||
blt::gp::operation_t op_perimeter([](const rice_record& rice_data) {
|
||||
return rice_data.perimeter;
|
||||
}, "perimeter");
|
||||
|
||||
blt::gp::operation_t op_major_axis_length([](const rice_record& rice_data) {
|
||||
return rice_data.major_axis_length;
|
||||
}, "major_axis_length");
|
||||
|
||||
blt::gp::operation_t op_minor_axis_length([](const rice_record& rice_data) {
|
||||
return rice_data.minor_axis_length;
|
||||
}, "minor_axis_length");
|
||||
|
||||
blt::gp::operation_t op_eccentricity([](const rice_record& rice_data) {
|
||||
return rice_data.eccentricity;
|
||||
}, "eccentricity");
|
||||
|
||||
blt::gp::operation_t op_convex_area([](const rice_record& rice_data) {
|
||||
return rice_data.convex_area;
|
||||
}, "convex_area");
|
||||
|
||||
blt::gp::operation_t op_extent([](const rice_record& rice_data) {
|
||||
return rice_data.extent;
|
||||
}, "extent");
|
||||
|
||||
constexpr auto fitness_function = [](blt::gp::tree_t& current_tree, blt::gp::fitness_t& fitness, blt::size_t) {
|
||||
for (auto& training_case : training_cases)
|
||||
{
|
||||
auto v = current_tree.get_evaluation_value<float>(&training_case);
|
||||
switch (training_case.type)
|
||||
{
|
||||
case rice_type_t::Cammeo:
|
||||
if (v >= 0)
|
||||
fitness.hits++;
|
||||
break;
|
||||
case rice_type_t::Osmancik:
|
||||
if (v < 0)
|
||||
fitness.hits++;
|
||||
break;
|
||||
}
|
||||
}
|
||||
fitness.raw_fitness = static_cast<double>(fitness.hits);
|
||||
fitness.standardized_fitness = fitness.raw_fitness;
|
||||
fitness.adjusted_fitness = 1.0 - (1.0 / (1.0 + fitness.standardized_fitness));
|
||||
return static_cast<blt::size_t>(fitness.hits) == training_cases.size();
|
||||
};
|
||||
|
||||
void load_rice_data(std::string_view rice_file_path)
|
||||
{
|
||||
auto rice_file_data = blt::fs::getLinesFromFile(rice_file_path);
|
||||
size_t index = 0;
|
||||
while (!blt::string::contains(rice_file_data[index++], "@DATA"))
|
||||
{}
|
||||
std::vector<rice_record> c;
|
||||
std::vector<rice_record> o;
|
||||
for (std::string_view v : blt::itr_offset(rice_file_data, index))
|
||||
{
|
||||
auto data = blt::string::split(v, ',');
|
||||
rice_record r{std::stof(data[0]), std::stof(data[1]), std::stof(data[2]), std::stof(data[3]), std::stof(data[4]), std::stof(data[5]),
|
||||
std::stof(data[6]), blt::string::contains(data[7], "Cammeo") ? rice_type_t::Cammeo : rice_type_t::Osmancik};
|
||||
switch (r.type)
|
||||
{
|
||||
case rice_type_t::Cammeo:
|
||||
c.push_back(r);
|
||||
break;
|
||||
case rice_type_t::Osmancik:
|
||||
o.push_back(r);
|
||||
break;
|
||||
}
|
||||
}
|
||||
|
||||
blt::size_t total_records = c.size() + o.size();
|
||||
blt::size_t training_size = std::min(total_records / 3, 1000ul);
|
||||
for (blt::size_t i = 0; i < training_size; i++)
|
||||
{
|
||||
auto& random = program.get_random();
|
||||
auto& vec = random.choice() ? c : o;
|
||||
auto pos = random.get_i64(0, static_cast<blt::i64>(vec.size()));
|
||||
training_cases.push_back(vec[pos]);
|
||||
vec.erase(vec.begin() + pos);
|
||||
}
|
||||
testing_cases.insert(testing_cases.end(), c.begin(), c.end());
|
||||
testing_cases.insert(testing_cases.end(), o.begin(), o.end());
|
||||
std::shuffle(testing_cases.begin(), testing_cases.end(), program.get_random());
|
||||
BLT_INFO("Created training set of size %ld, testing set is of size %ld", training_size, testing_cases.size());
|
||||
}
|
||||
|
||||
struct test_results_t
|
||||
{
|
||||
blt::size_t cc = 0;
|
||||
blt::size_t co = 0;
|
||||
blt::size_t oo = 0;
|
||||
blt::size_t oc = 0;
|
||||
blt::size_t hits = 0;
|
||||
blt::size_t size = 0;
|
||||
double percent_hit = 0;
|
||||
|
||||
test_results_t& operator+=(const test_results_t& a)
|
||||
{
|
||||
cc += a.cc;
|
||||
co += a.co;
|
||||
oo += a.oo;
|
||||
oc += a.oc;
|
||||
hits += a.hits;
|
||||
size += a.size;
|
||||
percent_hit += a.percent_hit;
|
||||
return *this;
|
||||
}
|
||||
|
||||
test_results_t& operator/=(blt::size_t s)
|
||||
{
|
||||
cc /= s;
|
||||
co /= s;
|
||||
oo /= s;
|
||||
oc /= s;
|
||||
hits /= s;
|
||||
size /= s;
|
||||
percent_hit /= static_cast<double>(s);
|
||||
return *this;
|
||||
}
|
||||
|
||||
friend bool operator<(const test_results_t& a, const test_results_t& b)
|
||||
{
|
||||
return a.hits < b.hits;
|
||||
}
|
||||
|
||||
friend bool operator>(const test_results_t& a, const test_results_t& b)
|
||||
{
|
||||
return a.hits > b.hits;
|
||||
}
|
||||
};
|
||||
|
||||
test_results_t test_individual(blt::gp::individual_t& i)
|
||||
{
|
||||
test_results_t results;
|
||||
|
||||
for (auto& testing_case : testing_cases)
|
||||
{
|
||||
auto result = i.tree.get_evaluation_value<float>(&testing_case);
|
||||
switch (testing_case.type)
|
||||
{
|
||||
case rice_type_t::Cammeo:
|
||||
if (result >= 0)
|
||||
results.cc++; // cammeo cammeo
|
||||
else
|
||||
results.co++; // cammeo osmancik
|
||||
break;
|
||||
case rice_type_t::Osmancik:
|
||||
if (result < 0)
|
||||
results.oo++; // osmancik osmancik
|
||||
else
|
||||
results.oc++; // osmancik cammeo
|
||||
break;
|
||||
}
|
||||
}
|
||||
|
||||
results.hits = results.cc + results.oo;
|
||||
results.size = testing_cases.size();
|
||||
results.percent_hit = static_cast<double>(results.hits) / static_cast<double>(results.size) * 100;
|
||||
|
||||
return results;
|
||||
}
|
||||
|
||||
int main(int argc, const char** argv)
|
||||
{
|
||||
blt::arg_parse parser;
|
||||
parser.addArgument(blt::arg_builder{"-f", "--file"}.setHelp("File for rice data. Should be in .arff format.").setRequired().build());
|
||||
|
||||
auto args = parser.parse_args(argc, argv);
|
||||
|
||||
if (!args.contains("file"))
|
||||
{
|
||||
BLT_WARN("Please provide path to file with -f or --file");
|
||||
return 1;
|
||||
}
|
||||
|
||||
auto rice_file_path = args.get<std::string>("file");
|
||||
|
||||
BLT_INFO("Starting BLT-GP Rice Classification Example");
|
||||
BLT_START_INTERVAL("Rice Classification", "Main");
|
||||
BLT_DEBUG("Setup Fitness cases");
|
||||
load_rice_data(rice_file_path);
|
||||
|
||||
BLT_DEBUG("Setup Types and Operators");
|
||||
|
||||
blt::gp::operator_builder<rice_record> builder{};
|
||||
program.set_operations(builder.build(add, sub, mul, pro_div, op_exp, op_log, lit, op_area, op_perimeter, op_major_axis_length,
|
||||
op_minor_axis_length, op_eccentricity, op_convex_area, op_extent));
|
||||
|
||||
BLT_DEBUG("Generate Initial Population");
|
||||
auto sel = blt::gp::select_tournament_t{};
|
||||
program.generate_population(program.get_typesystem().get_type<float>().id(), fitness_function, sel, sel, sel);
|
||||
|
||||
BLT_DEBUG("Begin Generation Loop");
|
||||
while (!program.should_terminate())
|
||||
{
|
||||
BLT_TRACE("------------{Begin Generation %ld}------------", program.get_current_generation());
|
||||
BLT_TRACE("Creating next generation");
|
||||
BLT_START_INTERVAL("Rice Classification", "Gen");
|
||||
program.create_next_generation();
|
||||
BLT_END_INTERVAL("Rice Classification", "Gen");
|
||||
BLT_TRACE("Move to next generation");
|
||||
BLT_START_INTERVAL("Rice Classification", "Fitness");
|
||||
program.next_generation();
|
||||
BLT_TRACE("Evaluate Fitness");
|
||||
program.evaluate_fitness();
|
||||
BLT_END_INTERVAL("Rice Classification", "Fitness");
|
||||
auto& stats = program.get_population_stats();
|
||||
BLT_TRACE("Stats:");
|
||||
BLT_TRACE("Average fitness: %lf", stats.average_fitness.load());
|
||||
BLT_TRACE("Best fitness: %lf", stats.best_fitness.load());
|
||||
BLT_TRACE("Worst fitness: %lf", stats.worst_fitness.load());
|
||||
BLT_TRACE("Overall fitness: %lf", stats.overall_fitness.load());
|
||||
BLT_TRACE("----------------------------------------------");
|
||||
std::cout << std::endl;
|
||||
}
|
||||
|
||||
BLT_END_INTERVAL("Rice Classification", "Main");
|
||||
|
||||
std::vector<std::pair<test_results_t, blt::gp::individual_t*>> results;
|
||||
for (auto& i : program.get_current_pop().get_individuals())
|
||||
results.emplace_back(test_individual(i), &i);
|
||||
std::sort(results.begin(), results.end(), [](const auto& a, const auto& b) {
|
||||
return a.first > b.first;
|
||||
});
|
||||
|
||||
BLT_INFO("Best results:");
|
||||
for (blt::size_t index = 0; index < 3; index++)
|
||||
{
|
||||
const auto& record = results[index].first;
|
||||
const auto& i = *results[index].second;
|
||||
|
||||
BLT_INFO("Hits %ld, Total Cases %ld, Percent Hit: %lf", record.hits, record.size, record.percent_hit);
|
||||
BLT_DEBUG("Cammeo Cammeo: %ld", record.cc);
|
||||
BLT_DEBUG("Cammeo Osmancik: %ld", record.co);
|
||||
BLT_DEBUG("Osmancik Osmancik: %ld", record.oo);
|
||||
BLT_DEBUG("Osmancik Cammeo: %ld", record.oc);
|
||||
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";
|
||||
}
|
||||
|
||||
BLT_INFO("Worst Results:");
|
||||
for (blt::size_t index = 0; index < 3; index++)
|
||||
{
|
||||
const auto& record = results[results.size() - 1 - index].first;
|
||||
const auto& i = *results[results.size() - 1 - index].second;
|
||||
|
||||
BLT_INFO("Hits %ld, Total Cases %ld, Percent Hit: %lf", record.hits, record.size, record.percent_hit);
|
||||
BLT_DEBUG("Cammeo Cammeo: %ld", record.cc);
|
||||
BLT_DEBUG("Cammeo Osmancik: %ld", record.co);
|
||||
BLT_DEBUG("Osmancik Osmancik: %ld", record.oo);
|
||||
BLT_DEBUG("Osmancik Cammeo: %ld", record.oc);
|
||||
BLT_DEBUG("Fitness: %lf, stand: %lf, raw: %lf", i.fitness.adjusted_fitness, i.fitness.standardized_fitness, i.fitness.raw_fitness);
|
||||
|
||||
std::cout << "\n";
|
||||
}
|
||||
|
||||
BLT_INFO("Average Results");
|
||||
test_results_t avg{};
|
||||
for (const auto& v : results)
|
||||
avg += v.first;
|
||||
avg /= results.size();
|
||||
BLT_INFO("Hits %ld, Total Cases %ld, Percent Hit: %lf", avg.hits, avg.size, avg.percent_hit);
|
||||
BLT_DEBUG("Cammeo Cammeo: %ld", avg.cc);
|
||||
BLT_DEBUG("Cammeo Osmancik: %ld", avg.co);
|
||||
BLT_DEBUG("Osmancik Osmancik: %ld", avg.oo);
|
||||
BLT_DEBUG("Osmancik Cammeo: %ld", avg.oc);
|
||||
std::cout << "\n";
|
||||
|
||||
BLT_PRINT_PROFILE("Rice Classification", blt::PRINT_CYCLES | blt::PRINT_THREAD | blt::PRINT_WALL);
|
||||
|
||||
#ifdef BLT_TRACK_ALLOCATIONS
|
||||
BLT_TRACE("Total Allocations: %ld times with a total of %s", blt::gp::tracker.getAllocations(),
|
||||
blt::byte_convert_t(blt::gp::tracker.getAllocatedBytes()).convert_to_nearest_type().to_pretty_string().c_str());
|
||||
#endif
|
||||
|
||||
return 0;
|
||||
}
|
||||
|
|
@ -19,7 +19,9 @@
|
|||
#include <blt/profiling/profiler_v2.h>
|
||||
#include <blt/gp/tree.h>
|
||||
#include <blt/std/logging.h>
|
||||
#include <blt/std/format.h>
|
||||
#include <iostream>
|
||||
#include "operations_common.h"
|
||||
|
||||
//static constexpr long SEED = 41912;
|
||||
static const unsigned long SEED = std::random_device()();
|
||||
|
|
@ -29,35 +31,25 @@ struct context
|
|||
float x, y;
|
||||
};
|
||||
|
||||
std::array<context, 200> fitness_cases;
|
||||
std::array<context, 200> training_cases;
|
||||
|
||||
blt::gp::mutation_t mut;
|
||||
|
||||
blt::gp::prog_config_t config = blt::gp::prog_config_t()
|
||||
.set_initial_min_tree_size(2)
|
||||
.set_initial_max_tree_size(6)
|
||||
.set_elite_count(2)
|
||||
.set_elite_count(200)
|
||||
.set_crossover_chance(0.9)
|
||||
.set_mutation_chance(0.1)
|
||||
.set_reproduction_chance(0)
|
||||
.set_max_generations(50)
|
||||
.set_pop_size(5000)
|
||||
.set_pop_size(20000)
|
||||
.set_thread_count(0);
|
||||
|
||||
blt::gp::type_provider type_system;
|
||||
blt::gp::gp_program program{type_system, SEED, config};
|
||||
|
||||
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");
|
||||
blt::gp::gp_program program{SEED, config};
|
||||
|
||||
auto lit = blt::gp::operation_t([]() {
|
||||
return program.get_random().get_float(-320.0f, 320.0f);
|
||||
return program.get_random().get_float(-1.0f, 1.0f);
|
||||
}, "lit").set_ephemeral();
|
||||
|
||||
blt::gp::operation_t op_x([](const context& context) {
|
||||
|
|
@ -66,7 +58,7 @@ blt::gp::operation_t op_x([](const context& context) {
|
|||
|
||||
constexpr auto fitness_function = [](blt::gp::tree_t& current_tree, blt::gp::fitness_t& fitness, blt::size_t) {
|
||||
constexpr double value_cutoff = 1.e15;
|
||||
for (auto& fitness_case : fitness_cases)
|
||||
for (auto& fitness_case : training_cases)
|
||||
{
|
||||
auto diff = std::abs(fitness_case.y - current_tree.get_evaluation_value<float>(&fitness_case));
|
||||
if (diff < value_cutoff)
|
||||
|
|
@ -79,7 +71,7 @@ constexpr auto fitness_function = [](blt::gp::tree_t& current_tree, blt::gp::fit
|
|||
}
|
||||
fitness.standardized_fitness = fitness.raw_fitness;
|
||||
fitness.adjusted_fitness = (1.0 / (1.0 + fitness.standardized_fitness));
|
||||
return static_cast<blt::size_t>(fitness.hits) == fitness_cases.size();
|
||||
return static_cast<blt::size_t>(fitness.hits) == training_cases.size();
|
||||
};
|
||||
|
||||
float example_function(float x)
|
||||
|
|
@ -92,7 +84,7 @@ int main()
|
|||
BLT_INFO("Starting BLT-GP Symbolic Regression Example");
|
||||
BLT_START_INTERVAL("Symbolic Regression", "Main");
|
||||
BLT_DEBUG("Setup Fitness cases");
|
||||
for (auto& fitness_case : fitness_cases)
|
||||
for (auto& fitness_case : training_cases)
|
||||
{
|
||||
constexpr float range = 10;
|
||||
constexpr float half_range = range / 2.0;
|
||||
|
|
@ -102,28 +94,47 @@ int main()
|
|||
}
|
||||
|
||||
BLT_DEBUG("Setup Types and Operators");
|
||||
type_system.register_type<float>();
|
||||
|
||||
blt::gp::operator_builder<context> builder{type_system};
|
||||
blt::gp::operator_builder<context> builder{};
|
||||
program.set_operations(builder.build(add, sub, mul, pro_div, op_sin, op_cos, op_exp, op_log, lit, op_x));
|
||||
|
||||
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);
|
||||
auto sel = blt::gp::select_tournament_t{};
|
||||
program.generate_population(program.get_typesystem().get_type<float>().id(), fitness_function, sel, sel, sel);
|
||||
|
||||
BLT_DEBUG("Begin Generation Loop");
|
||||
while (!program.should_terminate())
|
||||
{
|
||||
BLT_TRACE("------------{Begin Generation %ld}------------", program.get_current_generation());
|
||||
BLT_TRACE("Creating next generation");
|
||||
|
||||
#ifdef BLT_TRACK_ALLOCATIONS
|
||||
auto gen_alloc = blt::gp::tracker.start_measurement();
|
||||
#endif
|
||||
|
||||
BLT_START_INTERVAL("Symbolic Regression", "Gen");
|
||||
program.create_next_generation();
|
||||
BLT_END_INTERVAL("Symbolic Regression", "Gen");
|
||||
|
||||
#ifdef BLT_TRACK_ALLOCATIONS
|
||||
blt::gp::tracker.stop_measurement(gen_alloc);
|
||||
BLT_TRACE("Generation Allocated %ld times with a total of %s", gen_alloc.getAllocationDifference(),
|
||||
blt::byte_convert_t(gen_alloc.getAllocatedByteDifference()).convert_to_nearest_type().to_pretty_string().c_str());
|
||||
auto fitness_alloc = blt::gp::tracker.start_measurement();
|
||||
#endif
|
||||
|
||||
BLT_TRACE("Move to next generation");
|
||||
BLT_START_INTERVAL("Symbolic Regression", "Fitness");
|
||||
program.next_generation();
|
||||
BLT_TRACE("Evaluate Fitness");
|
||||
program.evaluate_fitness();
|
||||
BLT_END_INTERVAL("Symbolic Regression", "Fitness");
|
||||
|
||||
#ifdef BLT_TRACK_ALLOCATIONS
|
||||
blt::gp::tracker.stop_measurement(fitness_alloc);
|
||||
BLT_TRACE("Fitness Allocated %ld times with a total of %s", fitness_alloc.getAllocationDifference(),
|
||||
blt::byte_convert_t(fitness_alloc.getAllocatedByteDifference()).convert_to_nearest_type().to_pretty_string().c_str());
|
||||
#endif
|
||||
|
||||
BLT_TRACE("----------------------------------------------");
|
||||
std::cout << std::endl;
|
||||
}
|
||||
|
|
@ -150,5 +161,10 @@ int main()
|
|||
|
||||
BLT_PRINT_PROFILE("Symbolic Regression", blt::PRINT_CYCLES | blt::PRINT_THREAD | blt::PRINT_WALL);
|
||||
|
||||
#ifdef BLT_TRACK_ALLOCATIONS
|
||||
BLT_TRACE("Total Allocations: %ld times with a total of %s", blt::gp::tracker.getAllocations(),
|
||||
blt::byte_convert_t(blt::gp::tracker.getAllocatedBytes()).convert_to_nearest_type().to_pretty_string().c_str());
|
||||
#endif
|
||||
|
||||
return 0;
|
||||
}
|
||||
|
|
@ -22,16 +22,22 @@
|
|||
#include <functional>
|
||||
#include <blt/std/logging.h>
|
||||
#include <blt/std/types.h>
|
||||
#include <blt/gp/stats.h>
|
||||
#include <ostream>
|
||||
#include <optional>
|
||||
#include <cstdlib>
|
||||
|
||||
namespace blt::gp
|
||||
{
|
||||
inline allocation_tracker_t tracker;
|
||||
|
||||
class gp_program;
|
||||
|
||||
class type;
|
||||
|
||||
struct operator_id;
|
||||
|
||||
struct type_id;
|
||||
|
||||
class type_provider;
|
||||
|
||||
struct op_container_t;
|
||||
|
|
@ -40,6 +46,8 @@ namespace blt::gp
|
|||
|
||||
class tree_t;
|
||||
|
||||
struct individual_t;
|
||||
|
||||
class population_t;
|
||||
|
||||
class tree_generator_t;
|
||||
|
|
@ -50,12 +58,118 @@ namespace blt::gp
|
|||
|
||||
class stack_allocator;
|
||||
|
||||
template<typename T>
|
||||
class tracked_allocator_t;
|
||||
|
||||
template<typename T>
|
||||
using tracked_vector = std::vector<T, tracked_allocator_t<T>>;
|
||||
|
||||
// using operation_vector_t = tracked_vector<op_container_t>;
|
||||
// using individual_vector_t = tracked_vector<individual_t, tracked_allocator_t<individual_t>>;
|
||||
// using tree_vector_t = tracked_vector<tree_t>;
|
||||
|
||||
class aligned_allocator
|
||||
{
|
||||
public:
|
||||
void* allocate(blt::size_t bytes) // NOLINT
|
||||
{
|
||||
#ifdef BLT_TRACK_ALLOCATIONS
|
||||
tracker.allocate(bytes);
|
||||
#endif
|
||||
return std::aligned_alloc(8, bytes);
|
||||
}
|
||||
|
||||
void deallocate(void* ptr, blt::size_t bytes) // NOLINT
|
||||
{
|
||||
if (ptr == nullptr)
|
||||
return;
|
||||
#ifdef BLT_TRACK_ALLOCATIONS
|
||||
tracker.deallocate(bytes);
|
||||
#else
|
||||
(void) bytes;
|
||||
#endif
|
||||
std::free(ptr);
|
||||
}
|
||||
};
|
||||
|
||||
template<typename T>
|
||||
class tracked_allocator_t
|
||||
{
|
||||
public:
|
||||
using value_type = T;
|
||||
using reference = T&;
|
||||
using const_reference = const T&;
|
||||
using pointer = T*;
|
||||
using const_pointer = const T*;
|
||||
using void_pointer = void*;
|
||||
using const_void_pointer = const void*;
|
||||
using difference_type = blt::ptrdiff_t;
|
||||
using size_type = blt::size_t;
|
||||
template<class U>
|
||||
struct rebind
|
||||
{
|
||||
typedef tracked_allocator_t<U> other;
|
||||
};
|
||||
|
||||
pointer allocate(size_type n)
|
||||
{
|
||||
#ifdef BLT_TRACK_ALLOCATIONS
|
||||
tracker.allocate(n * sizeof(T));
|
||||
#endif
|
||||
return static_cast<pointer>(std::malloc(n * sizeof(T)));
|
||||
}
|
||||
|
||||
pointer allocate(size_type n, const_void_pointer)
|
||||
{
|
||||
return allocate(n);
|
||||
}
|
||||
|
||||
void deallocate(pointer p, size_type n)
|
||||
{
|
||||
#ifdef BLT_TRACK_ALLOCATIONS
|
||||
tracker.deallocate(n * sizeof(T));
|
||||
#else
|
||||
(void) n;
|
||||
#endif
|
||||
std::free(p);
|
||||
}
|
||||
|
||||
template<class U, class... Args>
|
||||
void construct(U* p, Args&& ... args)
|
||||
{
|
||||
new(p) T(args...);
|
||||
}
|
||||
|
||||
template<class U>
|
||||
void destroy(U* p)
|
||||
{
|
||||
p->~T();
|
||||
}
|
||||
|
||||
[[nodiscard]] size_type max_size() const noexcept
|
||||
{
|
||||
return std::numeric_limits<size_type>::max();
|
||||
}
|
||||
};
|
||||
|
||||
template<class T1, class T2>
|
||||
inline static bool operator==(const tracked_allocator_t<T1>& lhs, const tracked_allocator_t<T2>& rhs) noexcept
|
||||
{
|
||||
return &lhs == &rhs;
|
||||
}
|
||||
|
||||
template<class T1, class T2>
|
||||
inline static bool operator!=(const tracked_allocator_t<T1>& lhs, const tracked_allocator_t<T2>& rhs) noexcept
|
||||
{
|
||||
return &lhs != &rhs;
|
||||
}
|
||||
|
||||
namespace detail
|
||||
{
|
||||
class operator_storage_test;
|
||||
// context*, read stack, write stack
|
||||
using operator_func_t = std::function<void(void*, stack_allocator&, stack_allocator&)>;
|
||||
using eval_func_t = std::function<evaluation_context(const tree_t& tree, void* context)>;
|
||||
using eval_func_t = std::function<evaluation_context&(const tree_t& tree, void* context)>;
|
||||
// debug function,
|
||||
using print_func_t = std::function<void(std::ostream&, stack_allocator&)>;
|
||||
|
||||
|
|
@ -66,6 +180,9 @@ namespace blt::gp
|
|||
};
|
||||
|
||||
using destroy_func_t = std::function<void(destroy_t, stack_allocator&)>;
|
||||
|
||||
using const_op_iter_t = tracked_vector<op_container_t>::const_iterator;
|
||||
using op_iter_t = tracked_vector<op_container_t>::iterator;
|
||||
}
|
||||
|
||||
}
|
||||
|
|
|
|||
|
|
@ -51,7 +51,7 @@ namespace blt::gp
|
|||
class tree_generator_t
|
||||
{
|
||||
public:
|
||||
virtual tree_t generate(const generator_arguments& args) = 0;
|
||||
virtual void generate(tree_t& out, const generator_arguments& args) = 0;
|
||||
|
||||
virtual ~tree_generator_t() = default;
|
||||
};
|
||||
|
|
@ -59,13 +59,13 @@ namespace blt::gp
|
|||
class grow_generator_t : public tree_generator_t
|
||||
{
|
||||
public:
|
||||
tree_t generate(const generator_arguments& args) final;
|
||||
void generate(tree_t& out, const generator_arguments& args) final;
|
||||
};
|
||||
|
||||
class full_generator_t : public tree_generator_t
|
||||
{
|
||||
public:
|
||||
tree_t generate(const generator_arguments& args) final;
|
||||
void generate(tree_t& out, const generator_arguments& args) final;
|
||||
};
|
||||
|
||||
class population_initializer_t
|
||||
|
|
|
|||
|
|
@ -52,10 +52,10 @@
|
|||
#include <blt/gp/stack.h>
|
||||
#include <blt/gp/config.h>
|
||||
#include <blt/gp/random.h>
|
||||
#include "blt/std/format.h"
|
||||
|
||||
namespace blt::gp
|
||||
{
|
||||
|
||||
struct argc_t
|
||||
{
|
||||
blt::u32 argc = 0;
|
||||
|
|
@ -79,20 +79,22 @@ namespace blt::gp
|
|||
detail::operator_func_t func;
|
||||
};
|
||||
|
||||
struct operator_storage
|
||||
struct program_operator_storage_t
|
||||
{
|
||||
// indexed from return TYPE ID, returns index of operator
|
||||
blt::expanding_buffer<std::vector<operator_id>> terminals;
|
||||
blt::expanding_buffer<std::vector<operator_id>> non_terminals;
|
||||
blt::expanding_buffer<std::vector<std::pair<operator_id, blt::size_t>>> operators_ordered_terminals;
|
||||
// indexed from OPERATOR ID (operator number)
|
||||
blt::hashset_t<operator_id> static_types;
|
||||
blt::hashset_t<operator_id> ephemeral_leaf_operators;
|
||||
std::vector<operator_info> operators;
|
||||
std::vector<detail::print_func_t> print_funcs;
|
||||
std::vector<detail::destroy_func_t> destroy_funcs;
|
||||
std::vector<std::optional<std::string_view>> names;
|
||||
|
||||
detail::eval_func_t eval_func;
|
||||
|
||||
type_provider system;
|
||||
};
|
||||
|
||||
template<typename Context = detail::empty_t>
|
||||
|
|
@ -103,11 +105,10 @@ namespace blt::gp
|
|||
friend class blt::gp::detail::operator_storage_test;
|
||||
|
||||
public:
|
||||
explicit operator_builder(type_provider& system): system(system)
|
||||
{}
|
||||
explicit operator_builder() = default;
|
||||
|
||||
template<typename... Operators>
|
||||
operator_storage& build(Operators& ... operators)
|
||||
program_operator_storage_t& build(Operators& ... operators)
|
||||
{
|
||||
std::vector<blt::size_t> sizes;
|
||||
(sizes.push_back(add_operator(operators)), ...);
|
||||
|
|
@ -115,11 +116,12 @@ namespace blt::gp
|
|||
for (auto v : sizes)
|
||||
largest = std::max(v, largest);
|
||||
|
||||
storage.eval_func = [&operators..., largest](const tree_t& tree, void* context) {
|
||||
storage.eval_func = [&operators..., largest](const tree_t& tree, void* context) -> evaluation_context& {
|
||||
const auto& ops = tree.get_operations();
|
||||
const auto& vals = tree.get_values();
|
||||
|
||||
evaluation_context results{};
|
||||
static thread_local evaluation_context results{};
|
||||
results.values.reset();
|
||||
results.values.reserve(largest);
|
||||
|
||||
blt::size_t total_so_far = 0;
|
||||
|
|
@ -199,7 +201,7 @@ namespace blt::gp
|
|||
return storage;
|
||||
}
|
||||
|
||||
operator_storage&& grab()
|
||||
program_operator_storage_t&& grab()
|
||||
{
|
||||
return std::move(storage);
|
||||
}
|
||||
|
|
@ -208,10 +210,14 @@ namespace blt::gp
|
|||
template<typename RawFunction, typename Return, typename... Args>
|
||||
auto add_operator(operation_t<RawFunction, Return(Args...)>& op)
|
||||
{
|
||||
// check for types we can register
|
||||
(storage.system.register_type<Args>(), ...);
|
||||
storage.system.register_type<Return>();
|
||||
|
||||
auto total_size_required = stack_allocator::aligned_size(sizeof(Return));
|
||||
((total_size_required += stack_allocator::aligned_size(sizeof(Args))), ...);
|
||||
|
||||
auto return_type_id = system.get_type<Return>().id();
|
||||
auto return_type_id = storage.system.get_type<Return>().id();
|
||||
auto operator_id = blt::gp::operator_id(storage.operators.size());
|
||||
op.id = operator_id;
|
||||
|
||||
|
|
@ -260,8 +266,8 @@ namespace blt::gp
|
|||
});
|
||||
storage.names.push_back(op.get_name());
|
||||
if (op.is_ephemeral())
|
||||
storage.static_types.insert(operator_id);
|
||||
return total_size_required;
|
||||
storage.ephemeral_leaf_operators.insert(operator_id);
|
||||
return total_size_required * 2;
|
||||
}
|
||||
|
||||
template<typename T>
|
||||
|
|
@ -269,7 +275,7 @@ namespace blt::gp
|
|||
{
|
||||
if constexpr (!std::is_same_v<Context, detail::remove_cv_ref<T>>)
|
||||
{
|
||||
types.push_back(system.get_type<T>().id());
|
||||
types.push_back(storage.system.get_type<T>().id());
|
||||
}
|
||||
}
|
||||
|
||||
|
|
@ -314,8 +320,7 @@ namespace blt::gp
|
|||
call_jmp_table_internal(op, context, write_stack, read_stack, std::index_sequence_for<Operators...>(), operators...);
|
||||
}
|
||||
|
||||
type_provider& system;
|
||||
operator_storage storage;
|
||||
program_operator_storage_t storage;
|
||||
};
|
||||
|
||||
class gp_program
|
||||
|
|
@ -325,29 +330,89 @@ namespace blt::gp
|
|||
* Note about context size: This is required as context is passed to every operator in the GP tree, this context will be provided by your
|
||||
* call to one of the evaluator functions. This was the nicest way to provide this as C++ lacks reflection
|
||||
*
|
||||
* @param system type system to use in tree generation
|
||||
* @param engine random engine to use throughout the program.
|
||||
* @param context_size number of arguments which are always present as "context" to the GP system / operators
|
||||
*/
|
||||
explicit gp_program(type_provider& system, blt::u64 seed):
|
||||
system(system), seed(seed)
|
||||
explicit gp_program(blt::u64 seed): seed_func([seed] { return seed; })
|
||||
{ create_threads(); }
|
||||
|
||||
explicit gp_program(type_provider& system, blt::u64 seed, prog_config_t config):
|
||||
system(system), seed(seed), config(config)
|
||||
explicit gp_program(blt::u64 seed, prog_config_t config): seed_func([seed] { return seed; }), config(config)
|
||||
{ create_threads(); }
|
||||
|
||||
explicit gp_program(std::function<blt::u64()> seed_func): seed_func(std::move(seed_func))
|
||||
{ create_threads(); }
|
||||
|
||||
explicit gp_program(std::function<blt::u64()> seed_func, prog_config_t config): seed_func(std::move(seed_func)), config(config)
|
||||
{ create_threads(); }
|
||||
|
||||
~gp_program()
|
||||
{
|
||||
thread_helper.lifetime_over = true;
|
||||
thread_helper.barrier.notify_all();
|
||||
thread_helper.thread_function_condition.notify_all();
|
||||
for (auto& thread : thread_helper.threads)
|
||||
{
|
||||
if (thread->joinable())
|
||||
thread->join();
|
||||
}
|
||||
}
|
||||
|
||||
void create_next_generation()
|
||||
{
|
||||
#ifdef BLT_TRACK_ALLOCATIONS
|
||||
auto gen_alloc = blt::gp::tracker.start_measurement();
|
||||
#endif
|
||||
BLT_ASSERT_MSG(current_pop.get_individuals().size() == config.population_size,
|
||||
("cur pop size: " + std::to_string(current_pop.get_individuals().size())).c_str());
|
||||
BLT_ASSERT_MSG(next_pop.get_individuals().size() == config.population_size,
|
||||
("next pop size: " + std::to_string(next_pop.get_individuals().size())).c_str());
|
||||
// should already be empty
|
||||
next_pop.clear();
|
||||
thread_helper.next_gen_left.store(config.population_size, std::memory_order_release);
|
||||
(*thread_execution_service)(0);
|
||||
#ifdef BLT_TRACK_ALLOCATIONS
|
||||
blt::gp::tracker.stop_measurement(gen_alloc);
|
||||
BLT_TRACE("Generation Allocated %ld times with a total of %s", gen_alloc.getAllocationDifference(),
|
||||
blt::byte_convert_t(gen_alloc.getAllocatedByteDifference()).convert_to_nearest_type().to_pretty_string().c_str());
|
||||
#endif
|
||||
}
|
||||
|
||||
void next_generation()
|
||||
{
|
||||
BLT_ASSERT_MSG(current_pop.get_individuals().size() == config.population_size,
|
||||
("cur pop size: " + std::to_string(current_pop.get_individuals().size())).c_str());
|
||||
BLT_ASSERT_MSG(next_pop.get_individuals().size() == config.population_size,
|
||||
("next pop size: " + std::to_string(next_pop.get_individuals().size())).c_str());
|
||||
std::swap(current_pop, next_pop);
|
||||
current_generation++;
|
||||
}
|
||||
|
||||
void evaluate_fitness()
|
||||
{
|
||||
#ifdef BLT_TRACK_ALLOCATIONS
|
||||
auto fitness_alloc = blt::gp::tracker.start_measurement();
|
||||
#endif
|
||||
evaluate_fitness_internal();
|
||||
#ifdef BLT_TRACK_ALLOCATIONS
|
||||
blt::gp::tracker.stop_measurement(fitness_alloc);
|
||||
BLT_TRACE("Fitness Allocated %ld times with a total of %s", fitness_alloc.getAllocationDifference(),
|
||||
blt::byte_convert_t(fitness_alloc.getAllocatedByteDifference()).convert_to_nearest_type().to_pretty_string().c_str());
|
||||
#endif
|
||||
|
||||
}
|
||||
|
||||
void reset_program(type_id root_type, bool eval_fitness_now = true)
|
||||
{
|
||||
current_generation = 0;
|
||||
current_pop = config.pop_initializer.get().generate(
|
||||
{*this, root_type, config.population_size, config.initial_min_tree_size, config.initial_max_tree_size});
|
||||
next_pop = population_t(current_pop);
|
||||
if (eval_fitness_now)
|
||||
evaluate_fitness_internal();
|
||||
}
|
||||
|
||||
void kill()
|
||||
{
|
||||
thread_helper.lifetime_over = true;
|
||||
}
|
||||
|
||||
/**
|
||||
|
|
@ -368,61 +433,71 @@ namespace blt::gp
|
|||
using LambdaReturn = typename decltype(blt::meta::lambda_helper(fitness_function))::Return;
|
||||
current_pop = config.pop_initializer.get().generate(
|
||||
{*this, root_type, config.population_size, config.initial_min_tree_size, config.initial_max_tree_size});
|
||||
next_pop = population_t(current_pop);
|
||||
if (config.threads == 1)
|
||||
{
|
||||
BLT_INFO("Starting with single thread variant!");
|
||||
thread_execution_service = new std::function(
|
||||
thread_execution_service = std::unique_ptr<std::function<void(blt::size_t)>>(new std::function(
|
||||
[this, &fitness_function, &crossover_selection, &mutation_selection, &reproduction_selection, &func](blt::size_t) {
|
||||
if (thread_helper.evaluation_left > 0)
|
||||
{
|
||||
for (const auto& ind : blt::enumerate(current_pop.get_individuals()))
|
||||
current_stats.normalized_fitness.clear();
|
||||
double sum_of_prob = 0;
|
||||
for (const auto& [index, ind] : blt::enumerate(current_pop.get_individuals()))
|
||||
{
|
||||
if constexpr (std::is_same_v<LambdaReturn, bool> || std::is_convertible_v<LambdaReturn, bool>)
|
||||
{
|
||||
auto result = fitness_function(ind.second.tree, ind.second.fitness, ind.first);
|
||||
auto result = fitness_function(ind.tree, ind.fitness, index);
|
||||
if (result)
|
||||
fitness_should_exit = true;
|
||||
} else
|
||||
{
|
||||
fitness_function(ind.second.tree, ind.second.fitness, ind.first);
|
||||
fitness_function(ind.tree, ind.fitness, index);
|
||||
|
||||
if (ind.fitness.adjusted_fitness > current_stats.best_fitness)
|
||||
current_stats.best_fitness = ind.fitness.adjusted_fitness;
|
||||
|
||||
if (ind.fitness.adjusted_fitness < current_stats.worst_fitness)
|
||||
current_stats.worst_fitness = ind.fitness.adjusted_fitness;
|
||||
|
||||
current_stats.overall_fitness = current_stats.overall_fitness + ind.fitness.adjusted_fitness;
|
||||
}
|
||||
|
||||
if (ind.second.fitness.adjusted_fitness > current_stats.best_fitness)
|
||||
current_stats.best_fitness = ind.second.fitness.adjusted_fitness;
|
||||
|
||||
if (ind.second.fitness.adjusted_fitness < current_stats.worst_fitness)
|
||||
current_stats.worst_fitness = ind.second.fitness.adjusted_fitness;
|
||||
|
||||
current_stats.overall_fitness = current_stats.overall_fitness + ind.second.fitness.adjusted_fitness;
|
||||
for (auto& ind : current_pop)
|
||||
{
|
||||
auto prob = (ind.fitness.adjusted_fitness / current_stats.overall_fitness);
|
||||
current_stats.normalized_fitness.push_back(sum_of_prob + prob);
|
||||
sum_of_prob += prob;
|
||||
}
|
||||
thread_helper.evaluation_left = 0;
|
||||
}
|
||||
if (thread_helper.next_gen_left > 0)
|
||||
{
|
||||
static thread_local std::vector<tree_t> new_children;
|
||||
new_children.clear();
|
||||
auto args = get_selector_args(new_children);
|
||||
auto args = get_selector_args();
|
||||
|
||||
crossover_selection.pre_process(*this, current_pop, current_stats);
|
||||
mutation_selection.pre_process(*this, current_pop, current_stats);
|
||||
reproduction_selection.pre_process(*this, current_pop, current_stats);
|
||||
crossover_selection.pre_process(*this, current_pop);
|
||||
mutation_selection.pre_process(*this, current_pop);
|
||||
reproduction_selection.pre_process(*this, current_pop);
|
||||
|
||||
perform_elitism(args);
|
||||
perform_elitism(args, next_pop);
|
||||
|
||||
while (new_children.size() < config.population_size)
|
||||
func(args, crossover_selection, mutation_selection, reproduction_selection);
|
||||
blt::size_t start = config.elites;
|
||||
|
||||
for (auto& i : new_children)
|
||||
next_pop.get_individuals().emplace_back(std::move(i));
|
||||
while (start < config.population_size)
|
||||
{
|
||||
tree_t& c1 = next_pop.get_individuals()[start].tree;
|
||||
tree_t* c2 = nullptr;
|
||||
if (start + 1 < config.population_size)
|
||||
c2 = &next_pop.get_individuals()[start + 1].tree;
|
||||
start += func(args, crossover_selection, mutation_selection, reproduction_selection, c1, c2);
|
||||
}
|
||||
|
||||
thread_helper.next_gen_left = 0;
|
||||
}
|
||||
});
|
||||
}));
|
||||
} else
|
||||
{
|
||||
BLT_INFO("Starting thread execution service!");
|
||||
std::scoped_lock lock(thread_helper.thread_function_control);
|
||||
thread_execution_service = new std::function(
|
||||
thread_execution_service = std::unique_ptr<std::function<void(blt::size_t)>>(new std::function(
|
||||
[this, &fitness_function, &crossover_selection, &mutation_selection, &reproduction_selection, &func](blt::size_t id) {
|
||||
thread_helper.barrier.wait();
|
||||
if (thread_helper.evaluation_left > 0)
|
||||
|
|
@ -476,23 +551,27 @@ namespace blt::gp
|
|||
}
|
||||
if (thread_helper.next_gen_left > 0)
|
||||
{
|
||||
static thread_local std::vector<tree_t> new_children;
|
||||
new_children.clear();
|
||||
auto args = get_selector_args(new_children);
|
||||
auto args = get_selector_args();
|
||||
if (id == 0)
|
||||
{
|
||||
crossover_selection.pre_process(*this, current_pop, current_stats);
|
||||
current_stats.normalized_fitness.clear();
|
||||
double sum_of_prob = 0;
|
||||
for (auto& ind : current_pop)
|
||||
{
|
||||
auto prob = (ind.fitness.adjusted_fitness / current_stats.overall_fitness);
|
||||
current_stats.normalized_fitness.push_back(sum_of_prob + prob);
|
||||
sum_of_prob += prob;
|
||||
}
|
||||
|
||||
crossover_selection.pre_process(*this, current_pop);
|
||||
if (&crossover_selection != &mutation_selection)
|
||||
mutation_selection.pre_process(*this, current_pop, current_stats);
|
||||
mutation_selection.pre_process(*this, current_pop);
|
||||
if (&crossover_selection != &reproduction_selection)
|
||||
reproduction_selection.pre_process(*this, current_pop, current_stats);
|
||||
reproduction_selection.pre_process(*this, current_pop);
|
||||
|
||||
perform_elitism(args);
|
||||
perform_elitism(args, next_pop);
|
||||
|
||||
for (auto& i : new_children)
|
||||
next_pop.get_individuals().emplace_back(std::move(i));
|
||||
thread_helper.next_gen_left -= new_children.size();
|
||||
new_children.clear();
|
||||
thread_helper.next_gen_left -= config.elites;
|
||||
}
|
||||
thread_helper.barrier.wait();
|
||||
|
||||
|
|
@ -509,88 +588,26 @@ namespace blt::gp
|
|||
std::memory_order::memory_order_relaxed,
|
||||
std::memory_order::memory_order_relaxed));
|
||||
|
||||
for (blt::size_t i = begin; i < end; i++)
|
||||
func(args, crossover_selection, mutation_selection, reproduction_selection);
|
||||
while (begin != end)
|
||||
{
|
||||
auto index = config.elites + begin;
|
||||
tree_t& c1 = next_pop.get_individuals()[index].tree;
|
||||
tree_t* c2 = nullptr;
|
||||
if (index + 1 < end)
|
||||
c2 = &next_pop.get_individuals()[index + 1].tree;
|
||||
begin += func(args, crossover_selection, mutation_selection, reproduction_selection, c1, c2);
|
||||
}
|
||||
|
||||
{
|
||||
std::scoped_lock lock(thread_helper.thread_generation_lock);
|
||||
for (auto& i : new_children)
|
||||
{
|
||||
if (next_pop.get_individuals().size() < config.population_size)
|
||||
next_pop.get_individuals().emplace_back(i);
|
||||
}
|
||||
}
|
||||
}
|
||||
}
|
||||
thread_helper.barrier.wait();
|
||||
});
|
||||
}));
|
||||
thread_helper.thread_function_condition.notify_all();
|
||||
}
|
||||
if (eval_fitness_now)
|
||||
evaluate_fitness_internal();
|
||||
}
|
||||
|
||||
void reset_program(type_id root_type, bool eval_fitness_now = true)
|
||||
{
|
||||
current_generation = 0;
|
||||
current_pop = config.pop_initializer.get().generate(
|
||||
{*this, root_type, config.population_size, config.initial_min_tree_size, config.initial_max_tree_size});
|
||||
if (eval_fitness_now)
|
||||
evaluate_fitness_internal();
|
||||
}
|
||||
|
||||
void next_generation()
|
||||
{
|
||||
current_pop = std::move(next_pop);
|
||||
current_generation++;
|
||||
}
|
||||
|
||||
inline auto& get_current_pop()
|
||||
{
|
||||
return current_pop;
|
||||
}
|
||||
|
||||
template<blt::size_t size>
|
||||
std::array<blt::size_t, size> get_best_indexes()
|
||||
{
|
||||
std::array<blt::size_t, size> arr;
|
||||
|
||||
std::vector<std::pair<blt::size_t, double>> values;
|
||||
values.reserve(current_pop.get_individuals().size());
|
||||
|
||||
for (const auto& ind : blt::enumerate(current_pop.get_individuals()))
|
||||
values.emplace_back(ind.first, ind.second.fitness.adjusted_fitness);
|
||||
|
||||
std::sort(values.begin(), values.end(), [](const auto& a, const auto& b) {
|
||||
return a.second > b.second;
|
||||
});
|
||||
|
||||
for (blt::size_t i = 0; i < size; i++)
|
||||
arr[i] = values[i].first;
|
||||
|
||||
return arr;
|
||||
}
|
||||
|
||||
template<blt::size_t size>
|
||||
auto get_best_trees()
|
||||
{
|
||||
return convert_array<std::array<std::reference_wrapper<tree_t>, size>>(get_best_indexes<size>(),
|
||||
[this](auto&& arr, blt::size_t index) -> tree_t& {
|
||||
return current_pop.get_individuals()[arr[index]].tree;
|
||||
},
|
||||
std::make_integer_sequence<blt::size_t, size>());
|
||||
}
|
||||
|
||||
template<blt::size_t size>
|
||||
auto get_best_individuals()
|
||||
{
|
||||
return convert_array<std::array<std::reference_wrapper<individual>, size>>(get_best_indexes<size>(),
|
||||
[this](auto&& arr, blt::size_t index) -> individual& {
|
||||
return current_pop.get_individuals()[arr[index]];
|
||||
},
|
||||
std::make_integer_sequence<blt::size_t, size>());
|
||||
}
|
||||
|
||||
[[nodiscard]] bool should_terminate() const
|
||||
{
|
||||
return current_generation >= config.max_generations || fitness_should_exit;
|
||||
|
|
@ -601,13 +618,6 @@ namespace blt::gp
|
|||
return thread_helper.lifetime_over;
|
||||
}
|
||||
|
||||
[[nodiscard]] random_t& get_random() const;
|
||||
|
||||
[[nodiscard]] inline type_provider& get_typesystem()
|
||||
{
|
||||
return system;
|
||||
}
|
||||
|
||||
inline operator_id select_terminal(type_id id)
|
||||
{
|
||||
// we wanted a terminal, but could not find one, so we will select from a function that has a terminal
|
||||
|
|
@ -633,47 +643,49 @@ namespace blt::gp
|
|||
return get_random().select(storage.operators_ordered_terminals[id]).first;
|
||||
}
|
||||
|
||||
inline operator_info& get_operator_info(operator_id id)
|
||||
inline auto& get_current_pop()
|
||||
{
|
||||
return current_pop;
|
||||
}
|
||||
|
||||
[[nodiscard]] random_t& get_random() const;
|
||||
|
||||
[[nodiscard]] inline type_provider& get_typesystem()
|
||||
{
|
||||
return storage.system;
|
||||
}
|
||||
|
||||
[[nodiscard]] inline operator_info& get_operator_info(operator_id id)
|
||||
{
|
||||
return storage.operators[id];
|
||||
}
|
||||
|
||||
inline detail::print_func_t& get_print_func(operator_id id)
|
||||
[[nodiscard]] inline detail::print_func_t& get_print_func(operator_id id)
|
||||
{
|
||||
return storage.print_funcs[id];
|
||||
}
|
||||
|
||||
inline detail::destroy_func_t& get_destroy_func(operator_id id)
|
||||
[[nodiscard]] inline detail::destroy_func_t& get_destroy_func(operator_id id)
|
||||
{
|
||||
return storage.destroy_funcs[id];
|
||||
}
|
||||
|
||||
inline std::optional<std::string_view> get_name(operator_id id)
|
||||
[[nodiscard]] inline std::optional<std::string_view> get_name(operator_id id)
|
||||
{
|
||||
return storage.names[id];
|
||||
}
|
||||
|
||||
inline std::vector<operator_id>& get_type_terminals(type_id id)
|
||||
[[nodiscard]] inline std::vector<operator_id>& get_type_terminals(type_id id)
|
||||
{
|
||||
return storage.terminals[id];
|
||||
}
|
||||
|
||||
inline std::vector<operator_id>& get_type_non_terminals(type_id id)
|
||||
[[nodiscard]] inline std::vector<operator_id>& get_type_non_terminals(type_id id)
|
||||
{
|
||||
return storage.non_terminals[id];
|
||||
}
|
||||
|
||||
inline bool is_static(operator_id id)
|
||||
{
|
||||
return storage.static_types.contains(static_cast<blt::size_t>(id));
|
||||
}
|
||||
|
||||
inline void set_operations(operator_storage op)
|
||||
{
|
||||
storage = std::move(op);
|
||||
}
|
||||
|
||||
inline detail::eval_func_t& get_eval_func()
|
||||
[[nodiscard]] inline detail::eval_func_t& get_eval_func()
|
||||
{
|
||||
return storage.eval_func;
|
||||
}
|
||||
|
|
@ -683,68 +695,66 @@ namespace blt::gp
|
|||
return current_generation.load();
|
||||
}
|
||||
|
||||
[[nodiscard]] inline auto& get_population_stats()
|
||||
[[nodiscard]] inline const auto& get_population_stats() const
|
||||
{
|
||||
return current_stats;
|
||||
}
|
||||
|
||||
~gp_program()
|
||||
[[nodiscard]] inline bool is_operator_ephemeral(operator_id id)
|
||||
{
|
||||
thread_helper.lifetime_over = true;
|
||||
thread_helper.barrier.notify_all();
|
||||
thread_helper.thread_function_condition.notify_all();
|
||||
for (auto& thread : thread_helper.threads)
|
||||
{
|
||||
if (thread->joinable())
|
||||
thread->join();
|
||||
}
|
||||
auto* cpy = thread_execution_service.load(std::memory_order_acquire);
|
||||
thread_execution_service = nullptr;
|
||||
delete cpy;
|
||||
return storage.ephemeral_leaf_operators.contains(static_cast<blt::size_t>(id));
|
||||
}
|
||||
|
||||
void kill()
|
||||
inline void set_operations(program_operator_storage_t op)
|
||||
{
|
||||
thread_helper.lifetime_over = true;
|
||||
storage = std::move(op);
|
||||
}
|
||||
|
||||
template<blt::size_t size>
|
||||
std::array<blt::size_t, size> get_best_indexes()
|
||||
{
|
||||
std::array<blt::size_t, size> arr;
|
||||
|
||||
std::vector<std::pair<blt::size_t, double>> values;
|
||||
values.reserve(current_pop.get_individuals().size());
|
||||
|
||||
for (const auto& ind : blt::enumerate(current_pop.get_individuals()))
|
||||
values.emplace_back(ind.first, ind.second.fitness.adjusted_fitness);
|
||||
|
||||
std::sort(values.begin(), values.end(), [](const auto& a, const auto& b) {
|
||||
return a.second > b.second;
|
||||
});
|
||||
|
||||
for (blt::size_t i = 0; i < size; i++)
|
||||
arr[i] = values[i].first;
|
||||
|
||||
return arr;
|
||||
}
|
||||
|
||||
template<blt::size_t size>
|
||||
auto get_best_trees()
|
||||
{
|
||||
return convert_array<std::array<std::reference_wrapper<individual_t>, size>>(get_best_indexes<size>(),
|
||||
[this](auto&& arr, blt::size_t index) -> tree_t& {
|
||||
return current_pop.get_individuals()[arr[index]].tree;
|
||||
},
|
||||
std::make_integer_sequence<blt::size_t, size>());
|
||||
}
|
||||
|
||||
template<blt::size_t size>
|
||||
auto get_best_individuals()
|
||||
{
|
||||
return convert_array<std::array<std::reference_wrapper<individual_t>, size>>(get_best_indexes<size>(),
|
||||
[this](auto&& arr, blt::size_t index) -> individual_t& {
|
||||
return current_pop.get_individuals()[arr[index]];
|
||||
},
|
||||
std::make_integer_sequence<blt::size_t, size>());
|
||||
}
|
||||
|
||||
private:
|
||||
type_provider& system;
|
||||
|
||||
operator_storage storage;
|
||||
population_t current_pop;
|
||||
population_stats current_stats{};
|
||||
population_t next_pop;
|
||||
std::atomic_uint64_t current_generation = 0;
|
||||
std::atomic_bool fitness_should_exit = false;
|
||||
|
||||
blt::u64 seed;
|
||||
prog_config_t config{};
|
||||
|
||||
struct concurrency_storage
|
||||
inline selector_args get_selector_args()
|
||||
{
|
||||
std::vector<std::unique_ptr<std::thread>> threads;
|
||||
|
||||
std::mutex thread_function_control;
|
||||
std::mutex thread_generation_lock;
|
||||
std::condition_variable thread_function_condition{};
|
||||
|
||||
std::atomic_uint64_t evaluation_left = 0;
|
||||
std::atomic_uint64_t next_gen_left = 0;
|
||||
|
||||
std::atomic_bool lifetime_over = false;
|
||||
blt::barrier barrier;
|
||||
|
||||
explicit concurrency_storage(blt::size_t threads): barrier(threads, lifetime_over)
|
||||
{}
|
||||
} thread_helper{config.threads == 0 ? std::thread::hardware_concurrency() : config.threads};
|
||||
|
||||
// for convenience, shouldn't decrease performance too much
|
||||
std::atomic<std::function<void(blt::size_t)>*> thread_execution_service = nullptr;
|
||||
|
||||
inline selector_args get_selector_args(std::vector<tree_t>& next_pop_trees)
|
||||
{
|
||||
return {*this, next_pop_trees, current_pop, current_stats, config, get_random()};
|
||||
return {*this, current_pop, current_stats, config, get_random()};
|
||||
}
|
||||
|
||||
template<typename Return, blt::size_t size, typename Accessor, blt::size_t... indexes>
|
||||
|
|
@ -758,12 +768,47 @@ namespace blt::gp
|
|||
|
||||
void evaluate_fitness_internal()
|
||||
{
|
||||
statistic_history.push_back(current_stats);
|
||||
current_stats.clear();
|
||||
thread_helper.evaluation_left.store(current_pop.get_individuals().size(), std::memory_order_release);
|
||||
thread_helper.evaluation_left.store(config.population_size, std::memory_order_release);
|
||||
(*thread_execution_service)(0);
|
||||
|
||||
current_stats.average_fitness = current_stats.overall_fitness / static_cast<double>(config.population_size);
|
||||
}
|
||||
|
||||
private:
|
||||
program_operator_storage_t storage;
|
||||
std::function<blt::u64()> seed_func;
|
||||
prog_config_t config{};
|
||||
|
||||
population_t current_pop;
|
||||
population_t next_pop;
|
||||
|
||||
std::atomic_uint64_t current_generation = 0;
|
||||
|
||||
std::atomic_bool fitness_should_exit = false;
|
||||
|
||||
population_stats current_stats{};
|
||||
std::vector<population_stats> statistic_history;
|
||||
|
||||
struct concurrency_storage
|
||||
{
|
||||
std::vector<std::unique_ptr<std::thread>> threads;
|
||||
|
||||
std::mutex thread_function_control{};
|
||||
std::condition_variable thread_function_condition{};
|
||||
|
||||
std::atomic_uint64_t evaluation_left = 0;
|
||||
std::atomic_uint64_t next_gen_left = 0;
|
||||
|
||||
std::atomic_bool lifetime_over = false;
|
||||
blt::barrier barrier;
|
||||
|
||||
explicit concurrency_storage(blt::size_t threads): barrier(threads, lifetime_over)
|
||||
{}
|
||||
} thread_helper{config.threads == 0 ? std::thread::hardware_concurrency() : config.threads};
|
||||
|
||||
std::unique_ptr<std::function<void(blt::size_t)>> thread_execution_service = nullptr;
|
||||
};
|
||||
|
||||
}
|
||||
|
|
|
|||
|
|
@ -25,93 +25,7 @@
|
|||
namespace blt::gp
|
||||
{
|
||||
|
||||
#define BLT_RANDOM_FUNCTION blt::random::murmur_random64
|
||||
#define BLT_RANDOM_FLOAT blt::random::murmur_float64
|
||||
#define BLT_RANDOM_DOUBLE blt::random::murmur_double64
|
||||
|
||||
class random_t
|
||||
{
|
||||
public:
|
||||
explicit random_t(blt::u64 seed): seed(seed)
|
||||
{}
|
||||
|
||||
void set_seed(blt::u64 s)
|
||||
{
|
||||
seed = s;
|
||||
}
|
||||
|
||||
float get_float()
|
||||
{
|
||||
return BLT_RANDOM_FLOAT(seed);
|
||||
}
|
||||
|
||||
double get_double()
|
||||
{
|
||||
return BLT_RANDOM_DOUBLE(seed);
|
||||
}
|
||||
|
||||
// [min, max)
|
||||
double get_double(double min, double max)
|
||||
{
|
||||
return BLT_RANDOM_FUNCTION(seed, min, max);
|
||||
}
|
||||
|
||||
// [min, max)
|
||||
float get_float(float min, float max)
|
||||
{
|
||||
return BLT_RANDOM_FUNCTION(seed, min, max);
|
||||
}
|
||||
|
||||
i32 get_i32(i32 min, i32 max)
|
||||
{
|
||||
return BLT_RANDOM_FUNCTION(seed, min, max);
|
||||
}
|
||||
|
||||
u32 get_u32(u32 min, u32 max)
|
||||
{
|
||||
return BLT_RANDOM_FUNCTION(seed, min, max);
|
||||
}
|
||||
|
||||
i64 get_i64(i64 min, i64 max)
|
||||
{
|
||||
return BLT_RANDOM_FUNCTION(seed, min, max);
|
||||
}
|
||||
|
||||
u64 get_u64(u64 min, u64 max)
|
||||
{
|
||||
return BLT_RANDOM_FUNCTION(seed, min, max);
|
||||
}
|
||||
|
||||
blt::size_t get_size_t(blt::size_t min, blt::size_t max)
|
||||
{
|
||||
return BLT_RANDOM_FUNCTION(seed, min, max);
|
||||
}
|
||||
|
||||
bool choice()
|
||||
{
|
||||
return BLT_RANDOM_DOUBLE(seed) < 0.5;
|
||||
}
|
||||
|
||||
bool choice(double cutoff)
|
||||
{
|
||||
return BLT_RANDOM_DOUBLE(seed) <= cutoff;
|
||||
}
|
||||
|
||||
template<typename Container>
|
||||
auto& select(Container& container)
|
||||
{
|
||||
return container[get_u64(0, container.size())];
|
||||
}
|
||||
|
||||
template<typename Container>
|
||||
const auto& select(const Container& container)
|
||||
{
|
||||
return container[get_u64(0, container.size())];
|
||||
}
|
||||
|
||||
private:
|
||||
blt::u64 seed;
|
||||
};
|
||||
using random_t = blt::random::random_t;
|
||||
|
||||
}
|
||||
|
||||
|
|
|
|||
|
|
@ -24,6 +24,7 @@
|
|||
#include <blt/gp/config.h>
|
||||
#include <blt/gp/random.h>
|
||||
#include <blt/std/assert.h>
|
||||
#include "blt/std/format.h"
|
||||
|
||||
namespace blt::gp
|
||||
{
|
||||
|
|
@ -31,19 +32,19 @@ namespace blt::gp
|
|||
struct selector_args
|
||||
{
|
||||
gp_program& program;
|
||||
std::vector<tree_t>& next_pop;
|
||||
population_t& current_pop;
|
||||
const population_t& current_pop;
|
||||
population_stats& current_stats;
|
||||
prog_config_t& config;
|
||||
random_t& random;
|
||||
};
|
||||
|
||||
constexpr inline auto perform_elitism = [](const selector_args& args) {
|
||||
auto& [program, next_pop, current_pop, current_stats, config, random] = args;
|
||||
constexpr inline auto perform_elitism = [](const selector_args& args, population_t& next_pop) {
|
||||
auto& [program, current_pop, current_stats, config, random] = args;
|
||||
|
||||
if (config.elites > 0)
|
||||
{
|
||||
std::vector<std::pair<std::size_t, double>> values;
|
||||
static thread_local tracked_vector<std::pair<std::size_t, double>> values;
|
||||
values.clear();
|
||||
|
||||
for (blt::size_t i = 0; i < config.elites; i++)
|
||||
values.emplace_back(i, current_pop.get_individuals()[i].fitness.adjusted_fitness);
|
||||
|
|
@ -68,50 +69,66 @@ namespace blt::gp
|
|||
}
|
||||
|
||||
for (blt::size_t i = 0; i < config.elites; i++)
|
||||
next_pop.push_back(current_pop.get_individuals()[values[i].first].tree);
|
||||
next_pop.get_individuals()[i].copy_fast(current_pop.get_individuals()[values[i].first].tree);
|
||||
}
|
||||
};
|
||||
|
||||
template<typename Crossover, typename Mutation, typename Reproduction>
|
||||
constexpr inline auto default_next_pop_creator = [](
|
||||
blt::gp::selector_args& args, Crossover& crossover_selection, Mutation& mutation_selection, Reproduction& reproduction_selection) {
|
||||
auto& [program, next_pop, current_pop, current_stats, config, random] = args;
|
||||
blt::gp::selector_args& args, Crossover& crossover_selection, Mutation& mutation_selection, Reproduction& reproduction_selection,
|
||||
tree_t& c1, tree_t* c2) {
|
||||
auto& [program, current_pop, current_stats, config, random] = args;
|
||||
|
||||
int sel = random.get_i32(0, 3);
|
||||
switch (sel)
|
||||
{
|
||||
case 0:
|
||||
if (c2 == nullptr)
|
||||
return 0;
|
||||
// everyone gets a chance once per loop.
|
||||
if (random.choice(config.crossover_chance))
|
||||
{
|
||||
// auto state = tracker.start_measurement();
|
||||
// crossover
|
||||
auto& p1 = crossover_selection.select(program, current_pop, current_stats);
|
||||
auto& p2 = crossover_selection.select(program, current_pop, current_stats);
|
||||
|
||||
auto results = config.crossover.get().apply(program, p1, p2);
|
||||
|
||||
// if crossover fails, we can check for mutation on these guys. otherwise straight copy them into the next pop
|
||||
if (results)
|
||||
const tree_t* p1;
|
||||
const tree_t* p2;
|
||||
do
|
||||
{
|
||||
next_pop.push_back(std::move(results->child1));
|
||||
next_pop.push_back(std::move(results->child2));
|
||||
}
|
||||
p1 = &crossover_selection.select(program, current_pop);
|
||||
p2 = &crossover_selection.select(program, current_pop);
|
||||
} while (!config.crossover.get().apply(program, *p1, *p2, c1, *c2));
|
||||
// tracker.stop_measurement(state);
|
||||
// BLT_TRACE("Crossover Allocated %ld times with a total of %s", state.getAllocationDifference(),
|
||||
// blt::byte_convert_t(state.getAllocatedByteDifference()).convert_to_nearest_type().to_pretty_string().c_str());
|
||||
return 2;
|
||||
}
|
||||
break;
|
||||
case 1:
|
||||
if (random.choice(config.mutation_chance))
|
||||
{
|
||||
// auto state = tracker.start_measurement();
|
||||
// mutation
|
||||
auto& p = mutation_selection.select(program, current_pop, current_stats);
|
||||
next_pop.push_back(std::move(config.mutator.get().apply(program, p)));
|
||||
const tree_t* p;
|
||||
do
|
||||
{
|
||||
p = &mutation_selection.select(program, current_pop);
|
||||
} while (!config.mutator.get().apply(program, *p, c1));
|
||||
// tracker.stop_measurement(state);
|
||||
// BLT_TRACE("Mutation Allocated %ld times with a total of %s", state.getAllocationDifference(),
|
||||
// blt::byte_convert_t(state.getAllocatedByteDifference()).convert_to_nearest_type().to_pretty_string().c_str());
|
||||
return 1;
|
||||
}
|
||||
break;
|
||||
case 2:
|
||||
if (config.reproduction_chance > 0 && random.choice(config.reproduction_chance))
|
||||
{
|
||||
// auto state = tracker.start_measurement();
|
||||
// reproduction
|
||||
auto& p = reproduction_selection.select(program, current_pop, current_stats);
|
||||
next_pop.push_back(p);
|
||||
c1 = reproduction_selection.select(program, current_pop);
|
||||
// tracker.stop_measurement(state);
|
||||
// BLT_TRACE("Reproduction Allocated %ld times with a total of %s", state.getAllocationDifference(),
|
||||
// blt::byte_convert_t(state.getAllocatedByteDifference()).convert_to_nearest_type().to_pretty_string().c_str());
|
||||
return 1;
|
||||
}
|
||||
break;
|
||||
default:
|
||||
|
|
@ -121,6 +138,7 @@ namespace blt::gp
|
|||
BLT_UNREACHABLE;
|
||||
#endif
|
||||
}
|
||||
return 0;
|
||||
};
|
||||
|
||||
class selection_t
|
||||
|
|
@ -132,9 +150,9 @@ namespace blt::gp
|
|||
* @param stats the populations statistics
|
||||
* @return
|
||||
*/
|
||||
virtual tree_t& select(gp_program& program, population_t& pop, population_stats& stats) = 0;
|
||||
virtual const tree_t& select(gp_program& program, const population_t& pop) = 0;
|
||||
|
||||
virtual void pre_process(gp_program&, population_t&, population_stats&)
|
||||
virtual void pre_process(gp_program&, population_t&)
|
||||
{}
|
||||
|
||||
virtual ~selection_t() = default;
|
||||
|
|
@ -143,19 +161,19 @@ namespace blt::gp
|
|||
class select_best_t : public selection_t
|
||||
{
|
||||
public:
|
||||
tree_t& select(gp_program& program, population_t& pop, population_stats& stats) final;
|
||||
const tree_t& select(gp_program& program, const population_t& pop) final;
|
||||
};
|
||||
|
||||
class select_worst_t : public selection_t
|
||||
{
|
||||
public:
|
||||
tree_t& select(gp_program& program, population_t& pop, population_stats& stats) final;
|
||||
const tree_t& select(gp_program& program, const population_t& pop) final;
|
||||
};
|
||||
|
||||
class select_random_t : public selection_t
|
||||
{
|
||||
public:
|
||||
tree_t& select(gp_program& program, population_t& pop, population_stats& stats) final;
|
||||
const tree_t& select(gp_program& program, const population_t& pop) final;
|
||||
};
|
||||
|
||||
class select_tournament_t : public selection_t
|
||||
|
|
@ -163,11 +181,11 @@ namespace blt::gp
|
|||
public:
|
||||
explicit select_tournament_t(blt::size_t selection_size = 3): selection_size(selection_size)
|
||||
{
|
||||
if (selection_size < 1)
|
||||
BLT_ABORT("Unable to select with this size. Must select at least 1 individual!");
|
||||
if (selection_size == 0)
|
||||
BLT_ABORT("Unable to select with this size. Must select at least 1 individual_t!");
|
||||
}
|
||||
|
||||
tree_t& select(gp_program& program, population_t& pop, population_stats& stats) final;
|
||||
const tree_t& select(gp_program& program, const population_t& pop) final;
|
||||
|
||||
private:
|
||||
const blt::size_t selection_size;
|
||||
|
|
@ -176,9 +194,7 @@ namespace blt::gp
|
|||
class select_fitness_proportionate_t : public selection_t
|
||||
{
|
||||
public:
|
||||
void pre_process(gp_program& program, population_t& pop, population_stats& stats) final;
|
||||
|
||||
tree_t& select(gp_program& program, population_t& pop, population_stats& stats) final;
|
||||
const tree_t& select(gp_program& program, const population_t& pop) final;
|
||||
};
|
||||
|
||||
}
|
||||
|
|
|
|||
|
|
@ -20,12 +20,14 @@
|
|||
#define BLT_GP_STACK_H
|
||||
|
||||
#include <blt/std/types.h>
|
||||
#include <blt/std/bump_allocator.h>
|
||||
#include <blt/std/assert.h>
|
||||
#include <blt/std/logging.h>
|
||||
#include <blt/std/allocator.h>
|
||||
#include <blt/std/ranges.h>
|
||||
#include <blt/std/meta.h>
|
||||
#include <blt/gp/fwdecl.h>
|
||||
#include <blt/gp/stats.h>
|
||||
#include <utility>
|
||||
#include <stdexcept>
|
||||
#include <cstdlib>
|
||||
|
|
@ -36,29 +38,14 @@
|
|||
|
||||
namespace blt::gp
|
||||
{
|
||||
|
||||
namespace detail
|
||||
{
|
||||
BLT_META_MAKE_FUNCTION_CHECK(drop);
|
||||
}
|
||||
|
||||
class aligned_allocator
|
||||
{
|
||||
public:
|
||||
void* allocate(blt::size_t bytes) // NOLINT
|
||||
{
|
||||
return std::aligned_alloc(8, bytes);
|
||||
}
|
||||
|
||||
void deallocate(void* ptr, blt::size_t) // NOLINT
|
||||
{
|
||||
std::free(ptr);
|
||||
}
|
||||
};
|
||||
|
||||
class stack_allocator
|
||||
{
|
||||
constexpr static blt::size_t PAGE_SIZE = 0x1000;
|
||||
constexpr static blt::size_t PAGE_SIZE = 0x100;
|
||||
constexpr static blt::size_t MAX_ALIGNMENT = 8;
|
||||
template<typename T>
|
||||
using NO_REF_T = std::remove_cv_t<std::remove_reference_t<T>>;
|
||||
|
|
@ -106,7 +93,7 @@ namespace blt::gp
|
|||
}
|
||||
|
||||
stack_allocator(stack_allocator&& move) noexcept:
|
||||
data_(std::exchange(move.data_, nullptr)), bytes_stored(move.bytes_stored), size_(move.size_)
|
||||
data_(std::exchange(move.data_, nullptr)), bytes_stored(std::exchange(move.bytes_stored, 0)), size_(std::exchange(move.size_, 0))
|
||||
{}
|
||||
|
||||
stack_allocator& operator=(const stack_allocator& copy) = delete;
|
||||
|
|
@ -121,7 +108,6 @@ namespace blt::gp
|
|||
|
||||
~stack_allocator()
|
||||
{
|
||||
//std::free(data_);
|
||||
get_allocator().deallocate(data_, size_);
|
||||
}
|
||||
|
||||
|
|
@ -265,13 +251,33 @@ namespace blt::gp
|
|||
void reserve(blt::size_t bytes)
|
||||
{
|
||||
if (bytes > size_)
|
||||
expand(bytes);
|
||||
expand_raw(bytes);
|
||||
}
|
||||
|
||||
[[nodiscard]] blt::size_t stored() const
|
||||
{
|
||||
return bytes_stored;
|
||||
}
|
||||
|
||||
[[nodiscard]] blt::size_t internal_storage_size() const
|
||||
{
|
||||
return size_;
|
||||
}
|
||||
|
||||
void reset()
|
||||
{
|
||||
bytes_stored = 0;
|
||||
}
|
||||
|
||||
private:
|
||||
void expand(blt::size_t bytes)
|
||||
{
|
||||
bytes = to_nearest_page_size(bytes);
|
||||
//bytes = to_nearest_page_size(bytes);
|
||||
expand_raw(bytes);
|
||||
}
|
||||
|
||||
void expand_raw(blt::size_t bytes)
|
||||
{
|
||||
auto new_data = static_cast<blt::u8*>(get_allocator().allocate(bytes));
|
||||
if (bytes_stored > 0)
|
||||
std::memcpy(new_data, data_, bytes_stored);
|
||||
|
|
|
|||
|
|
@ -0,0 +1,134 @@
|
|||
#pragma once
|
||||
/*
|
||||
* 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/>.
|
||||
*/
|
||||
|
||||
#ifndef BLT_GP_STATS_H
|
||||
#define BLT_GP_STATS_H
|
||||
|
||||
#include <blt/std/types.h>
|
||||
#include <atomic>
|
||||
#include <cmath>
|
||||
|
||||
namespace blt::gp
|
||||
{
|
||||
|
||||
class allocation_tracker_t
|
||||
{
|
||||
public:
|
||||
struct allocation_data_t
|
||||
{
|
||||
blt::u64 start_allocations = 0;
|
||||
blt::u64 start_deallocations = 0;
|
||||
blt::u64 start_allocated_bytes = 0;
|
||||
blt::u64 start_deallocated_bytes = 0;
|
||||
|
||||
blt::u64 end_allocations = 0;
|
||||
blt::u64 end_deallocations = 0;
|
||||
blt::u64 end_allocated_bytes = 0;
|
||||
blt::u64 end_deallocated_bytes = 0;
|
||||
|
||||
[[nodiscard]] blt::u64 getAllocationDifference() const
|
||||
{
|
||||
return end_allocations - start_allocations;
|
||||
}
|
||||
|
||||
[[nodiscard]] blt::u64 getDeallocationDifference() const
|
||||
{
|
||||
return end_deallocations - start_deallocations;
|
||||
}
|
||||
|
||||
[[nodiscard]] blt::u64 getAllocatedByteDifference() const
|
||||
{
|
||||
return end_allocated_bytes - start_allocated_bytes;
|
||||
}
|
||||
|
||||
[[nodiscard]] blt::u64 getDeallocatedByteDifference() const
|
||||
{
|
||||
return end_deallocated_bytes - start_deallocated_bytes;
|
||||
}
|
||||
};
|
||||
|
||||
void allocate(blt::size_t bytes)
|
||||
{
|
||||
allocations++;
|
||||
allocated_bytes += bytes;
|
||||
}
|
||||
|
||||
void deallocate(blt::size_t bytes)
|
||||
{
|
||||
deallocations++;
|
||||
deallocated_bytes += bytes;
|
||||
}
|
||||
|
||||
[[nodiscard]] blt::u64 getAllocations() const
|
||||
{
|
||||
return allocations;
|
||||
}
|
||||
|
||||
[[nodiscard]] blt::u64 getDeallocations() const
|
||||
{
|
||||
return deallocations;
|
||||
}
|
||||
|
||||
[[nodiscard]] blt::u64 getAllocatedBytes() const
|
||||
{
|
||||
return allocated_bytes;
|
||||
}
|
||||
|
||||
[[nodiscard]] blt::u64 getDeallocatedBytes() const
|
||||
{
|
||||
return deallocated_bytes;
|
||||
}
|
||||
|
||||
[[nodiscard]] blt::u64 getAllocationDifference() const
|
||||
{
|
||||
return std::abs(static_cast<blt::i64>(getAllocations()) - static_cast<blt::i64>(getDeallocations()));
|
||||
}
|
||||
|
||||
[[nodiscard]] blt::u64 getCurrentlyAllocatedBytes() const
|
||||
{
|
||||
return getAllocatedBytes() - getDeallocatedBytes();
|
||||
}
|
||||
|
||||
[[nodiscard]] allocation_data_t start_measurement() const
|
||||
{
|
||||
allocation_data_t data{};
|
||||
data.start_allocations = allocations;
|
||||
data.start_deallocations = deallocations;
|
||||
data.start_allocated_bytes = allocated_bytes;
|
||||
data.start_deallocated_bytes = deallocated_bytes;
|
||||
return data;
|
||||
}
|
||||
|
||||
void stop_measurement(allocation_data_t& data) const
|
||||
{
|
||||
data.end_allocations = allocations;
|
||||
data.end_deallocations = deallocations;
|
||||
data.end_allocated_bytes = allocated_bytes;
|
||||
data.end_deallocated_bytes = deallocated_bytes;
|
||||
}
|
||||
|
||||
private:
|
||||
std::atomic_uint64_t allocations = 0;
|
||||
std::atomic_uint64_t deallocations = 0;
|
||||
std::atomic_uint64_t allocated_bytes = 0;
|
||||
std::atomic_uint64_t deallocated_bytes = 0;
|
||||
};
|
||||
|
||||
}
|
||||
|
||||
#endif //BLT_GP_STATS_H
|
||||
|
|
@ -29,8 +29,6 @@ namespace blt::gp
|
|||
{
|
||||
namespace detail
|
||||
{
|
||||
using op_iter = std::vector<blt::gp::op_container_t>::iterator;
|
||||
|
||||
template<typename T>
|
||||
inline static constexpr double sum(const T& array)
|
||||
{
|
||||
|
|
@ -59,16 +57,6 @@ namespace blt::gp
|
|||
class crossover_t
|
||||
{
|
||||
public:
|
||||
enum class error_t
|
||||
{
|
||||
NO_VALID_TYPE,
|
||||
TREE_TOO_SMALL
|
||||
};
|
||||
struct result_t
|
||||
{
|
||||
tree_t child1;
|
||||
tree_t child2;
|
||||
};
|
||||
struct crossover_point_t
|
||||
{
|
||||
blt::ptrdiff_t p1_crossover_point;
|
||||
|
|
@ -89,7 +77,7 @@ namespace blt::gp
|
|||
explicit crossover_t(const config_t& config): config(config)
|
||||
{}
|
||||
|
||||
blt::expected<crossover_t::crossover_point_t, error_t> get_crossover_point(gp_program& program, const tree_t& c1, const tree_t& c2) const;
|
||||
std::optional<crossover_t::crossover_point_t> get_crossover_point(gp_program& program, const tree_t& c1, const tree_t& c2) const;
|
||||
|
||||
/**
|
||||
* child1 and child2 are copies of the parents, the result of selecting a crossover point and performing standard subtree crossover.
|
||||
|
|
@ -99,7 +87,7 @@ namespace blt::gp
|
|||
* @param p2 reference to the second parent
|
||||
* @return expected pair of child otherwise returns error enum
|
||||
*/
|
||||
virtual blt::expected<result_t, error_t> apply(gp_program& program, const tree_t& p1, const tree_t& p2); // NOLINT
|
||||
virtual bool apply(gp_program& program, const tree_t& p1, const tree_t& p2, tree_t& c1, tree_t& c2); // NOLINT
|
||||
|
||||
virtual ~crossover_t() = default;
|
||||
|
||||
|
|
@ -128,7 +116,7 @@ namespace blt::gp
|
|||
explicit mutation_t(const config_t& config): config(config)
|
||||
{}
|
||||
|
||||
virtual tree_t apply(gp_program& program, const tree_t& p);
|
||||
virtual bool apply(gp_program& program, const tree_t& p, tree_t& c);
|
||||
|
||||
// returns the point after the mutation
|
||||
blt::size_t mutate_point(gp_program& program, tree_t& c, blt::size_t node);
|
||||
|
|
@ -157,7 +145,7 @@ namespace blt::gp
|
|||
explicit advanced_mutation_t(const config_t& config): mutation_t(config)
|
||||
{}
|
||||
|
||||
tree_t apply(gp_program& program, const tree_t& p) final;
|
||||
bool apply(gp_program& program, const tree_t& p, tree_t& c) final;
|
||||
|
||||
advanced_mutation_t& set_per_node_mutation_chance(double v)
|
||||
{
|
||||
|
|
@ -172,11 +160,11 @@ namespace blt::gp
|
|||
double per_node_mutation_chance = 5.0;
|
||||
|
||||
static constexpr std::array<double, operators_size> mutation_operator_chances = detail::aggregate_array<operators_size>(
|
||||
0.1, // EXPRESSION
|
||||
0.25, // ADJUST
|
||||
0.25, // EXPRESSION
|
||||
0.15, // ADJUST
|
||||
0.01, // SUB_FUNC
|
||||
0.25, // JUMP_FUNC
|
||||
0.12 // COPY
|
||||
0.01, // JUMP_FUNC
|
||||
0.05 // COPY
|
||||
);
|
||||
};
|
||||
|
||||
|
|
|
|||
|
|
@ -53,10 +53,42 @@ namespace blt::gp
|
|||
|
||||
class tree_t
|
||||
{
|
||||
using iter_type = std::vector<op_container_t>::const_iterator;
|
||||
public:
|
||||
explicit tree_t(gp_program& program);
|
||||
|
||||
tree_t(const tree_t& copy) = default;
|
||||
|
||||
tree_t& operator=(const tree_t& copy)
|
||||
{
|
||||
if (this == ©)
|
||||
return *this;
|
||||
copy_fast(copy);
|
||||
return *this;
|
||||
}
|
||||
|
||||
/**
|
||||
* This function copies the data from the provided tree, will attempt to reserve and copy in one step.
|
||||
* will avoid reallocation if enough space is already present.
|
||||
*/
|
||||
void copy_fast(const tree_t& copy)
|
||||
{
|
||||
if (this == ©)
|
||||
return;
|
||||
values.reserve(copy.values.internal_storage_size());
|
||||
values.reset();
|
||||
values.insert(copy.values);
|
||||
|
||||
operations.clear();
|
||||
operations.reserve(copy.operations.size());
|
||||
operations.insert(operations.begin(), copy.operations.begin(), copy.operations.end());
|
||||
}
|
||||
|
||||
tree_t(tree_t&& move) = default;
|
||||
|
||||
tree_t& operator=(tree_t&& move) = default;
|
||||
|
||||
void clear(gp_program& program);
|
||||
|
||||
struct child_t
|
||||
{
|
||||
blt::ptrdiff_t start;
|
||||
|
|
@ -64,12 +96,12 @@ namespace blt::gp
|
|||
blt::ptrdiff_t end;
|
||||
};
|
||||
|
||||
[[nodiscard]] inline std::vector<op_container_t>& get_operations()
|
||||
[[nodiscard]] inline tracked_vector<op_container_t>& get_operations()
|
||||
{
|
||||
return operations;
|
||||
}
|
||||
|
||||
[[nodiscard]] inline const std::vector<op_container_t>& get_operations() const
|
||||
[[nodiscard]] inline const tracked_vector<op_container_t>& get_operations() const
|
||||
{
|
||||
return operations;
|
||||
}
|
||||
|
|
@ -84,7 +116,7 @@ namespace blt::gp
|
|||
return values;
|
||||
}
|
||||
|
||||
evaluation_context evaluate(void* context) const
|
||||
evaluation_context& evaluate(void* context) const
|
||||
{
|
||||
return (*func)(*this, context);
|
||||
}
|
||||
|
|
@ -115,7 +147,7 @@ namespace blt::gp
|
|||
template<typename T>
|
||||
T get_evaluation_value(void* context)
|
||||
{
|
||||
auto results = evaluate(context);
|
||||
auto& results = evaluate(context);
|
||||
return results.values.pop<T>();
|
||||
}
|
||||
|
||||
|
|
@ -131,7 +163,7 @@ namespace blt::gp
|
|||
blt::ptrdiff_t find_parent(blt::gp::gp_program& program, blt::ptrdiff_t start) const;
|
||||
|
||||
// valid for [begin, end)
|
||||
static blt::size_t total_value_bytes(iter_type begin, iter_type end)
|
||||
static blt::size_t total_value_bytes(detail::const_op_iter_t begin, detail::const_op_iter_t end)
|
||||
{
|
||||
blt::size_t total = 0;
|
||||
for (auto it = begin; it != end; it++)
|
||||
|
|
@ -159,7 +191,7 @@ namespace blt::gp
|
|||
}
|
||||
|
||||
private:
|
||||
std::vector<op_container_t> operations;
|
||||
tracked_vector<op_container_t> operations;
|
||||
blt::gp::stack_allocator values;
|
||||
detail::eval_func_t* func;
|
||||
};
|
||||
|
|
@ -172,30 +204,49 @@ namespace blt::gp
|
|||
blt::i64 hits = 0;
|
||||
};
|
||||
|
||||
struct individual
|
||||
struct individual_t
|
||||
{
|
||||
tree_t tree;
|
||||
fitness_t fitness;
|
||||
|
||||
individual() = default;
|
||||
void copy_fast(const tree_t& copy)
|
||||
{
|
||||
// fast copy of the tree
|
||||
tree.copy_fast(copy);
|
||||
// reset fitness
|
||||
fitness = {};
|
||||
}
|
||||
|
||||
explicit individual(tree_t&& tree): tree(std::move(tree))
|
||||
individual_t() = delete;
|
||||
|
||||
explicit individual_t(tree_t&& tree): tree(std::move(tree))
|
||||
{}
|
||||
|
||||
explicit individual(const tree_t& tree): tree(tree)
|
||||
explicit individual_t(const tree_t& tree): tree(tree)
|
||||
{}
|
||||
|
||||
individual(const individual&) = default;
|
||||
individual_t(const individual_t&) = default;
|
||||
|
||||
individual(individual&&) = default;
|
||||
individual_t(individual_t&&) = default;
|
||||
|
||||
individual& operator=(const individual&) = delete;
|
||||
individual_t& operator=(const individual_t&) = delete;
|
||||
|
||||
individual& operator=(individual&&) = default;
|
||||
individual_t& operator=(individual_t&&) = default;
|
||||
};
|
||||
|
||||
struct population_stats
|
||||
{
|
||||
population_stats() = default;
|
||||
|
||||
population_stats(const population_stats& copy):
|
||||
overall_fitness(copy.overall_fitness.load()), average_fitness(copy.average_fitness.load()), best_fitness(copy.best_fitness.load()),
|
||||
worst_fitness(copy.worst_fitness.load())
|
||||
{
|
||||
normalized_fitness.reserve(copy.normalized_fitness.size());
|
||||
for (auto v : copy.normalized_fitness)
|
||||
normalized_fitness.push_back(v);
|
||||
}
|
||||
|
||||
std::atomic<double> overall_fitness = 0;
|
||||
std::atomic<double> average_fitness = 0;
|
||||
std::atomic<double> best_fitness = 0;
|
||||
|
|
@ -218,7 +269,7 @@ namespace blt::gp
|
|||
class population_tree_iterator
|
||||
{
|
||||
public:
|
||||
population_tree_iterator(std::vector<individual>& ind, blt::size_t pos): ind(ind), pos(pos)
|
||||
population_tree_iterator(tracked_vector<individual_t>& ind, blt::size_t pos): ind(ind), pos(pos)
|
||||
{}
|
||||
|
||||
auto begin()
|
||||
|
|
@ -263,11 +314,16 @@ namespace blt::gp
|
|||
}
|
||||
|
||||
private:
|
||||
std::vector<individual>& ind;
|
||||
tracked_vector<individual_t>& ind;
|
||||
blt::size_t pos;
|
||||
};
|
||||
|
||||
std::vector<individual>& get_individuals()
|
||||
tracked_vector<individual_t>& get_individuals()
|
||||
{
|
||||
return individuals;
|
||||
}
|
||||
|
||||
[[nodiscard]] const tracked_vector<individual_t>& get_individuals() const
|
||||
{
|
||||
return individuals;
|
||||
}
|
||||
|
|
@ -313,7 +369,7 @@ namespace blt::gp
|
|||
population_t& operator=(population_t&&) = default;
|
||||
|
||||
private:
|
||||
std::vector<individual> individuals;
|
||||
tracked_vector<individual_t> individuals;
|
||||
};
|
||||
}
|
||||
|
||||
|
|
|
|||
|
|
@ -85,12 +85,13 @@ namespace blt::gp
|
|||
type_provider() = default;
|
||||
|
||||
template<typename T>
|
||||
inline type register_type()
|
||||
inline void register_type()
|
||||
{
|
||||
if (has_type<T>())
|
||||
return;
|
||||
auto t = type::make_type<T>(types.size());
|
||||
types.insert({blt::type_string_raw<T>(), t});
|
||||
types_from_id[t.id()] = t;
|
||||
return t;
|
||||
}
|
||||
|
||||
template<typename T>
|
||||
|
|
@ -99,6 +100,11 @@ namespace blt::gp
|
|||
return types[blt::type_string_raw<T>()];
|
||||
}
|
||||
|
||||
template<typename T>
|
||||
inline bool has_type(){
|
||||
return types.find(blt::type_string_raw<T>()) != types.end();
|
||||
}
|
||||
|
||||
inline type get_type(type_id id)
|
||||
{
|
||||
return types_from_id[id];
|
||||
|
|
|
|||
2
lib/blt
2
lib/blt
|
|
@ -1 +1 @@
|
|||
Subproject commit 6632d045286b42d257eb3783e96256c13b588186
|
||||
Subproject commit 79e080cfd34fb47342f67f19b95ffa27efb0f715
|
||||
|
|
@ -49,11 +49,10 @@ namespace blt::gp
|
|||
}
|
||||
|
||||
template<typename Func>
|
||||
inline tree_t create_tree(Func&& perChild, const generator_arguments& args)
|
||||
inline void create_tree(tree_t& tree, Func&& perChild, const generator_arguments& args)
|
||||
{
|
||||
std::stack<stack> tree_generator = get_initial_stack(args.program, args.root_type);
|
||||
blt::size_t max_depth = 0;
|
||||
tree_t tree{args.program};
|
||||
|
||||
while (!tree_generator.empty())
|
||||
{
|
||||
|
|
@ -65,10 +64,10 @@ namespace blt::gp
|
|||
tree.get_operations().emplace_back(
|
||||
args.program.get_typesystem().get_type(info.return_type).size(),
|
||||
top.id,
|
||||
args.program.is_static(top.id));
|
||||
args.program.is_operator_ephemeral(top.id));
|
||||
max_depth = std::max(max_depth, top.depth);
|
||||
|
||||
if (args.program.is_static(top.id))
|
||||
if (args.program.is_operator_ephemeral(top.id))
|
||||
{
|
||||
info.func(nullptr, tree.get_values(), tree.get_values());
|
||||
continue;
|
||||
|
|
@ -77,13 +76,11 @@ namespace blt::gp
|
|||
for (const auto& child : info.argument_types)
|
||||
std::forward<Func>(perChild)(args.program, tree_generator, child, top.depth + 1);
|
||||
}
|
||||
|
||||
return tree;
|
||||
}
|
||||
|
||||
tree_t grow_generator_t::generate(const generator_arguments& args)
|
||||
void grow_generator_t::generate(tree_t& tree, const generator_arguments& args)
|
||||
{
|
||||
return create_tree([args](gp_program& program, std::stack<stack>& tree_generator, type_id type, blt::size_t new_depth) {
|
||||
return create_tree(tree, [args](gp_program& program, std::stack<stack>& tree_generator, type_id type, blt::size_t new_depth) {
|
||||
if (new_depth >= args.max_depth)
|
||||
{
|
||||
if (program.get_type_terminals(type).empty())
|
||||
|
|
@ -99,9 +96,9 @@ namespace blt::gp
|
|||
}, args);
|
||||
}
|
||||
|
||||
tree_t full_generator_t::generate(const generator_arguments& args)
|
||||
void full_generator_t::generate(tree_t& tree, const generator_arguments& args)
|
||||
{
|
||||
return create_tree([args](gp_program& program, std::stack<stack>& tree_generator, type_id type, blt::size_t new_depth) {
|
||||
return create_tree(tree, [args](gp_program& program, std::stack<stack>& tree_generator, type_id type, blt::size_t new_depth) {
|
||||
if (new_depth >= args.max_depth)
|
||||
{
|
||||
if (program.get_type_terminals(type).empty())
|
||||
|
|
@ -119,7 +116,11 @@ namespace blt::gp
|
|||
population_t pop;
|
||||
|
||||
for (auto i = 0ul; i < args.size; i++)
|
||||
pop.get_individuals().emplace_back(grow.generate(args.to_gen_args()));
|
||||
{
|
||||
tree_t tree{args.program};
|
||||
grow.generate(tree, args.to_gen_args());
|
||||
pop.get_individuals().emplace_back(tree);
|
||||
}
|
||||
|
||||
return pop;
|
||||
}
|
||||
|
|
@ -129,7 +130,11 @@ namespace blt::gp
|
|||
population_t pop;
|
||||
|
||||
for (auto i = 0ul; i < args.size; i++)
|
||||
pop.get_individuals().emplace_back(full.generate(args.to_gen_args()));
|
||||
{
|
||||
tree_t tree{args.program};
|
||||
full.generate(tree, args.to_gen_args());
|
||||
pop.get_individuals().emplace_back(tree);
|
||||
}
|
||||
|
||||
return pop;
|
||||
}
|
||||
|
|
@ -140,10 +145,12 @@ namespace blt::gp
|
|||
|
||||
for (auto i = 0ul; i < args.size; i++)
|
||||
{
|
||||
tree_t tree{args.program};
|
||||
if (args.program.get_random().choice())
|
||||
pop.get_individuals().emplace_back(full.generate(args.to_gen_args()));
|
||||
full.generate(tree, args.to_gen_args());
|
||||
else
|
||||
pop.get_individuals().emplace_back(grow.generate(args.to_gen_args()));
|
||||
grow.generate(tree, args.to_gen_args());
|
||||
pop.get_individuals().emplace_back(tree);
|
||||
}
|
||||
|
||||
return pop;
|
||||
|
|
@ -160,22 +167,26 @@ namespace blt::gp
|
|||
{
|
||||
for (auto i = 0ul; i < per_step; i++)
|
||||
{
|
||||
tree_t tree{args.program};
|
||||
if (args.program.get_random().choice())
|
||||
pop.get_individuals().emplace_back(full.generate({args.program, args.root_type, args.min_depth, depth}));
|
||||
full.generate(tree, {args.program, args.root_type, args.min_depth, depth});
|
||||
else
|
||||
pop.get_individuals().emplace_back(grow.generate({args.program, args.root_type, args.min_depth, depth}));
|
||||
grow.generate(tree, {args.program, args.root_type, args.min_depth, depth});
|
||||
pop.get_individuals().emplace_back(tree);
|
||||
}
|
||||
}
|
||||
|
||||
for (auto i = 0ul; i < remainder; i++)
|
||||
{
|
||||
tree_t tree{args.program};
|
||||
if (args.program.get_random().choice())
|
||||
pop.get_individuals().emplace_back(full.generate(args.to_gen_args()));
|
||||
full.generate(tree, args.to_gen_args());
|
||||
else
|
||||
pop.get_individuals().emplace_back(grow.generate(args.to_gen_args()));
|
||||
grow.generate(tree, args.to_gen_args());
|
||||
pop.get_individuals().emplace_back(tree);
|
||||
}
|
||||
|
||||
blt_assert(pop.get_individuals().size() == args.size);
|
||||
BLT_ASSERT(pop.get_individuals().size() == args.size);
|
||||
|
||||
return pop;
|
||||
}
|
||||
|
|
|
|||
|
|
@ -46,7 +46,7 @@ namespace blt::gp
|
|||
|
||||
random_t& gp_program::get_random() const
|
||||
{
|
||||
thread_local static blt::gp::random_t random_engine{seed};
|
||||
thread_local static blt::gp::random_t random_engine{seed_func()};
|
||||
return random_engine;
|
||||
}
|
||||
|
||||
|
|
@ -76,7 +76,7 @@ namespace blt::gp
|
|||
if (should_thread_terminate())
|
||||
return;
|
||||
}
|
||||
execution_function = thread_execution_service.load(std::memory_order_acquire);
|
||||
execution_function = thread_execution_service.get();
|
||||
}
|
||||
if (execution_function != nullptr)
|
||||
(*execution_function)(i);
|
||||
|
|
|
|||
|
|
@ -21,11 +21,11 @@
|
|||
namespace blt::gp
|
||||
{
|
||||
|
||||
tree_t& select_best_t::select(gp_program&, population_t& pop, population_stats&)
|
||||
const tree_t& select_best_t::select(gp_program&, const population_t& pop)
|
||||
{
|
||||
auto& first = pop.get_individuals()[0];
|
||||
double best_fitness = first.fitness.adjusted_fitness;
|
||||
tree_t* tree = &first.tree;
|
||||
const tree_t* tree = &first.tree;
|
||||
for (auto& ind : pop.get_individuals())
|
||||
{
|
||||
if (ind.fitness.adjusted_fitness > best_fitness)
|
||||
|
|
@ -37,11 +37,11 @@ namespace blt::gp
|
|||
return *tree;
|
||||
}
|
||||
|
||||
tree_t& select_worst_t::select(gp_program&, population_t& pop, population_stats&)
|
||||
const tree_t& select_worst_t::select(gp_program&, const population_t& pop)
|
||||
{
|
||||
auto& first = pop.get_individuals()[0];
|
||||
double worst_fitness = first.fitness.adjusted_fitness;
|
||||
tree_t* tree = &first.tree;
|
||||
const tree_t* tree = &first.tree;
|
||||
for (auto& ind : pop.get_individuals())
|
||||
{
|
||||
if (ind.fitness.adjusted_fitness < worst_fitness)
|
||||
|
|
@ -53,32 +53,27 @@ namespace blt::gp
|
|||
return *tree;
|
||||
}
|
||||
|
||||
tree_t& select_random_t::select(gp_program& program, population_t& pop, population_stats&)
|
||||
const tree_t& select_random_t::select(gp_program& program, const population_t& pop)
|
||||
{
|
||||
return pop.get_individuals()[program.get_random().get_size_t(0ul, pop.get_individuals().size())].tree;
|
||||
}
|
||||
|
||||
tree_t& select_tournament_t::select(gp_program& program, population_t& pop, population_stats&)
|
||||
const tree_t& select_tournament_t::select(gp_program& program, const population_t& pop)
|
||||
{
|
||||
|
||||
auto& first = pop.get_individuals()[program.get_random().get_size_t(0ul, pop.get_individuals().size())];
|
||||
individual* ind = &first;
|
||||
double best_guy = first.fitness.adjusted_fitness;
|
||||
for (blt::size_t i = 0; i < selection_size - 1; i++)
|
||||
blt::u64 best = program.get_random().get_u64(0, pop.get_individuals().size());
|
||||
auto& i_ref = pop.get_individuals();
|
||||
for (blt::size_t i = 0; i < selection_size; i++)
|
||||
{
|
||||
auto& sel = pop.get_individuals()[program.get_random().get_size_t(0ul, pop.get_individuals().size())];
|
||||
if (sel.fitness.adjusted_fitness > best_guy)
|
||||
{
|
||||
best_guy = sel.fitness.adjusted_fitness;
|
||||
ind = &sel;
|
||||
auto sel_point = program.get_random().get_u64(0ul, pop.get_individuals().size());
|
||||
if (i_ref[sel_point].fitness.adjusted_fitness > i_ref[best].fitness.adjusted_fitness)
|
||||
best = sel_point;
|
||||
}
|
||||
return i_ref[best].tree;
|
||||
}
|
||||
|
||||
return ind->tree;
|
||||
}
|
||||
|
||||
tree_t& select_fitness_proportionate_t::select(gp_program& program, population_t& pop, population_stats& stats)
|
||||
const tree_t& select_fitness_proportionate_t::select(gp_program& program, const population_t& pop)
|
||||
{
|
||||
auto& stats = program.get_population_stats();
|
||||
auto choice = program.get_random().get_double();
|
||||
for (const auto& [index, ref] : blt::enumerate(pop))
|
||||
{
|
||||
|
|
@ -92,20 +87,8 @@ namespace blt::gp
|
|||
return ref.tree;
|
||||
}
|
||||
}
|
||||
BLT_WARN("Unable to find individual with fitness proportionate. This should not be a possible code path! (%lf)", choice);
|
||||
BLT_WARN("Unable to find individual_t with fitness proportionate. This should not be a possible code path! (%lf)", choice);
|
||||
return pop.get_individuals()[0].tree;
|
||||
//BLT_ABORT("Unable to find individual");
|
||||
}
|
||||
|
||||
void select_fitness_proportionate_t::pre_process(gp_program&, population_t& pop, population_stats& stats)
|
||||
{
|
||||
stats.normalized_fitness.clear();
|
||||
double sum_of_prob = 0;
|
||||
for (auto& ind : pop)
|
||||
{
|
||||
auto prob = (ind.fitness.adjusted_fitness / stats.overall_fitness);
|
||||
stats.normalized_fitness.push_back(sum_of_prob + prob);
|
||||
sum_of_prob += prob;
|
||||
}
|
||||
}
|
||||
}
|
||||
|
|
@ -0,0 +1,24 @@
|
|||
/*
|
||||
* <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/stats.h>
|
||||
#include <blt/std/logging.h>
|
||||
|
||||
namespace blt::gp
|
||||
{
|
||||
|
||||
}
|
||||
|
|
@ -27,7 +27,16 @@
|
|||
namespace blt::gp
|
||||
{
|
||||
|
||||
inline blt::size_t accumulate_type_sizes(detail::op_iter begin, detail::op_iter end)
|
||||
grow_generator_t grow_generator;
|
||||
|
||||
inline tree_t& get_static_tree_tl(gp_program& program)
|
||||
{
|
||||
static thread_local tree_t new_tree{program};
|
||||
new_tree.clear(program);
|
||||
return new_tree;
|
||||
}
|
||||
|
||||
inline blt::size_t accumulate_type_sizes(detail::op_iter_t begin, detail::op_iter_t end)
|
||||
{
|
||||
blt::size_t total = 0;
|
||||
for (auto it = begin; it != end; ++it)
|
||||
|
|
@ -47,28 +56,24 @@ namespace blt::gp
|
|||
return buffer.data();
|
||||
}
|
||||
|
||||
grow_generator_t grow_generator;
|
||||
|
||||
mutation_t::config_t::config_t(): generator(grow_generator)
|
||||
{}
|
||||
|
||||
blt::expected<crossover_t::result_t, crossover_t::error_t> crossover_t::apply(gp_program& program, const tree_t& p1, const tree_t& p2) // NOLINT
|
||||
bool crossover_t::apply(gp_program& program, const tree_t& p1, const tree_t& p2, tree_t& c1, tree_t& c2) // NOLINT
|
||||
{
|
||||
result_t result{p1, p2};
|
||||
|
||||
auto& c1 = result.child1;
|
||||
auto& c2 = result.child2;
|
||||
c1.copy_fast(p1);
|
||||
c2.copy_fast(p2);
|
||||
|
||||
auto& c1_ops = c1.get_operations();
|
||||
auto& c2_ops = c2.get_operations();
|
||||
|
||||
if (c1_ops.size() < 5 || c2_ops.size() < 5)
|
||||
return blt::unexpected(error_t::TREE_TOO_SMALL);
|
||||
return false;
|
||||
|
||||
auto point = get_crossover_point(program, c1, c2);
|
||||
auto point = get_crossover_point(program, p1, p2);
|
||||
|
||||
if (!point)
|
||||
return blt::unexpected(point.error());
|
||||
return false;
|
||||
|
||||
auto crossover_point_begin_itr = c1_ops.begin() + point->p1_crossover_point;
|
||||
auto crossover_point_end_itr = c1_ops.begin() + c1.find_endpoint(program, point->p1_crossover_point);
|
||||
|
|
@ -97,8 +102,8 @@ namespace blt::gp
|
|||
blt::size_t c2_stack_for_bytes = accumulate_type_sizes(found_point_begin_itr, found_point_end_itr);
|
||||
auto c1_total = static_cast<blt::ptrdiff_t>(c1_stack_after_bytes + c1_stack_for_bytes);
|
||||
auto c2_total = static_cast<blt::ptrdiff_t>(c2_stack_after_bytes + c2_stack_for_bytes);
|
||||
auto copy_ptr_c1 = get_thread_pointer_for_size<struct c1>(c1_total);
|
||||
auto copy_ptr_c2 = get_thread_pointer_for_size<struct c2>(c2_total);
|
||||
auto copy_ptr_c1 = get_thread_pointer_for_size<struct c1_t>(c1_total);
|
||||
auto copy_ptr_c2 = get_thread_pointer_for_size<struct c2_t>(c2_total);
|
||||
|
||||
c1_stack.copy_to(copy_ptr_c1, c1_total);
|
||||
c1_stack.pop_bytes(c1_total);
|
||||
|
|
@ -124,8 +129,8 @@ namespace blt::gp
|
|||
c2_ops.insert(++insert_point_c2, c1_operators.begin(), c1_operators.end());
|
||||
|
||||
#if BLT_DEBUG_LEVEL >= 2
|
||||
blt::size_t c1_found_bytes = result.child1.get_values().size().total_used_bytes;
|
||||
blt::size_t c2_found_bytes = result.child2.get_values().size().total_used_bytes;
|
||||
blt::size_t c1_found_bytes = c1.get_values().size().total_used_bytes;
|
||||
blt::size_t c2_found_bytes = c2.get_values().size().total_used_bytes;
|
||||
blt::size_t c1_expected_bytes = std::accumulate(result.child1.get_operations().begin(), result.child1.get_operations().end(), 0ul,
|
||||
[](const auto& v1, const auto& v2) {
|
||||
if (v2.is_value)
|
||||
|
|
@ -146,10 +151,10 @@ namespace blt::gp
|
|||
}
|
||||
#endif
|
||||
|
||||
return result;
|
||||
return true;
|
||||
}
|
||||
|
||||
blt::expected<crossover_t::crossover_point_t, crossover_t::error_t> crossover_t::get_crossover_point(gp_program& program, const tree_t& c1,
|
||||
std::optional<crossover_t::crossover_point_t> crossover_t::get_crossover_point(gp_program& program, const tree_t& c1,
|
||||
const tree_t& c2) const
|
||||
{
|
||||
auto& c1_ops = c1.get_operations();
|
||||
|
|
@ -187,10 +192,10 @@ namespace blt::gp
|
|||
}
|
||||
}
|
||||
if (!found)
|
||||
return blt::unexpected(error_t::NO_VALID_TYPE);
|
||||
return {};
|
||||
}
|
||||
// should we try again over the whole tree? probably not.
|
||||
return blt::unexpected(error_t::NO_VALID_TYPE);
|
||||
return {};
|
||||
} else
|
||||
{
|
||||
attempted_point = program.get_random().get_size_t(1ul, c2_ops.size());
|
||||
|
|
@ -206,13 +211,13 @@ namespace blt::gp
|
|||
return crossover_point_t{static_cast<blt::ptrdiff_t>(crossover_point), static_cast<blt::ptrdiff_t>(attempted_point)};
|
||||
}
|
||||
|
||||
tree_t mutation_t::apply(gp_program& program, const tree_t& p)
|
||||
bool mutation_t::apply(gp_program& program, const tree_t& p, tree_t& c)
|
||||
{
|
||||
auto c = p;
|
||||
c.copy_fast(p);
|
||||
|
||||
mutate_point(program, c, program.get_random().get_size_t(0ul, c.get_operations().size()));
|
||||
|
||||
return c;
|
||||
return true;
|
||||
}
|
||||
|
||||
blt::size_t mutation_t::mutate_point(gp_program& program, tree_t& c, blt::size_t node)
|
||||
|
|
@ -228,7 +233,8 @@ namespace blt::gp
|
|||
auto begin_itr = ops_r.begin() + begin_point;
|
||||
auto end_itr = ops_r.begin() + end_point;
|
||||
|
||||
auto new_tree = config.generator.get().generate({program, type_info.return_type, config.replacement_min_depth, config.replacement_max_depth});
|
||||
auto& new_tree = get_static_tree_tl(program);
|
||||
config.generator.get().generate(new_tree, {program, type_info.return_type, config.replacement_min_depth, config.replacement_max_depth});
|
||||
|
||||
auto& new_ops_r = new_tree.get_operations();
|
||||
auto& new_vals_r = new_tree.get_values();
|
||||
|
|
@ -296,10 +302,10 @@ namespace blt::gp
|
|||
return begin_point + new_ops_r.size();
|
||||
}
|
||||
|
||||
tree_t advanced_mutation_t::apply(gp_program& program, const tree_t& p)
|
||||
bool advanced_mutation_t::apply(gp_program& program, const tree_t& p, tree_t& c)
|
||||
{
|
||||
// child tree
|
||||
tree_t c = p;
|
||||
c.copy_fast(p);
|
||||
|
||||
auto& ops = c.get_operations();
|
||||
auto& vals = c.get_values();
|
||||
|
|
@ -364,7 +370,8 @@ namespace blt::gp
|
|||
if (index < current_func_info.argument_types.size() && val.id != current_func_info.argument_types[index].id)
|
||||
{
|
||||
// TODO: new config?
|
||||
auto tree = config.generator.get().generate(
|
||||
auto& tree = get_static_tree_tl(program);
|
||||
config.generator.get().generate(tree,
|
||||
{program, val.id, config.replacement_min_depth, config.replacement_max_depth});
|
||||
|
||||
auto& child = children_data[children_data.size() - 1 - index];
|
||||
|
|
@ -445,7 +452,8 @@ namespace blt::gp
|
|||
for (blt::ptrdiff_t i = static_cast<blt::ptrdiff_t>(replacement_func_info.argc.argc) - 1;
|
||||
i >= current_func_info.argc.argc; i--)
|
||||
{
|
||||
auto tree = config.generator.get().generate(
|
||||
auto& tree = get_static_tree_tl(program);
|
||||
config.generator.get().generate(tree,
|
||||
{program, replacement_func_info.argument_types[i].id, config.replacement_min_depth,
|
||||
config.replacement_max_depth});
|
||||
blt::size_t total_bytes_for = tree.total_value_bytes();
|
||||
|
|
@ -458,7 +466,7 @@ namespace blt::gp
|
|||
}
|
||||
// now finally update the type.
|
||||
ops[c_node] = {program.get_typesystem().get_type(replacement_func_info.return_type).size(), random_replacement,
|
||||
program.is_static(random_replacement)};
|
||||
program.is_operator_ephemeral(random_replacement)};
|
||||
}
|
||||
#if BLT_DEBUG_LEVEL >= 2
|
||||
if (!c.check(program, nullptr))
|
||||
|
|
@ -518,7 +526,8 @@ namespace blt::gp
|
|||
blt::size_t start_index = c_node;
|
||||
for (blt::ptrdiff_t i = new_argc - 1; i > static_cast<blt::ptrdiff_t>(arg_position); i--)
|
||||
{
|
||||
auto tree = config.generator.get().generate(
|
||||
auto& tree = get_static_tree_tl(program);
|
||||
config.generator.get().generate(tree,
|
||||
{program, replacement_func_info.argument_types[i].id, config.replacement_min_depth,
|
||||
config.replacement_max_depth});
|
||||
blt::size_t total_bytes_for = tree.total_value_bytes();
|
||||
|
|
@ -531,7 +540,8 @@ namespace blt::gp
|
|||
vals.copy_from(combined_ptr, for_bytes);
|
||||
for (blt::ptrdiff_t i = static_cast<blt::ptrdiff_t>(arg_position) - 1; i >= 0; i--)
|
||||
{
|
||||
auto tree = config.generator.get().generate(
|
||||
auto& tree = get_static_tree_tl(program);
|
||||
config.generator.get().generate(tree,
|
||||
{program, replacement_func_info.argument_types[i].id, config.replacement_min_depth,
|
||||
config.replacement_max_depth});
|
||||
blt::size_t total_bytes_for = tree.total_value_bytes();
|
||||
|
|
@ -544,7 +554,7 @@ namespace blt::gp
|
|||
|
||||
ops.insert(ops.begin() + static_cast<blt::ptrdiff_t>(c_node),
|
||||
{program.get_typesystem().get_type(replacement_func_info.return_type).size(),
|
||||
random_replacement, program.is_static(random_replacement)});
|
||||
random_replacement, program.is_operator_ephemeral(random_replacement)});
|
||||
|
||||
#if BLT_DEBUG_LEVEL >= 2
|
||||
if (!c.check(program, nullptr))
|
||||
|
|
@ -720,6 +730,6 @@ namespace blt::gp
|
|||
}
|
||||
#endif
|
||||
|
||||
return c;
|
||||
return true;
|
||||
}
|
||||
}
|
||||
41
src/tree.cpp
41
src/tree.cpp
|
|
@ -92,7 +92,7 @@ namespace blt::gp
|
|||
if (print_literals)
|
||||
{
|
||||
create_indent(out, indent, pretty_print);
|
||||
if (program.is_static(v.id))
|
||||
if (program.is_operator_ephemeral(v.id))
|
||||
{
|
||||
program.get_print_func(v.id)(out, reversed);
|
||||
reversed.pop_bytes(stack_allocator::aligned_size(v.type_size));
|
||||
|
|
@ -247,22 +247,20 @@ namespace blt::gp
|
|||
blt::size_t total_produced = 0;
|
||||
blt::size_t total_consumed = 0;
|
||||
|
||||
// for (const auto& operation : blt::reverse_iterate(operations.begin(), operations.end()))
|
||||
// {
|
||||
// if (operation.is_value)
|
||||
// {
|
||||
// value_stack.transfer_bytes(values_process, operation.type_size);
|
||||
// total_produced += stack_allocator::aligned_size(operation.type_size);
|
||||
// bitfield.push_back(false);
|
||||
// continue;
|
||||
// }
|
||||
// auto& info = program.get_operator_info(operation.id);
|
||||
// for (auto& arg : info.argument_types)
|
||||
// total_consumed += stack_allocator::aligned_size(program.get_typesystem().get_type(arg).size());
|
||||
// operation.func(context, values_process, values_process, &bitfield);
|
||||
// bitfield.push_back(true);
|
||||
// total_produced += stack_allocator::aligned_size(program.get_typesystem().get_type(info.return_type).size());
|
||||
// }
|
||||
for (const auto& operation : blt::reverse_iterate(operations.begin(), operations.end()))
|
||||
{
|
||||
if (operation.is_value)
|
||||
{
|
||||
value_stack.transfer_bytes(values_process, operation.type_size);
|
||||
total_produced += stack_allocator::aligned_size(operation.type_size);
|
||||
continue;
|
||||
}
|
||||
auto& info = program.get_operator_info(operation.id);
|
||||
for (auto& arg : info.argument_types)
|
||||
total_consumed += stack_allocator::aligned_size(program.get_typesystem().get_type(arg).size());
|
||||
program.get_operator_info(operation.id).func(context, values_process, values_process);
|
||||
total_produced += stack_allocator::aligned_size(program.get_typesystem().get_type(info.return_type).size());
|
||||
}
|
||||
|
||||
auto v1 = results.values.bytes_in_head();
|
||||
auto v2 = static_cast<blt::ptrdiff_t>(stack_allocator::aligned_size(operations.front().type_size));
|
||||
|
|
@ -301,4 +299,13 @@ namespace blt::gp
|
|||
{
|
||||
|
||||
}
|
||||
|
||||
void tree_t::clear(gp_program& program)
|
||||
{
|
||||
auto* f = &program.get_eval_func();
|
||||
if (f != func)
|
||||
func = f;
|
||||
operations.clear();
|
||||
values.reset();
|
||||
}
|
||||
}
|
||||
|
|
@ -107,7 +107,7 @@ struct context
|
|||
float x, y;
|
||||
};
|
||||
|
||||
std::array<context, 200> fitness_cases;
|
||||
std::array<context, 200> training_cases;
|
||||
|
||||
blt::gp::prog_config_t config = blt::gp::prog_config_t()
|
||||
.set_initial_min_tree_size(2)
|
||||
|
|
@ -141,7 +141,7 @@ blt::gp::operation_t op_x([](const context& context) {
|
|||
|
||||
constexpr auto fitness_function = [](blt::gp::tree_t& current_tree, blt::gp::fitness_t& fitness, blt::size_t) {
|
||||
constexpr double value_cutoff = 1.e15;
|
||||
for (auto& fitness_case : fitness_cases)
|
||||
for (auto& fitness_case : training_cases)
|
||||
{
|
||||
auto ctx = current_tree.evaluate(&fitness_case);
|
||||
auto diff = std::abs(fitness_case.y - *current_tree.get_evaluation_ref<move_float>(ctx));
|
||||
|
|
@ -157,7 +157,7 @@ constexpr auto fitness_function = [](blt::gp::tree_t& current_tree, blt::gp::fit
|
|||
}
|
||||
fitness.standardized_fitness = fitness.raw_fitness;
|
||||
fitness.adjusted_fitness = (1.0 / (1.0 + fitness.standardized_fitness));
|
||||
return static_cast<blt::size_t>(fitness.hits) == fitness_cases.size();
|
||||
return static_cast<blt::size_t>(fitness.hits) == training_cases.size();
|
||||
};
|
||||
|
||||
float example_function(float x)
|
||||
|
|
@ -170,7 +170,7 @@ int main()
|
|||
BLT_INFO("Starting BLT-GP Symbolic Regression Example");
|
||||
BLT_START_INTERVAL("Symbolic Regression", "Main");
|
||||
BLT_DEBUG("Setup Fitness cases");
|
||||
for (auto& fitness_case : fitness_cases)
|
||||
for (auto& fitness_case : training_cases)
|
||||
{
|
||||
constexpr float range = 10;
|
||||
constexpr float half_range = range / 2.0;
|
||||
|
|
|
|||
Loading…
Reference in New Issue