claros 0.7.0__py3-none-any.whl

claros/__init__.py

@@ -0,0 +1,58 @@
+"""Claros — учебная ML-библиотека, написанная с нуля на чистом NumPy.
+
+Ничего не берётся из готовых ML-библиотек — всё реализовано руками.
+
+Модели
+  линейные   : LinearRegression, LogisticRegression
+  SVM        : LinearSVC
+  байес      : GaussianNB
+  деревья    : DecisionTreeRegressor, DecisionTreeClassifier
+  ансамбли   : RandomForestRegressor/Classifier, GradientBoostingRegressor/Classifier
+  соседи     : KNeighborsRegressor, KNeighborsClassifier
+  мультикласс: OneVsRestClassifier (обёртка над бинарной моделью)
+Кластеризация: DBSCAN, KMeans
+Снижение разм.: PCA
+Предобработка: StandardScaler, NoiseFeatureRemover
+Подбор/оценка: Pipeline, train_test_split, cross_val_score, GridSearchCV, claros.metrics
+Удобство     : prep(model, scale=1, clean_noise_features=1) — предобработка без Pipeline
+
+Своё, чего нет в sklearn: DeadZoneLoss, ArctanLink, NoiseFeatureRemover.
+"""
+from .base import Estimator, RegressorMixin, ClassifierMixin
+from .losses import Loss, DeadZoneLoss, LogLoss, MSE, HingeLoss
+from .links import Link, Identity, Sigmoid, ArctanLink
+from .linear_model import LinearRegression, LogisticRegression
+from .svm import LinearSVC
+from .naive_bayes import GaussianNB
+from .tree import DecisionTreeRegressor, DecisionTreeClassifier
+from .ensemble import (RandomForestRegressor, RandomForestClassifier,
+                       GradientBoostingRegressor, GradientBoostingClassifier)
+from .neighbors import KNeighborsRegressor, KNeighborsClassifier
+from .multiclass import OneVsRestClassifier
+from .preprocessing import StandardScaler
+from .feature_selection import NoiseFeatureRemover
+from .decomposition import PCA
+from .cluster import DBSCAN, KMeans
+from .pipeline import Pipeline, prep
+from .model_selection import train_test_split, cross_val_score, GridSearchCV
+from . import metrics
+
+__version__ = "0.7.0"
+
+__all__ = [
+    "Estimator", "RegressorMixin", "ClassifierMixin",
+    "Loss", "DeadZoneLoss", "LogLoss", "MSE", "HingeLoss",
+    "Link", "Identity", "Sigmoid", "ArctanLink",
+    "LinearRegression", "LogisticRegression",
+    "LinearSVC", "GaussianNB",
+    "DecisionTreeRegressor", "DecisionTreeClassifier",
+    "RandomForestRegressor", "RandomForestClassifier",
+    "GradientBoostingRegressor", "GradientBoostingClassifier",
+    "KNeighborsRegressor", "KNeighborsClassifier",
+    "OneVsRestClassifier",
+    "PCA",
+    "StandardScaler", "NoiseFeatureRemover",
+    "DBSCAN", "KMeans",
+    "Pipeline", "prep", "train_test_split", "cross_val_score", "GridSearchCV",
+    "metrics",
+]

claros/base.py

@@ -0,0 +1,27 @@
+import inspect
+import numpy as np
+
+
+class Estimator:  # общий базовый класс: даёт get_params / set_params (клонирование, GridSearch)
+    def get_params(self):
+        params = inspect.signature(self.__init__).parameters.values()
+        return {p.name: getattr(self, p.name) for p in params
+                if p.kind not in (p.VAR_POSITIONAL, p.VAR_KEYWORD)}
+
+    def set_params(self, **params):
+        for key, value in params.items():
+            setattr(self, key, value)
+        return self
+
+
+class RegressorMixin:  # даёт регрессорам метод score (R²)
+    def score(self, X, y):
+        y_pred = self.predict(X)
+        ss_res = np.sum((y - y_pred) ** 2)
+        ss_tot = np.sum((y - np.mean(y)) ** 2)
+        return 1 - ss_res / ss_tot
+
+
+class ClassifierMixin:  # даёт классификаторам метод score (доля верных ответов)
+    def score(self, X, y):
+        return np.mean(self.predict(X) == y)

claros/cluster.py

@@ -0,0 +1,109 @@
+"""Кластеризация: DBSCAN (по плотности) и KMeans (по центрам)."""
+import numpy as np
+from .base import Estimator
+from .feature_selection import NoiseFeatureRemover
+
+
+class DBSCAN(Estimator):
+    """Плотностная кластеризация. Сгустки — кластеры, разреженные точки — шум (метка -1).
+
+    clean_noise_features=1 включает нашу доработку: перед кластеризацией убрать
+    шумовые признаки (NoiseFeatureRemover). 0 — обычный DBSCAN (совпадает со sklearn).
+    """
+    def __init__(self, eps=0.5, min_samples=5, clean_noise_features=0, feature_threshold=0.9):
+        self.eps = eps
+        self.min_samples = min_samples
+        self.clean_noise_features = clean_noise_features
+        self.feature_threshold = feature_threshold
+
+    def _neighbors(self, X, i):
+        dist = np.sqrt(((X - X[i]) ** 2).sum(axis=1))
+        return np.where(dist <= self.eps)[0]
+
+    def fit(self, X):
+        X = np.asarray(X, float)
+        if self.clean_noise_features:
+            self.remover_ = NoiseFeatureRemover(threshold=self.feature_threshold)
+            X = self.remover_.fit_transform(X)
+        n = X.shape[0]
+        labels = np.full(n, -2)                  # -2 не посещён, -1 шум, >=0 номер кластера
+        cluster = 0
+        for i in range(n):
+            if labels[i] != -2:
+                continue
+            neigh = self._neighbors(X, i)
+            if len(neigh) < self.min_samples:
+                labels[i] = -1
+                continue
+            labels[i] = cluster
+            seeds = list(neigh)
+            k = 0
+            while k < len(seeds):                # заливка: очередь растёт по мере находок
+                j = seeds[k]; k += 1
+                if labels[j] == -1:
+                    labels[j] = cluster          # бывший шум — граница кластера
+                if labels[j] != -2:
+                    continue
+                labels[j] = cluster
+                j_neigh = self._neighbors(X, j)
+                if len(j_neigh) >= self.min_samples:
+                    seeds.extend(j_neigh)        # j тоже ядро — доливаем его соседей
+            cluster += 1
+        self.labels_ = labels
+        return self
+
+    def fit_predict(self, X):
+        return self.fit(X).labels_
+
+
+class KMeans(Estimator):
+    """Кластеризация по центрам (Ллойд) с n_init перезапусками (лучший по inertia).
+
+    clean_noise_features=1 — убрать шумовые признаки перед кластеризацией (как у DBSCAN).
+    """
+    def __init__(self, n_clusters=3, max_iter=100, n_init=10, random_state=None,
+                 clean_noise_features=0, feature_threshold=0.9):
+        self.n_clusters = n_clusters
+        self.max_iter = max_iter
+        self.n_init = n_init
+        self.random_state = random_state
+        self.clean_noise_features = clean_noise_features
+        self.feature_threshold = feature_threshold
+
+    def _one_run(self, X, rng):
+        centers = X[rng.choice(len(X), self.n_clusters, replace=False)].copy()
+        labels = np.zeros(len(X), dtype=int)
+        for _ in range(self.max_iter):
+            dist = np.sqrt(((X[:, None, :] - centers[None, :, :]) ** 2).sum(axis=2))
+            labels = dist.argmin(axis=1)
+            new = np.array([X[labels == c].mean(axis=0) if np.any(labels == c) else centers[c]
+                            for c in range(self.n_clusters)])
+            if np.allclose(new, centers):
+                break
+            centers = new
+        inertia = ((X - centers[labels]) ** 2).sum()
+        return centers, labels, inertia
+
+    def fit(self, X, y=None):
+        X = np.asarray(X, float)
+        if self.clean_noise_features:
+            self.remover_ = NoiseFeatureRemover(threshold=self.feature_threshold)
+            X = self.remover_.fit_transform(X)
+        rng = np.random.default_rng(self.random_state)
+        best = None
+        for _ in range(self.n_init):
+            centers, labels, inertia = self._one_run(X, rng)
+            if best is None or inertia < best[2]:
+                best = (centers, labels, inertia)
+        self.cluster_centers_, self.labels_, self.inertia_ = best
+        return self
+
+    def predict(self, X):
+        X = np.asarray(X, float)
+        if self.clean_noise_features:
+            X = self.remover_.transform(X)
+        dist = np.sqrt(((X[:, None, :] - self.cluster_centers_[None, :, :]) ** 2).sum(axis=2))
+        return dist.argmin(axis=1)
+
+    def fit_predict(self, X, y=None):
+        return self.fit(X).labels_

