129 lines
4.1 KiB
Python
129 lines
4.1 KiB
Python
import random
|
|
from math import log
|
|
|
|
import numpy as np
|
|
from numpy.typing import NDArray
|
|
|
|
from gp import Chromosome
|
|
from gp.crossovers import crossover_subtree
|
|
from gp.fitness import (
|
|
MAEFitness,
|
|
MSEFitness,
|
|
NRMSEFitness,
|
|
PenalizedFitness,
|
|
RMSEFitness,
|
|
)
|
|
from gp.ga import GARunConfig, genetic_algorithm
|
|
from gp.mutations import (
|
|
grow_mutation,
|
|
hoist_mutation,
|
|
node_replacement_mutation,
|
|
shrink_mutation,
|
|
)
|
|
from gp.ops import ADD, COS, DIV, EXP, MUL, NEG, POW, SIN, SQUARE, SUB
|
|
from gp.population import ramped_initialization
|
|
from gp.primitive import Const, Var
|
|
from gp.selection import roulette_selection, tournament_selection
|
|
|
|
NUM_VARS = 8
|
|
TEST_POINTS = 10000
|
|
MAX_DEPTH = 10
|
|
MAX_GENERATIONS = 200
|
|
SEED = 17
|
|
np.random.seed(SEED)
|
|
random.seed(SEED)
|
|
X = np.random.uniform(-5.536, 5.536, size=(TEST_POINTS, NUM_VARS))
|
|
# axes = [np.linspace(-5.536, 5.536, TEST_POINTS) for _ in range(NUM_VARS)]
|
|
# X = np.array(np.meshgrid(*axes)).T.reshape(-1, NUM_VARS)
|
|
operations = [SQUARE, SIN, COS, EXP, ADD, SUB, MUL, DIV, POW]
|
|
# operations = [SQUARE, ADD, SUB, MUL]
|
|
terminals = [Var(f"x{i}") for i in range(1, NUM_VARS + 1)]
|
|
|
|
|
|
def target_function(x: NDArray[np.float64]) -> NDArray[np.float64]:
|
|
"""
|
|
Векторизованная версия функции:
|
|
f(x) = sum_{i=1}^n sum_{j=1}^i x_j^2
|
|
x имеет форму (n_samples, n_vars)
|
|
"""
|
|
# Префиксные суммы квадратов по оси переменных
|
|
x_sq = x**2
|
|
prefix_sums = np.cumsum(x_sq, axis=1)
|
|
# Суммируем по i (ось 1)
|
|
return np.sum(prefix_sums, axis=1)
|
|
|
|
|
|
# fitness_function = MSEFitness(target_function, lambda: X)
|
|
# fitness_function = HuberFitness(target_function, lambda: X, delta=0.5)
|
|
# fitness_function = PenalizedFitness(
|
|
# target_function, lambda: X, base_fitness=fitness, lambda_=0.1
|
|
# )
|
|
# fitness_function = NRMSEFitness(target_function, lambda: X)
|
|
fitness_function = RMSEFitness(target_function, lambda: X)
|
|
|
|
# fitness_function = PenalizedFitness(
|
|
# target_function, lambda: X, base_fitness=fitness_function, lambda_=0.0001
|
|
# )
|
|
|
|
|
|
def adaptive_mutation(
|
|
chromosome: Chromosome,
|
|
generation: int,
|
|
max_generations: int,
|
|
max_depth: int,
|
|
) -> Chromosome:
|
|
r = random.random()
|
|
|
|
if r < 0.4:
|
|
return grow_mutation(chromosome, max_depth=max_depth)
|
|
elif r < 0.7:
|
|
return node_replacement_mutation(chromosome)
|
|
elif r < 0.85:
|
|
return hoist_mutation(chromosome)
|
|
|
|
return shrink_mutation(chromosome)
|
|
|
|
|
|
init_population = ramped_initialization(
|
|
20, [i for i in range(MAX_DEPTH - 9, MAX_DEPTH + 1)], terminals, operations
|
|
)
|
|
|
|
print("Population size:", len(init_population))
|
|
|
|
config = GARunConfig(
|
|
fitness_func=fitness_function,
|
|
crossover_fn=lambda p1, p2: crossover_subtree(p1, p2, max_depth=MAX_DEPTH),
|
|
mutation_fn=lambda chrom, gen_num: adaptive_mutation(
|
|
chrom, gen_num, MAX_GENERATIONS, MAX_DEPTH
|
|
),
|
|
# selection_fn=roulette_selection,
|
|
selection_fn=lambda p, f: tournament_selection(p, f, k=3),
|
|
init_population=init_population,
|
|
seed=SEED,
|
|
pc=0.85,
|
|
pm=0.15,
|
|
elitism=15,
|
|
max_generations=MAX_GENERATIONS,
|
|
log_every_generation=True,
|
|
)
|
|
|
|
result = genetic_algorithm(config)
|
|
|
|
|
|
# Выводим результаты
|
|
print(f"Лучшая особь: {result.best_generation.best}")
|
|
print(result.best_generation.best.root.to_str_tree())
|
|
print(f"Лучшее значение фитнеса: {result.best_generation.best_fitness:.6f}")
|
|
print(f"Количество поколений: {result.generations_count}")
|
|
print(f"Время выполнения: {result.time_ms:.2f} мс")
|
|
print("Population size:", len(init_population))
|
|
|
|
mse_fitness = MSEFitness(target_function, lambda: X)
|
|
print(f"MSE: {mse_fitness(result.best_generation.best):.6f}")
|
|
rmse_fitness = RMSEFitness(target_function, lambda: X)
|
|
print(f"RMSE: {rmse_fitness(result.best_generation.best):.6f}")
|
|
mae_fitness = MAEFitness(target_function, lambda: X)
|
|
print(f"MAE: {mae_fitness(result.best_generation.best):.6f}")
|
|
nrmse_fitness = NRMSEFitness(target_function, lambda: X)
|
|
print(f"NRMSE: {nrmse_fitness(result.best_generation.best):.6f}")
|