operator rebuild

sherstpasha · Apr 10, 2024 · 5405498 · 5405498
1 parent ca78f70
commit 5405498
Show file tree

Hide file tree

Showing 9 changed files with 235 additions and 298 deletions.
diff --git a/src/test.py b/src/test.py
@@ -6,12 +6,13 @@
 from thefittest.base import EphemeralNode
 from thefittest.base import UniversalSet
 from thefittest.optimizers import GeneticProgramming
-from thefittest.base._tree import Mul
-from thefittest.base._tree import Add
-from thefittest.base._tree import Div
-from thefittest.base._tree import Neg
 from thefittest.utils._metrics import coefficient_determination
-# from thefittest.tools.print import print_tree
+from thefittest.base import create_operator
+from thefittest.base._tree import save_div
+
+from operator import add
+from operator import mul
+from operator import sub
 
 
 def generator1():
@@ -23,71 +24,83 @@ def generator2():
 
 
 def problem(x):
-    return np.sin(x[:,0])
+    return np.sin(x[:, 0])
 
 
 function = problem
-left_border = -4.5
-right_border = 4.5
+left_border = -4.5 * 2
+right_border = 4.5 * 2
 sample_size = 300
 n_dimension = 1
 
-number_of_iterations = 100
-population_size = 500
+number_of_iterations = 300
+population_size = 5000
 
-X = np.array([np.linspace(left_border, right_border, sample_size)
-              for _ in range(n_dimension)]).T
+X = np.array([np.linspace(left_border, right_border, sample_size) for _ in range(n_dimension)]).T
 y = function(X)
 
 
-functional_set = (FunctionalNode(Add()),
-                  FunctionalNode(Mul()),
-                  FunctionalNode(Neg()),
-                  FunctionalNode(Div()))
+def my_func(x, y, z):
+    return x + y - z
+
+
+functional_set = (
+    FunctionalNode(create_operator("({} + {})", "add", "+", add)),
+    FunctionalNode(create_operator("({} * {})", "mul", "*", mul)),
+    FunctionalNode(create_operator("({} - {})", "sub", "-", sub)),
+    FunctionalNode(create_operator("({} / {})", "div", "/", save_div)),
+    FunctionalNode(create_operator("({} + {} - {})", "my_func", "+-", my_func)),
+)
 
+print(functional_set[0]._n_args)
+print(functional_set[1]._n_args)
+print(functional_set[2]._n_args)
+print(functional_set[3]._n_args)
 
-terminal_set = [TerminalNode(X[:, i], f'x{i}') for i in range(n_dimension)]
+terminal_set = [TerminalNode(X[:, i], f"x{i}") for i in range(n_dimension)]
 terminal_set.extend([EphemeralNode(generator1), EphemeralNode(generator2)])
 uniset = UniversalSet(functional_set, tuple(terminal_set))
 
 
 def fitness_function(trees):
     fitness = []
     for tree in trees:
-        y_pred = tree()*np.ones(len(y))
+        y_pred = tree() * np.ones(len(y))
         fitness.append(coefficient_determination(y, y_pred))
     return np.array(fitness)
 
 
-optimizer = GeneticProgramming(fitness_function=fitness_function,
-                               uniset=uniset,
-                               pop_size=population_size,
-                               iters=number_of_iterations,
-                               show_progress_each=10,
-                               minimization=False,
-                               keep_history=False, 
-                               selection="tournament_k",
-                               mutation="gp_weak_grow", 
-                               tour_size=5,
-                               max_level=7)
+optimizer = GeneticProgramming(
+    fitness_function=fitness_function,
+    uniset=uniset,
+    pop_size=population_size,
+    iters=number_of_iterations,
+    show_progress_each=10,
+    minimization=False,
+    keep_history=False,
+    selection="tournament_k",
+    mutation="gp_weak_grow",
+    tour_size=5,
+    max_level=14,
+)
 
 optimizer.fit()
 
-# fittest = optimizer.get_fittest()
-# stats = optimizer.get_stats()
+fittest = optimizer.get_fittest()
+stats = optimizer.get_stats()
 
-# predict = fittest['phenotype']()
+predict = fittest["phenotype"]()
 
-# print('The fittest individ:', fittest['phenotype'])
-# print('with fitness', fittest['fitness'])
+print("The fittest individ:", fittest["phenotype"])
+print("with fitness", fittest["fitness"])
 
-# fig, ax = plt.subplots(figsize=(14, 7), ncols=2, nrows=1)
+fig, ax = plt.subplots(figsize=(14, 7), ncols=2, nrows=1)
 
-# ax[0].plot(X[:,0], y, label = "True y")
-# ax[0].plot(X[:,0], predict, label = "Predict y")
-# ax[0].legend()
+ax[0].plot(X[:, 0], y, label="True y")
+ax[0].plot(X[:, 0], predict, label="Predict y")
+ax[0].legend()
 
-# # print_tree(tree=fittest['phenotype'], ax=ax[1])
+fittest["phenotype"].plot(ax[1])
 
-# plt.tight_layout()
-# plt.show()
+plt.tight_layout()
+plt.show()
diff --git a/src/thefittest/base/__init__.py b/src/thefittest/base/__init__.py
@@ -5,6 +5,7 @@
 from ._tree import Tree
 from ._tree import UniversalSet
 from ._tree import init_symbolic_regression_uniset
+from ._tree import create_operator
 
 
 __all__ = [

diff --git a/src/thefittest/base/_gp.py b/src/thefittest/base/_gp.py
@@ -67,7 +67,7 @@ def __init__(
         *,
         n_iter: int = 500,
         pop_size: int = 1000,
-        functional_set_names: Tuple[str, ...] = ("cos", "sin", "add", "inv", "neg", "mul"),
+        functional_set_names: Tuple[str, ...] = ("cos", "sin", "add", "sub", "mul", "div"),
         optimizer: Union[Type[SelfCGP], Type[GeneticProgramming]] = SelfCGP,
         optimizer_args: Optional[dict[str, Any]] = None,
         random_state: Optional[Union[int, np.random.RandomState]] = None,