claros/decomposition.py

@@ -0,0 +1,32 @@
+"""Снижение размерности: метод главных компонент (PCA)."""
+import numpy as np
+from .base import Estimator
+
+
+class PCA(Estimator):
+    """Метод главных компонент: проекция на направления максимальной дисперсии.
+
+    Центрируем данные и берём ведущие правые сингулярные векторы (через SVD) —
+    это и есть главные компоненты. transform проецирует на них.
+    """
+    def __init__(self, n_components=2):
+        self.n_components = n_components
+
+    def fit(self, X, y=None):
+        X = np.asarray(X, float)
+        self.mean_ = X.mean(axis=0)
+        U, S, Vt = np.linalg.svd(X - self.mean_, full_matrices=False)
+        var = (S ** 2) / (len(X) - 1)
+        self.components_ = Vt[:self.n_components]                       # (k, d) — оси
+        self.explained_variance_ = var[:self.n_components]
+        self.explained_variance_ratio_ = (var / var.sum())[:self.n_components]
+        return self
+
+    def transform(self, X):
+        return (np.asarray(X, float) - self.mean_) @ self.components_.T
+
+    def fit_transform(self, X, y=None):
+        return self.fit(X).transform(X)
+
+    def inverse_transform(self, Xt):
+        return np.asarray(Xt, float) @ self.components_ + self.mean_

claros/ensemble.py

@@ -0,0 +1,132 @@
+"""Ансамбли деревьев: случайный лес (бэггинг) и градиентный бустинг."""
+import numpy as np
+from .base import Estimator, RegressorMixin, ClassifierMixin
+from .tree import DecisionTreeRegressor, DecisionTreeClassifier
+
+
+def _sigmoid(z):
+    return 1.0 / (1.0 + np.exp(-z))
+
+
+class _Forest(Estimator):
+    """Бэггинг: много деревьев на бутстрэп-выборках со случайным подмножеством признаков."""
+    def __init__(self, n_estimators=50, max_depth=10, max_features="sqrt", random_state=None):
+        self.n_estimators = n_estimators
+        self.max_depth = max_depth
+        self.max_features = max_features
+        self.random_state = random_state
+
+    def _mf(self, d):
+        if self.max_features == "sqrt":
+            return max(1, int(np.sqrt(d)))
+        if self.max_features is None:
+            return d
+        return self.max_features
+
+    def fit(self, X, y):
+        X, y = np.asarray(X, float), np.asarray(y)
+        rng = np.random.default_rng(self.random_state)
+        n, d = X.shape
+        mf = self._mf(d)
+        self.trees_ = []
+        for _ in range(self.n_estimators):
+            idx = rng.integers(0, n, n)                       # бутстрэп: выборка с возвращением
+            seed = int(rng.integers(0, 2 ** 31 - 1))
+            self.trees_.append(self._make_tree(mf, seed).fit(X[idx], y[idx]))
+        return self
+
+    def _all_preds(self, X):
+        return np.array([t.predict(X) for t in self.trees_])  # (деревья, объекты)
+
+
+class RandomForestRegressor(_Forest, RegressorMixin):
+    """Случайный лес для регрессии: усреднение предсказаний деревьев."""
+    def _make_tree(self, mf, seed):
+        return DecisionTreeRegressor(max_depth=self.max_depth, max_features=mf, random_state=seed)
+
+    def predict(self, X):
+        return self._all_preds(np.asarray(X, float)).mean(axis=0)
+
+
+class RandomForestClassifier(_Forest, ClassifierMixin):
+    """Случайный лес для классификации: голосование большинством."""
+    def _make_tree(self, mf, seed):
+        return DecisionTreeClassifier(max_depth=self.max_depth, max_features=mf, random_state=seed)
+
+    def predict(self, X):
+        preds = self._all_preds(np.asarray(X, float))
+        return np.array([self._vote(preds[:, j]) for j in range(preds.shape[1])])
+
+    @staticmethod
+    def _vote(col):
+        vals, counts = np.unique(col, return_counts=True)
+        return vals[np.argmax(counts)]
+
+
+class GradientBoostingRegressor(Estimator, RegressorMixin):
+    """Градиентный бустинг (CatBoost-стиль) для регрессии.
+
+    Стартуем со среднего и последовательно добавляем неглубокие деревья;
+    каждое предсказывает остаток y − F (антиградиент квадратичной потери).
+    """
+    def __init__(self, n_estimators=100, learning_rate=0.1, max_depth=3):
+        self.n_estimators = n_estimators
+        self.learning_rate = learning_rate
+        self.max_depth = max_depth
+
+    def fit(self, X, y):
+        X, y = np.asarray(X, float), np.asarray(y, float)
+        self.init_ = float(np.mean(y))
+        F = np.full(len(y), self.init_)
+        self.trees_ = []
+        for _ in range(self.n_estimators):
+            residual = y - F
+            tree = DecisionTreeRegressor(max_depth=self.max_depth).fit(X, residual)
+            F += self.learning_rate * tree.predict(X)
+            self.trees_.append(tree)
+        return self
+
+    def predict(self, X):
+        X = np.asarray(X, float)
+        F = np.full(X.shape[0], self.init_)
+        for tree in self.trees_:
+            F += self.learning_rate * tree.predict(X)
+        return F
+
+
+class GradientBoostingClassifier(Estimator, ClassifierMixin):
+    """Градиентный бустинг для бинарной классификации (log-loss).
+
+    Бустим в пространстве log-odds: каждое дерево учится на остатке y − p,
+    где p = sigmoid(текущей суммы) — это антиградиент log-loss по сумме.
+    """
+    def __init__(self, n_estimators=100, learning_rate=0.1, max_depth=3):
+        self.n_estimators = n_estimators
+        self.learning_rate = learning_rate
+        self.max_depth = max_depth
+
+    def fit(self, X, y):
+        X, y = np.asarray(X, float), np.asarray(y, float)
+        p0 = np.clip(np.mean(y), 1e-6, 1 - 1e-6)
+        self.init_ = float(np.log(p0 / (1 - p0)))            # базовые log-odds
+        F = np.full(len(y), self.init_)
+        self.trees_ = []
+        for _ in range(self.n_estimators):
+            residual = y - _sigmoid(F)
+            tree = DecisionTreeRegressor(max_depth=self.max_depth).fit(X, residual)
+            F += self.learning_rate * tree.predict(X)
+            self.trees_.append(tree)
+        return self
+
+    def _decision(self, X):
+        X = np.asarray(X, float)
+        F = np.full(X.shape[0], self.init_)
+        for tree in self.trees_:
+            F += self.learning_rate * tree.predict(X)
+        return F
+
+    def predict_proba(self, X):
+        return _sigmoid(self._decision(X))
+
+    def predict(self, X):
+        return (self.predict_proba(X) > 0.5).astype(int)

