new rules

Author: itbert

LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2025 itbert
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

README.md

@@ -0,0 +1,56 @@
+# hyperboost
+
+Подходит как для исследовательских задач, так и для практического использования в реальных проектах.
+
+
+## ✅ Поддерживаемые методы
+
+| Метод                  | Описание |
+|------------------------|----------|
+| `BayesianOptimizer`    | Байесовская оптимизация с использованием Gaussian Process |
+| `EvolutionaryOptimizer` | Простой генетический алгоритм (GA) |
+
+
+## 📦 Установка
+
+```bash
+pip install hyperoptlib
+```
+
+## 🧪 Пример использования
+
+```python
+from sklearn.datasets import load_iris
+from sklearn.ensemble import RandomForestClassifier
+from sklearn.model_selection import train_test_split
+from hyperboost.space import SearchSpace
+from hyperboost.space import Real, Integer, Categorical
+from hyperboost.optimizers import BayesianOptimizer
+from hyperboost.optimizers import EvolutionaryOptimizer
+
+X, y = load_iris(return_X_y=True)
+X_train, X_test, y_train, y_test = train_test_split(X, y, test_size=0.2, random_state=42)
+
+space = SearchSpace({
+    "n_estimators": Integer(50, 300),
+    "max_depth": Integer(3, 20),
+    "criterion": Categorical(["gini", "entropy"]),
+})
+
+def objective(params):
+    model = RandomForestClassifier(**params, random_state=42)
+    model.fit(X_train, y_train)
+    score = model.score(X_test, y_test)
+    return -score  # минимизируем ошибку
+
+# Байесовская оптимизация
+bo = BayesianOptimizer(space, objective)
+best_bo = bo.optimize(n_iter=30)
+print("Bayesian best:", best_bo)
+
+# Эволюционный алгоритм
+ea = EvolutionaryOptimizer(space, objective)
+best_ea = ea.optimize(population_size=20, generations=10)
+print("Evolutionary best:", best_ea)
+```
+

examples/sk.py

@@ -0,0 +1,32 @@
+from sklearn.datasets import load_iris
+from sklearn.ensemble import RandomForestClassifier
+from sklearn.model_selection import train_test_split
+from hyperboost.space import SearchSpace
+from hyperboost.space import Real, Integer, Categorical
+from hyperboost.optimizers import BayesianOptimizer
+from hyperboost.optimizers import EvolutionaryOptimizer
+
+X, y = load_iris(return_X_y=True)
+X_train, X_test, y_train, y_test = train_test_split(X, y, test_size=0.2, random_state=42)
+
+space = SearchSpace({
+    "n_estimators": Integer(50, 300),
+    "max_depth": Integer(3, 20),
+    "criterion": Categorical(["gini", "entropy"]),
+})
+
+def objective(params):
+    model = RandomForestClassifier(**params, random_state=42)
+    model.fit(X_train, y_train)
+    score = model.score(X_test, y_test)
+    return -score  # минимизируем ошибку
+
+# Байесовская оптимизация
+bo = BayesianOptimizer(space, objective)
+best_bo = bo.optimize(n_iter=30)
+print("Bayesian best:", best_bo)
+
+# Эволюционный алгоритм
+ea = EvolutionaryOptimizer(space, objective)
+best_ea = ea.optimize(population_size=20, generations=10)
+print("Evolutionary best:", best_ea)

optimizers/__init__.py

@@ -0,0 +1,2 @@
+from bayesian import BayesianOptimizer
+from evo import EvolutionaryOptimizer

optimizers/bayesian.py

@@ -0,0 +1,59 @@
+import numpy as np
+from sklearn.gaussian_process import GaussianProcessRegressor
+from sklearn.gaussian_process.kernels import Matern
+from scipy.optimize import minimize
+from hyperboost.utils.visual import plot_convergence
+
+
+class BayesianOptimizer:
+    def __init__(self, space, objective_func, n_initial_points=5):
+        self.model = None
+        self.space = space
+        self.objective_func = objective_func
+        self.n_initial_points = n_initial_points
+        self.X = []
+        self.y = []
+        self.history = []
+        self._initialize()
+
+    def _initialize(self):
+        initial_points = self.space.sample(self.n_initial_points)
+        for point in initial_points:
+            loss = self.objective_func(point)
+            self.X.append(self.space.transform(point))
+            self.y.append(loss)
+            self.history.append(loss)
+
+    def _acquisition(self, x, kappa=2.0):
+        mu, sigma = self.model.predict([x], return_std=True)
+        mu = mu[0]
+        sigma = sigma[0]
+        return mu - kappa * sigma
+
+    def _optimize_acquisition(self):
+        best_x = None
+        best_score = float('inf')
+        bounds = [(0.0, 1.0)] * len(self.space.param_names)
+        for _ in range(20):
+            x0 = np.random.rand(len(bounds))
+            res = minimize(lambda x: self._acquisition(x), x0=x0, bounds=bounds)
+            if res.fun < best_score:
+                best_score = res.fun
+                best_x = res.x
+        return best_x
+
+    def optimize(self, n_iter=30):
+        kernel = Matern(nu=2.5)
+        self.model = GaussianProcessRegressor(kernel=kernel, n_restarts_optimizer=10)
+        for _ in range(n_iter):
+            self.model.fit(self.X, self.y)
+            next_point = self._optimize_acquisition()
+            params = self.space.inverse_transform(next_point)
+            loss = self.objective_func(params)
+            self.X.append(next_point)
+            self.y.append(loss)
+            self.history.append(loss)
+        best_idx = np.argmin(self.y)
+        plot_convergence(self.history)
+        return self.space.inverse_transform(self.X[best_idx])
+    