claros/feature_selection.py

@@ -0,0 +1,26 @@
+import numpy as np
+from .base import Estimator
+
+
+class NoiseFeatureRemover(Estimator):  # выкидывает признаки-шум: их гистограмма почти равномерна
+    def __init__(self, bins=20, threshold=0.9):
+        self.bins = bins
+        self.threshold = threshold
+
+    def _uniformity(self, col):  # 1.0 = идеально равномерно (максимум энтропии), ниже = есть структура
+        counts, _ = np.histogram(col, bins=self.bins)
+        p = counts / counts.sum()
+        p = p[p > 0]
+        entropy = -np.sum(p * np.log(p))
+        return entropy / np.log(self.bins)
+
+    def fit(self, X, y=None):
+        self.uniformity_ = np.array([self._uniformity(X[:, j]) for j in range(X.shape[1])])
+        self.keep_mask_ = self.uniformity_ < self.threshold   # держим НЕ-равномерные признаки
+        return self
+
+    def transform(self, X):
+        return X[:, self.keep_mask_]
+
+    def fit_transform(self, X, y=None):
+        return self.fit(X).transform(X)

claros/linear_model.py

@@ -0,0 +1,51 @@
+import numpy as np
+from .base import Estimator, RegressorMixin, ClassifierMixin
+from .losses import MSE, LogLoss
+from .links import Identity, Sigmoid
+
+
+class _LinearModel(Estimator):  # общий движок: линейный счёт z=Xw+b, спуск с loss, link и L2
+    def __init__(self, loss, link, lr=0.1, n_iters=300, l2=0.0):
+        self.loss = loss
+        self.link = link
+        self.lr = lr
+        self.n_iters = n_iters
+        self.l2 = l2
+
+    def fit(self, X, y):
+        n, d = X.shape
+        self.coef_ = np.zeros(d)
+        self.intercept_ = 0.0
+        self.loss_history_ = []
+        for _ in range(self.n_iters):
+            z = X @ self.coef_ + self.intercept_
+            p = self.link.forward(z)
+            g = self.loss.gradient(y, p) * self.link.derivative(z)
+            grad_w = (X.T @ g) / n + self.l2 * self.coef_   # L2 штрафует веса, но не сдвиг
+            grad_b = g.sum() / n
+            self.coef_ -= self.lr * grad_w
+            self.intercept_ -= self.lr * grad_b
+            self.loss_history_.append(self.loss.value(y, p) + 0.5 * self.l2 * np.sum(self.coef_ ** 2))
+        return self
+
+    def _output(self, X):
+        return self.link.forward(X @ self.coef_ + self.intercept_)
+
+
+class LinearRegression(_LinearModel, RegressorMixin):  # регрессия: по умолчанию Identity-link + MSE
+    def __init__(self, loss=None, link=None, lr=0.1, n_iters=300, l2=0.0):
+        super().__init__(loss or MSE(), link or Identity(), lr, n_iters, l2)
+
+    def predict(self, X):
+        return self._output(X)
+
+
+class LogisticRegression(_LinearModel, ClassifierMixin):  # классификация: по умолчанию Sigmoid + log-loss
+    def __init__(self, loss=None, link=None, lr=0.1, n_iters=300, l2=0.0):
+        super().__init__(loss or LogLoss(), link or Sigmoid(), lr, n_iters, l2)
+
+    def predict_proba(self, X):
+        return self._output(X)
+
+    def predict(self, X):
+        return (self.predict_proba(X) > 0.5).astype(int)

claros/links.py

@@ -0,0 +1,34 @@
+import numpy as np
+
+
+class Link:  # контракт сжимающей функции: счёт z -> p и её производная dp/dz
+    def forward(self, z):
+        raise NotImplementedError
+
+    def derivative(self, z):
+        raise NotImplementedError
+
+
+class Identity(Link):  # без сжатия: p = z (для регрессии)
+    def forward(self, z):
+        return z
+
+    def derivative(self, z):
+        return np.ones_like(z)
+
+
+class Sigmoid(Link):  # классическая сигмоида
+    def forward(self, z):
+        return 1 / (1 + np.exp(-z))
+
+    def derivative(self, z):
+        p = self.forward(z)
+        return p * (1 - p)
+
+
+class ArctanLink(Link):  # твоя сжимающая функция (Коши / арктангенс)
+    def forward(self, z):
+        return 0.5 + np.arctan(z) / np.pi
+
+    def derivative(self, z):
+        return 1 / (np.pi * (1 + z ** 2))

claros/losses.py

@@ -0,0 +1,58 @@
+import numpy as np
+
+
+class Loss:  # контракт потери: значение, градиент по своему входу, опц. гессиан
+    def value(self, y, pred):
+        raise NotImplementedError
+
+    def gradient(self, y, pred):
+        raise NotImplementedError
+
+    def hessian(self, y, pred):
+        raise NotImplementedError
+
+
+class DeadZoneLoss(Loss):  # твоя робастная регрессионная потеря с плоским дном
+    def __init__(self, delta=1.0):
+        self.delta = delta
+
+    def value(self, y, pred):
+        u = (pred - y) / self.delta
+        return np.mean(self.delta * ((1 + u ** 4) ** 0.25 - 1))
+
+    def gradient(self, y, pred):
+        u = (pred - y) / self.delta
+        return u ** 3 / (1 + u ** 4) ** 0.75
+
+    def hessian(self, y, pred):
+        u = (pred - y) / self.delta
+        return 3 * u ** 2 / (self.delta * (1 + u ** 4) ** 1.75)
+
+
+class LogLoss(Loss):  # бинарная кросс-энтропия; gradient — это ∂L/∂p (по вероятности)
+    def value(self, y, p):
+        p = np.clip(p, 1e-6, 1 - 1e-6)
+        return np.mean(-(y * np.log(p) + (1 - y) * np.log(1 - p)))
+
+    def gradient(self, y, p):
+        p = np.clip(p, 1e-6, 1 - 1e-6)
+        return (p - y) / (p * (1 - p))
+
+
+class MSE(Loss):  # стандартная средняя квадратичная потеря
+    def value(self, y, pred):
+        return np.mean((pred - y) ** 2)
+
+    def gradient(self, y, pred):
+        return 2 * (pred - y)
+
+
+class HingeLoss(Loss):  # потеря SVM: max(0, 1 − y·z), метки y ∈ {−1, +1}, z — линейный счёт
+    def value(self, y, z):
+        return np.mean(np.maximum(0, 1 - y * z))
+
+    def gradient(self, y, z):
+        return np.where(y * z < 1, -y, 0.0)   # субградиент: −y там, где зазор нарушен, иначе 0
+
+    def hessian(self, y, z):
+        return np.zeros_like(z)

claros/metrics.py

@@ -0,0 +1,42 @@
+import numpy as np
+
+
+# --- регрессия ---
+def mse(y_true, y_pred):
+    return np.mean((y_true - y_pred) ** 2)
+
+
+def rmse(y_true, y_pred):
+    return np.sqrt(mse(y_true, y_pred))
+
+
+def mae(y_true, y_pred):
+    return np.mean(np.abs(y_true - y_pred))
+
+
+def r2_score(y_true, y_pred):
+    ss_res = np.sum((y_true - y_pred) ** 2)
+    ss_tot = np.sum((y_true - np.mean(y_true)) ** 2)
+    return 1 - ss_res / ss_tot
+
+
+# --- бинарная классификация (положительный класс = 1) ---
+def accuracy(y_true, y_pred):
+    return np.mean(y_true == y_pred)
+
+
+def precision(y_true, y_pred):
+    tp = np.sum((y_pred == 1) & (y_true == 1))
+    fp = np.sum((y_pred == 1) & (y_true == 0))
+    return tp / (tp + fp) if (tp + fp) > 0 else 0.0
+
+
+def recall(y_true, y_pred):
+    tp = np.sum((y_pred == 1) & (y_true == 1))
+    fn = np.sum((y_pred == 0) & (y_true == 1))
+    return tp / (tp + fn) if (tp + fn) > 0 else 0.0
+
+
+def f1_score(y_true, y_pred):
+    p, r = precision(y_true, y_pred), recall(y_true, y_pred)
+    return 2 * p * r / (p + r) if (p + r) > 0 else 0.0

claros/model_selection.py

@@ -0,0 +1,57 @@
+import numpy as np
+from itertools import product
+from .base import Estimator
+
+
+def train_test_split(X, y, test_size=0.25, random_state=None, shuffle=True):  # делит данные на train и test
+    n = X.shape[0]
+    idx = np.arange(n)
+    if shuffle:
+        np.random.default_rng(random_state).shuffle(idx)
+    n_test = int(n * test_size)
+    test_idx, train_idx = idx[:n_test], idx[n_test:]
+    return X[train_idx], X[test_idx], y[train_idx], y[test_idx]
+
+
+def cross_val_score(model, X, y, cv=5, shuffle=True, random_state=None):  # k-fold: учим на k-1 частях, оцениваем на оставшейся
+    X, y = np.asarray(X), np.asarray(y)
+    idx = np.arange(X.shape[0])
+    if shuffle:
+        np.random.default_rng(random_state).shuffle(idx)
+    folds = np.array_split(idx, cv)
+    scores = []
+    for i in range(cv):
+        test_idx = folds[i]
+        train_idx = np.concatenate([folds[j] for j in range(cv) if j != i])
+        fresh = type(model)(**model.get_params())          # свежая копия модели на каждый фолд
+        fresh.fit(X[train_idx], y[train_idx])
+        scores.append(fresh.score(X[test_idx], y[test_idx]))
+    return np.array(scores)
+
+
+class GridSearchCV(Estimator):  # перебор гиперпараметров по сетке с кросс-валидацией
+    def __init__(self, estimator, param_grid, cv=5):
+        self.estimator = estimator
+        self.param_grid = param_grid
+        self.cv = cv
+
+    def fit(self, X, y):
+        names = list(self.param_grid.keys())
+        base = self.estimator.get_params()
+        self.results_ = []
+        self.best_score_, self.best_params_ = -np.inf, None
+        for combo in product(*[self.param_grid[k] for k in names]):
+            params = dict(zip(names, combo))
+            model = type(self.estimator)(**{**base, **params})
+            mean = cross_val_score(model, X, y, cv=self.cv).mean()
+            self.results_.append((params, mean))
+            if mean > self.best_score_:
+                self.best_score_, self.best_params_ = mean, params
+        self.best_estimator_ = type(self.estimator)(**{**base, **self.best_params_}).fit(X, y)
+        return self
+
+    def predict(self, X):
+        return self.best_estimator_.predict(X)
+
+    def score(self, X, y):
+        return self.best_estimator_.score(X, y)

claros/multiclass.py

@@ -0,0 +1,36 @@
+"""Мультикласс поверх бинарных моделей: схема one-vs-rest."""
+import numpy as np
+from .base import Estimator, ClassifierMixin
+
+
+class OneVsRestClassifier(Estimator, ClassifierMixin):
+    """Один бинарный классификатор на класс («этот класс против всех остальных»).
+
+    Предсказание — класс с наибольшей уверенностью бинарной модели
+    (predict_proba, иначе decision_function, иначе predict). Превращает любой
+    бинарный классификатор (логрег, SVM, бустинг) в мультиклассовый.
+    """
+    def __init__(self, estimator):
+        self.estimator = estimator
+
+    def fit(self, X, y):
+        X, y = np.asarray(X, float), np.asarray(y)
+        self.classes_ = np.unique(y)
+        self.models_ = []
+        for c in self.classes_:
+            model = type(self.estimator)(**self.estimator.get_params())
+            model.fit(X, (y == c).astype(int))
+            self.models_.append(model)
+        return self
+
+    def _confidence(self, model, X):
+        if hasattr(model, "predict_proba"):
+            return model.predict_proba(X)
+        if hasattr(model, "decision_function"):
+            return model.decision_function(X)
+        return model.predict(X)
+
+    def predict(self, X):
+        X = np.asarray(X, float)
+        scores = np.array([self._confidence(m, X) for m in self.models_])   # (классы, объекты)
+        return self.classes_[scores.argmax(axis=0)]

claros/naive_bayes.py

@@ -0,0 +1,42 @@
+"""Наивный байесовский классификатор с гауссовыми признаками."""
+import numpy as np
+from .base import Estimator, ClassifierMixin
+
+
+class GaussianNB(Estimator, ClassifierMixin):
+    """Наивный Байес: каждый признак внутри класса считается гауссовым и независимым.
+
+    Класс выбирается по максимуму апостериорной вероятности
+    (log-prior + сумма log-плотностей признаков). Поддерживает любое число классов.
+    """
+    def __init__(self, var_smoothing=1e-9):
+        self.var_smoothing = var_smoothing
+
+    def fit(self, X, y):
+        X, y = np.asarray(X, float), np.asarray(y)
+        self.classes_ = np.unique(y)
+        eps = self.var_smoothing * X.var(axis=0).max()
+        self.theta_, self.var_, self.priors_ = [], [], []
+        for c in self.classes_:
+            Xc = X[y == c]
+            self.theta_.append(Xc.mean(axis=0))
+            self.var_.append(Xc.var(axis=0) + eps)
+            self.priors_.append(len(Xc) / len(X))
+        self.theta_, self.var_, self.priors_ = map(np.array, (self.theta_, self.var_, self.priors_))
+        return self
+
+    def _log_joint(self, X):
+        out = []
+        for i in range(len(self.classes_)):
+            ll = -0.5 * np.sum(np.log(2 * np.pi * self.var_[i]) + (X - self.theta_[i]) ** 2 / self.var_[i], axis=1)
+            out.append(np.log(self.priors_[i]) + ll)
+        return np.array(out).T                              # (объекты, классы)
+
+    def predict(self, X):
+        return self.classes_[np.argmax(self._log_joint(np.asarray(X, float)), axis=1)]
+
+    def predict_proba(self, X):
+        lj = self._log_joint(np.asarray(X, float))
+        lj = lj - lj.max(axis=1, keepdims=True)
+        p = np.exp(lj)
+        return p / p.sum(axis=1, keepdims=True)