optimizers/evo.py

@@ -0,0 +1,55 @@
+import random
+import numpy as np
+from hyperboost.utils.visual import plot_convergence
+
+
+class EvolutionaryOptimizer:
+    def __init__(self, space, objective_func):
+        self.space = space
+        self.objective_func = objective_func
+        self.population = []
+        self.history = []
+
+    def _create_individual(self):
+        return self.space.sample()[0]
+
+    def _evaluate_population(self):
+        scores = []
+        for ind in self.population:
+            score = self.objective_func(ind)
+            scores.append((ind, score))
+        return sorted(scores, key=lambda x: x[1])
+
+    def _crossover(self, parent1, parent2):
+        child = {}
+        for name in self.space.param_names:
+            if random.random() < 0.5:
+                child[name] = parent1[name]
+            else:
+                child[name] = parent2[name]
+        return child
+
+    def _mutate(self, individual, mutation_rate=0.1):
+        mutated = individual.copy()
+        for name in self.space.param_names:
+            if random.random() < mutation_rate:
+                param = self.space.space_dict[name]
+                mutated[name] = param.sample()[0]
+        return mutated
+
+    def optimize(self, population_size=20, generations=10):
+        self.population = self.space.sample(population_size)
+        for gen in range(generations):
+            evaluated = self._evaluate_population()
+            next_gen = [evaluated[0][0]]  # Elitism
+            while len(next_gen) < population_size:
+                p1, p2 = random.choices(evaluated[:5], k=2)
+                child = self._crossover(p1[0], p2[0])
+                child = self._mutate(child)
+                next_gen.append(child)
+            self.population = next_gen
+            best_score = evaluated[0][1]
+            self.history.append(best_score)
+        plot_convergence(self.history)
+        best = self._evaluate_population()[0][0]
+        return best

parallel/evaluate.py

@@ -0,0 +1,10 @@
+from concurrent.futures import ThreadPoolExecutor
+
+
+def eval(func, points):
+    try:
+        with ThreadPoolExecutor() as executor:
+            results = list(executor.map(func, points))
+        return results
+    except AttributeError:
+        raise "Your model dont have a parallel mode"

space/__init__.py

@@ -0,0 +1,2 @@
+from .types import Real, Integer, Categorical
+from .search import SearchSpace

space/search.py

@@ -0,0 +1,31 @@
+import numpy as np
+
+class SearchSpace:
+    def __init__(self, space_dict):
+        self.space_dict = space_dict
+        self.param_names = list(space_dict.keys())
+        self.param_objs = list(space_dict.values())
+
+    def sample(self, n=1):
+        samples = []
+        for _ in range(n):
+            point = {}
+            for name, param in zip(self.param_names, self.param_objs):
+                point[name] = param.sample()[0]
+            samples.append(point)
+        return samples
+
+    def transform(self, params):
+        vec = []
+        for name in self.param_names:
+            val = params[name]
+            param_obj = self.space_dict[name]
+            vec.append(param_obj.transform(val))
+        return np.array(vec)
+
+    def inverse_transform(self, vector):
+        params = {}
+        for i, name in enumerate(self.param_names):
+            param_obj = self.space_dict[name]
+            params[name] = param_obj.inverse_transform(vector[i])
+        return params

space/types.py

@@ -0,0 +1,45 @@
+import numpy as np
+
+class Real:
+    def __init__(self, low, high):
+        self.low = low
+        self.high = high
+
+    def sample(self, n=1):
+        return np.random.uniform(self.low, self.high, size=n)
+
+    def transform(self, value):
+        return (value - self.low) / (self.high - self.low)
+
+    def inverse_transform(self, value):
+        return value * (self.high - self.low) + self.low
+
+
+class Integer:
+    def __init__(self, low, high):
+        self.low = low
+        self.high = high
+
+    def sample(self, n=1):
+        return np.random.randint(self.low, self.high + 1, size=n)
+
+    def transform(self, value):
+        return (value - self.low) / (self.high - self.low)
+
+    def inverse_transform(self, value):
+        return int(round(value * (self.high - self.low) + self.low))
+
+
+class Categorical:
+    def __init__(self, choices):
+        self.choices = choices
+
+    def sample(self, n=1):
+        return [np.random.choice(self.choices) for _ in range(n)]
+
+    def transform(self, value):
+        return self.choices.index(value) / (len(self.choices) - 1)
+
+    def inverse_transform(self, value):
+        idx = round(value * (len(self.choices) - 1))
+        return self.choices[int(idx)]