claros/neighbors.py

@@ -0,0 +1,35 @@
+"""Метод k ближайших соседей (KNN) с векторным поиском соседей."""
+import numpy as np
+from .base import Estimator, RegressorMixin, ClassifierMixin
+
+
+class _KNeighbors(Estimator):
+    """Ленивая модель: запоминает обучающие точки, при предсказании считает все расстояния разом."""
+    def __init__(self, n_neighbors=5):
+        self.n_neighbors = n_neighbors
+
+    def fit(self, X, y):
+        self.X_ = np.asarray(X, float)
+        self.y_ = np.asarray(y)
+        self._sq_ = (self.X_ ** 2).sum(axis=1)
+        return self
+
+    def predict(self, X):
+        X = np.asarray(X, float)
+        k = min(self.n_neighbors, len(self.X_))
+        d2 = (X ** 2).sum(axis=1)[:, None] + self._sq_[None, :] - 2 * (X @ self.X_.T)
+        nn = np.argpartition(d2, k - 1, axis=1)[:, :k]      # k ближайших на каждый запрос (векторно)
+        return np.array([self._aggregate(self.y_[row]) for row in nn])
+
+
+class KNeighborsClassifier(_KNeighbors, ClassifierMixin):
+    """KNN-классификатор: класс — большинство среди соседей."""
+    def _aggregate(self, labels):
+        vals, counts = np.unique(labels, return_counts=True)
+        return vals[np.argmax(counts)]
+
+
+class KNeighborsRegressor(_KNeighbors, RegressorMixin):
+    """KNN-регрессор: значение — среднее по соседям."""
+    def _aggregate(self, values):
+        return float(np.mean(values))

claros/pipeline.py

@@ -0,0 +1,49 @@
+from .base import Estimator
+
+
+class Pipeline(Estimator):  # цепочка: трансформеры по очереди, затем финальная модель
+    def __init__(self, steps):
+        self.steps = steps   # [(имя, объект), ...]; последний — модель, остальные — трансформеры
+
+    def _through(self, X, fit):
+        for _, step in self.steps[:-1]:
+            X = step.fit_transform(X) if fit else step.transform(X)
+        return X
+
+    def fit(self, X, y=None):
+        final = self.steps[-1][1]
+        Xt = self._through(X, fit=True)
+        final.fit(Xt) if y is None else final.fit(Xt, y)
+        return self
+
+    def fit_predict(self, X, y=None):
+        return self.steps[-1][1].fit_predict(self._through(X, fit=True))
+
+    def predict(self, X):
+        return self.steps[-1][1].predict(self._through(X, fit=False))
+
+    def transform(self, X):
+        return self._through(X, fit=False)
+
+    def score(self, X, y):
+        return self.steps[-1][1].score(self._through(X, fit=False), y)
+
+
+def prep(model, scale=0, clean_noise_features=0, pca=0):  # предобработка к любой модели без ручного Pipeline
+    """scale=1 — масштабировать; clean_noise_features=1 — убрать шумовые признаки; pca=k — сжать до k компонент.
+
+    Покрывает все трансформеры библиотеки. Порядок: чистка → масштабирование → PCA → модель.
+    Возвращает объект с обычным fit/predict/score/fit_predict.
+    """
+    from .feature_selection import NoiseFeatureRemover
+    from .preprocessing import StandardScaler
+    from .decomposition import PCA
+    steps = []
+    if clean_noise_features:
+        steps.append(("clean", NoiseFeatureRemover()))
+    if scale:
+        steps.append(("scale", StandardScaler()))
+    if pca:
+        steps.append(("pca", PCA(n_components=pca)))
+    steps.append(("model", model))
+    return Pipeline(steps)

claros/preprocessing.py

@@ -0,0 +1,16 @@
+import numpy as np
+from .base import Estimator
+
+
+class StandardScaler(Estimator):  # приводит каждый признак к среднему 0 и дисперсии 1
+    def fit(self, X, y=None):
+        self.mean_ = X.mean(axis=0)
+        self.std_ = X.std(axis=0)
+        self.std_[self.std_ == 0] = 1.0   # константный признак не делим на ноль
+        return self
+
+    def transform(self, X):
+        return (X - self.mean_) / self.std_
+
+    def fit_transform(self, X, y=None):
+        return self.fit(X).transform(X)

claros/svm.py

@@ -0,0 +1,32 @@
+"""Метод опорных векторов (линейный, мягкий зазор) на общем линейном движке."""
+import numpy as np
+from .base import ClassifierMixin
+from .linear_model import _LinearModel
+from .losses import HingeLoss
+from .links import Identity
+
+
+class LinearSVC(_LinearModel, ClassifierMixin):
+    """Линейный SVM через hinge-потерю.
+
+    Это тот же движок, что у регрессий: Identity-линк + HingeLoss + L2 дают
+    субградиентный спуск по задаче мягкого зазора. То есть SVM получается из
+    уже готового _LinearModel, не добавляя нового цикла обучения.
+    C — обратная сила регуляризации (больше C — меньше регуляризация).
+    """
+    def __init__(self, C=1.0, lr=0.01, n_iters=1000):
+        self.C = C
+        super().__init__(HingeLoss(), Identity(), lr=lr, n_iters=n_iters, l2=1.0 / C)
+
+    def fit(self, X, y):
+        y = np.asarray(y)
+        self.classes_ = np.unique(y)                                   # ожидаются два класса
+        y_pm = np.where(y == self.classes_[1], 1.0, -1.0)              # перевод в {−1, +1}
+        super().fit(np.asarray(X, float), y_pm)
+        return self
+
+    def decision_function(self, X):
+        return np.asarray(X, float) @ self.coef_ + self.intercept_
+
+    def predict(self, X):
+        return np.where(self.decision_function(X) > 0, self.classes_[1], self.classes_[0])

claros/tree.py

@@ -0,0 +1,92 @@
+"""Деревья решений (CART): рекурсивная нарезка пространства признаков по порогам."""
+import numpy as np
+from .base import Estimator, RegressorMixin, ClassifierMixin
+
+
+class _Node:
+    """Узел дерева: либо порог с двумя детьми, либо лист со значением."""
+    def __init__(self, feature=None, threshold=None, left=None, right=None, value=None):
+        self.feature = feature
+        self.threshold = threshold
+        self.left = left
+        self.right = right
+        self.value = value
+
+
+class _DecisionTree(Estimator):
+    """Общий движок CART. Подклассы задают примесь и значение листа.
+
+    max_features — сколько признаков рассматривать на каждом разрезе
+    (None = все); случайное подмножество нужно случайному лесу.
+    """
+    def __init__(self, max_depth=5, min_samples_split=2, max_features=None, random_state=None):
+        self.max_depth = max_depth
+        self.min_samples_split = min_samples_split
+        self.max_features = max_features
+        self.random_state = random_state
+
+    def _feature_subset(self, d):
+        if self.max_features is None or self.max_features >= d:
+            return range(d)
+        return self._rng.choice(d, self.max_features, replace=False)
+
+    def _best_split(self, X, y):
+        n = len(y)
+        parent = self._impurity(y)
+        best_gain, best_feat, best_thr = 0.0, None, None
+        for feat in self._feature_subset(X.shape[1]):
+            values = np.unique(X[:, feat])
+            for thr in (values[:-1] + values[1:]) / 2:           # пороги — середины между значениями
+                left, right = y[X[:, feat] <= thr], y[X[:, feat] > thr]
+                child = (len(left) * self._impurity(left) + len(right) * self._impurity(right)) / n
+                gain = parent - child
+                if gain > best_gain:
+                    best_gain, best_feat, best_thr = gain, feat, thr
+        return best_feat, best_thr
+
+    def _build(self, X, y, depth):
+        if depth >= self.max_depth or len(y) < self.min_samples_split or len(np.unique(y)) == 1:
+            return _Node(value=self._leaf_value(y))
+        feat, thr = self._best_split(X, y)
+        if feat is None:
+            return _Node(value=self._leaf_value(y))
+        mask = X[:, feat] <= thr
+        left = self._build(X[mask], y[mask], depth + 1)
+        right = self._build(X[~mask], y[~mask], depth + 1)
+        return _Node(feat, thr, left, right)
+
+    def fit(self, X, y):
+        self._rng = np.random.default_rng(self.random_state)
+        self.root_ = self._build(np.asarray(X, float), np.asarray(y), 0)
+        return self
+
+    def _descend(self, x, node):
+        while node.value is None:
+            node = node.left if x[node.feature] <= node.threshold else node.right
+        return node.value
+
+    def predict(self, X):
+        return np.array([self._descend(x, self.root_) for x in np.asarray(X, float)])
+
+
+class DecisionTreeRegressor(_DecisionTree, RegressorMixin):
+    """Дерево регрессии: примесь — дисперсия, лист — среднее."""
+    def _impurity(self, y):
+        return np.var(y) if len(y) else 0.0
+
+    def _leaf_value(self, y):
+        return float(np.mean(y))
+
+
+class DecisionTreeClassifier(_DecisionTree, ClassifierMixin):
+    """Дерево классификации: примесь — Gini, лист — класс-большинство."""
+    def _impurity(self, y):
+        if len(y) == 0:
+            return 0.0
+        _, counts = np.unique(y, return_counts=True)
+        p = counts / counts.sum()
+        return 1.0 - np.sum(p ** 2)
+
+    def _leaf_value(self, y):
+        values, counts = np.unique(y, return_counts=True)
+        return values[np.argmax(counts)]

claros-0.7.0.dist-info/METADATA

@@ -0,0 +1,318 @@
+Metadata-Version: 2.4
+Name: claros
+Version: 0.7.0
+Summary: Учебная ML-библиотека с нуля на NumPy: sklearn-подобный интерфейс и свои робастные компоненты
+Author-email: Сафин Георгий <sikirchannel@gmail.com>
+License: MIT
+Project-URL: Homepage, https://github.com/kuketa-tech/claros
+Project-URL: Repository, https://github.com/kuketa-tech/claros
+Keywords: machine-learning,numpy,from-scratch,education,scikit-learn
+Classifier: Development Status :: 4 - Beta
+Classifier: Intended Audience :: Science/Research
+Classifier: Intended Audience :: Education
+Classifier: License :: OSI Approved :: MIT License
+Classifier: Operating System :: OS Independent
+Classifier: Programming Language :: Python :: 3
+Classifier: Programming Language :: Python :: 3.9
+Classifier: Programming Language :: Python :: 3.10
+Classifier: Programming Language :: Python :: 3.11
+Classifier: Programming Language :: Python :: 3.12
+Classifier: Topic :: Scientific/Engineering :: Artificial Intelligence
+Requires-Python: >=3.9
+Description-Content-Type: text/markdown
+License-File: LICENSE
+Requires-Dist: numpy>=1.20
+Provides-Extra: dev
+Requires-Dist: pytest; extra == "dev"
+Requires-Dist: scikit-learn; extra == "dev"
+Dynamic: license-file
+
+# Claros
+
+**Учебная ML-библиотека, написанная с нуля на чистом NumPy.** Sklearn-подобный интерфейс, никаких готовых ML-зависимостей — все алгоритмы реализованы руками.
+
+`Python ≥ 3.9` · `только NumPy` · `лицензия MIT` · `32 теста зелёных`
+
+---
+
+## Содержание
+
+- [Установка](#установка)
+- [Документация](#документация)
+- [Как устроено](#как-устроено)
+- [Удобство: предобработка без Pipeline](#удобство-предобработка-без-pipeline)
+- [Функции с примерами](#функции-с-примерами)
+- [Валидация](#валидация)
+- [Структура и тесты](#структура-и-тесты)
+- [Дорожная карта](#дорожная-карта)
+
+---
+
+## Установка
+
+```bash
+pip install -e .            # библиотека
+pip install -e ".[dev]"     # + pytest и scikit-learn для тестов
+```
+
+## Документация
+
+Полная документация — в папке [`docs/`](docs/index.md): по каждому классу параметры (тип, дефолт, смысл), методы, что возвращают, атрибуты, примеры, плюс гайд «как писать свои компоненты».
+
+- [**Полный справочник всех функций**](docs/reference.md) — всё одним списком
+- [Модели](docs/models.md) · [Кластеризация и PCA](docs/clustering.md) · [Потери и сжимающие функции](docs/losses-and-links.md)
+- [Предобработка и конвейеры](docs/preprocessing-and-pipelines.md) · [Оценка и подбор](docs/evaluation.md) · [Как писать свои компоненты](docs/extending.md)
+
+Можно собрать в сайт: `pip install mkdocs && mkdocs serve`.
+
+## Как устроено
+
+Все модели наследуют `Estimator` и говорят на одном языке: `fit(X, y)` обучает (возвращает `self`), `predict(X)` предсказывает, `score(X, y)` — R² (регрессоры) или доля верных (классификаторы), `get_params` / `set_params` дают клонирование. Обученные величины оканчиваются на `_` (`coef_`, `labels_`).
+
+Стержень дизайна — **потеря определяет модель**: весь шаг спуска это `g = loss.gradient(y, p) * link.derivative(z)`, поэтому линейная регрессия, логистическая регрессия и SVM — один движок с разной потерей и сжимающей функцией.
+
+---
+
+## Удобство: предобработка без Pipeline
+
+Чтобы не собирать `Pipeline` руками, предобработку можно подключить прямо к модели.
+
+**`prep(model, scale=1, clean_noise_features=1, pca=2)`** оборачивает **любую** модель и возвращает объект с обычным `fit`/`predict`/`score`/`fit_predict`. Опции: `scale=1` — масштабирование, `clean_noise_features=1` — убрать шумовые признаки, `pca=k` — сжать до k главных компонент (порядок: чистка → масштабирование → PCA → модель):
+
+```python
+from claros import prep, LogisticRegression, KNeighborsClassifier
+
+prep(LogisticRegression(), scale=1).fit(X, y)                     # + масштабирование
+prep(KNeighborsClassifier(5), scale=1, clean_noise_features=1).fit(X, y)  # + чистка шумовых признаков
+prep(LogisticRegression(), pca=2).fit(X, y)                       # + сжатие до 2 главных компонент
+```
+
+Это все предобработчики библиотеки (`StandardScaler`, `NoiseFeatureRemover`, `PCA`) — больше ничего через Pipeline не идёт. Полноценный `Pipeline` остаётся для произвольных цепочек.
+
+У `DBSCAN` и `KMeans` есть встроенный флаг-сокращение `clean_noise_features` (1 — включить нашу чистку шумовых признаков, 0 — обычный режим):
+
+```python
+from claros import DBSCAN
+DBSCAN(eps=0.6, min_samples=6, clean_noise_features=1).fit_predict(X)
+```
+
+Полноценный `Pipeline` (см. ниже) тоже остаётся — для произвольных цепочек.
+
+---
+
+## Функции с примерами
+
+> В примерах `X` — матрица признаков `(n, d)`, `y` — цель, `X_new` — новые объекты.
+
+### Линейные модели
+
+**`LinearRegression(loss=MSE(), link=Identity(), lr=0.1, n_iters=300, l2=0.0)`** — линейная регрессия градиентным спуском. Атрибуты: `coef_`, `intercept_`.
+```python
+from claros import LinearRegression
+m = LinearRegression().fit(X, y)
+m.predict(X_new); m.score(X, y)
+```
+
+**`LogisticRegression(loss=LogLoss(), link=Sigmoid(), lr=0.1, n_iters=300, l2=0.0)`** — бинарная классификация.
+```python
+from claros import LogisticRegression
+clf = LogisticRegression().fit(X, y)
+clf.predict(X_new); clf.predict_proba(X_new)
+```
+
+### SVM
+
+**`LinearSVC(C=1.0, lr=0.01, n_iters=1000)`** — линейный SVM (тот же движок + `HingeLoss`). `C` — обратная сила регуляризации.
+```python
+from claros import LinearSVC
+clf = LinearSVC(C=1.0).fit(X, y)
+clf.predict(X_new); clf.decision_function(X_new)
+```
+
+### Наивный Байес
+
+**`GaussianNB(var_smoothing=1e-9)`** — гауссов наивный Байес, мультикласс. Есть `predict_proba`.
+```python
+from claros import GaussianNB
+clf = GaussianNB().fit(X, y)
+```
+
+### Деревья решений
+
+**`DecisionTreeClassifier(max_depth=5, min_samples_split=2, max_features=None, random_state=None)`** — примесь Gini.
+**`DecisionTreeRegressor(...)`** — примесь = дисперсия.
+```python
+from claros import DecisionTreeClassifier
+clf = DecisionTreeClassifier(max_depth=5).fit(X, y)
+```
+
+### Ансамбли
+
+**`RandomForestClassifier(n_estimators=50, max_depth=10, max_features="sqrt", random_state=None)`** / **`RandomForestRegressor(...)`** — бэггинг деревьев.
+```python
+from claros import RandomForestClassifier
+clf = RandomForestClassifier(n_estimators=100).fit(X, y)
+```
+
+**`GradientBoostingClassifier(n_estimators=100, learning_rate=0.1, max_depth=3)`** / **`GradientBoostingRegressor(...)`** — бустинг по остаткам.
+```python
+from claros import GradientBoostingRegressor
+m = GradientBoostingRegressor(n_estimators=200).fit(X, y)
+```
+
+### Ближайшие соседи
+
+**`KNeighborsClassifier(n_neighbors=5)`** / **`KNeighborsRegressor(n_neighbors=5)`** — k ближайших (векторный поиск, ×3 к прежнему).
+```python
+from claros import KNeighborsClassifier
+clf = KNeighborsClassifier(5).fit(X, y)
+```
+
+### Мультикласс
+
+**`OneVsRestClassifier(estimator)`** — мультикласс из любой бинарной модели.
+```python
+from claros import OneVsRestClassifier, LogisticRegression
+clf = OneVsRestClassifier(LogisticRegression()).fit(X, y)
+```
+
+### Кластеризация
+
+**`DBSCAN(eps=0.5, min_samples=5, clean_noise_features=0, feature_threshold=0.9)`** — плотностная кластеризация; метка `-1` — шум. `clean_noise_features=1` убирает шумовые признаки перед кластеризацией (наша доработка). Атрибуты: `labels_`, `remover_` (при включённом флаге).
+```python
+from claros import DBSCAN
+DBSCAN(eps=0.5, min_samples=5).fit_predict(X)                          # обычный DBSCAN
+DBSCAN(eps=0.6, min_samples=6, clean_noise_features=1).fit_predict(X)  # + чистка шумовых признаков
+```
+
+**`KMeans(n_clusters=3, max_iter=100, n_init=10, random_state=None, clean_noise_features=0, feature_threshold=0.9)`** — по центрам, `n_init` перезапусков. Атрибуты: `cluster_centers_`, `labels_`, `inertia_`.
+```python
+from claros import KMeans
+KMeans(n_clusters=3).fit_predict(X)
+```
+
+### Снижение размерности
+
+**`PCA(n_components=2)`** — главные компоненты через SVD. Методы: `transform`, `inverse_transform`; атрибут `explained_variance_ratio_`.
+```python
+from claros import PCA
+X2 = PCA(n_components=2).fit_transform(X)
+```
+
+### Функции потерь
+
+**`MSE()`**, **`LogLoss()`**, **`HingeLoss()`**, **`DeadZoneLoss(delta=1.0)`** — `DeadZoneLoss` робастная (плоское дно + насыщение градиента, устойчива к выбросам).
+```python
+from claros import LinearRegression, DeadZoneLoss
+LinearRegression(loss=DeadZoneLoss(0.5), lr=0.02, n_iters=40000).fit(X, y)
+```
+
+### Сжимающие функции
+
+**`Identity()`**, **`Sigmoid()`**, **`ArctanLink()`** — `ArctanLink` осторожнее сигмоиды (тяжёлые хвосты).
+```python
+from claros import LogisticRegression, ArctanLink
+LogisticRegression(link=ArctanLink()).fit(X, y)
+```
+
+### Предобработка и отбор признаков
+
+**`StandardScaler()`** — среднее 0, дисперсия 1.
+```python
+from claros import StandardScaler
+Xs = StandardScaler().fit_transform(X)
+```
+
+**`NoiseFeatureRemover(bins=20, threshold=0.9)`** — убирает признаки-шум (почти равномерная гистограмма). Атрибут `keep_mask_`.
+```python
+from claros import NoiseFeatureRemover
+Xc = NoiseFeatureRemover().fit_transform(X)
+```
+
+### Конвейер
+
+**`prep(model, scale=0, clean_noise_features=0, pca=0)`** — предобработка к любой модели без ручного Pipeline: масштабирование, чистка шумовых признаков, PCA (см. раздел выше).
+```python
+from claros import prep, KNeighborsClassifier
+prep(KNeighborsClassifier(5), scale=1, clean_noise_features=1, pca=2).fit(X, y)
+```
+
+**`Pipeline(steps)`** — произвольная цепочка `[(имя, объект), …]`: трансформеры по очереди, затем модель.
+```python
+from claros import Pipeline, StandardScaler, LogisticRegression
+Pipeline([("scale", StandardScaler()), ("model", LogisticRegression())]).fit(X, y)
+```
+
+### Подбор и оценка
+
+**`train_test_split(X, y, test_size=0.25, random_state=None, shuffle=True)`** → `X_train, X_test, y_train, y_test`.
+```python
+from claros import train_test_split
+Xtr, Xte, ytr, yte = train_test_split(X, y, test_size=0.3, random_state=0)
+```
+
+**`cross_val_score(model, X, y, cv=5, shuffle=True, random_state=None)`** → массив оценок.
+```python
+from claros import cross_val_score, RandomForestClassifier
+cross_val_score(RandomForestClassifier(), X, y, cv=5).mean()
+```
+
+**`GridSearchCV(estimator, param_grid, cv=5)`** — перебор по сетке. Атрибуты: `best_params_`, `best_score_`, `best_estimator_`.
+```python
+from claros import GridSearchCV, DecisionTreeClassifier
+gs = GridSearchCV(DecisionTreeClassifier(), {"max_depth": [3, 5, 7]}, cv=5).fit(X, y)
+gs.best_params_; gs.best_score_
+```
+
+### Метрики
+
+Модуль **`claros.metrics`**, все вида `f(y_true, y_pred)`: регрессия — `mse`, `rmse`, `mae`, `r2_score`; классификация — `accuracy`, `precision`, `recall`, `f1_score`.
+```python
+from claros.metrics import accuracy, r2_score
+accuracy(y_true, y_pred); r2_score(y_true, y_pred)
+```
+
+---
+
+## Валидация
+
+Сверено со scikit-learn на одинаковых данных:
+
+| Модель                              | claros  | sklearn |
+|-------------------------------------|-------|---------|
+| RandomForest — accuracy (круг)      | 0.972 | 0.972   |
+| KNN — accuracy (круг)               | 0.983 | 0.983   |
+| GradientBoosting — R^2 (sin)        | 0.991 | 0.991   |
+| LinearSVC — accuracy (две группы)   | 1.000 | 1.000   |
+| GaussianNB — accuracy (3 класса)    | 0.972 | 0.972   |
+
+Метки `GaussianNB` и `DBSCAN` совпадают со scikit-learn один-в-один, доли дисперсии `PCA` — до 4-го знака.
+
+## Структура и тесты
+
+```
+claros-project/
+├── pyproject.toml   README.md   LICENSE   PUBLISHING.md
+├── claros/            # base, losses, links, linear_model, svm, naive_bayes,
+│                    # tree, ensemble, neighbors, multiclass, decomposition,
+│                    # cluster, preprocessing, feature_selection, pipeline,
+│                    # model_selection, metrics
+└── tests/           # 32 теста
+```
+
+```bash
+pytest tests/ -q     # 32 passed
+```
+
+## Дорожная карта
+
+- [x] линейные модели, деревья, ансамбли, KNN, кластеризация, PCA
+- [x] SVM, наивный Байес, GridSearchCV, мультикласс
+- [x] удобство: флаг `clean_noise_features` и `prep(...)` — предобработка без Pipeline
+- [x] ускорение: KNN векторизован (×3); DBSCAN — поточечный поиск O(n²) (для масштаба нужен C-индекс)
+- [ ] публикация на PyPI — имя `claros` (инструкция в `PUBLISHING.md`)
+- [ ] оформить результаты в виде научной статьи
+
+## Лицензия
+
+MIT.

claros-0.7.0.dist-info/RECORD

@@ -0,0 +1,23 @@
+claros/__init__.py,sha256=fLh0mc0-C-HTqH21OzozR8HONVcZG8Goeqy66OBjQko,2763
+claros/base.py,sha256=QAVJGo-ZFlCHc0Y551mPiRjJZ_usAW4_e9TFNRljFzk,992
+claros/cluster.py,sha256=bmUGoH2755QRPfwQF4K5Mpe5yzhpXKGG5cpvTEWG_KA,4787
+claros/decomposition.py,sha256=NkPLNH8sLdu2P3o5EL8GsfKVndzeFwlCfCFdmM1tK1E,1393
+claros/ensemble.py,sha256=-brW4x9894cHCHmEmmG97B_lj2r4Jz2O90sGaqo2ack,5471
+claros/feature_selection.py,sha256=c6lR28qXrkzKej0u-Kq3utuOJe0vbgQuQxEaDGOASik,1065
+claros/linear_model.py,sha256=PY9d2Zz-tGctvt1FVwbH-q-oPgTGxTPjgja7byORg64,2022
+claros/links.py,sha256=zGWaUbpVf4AYd2_Wg8sNgTpo2lBScSYRohy1tjJToI4,912
+claros/losses.py,sha256=NEHH7Ic01yD5-1swpyabXcFS4GX1Qhg0vG5NF-m_-Aw,1955
+claros/metrics.py,sha256=KKgCrDS2B11Tlotkt92ENpQzNG1qVQ8msrEH-GEkN18,1087
+claros/model_selection.py,sha256=4TY8tT4NllmjXRx8YyidcwN4_K5PjUbafr9ihb1QwJY,2358
+claros/multiclass.py,sha256=dWI7roORGSeX6XFDmGoLZ34NgWLUrSpn-ZivM1gbTo0,1609
+claros/naive_bayes.py,sha256=kINCwbgXVRZ5VoJT8udOpu_P5UTYXIwFBaUes63FLIE,1951
+claros/neighbors.py,sha256=BJiDyg2vUCNf94BszHnMonhntW3SmCcrNImKEL0B1bY,1564
+claros/pipeline.py,sha256=DqmG396tGcEL7-3B_6WPWBKK-cFkfGIw-5Bs7p6BQTA,2069
+claros/preprocessing.py,sha256=kQEtabgKPWBZkt25N1fy7KMQ1a9fiF7IPadMJSD6aYA,562
+claros/svm.py,sha256=ISRnvov_Nm9pnzjaXHRjtNiF1g1w5YLnwsF_rtxYLuk,1600
+claros/tree.py,sha256=n3QAKLEZfmbpxpaevKYI34n4QamZYqAnPsbbvmnEgns,3959
+claros-0.7.0.dist-info/licenses/LICENSE,sha256=PiFis7GpFhB-Ck2BRM2eJfVqlOuhWwJ9DYqdSPdXPo8,1082
+claros-0.7.0.dist-info/METADATA,sha256=D5gu7ilKiCe57pJ8yxpDpqwdh6fAurqoRnAb2wmJ2Ao,15623
+claros-0.7.0.dist-info/WHEEL,sha256=aeYiig01lYGDzBgS8HxWXOg3uV61G9ijOsup-k9o1sk,91
+claros-0.7.0.dist-info/top_level.txt,sha256=qibeNIu06iT56xOL2AYwbqDx_BQN2jljnIjnXGAyu70,7
+claros-0.7.0.dist-info/RECORD,,

claros-0.7.0.dist-info/WHEEL

@@ -0,0 +1,5 @@
+Wheel-Version: 1.0
+Generator: setuptools (82.0.1)
+Root-Is-Purelib: true
+Tag: py3-none-any
+

claros-0.7.0.dist-info/licenses/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2026 Сафин Георгий
+
+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.

claros-0.7.0.dist-info/top_level.txt

@@ -0,0 +1 @@
+claros