vectorphile 0.1.0__py3-none-any.whl

vectorphile/data/index.py

@@ -0,0 +1,86 @@
+"""Index class for DataFrame/Series labels."""
+from __future__ import annotations
+import numpy as np
+from typing import Any, List, Optional
+
+
+class Index:
+    def __init__(self, data=None, name=None):
+        if data is None:
+            self._data = np.array([])
+        elif isinstance(data, Index):
+            self._data = data._data.copy()
+        else:
+            self._data = np.array(data)
+        self.name = name
+
+    @property
+    def values(self) -> np.ndarray:
+        return self._data
+
+    @property
+    def dtype(self):
+        return self._data.dtype
+
+    def __len__(self):
+        return len(self._data)
+
+    def __contains__(self, item):
+        return item in self._data
+
+    def __getitem__(self, key):
+        return self._data[key]
+
+    def __iter__(self):
+        return iter(self._data)
+
+    def tolist(self) -> list:
+        return self._data.tolist()
+
+    def get_loc(self, key) -> int:
+        matches = np.where(self._data == key)[0]
+        if len(matches) == 0:
+            raise KeyError(key)
+        return int(matches[0])
+
+    def isin(self, values) -> np.ndarray:
+        return np.isin(self._data, values)
+
+    def unique(self) -> 'Index':
+        return Index(np.unique(self._data), name=self.name)
+
+    def sort_values(self, ascending=True) -> 'Index':
+        order = np.argsort(self._data)
+        if not ascending:
+            order = order[::-1]
+        return Index(self._data[order], name=self.name)
+
+    def append(self, other: 'Index') -> 'Index':
+        return Index(np.concatenate([self._data, other._data]), name=self.name)
+
+    def difference(self, other: 'Index') -> 'Index':
+        return Index(np.setdiff1d(self._data, other._data), name=self.name)
+
+    def intersection(self, other: 'Index') -> 'Index':
+        return Index(np.intersect1d(self._data, other._data), name=self.name)
+
+    def union(self, other: 'Index') -> 'Index':
+        return Index(np.union1d(self._data, other._data), name=self.name)
+
+    def __repr__(self):
+        return f"Index({self._data.tolist()}, name={self.name!r})"
+
+    def __str__(self):
+        return self.__repr__()
+
+
+class RangeIndex(Index):
+    def __init__(self, start=0, stop=None, step=1, name=None):
+        if stop is None:
+            stop = start
+            start = 0
+        super().__init__(np.arange(start, stop, step), name=name)
+        self.start, self.stop, self.step = start, stop, step
+
+    def __repr__(self):
+        return f"RangeIndex(start={self.start}, stop={self.stop}, step={self.step})"

vectorphile/data/series.py

@@ -0,0 +1,228 @@
+"""Series — 1D labeled array, pandas-compatible API."""
+from __future__ import annotations
+import numpy as np
+from typing import Any, Callable, Iterable, Optional, Union
+
+
+class Series:
+    def __init__(self, data=None, index=None, name=None, dtype=None):
+        if isinstance(data, Series):
+            self._data = data._data.copy()
+            self._index = data._index.copy() if index is None else list(index)
+            self.name = data.name if name is None else name
+        elif isinstance(data, dict):
+            self._index = list(data.keys())
+            self._data = np.array(list(data.values()), dtype=dtype)
+            self.name = name
+        elif data is None:
+            self._data = np.array([], dtype=dtype or np.float64)
+            self._index = []
+            self.name = name
+        else:
+            self._data = np.array(data, dtype=dtype)
+            self._index = list(index) if index is not None else list(range(len(self._data)))
+            self.name = name
+
+    @property
+    def values(self) -> np.ndarray:
+        return self._data
+
+    @property
+    def index(self):
+        return self._index
+
+    @index.setter
+    def index(self, val):
+        self._index = list(val)
+
+    @property
+    def dtype(self):
+        return self._data.dtype
+
+    @property
+    def shape(self):
+        return self._data.shape
+
+    def __len__(self):
+        return len(self._data)
+
+    def __getitem__(self, key):
+        if isinstance(key, str) or (not isinstance(key, (int, slice, np.ndarray, list))):
+            if key in self._index:
+                return self._data[self._index.index(key)]
+            raise KeyError(key)
+        if isinstance(key, slice):
+            return Series(self._data[key], index=self._index[key], name=self.name)
+        if isinstance(key, (list, np.ndarray)):
+            if isinstance(key, list) and len(key) > 0 and isinstance(key[0], bool):
+                key = np.array(key)
+            if isinstance(key, np.ndarray) and key.dtype == bool:
+                idx = [self._index[i] for i in np.where(key)[0]]
+                return Series(self._data[key], index=idx, name=self.name)
+            idxs = [self._index.index(k) for k in key]
+            return Series(self._data[idxs], index=key, name=self.name)
+        return self._data[key]
+
+    def __setitem__(self, key, value):
+        if isinstance(key, str) and key in self._index:
+            self._data[self._index.index(key)] = value
+        else:
+            self._data[key] = value
+
+    def _op(self, other, fn):
+        if isinstance(other, Series):
+            return Series(fn(self._data, other._data), index=self._index, name=self.name)
+        return Series(fn(self._data, other), index=self._index, name=self.name)
+
+    def __add__(self, other): return self._op(other, np.add)
+    def __radd__(self, other): return self._op(other, lambda a, b: np.add(b, a))
+    def __sub__(self, other): return self._op(other, np.subtract)
+    def __rsub__(self, other): return self._op(other, lambda a, b: np.subtract(b, a))
+    def __mul__(self, other): return self._op(other, np.multiply)
+    def __rmul__(self, other): return self._op(other, lambda a, b: np.multiply(b, a))
+    def __truediv__(self, other): return self._op(other, np.true_divide)
+    def __floordiv__(self, other): return self._op(other, np.floor_divide)
+    def __pow__(self, other): return self._op(other, np.power)
+    def __neg__(self): return Series(-self._data, index=self._index, name=self.name)
+    def __eq__(self, other): return self._op(other, np.equal)
+    def __ne__(self, other): return self._op(other, np.not_equal)
+    def __lt__(self, other): return self._op(other, np.less)
+    def __le__(self, other): return self._op(other, np.less_equal)
+    def __gt__(self, other): return self._op(other, np.greater)
+    def __ge__(self, other): return self._op(other, np.greater_equal)
+
+    def apply(self, func: Callable) -> 'Series':
+        return Series([func(v) for v in self._data], index=self._index, name=self.name)
+
+    def map(self, func_or_dict) -> 'Series':
+        if callable(func_or_dict):
+            return self.apply(func_or_dict)
+        return Series([func_or_dict.get(v, np.nan) for v in self._data], index=self._index, name=self.name)
+
+    def isnull(self) -> 'Series':
+        try:
+            return Series(np.isnan(self._data.astype(float)), index=self._index)
+        except (ValueError, TypeError):
+            return Series([v is None for v in self._data], index=self._index)
+
+    def notnull(self) -> 'Series':
+        null = self.isnull()
+        return Series(~null._data, index=self._index)
+
+    def dropna(self) -> 'Series':
+        mask = self.notnull()._data
+        new_idx = [self._index[i] for i in range(len(mask)) if mask[i]]
+        return Series(self._data[mask], index=new_idx, name=self.name)
+
+    def fillna(self, value) -> 'Series':
+        result = self._data.copy().astype(object)
+        try:
+            null_mask = np.isnan(self._data.astype(float))
+            result = self._data.copy().astype(float)
+            result[null_mask] = value
+        except (ValueError, TypeError):
+            result = np.array([value if v is None else v for v in self._data])
+        return Series(result, index=self._index, name=self.name)
+
+    def sort_values(self, ascending=True) -> 'Series':
+        order = np.argsort(self._data)
+        if not ascending:
+            order = order[::-1]
+        new_idx = [self._index[i] for i in order]
+        return Series(self._data[order], index=new_idx, name=self.name)
+
+    def sort_index(self, ascending=True) -> 'Series':
+        order = np.argsort(self._index)
+        if not ascending:
+            order = order[::-1]
+        new_idx = [self._index[i] for i in order]
+        return Series(self._data[order], index=new_idx, name=self.name)
+
+    def unique(self) -> np.ndarray:
+        return np.unique(self._data)
+
+    def nunique(self) -> int:
+        return len(np.unique(self._data))
+
+    def value_counts(self, normalize=False) -> 'Series':
+        vals, counts = np.unique(self._data, return_counts=True)
+        order = np.argsort(-counts)
+        vals, counts = vals[order], counts[order]
+        if normalize:
+            counts = counts / counts.sum()
+        return Series(counts, index=list(vals), name=self.name)
+
+    def mean(self): return float(np.nanmean(self._data.astype(float)))
+    def median(self): return float(np.nanmedian(self._data.astype(float)))
+    def std(self, ddof=1): return float(np.nanstd(self._data.astype(float), ddof=ddof))
+    def var(self, ddof=1): return float(np.nanvar(self._data.astype(float), ddof=ddof))
+    def min(self): return self._data.min()
+    def max(self): return self._data.max()
+    def sum(self): return self._data.sum()
+    def prod(self): return self._data.prod()
+    def count(self): return int(self.notnull()._data.sum())
+    def abs(self): return Series(np.abs(self._data), index=self._index, name=self.name)
+    def cumsum(self): return Series(np.cumsum(self._data), index=self._index, name=self.name)
+    def cumprod(self): return Series(np.cumprod(self._data), index=self._index, name=self.name)
+
+    def head(self, n=5) -> 'Series':
+        return Series(self._data[:n], index=self._index[:n], name=self.name)
+
+    def tail(self, n=5) -> 'Series':
+        return Series(self._data[-n:], index=self._index[-n:], name=self.name)
+
+    def reset_index(self, drop=False) -> 'Series':
+        if drop:
+            return Series(self._data, index=list(range(len(self._data))), name=self.name)
+        # Return as DataFrame when drop=False
+        from vectorphile.data.frame import DataFrame
+        return DataFrame({'index': self._index, self.name or 0: self._data})
+
+    def to_list(self):
+        return self._data.tolist()
+
+    def to_numpy(self) -> np.ndarray:
+        return self._data.copy()
+
+    def __iter__(self):
+        return iter(self._data)
+
+    def __repr__(self):
+        lines = []
+        for i, v in zip(self._index, self._data):
+            lines.append(f'{i}    {v}')
+        if self.name:
+            lines.append(f'Name: {self.name}, dtype: {self.dtype}')
+        return '\n'.join(lines)
+
+    def __str__(self):
+        return self.__repr__()
+
+    def astype(self, dtype) -> 'Series':
+        return Series(self._data.astype(dtype), index=self._index, name=self.name)
+
+    def clip(self, lower=None, upper=None) -> 'Series':
+        return Series(np.clip(self._data, lower, upper), index=self._index, name=self.name)
+
+    def round(self, decimals=0) -> 'Series':
+        return Series(np.round(self._data.astype(float), decimals), index=self._index, name=self.name)
+
+    def quantile(self, q=0.5):
+        return float(np.nanpercentile(self._data.astype(float), q * 100))
+
+    def corr(self, other: 'Series') -> float:
+        return float(np.corrcoef(self._data.astype(float), other._data.astype(float))[0, 1])
+
+    def describe(self) -> 'Series':
+        d = self._data.astype(float)
+        stats = {
+            'count': float(len(d)),
+            'mean': float(np.nanmean(d)),
+            'std': float(np.nanstd(d, ddof=1)),
+            'min': float(np.nanmin(d)),
+            '25%': float(np.nanpercentile(d, 25)),
+            '50%': float(np.nanpercentile(d, 50)),
+            '75%': float(np.nanpercentile(d, 75)),
+            'max': float(np.nanmax(d)),
+        }
+        return Series(list(stats.values()), index=list(stats.keys()), name=self.name)

vectorphile/fft/__init__.py

@@ -0,0 +1,34 @@
+"""FFT operations."""
+import numpy as np
+from vectorphile.core.tensor import Tensor
+
+
+def fft(input: Tensor, n=None, dim=-1, norm=None) -> Tensor:
+    return Tensor(np.fft.fft(input._data, n=n, axis=dim, norm=norm))
+
+def ifft(input: Tensor, n=None, dim=-1, norm=None) -> Tensor:
+    return Tensor(np.fft.ifft(input._data, n=n, axis=dim, norm=norm))
+
+def fft2(input: Tensor, s=None, dim=(-2, -1), norm=None) -> Tensor:
+    return Tensor(np.fft.fft2(input._data, s=s, axes=dim, norm=norm))
+
+def ifft2(input: Tensor, s=None, dim=(-2, -1), norm=None) -> Tensor:
+    return Tensor(np.fft.ifft2(input._data, s=s, axes=dim, norm=norm))
+
+def rfft(input: Tensor, n=None, dim=-1, norm=None) -> Tensor:
+    return Tensor(np.fft.rfft(input._data, n=n, axis=dim, norm=norm))
+
+def irfft(input: Tensor, n=None, dim=-1, norm=None) -> Tensor:
+    return Tensor(np.fft.irfft(input._data, n=n, axis=dim, norm=norm).astype(np.float32))
+
+def fftshift(input: Tensor, dim=None) -> Tensor:
+    return Tensor(np.fft.fftshift(input._data, axes=dim))
+
+def ifftshift(input: Tensor, dim=None) -> Tensor:
+    return Tensor(np.fft.ifftshift(input._data, axes=dim))
+
+def fftfreq(n: int, d: float = 1.0) -> Tensor:
+    return Tensor(np.fft.fftfreq(n, d).astype(np.float32))
+
+def rfftfreq(n: int, d: float = 1.0) -> Tensor:
+    return Tensor(np.fft.rfftfreq(n, d).astype(np.float32))

vectorphile/linalg/__init__.py

@@ -0,0 +1,63 @@
+"""Linear algebra operations."""
+import numpy as np
+from vectorphile.core.tensor import Tensor
+
+
+def det(a: Tensor) -> Tensor:
+    return Tensor(np.linalg.det(a._data))
+
+def inv(a: Tensor) -> Tensor:
+    return Tensor(np.linalg.inv(a._data))
+
+def svd(a: Tensor, full_matrices=True):
+    U, S, Vh = np.linalg.svd(a._data, full_matrices=full_matrices)
+    return Tensor(U), Tensor(S), Tensor(Vh)
+
+def eig(a: Tensor):
+    vals, vecs = np.linalg.eig(a._data)
+    return Tensor(vals.real.astype(np.float32)), Tensor(vecs.real.astype(np.float32))
+
+def eigh(a: Tensor):
+    vals, vecs = np.linalg.eigh(a._data)
+    return Tensor(vals.astype(np.float32)), Tensor(vecs.astype(np.float32))
+
+def lstsq(a: Tensor, b: Tensor):
+    result = np.linalg.lstsq(a._data, b._data, rcond=None)
+    return Tensor(result[0])
+
+def solve(a: Tensor, b: Tensor) -> Tensor:
+    return Tensor(np.linalg.solve(a._data, b._data))
+
+def norm(a: Tensor, ord=None, dim=None, keepdim=False) -> Tensor:
+    return Tensor(np.linalg.norm(a._data, ord=ord, axis=dim, keepdims=keepdim))
+
+def matrix_rank(a: Tensor, tol=None) -> Tensor:
+    return Tensor(np.linalg.matrix_rank(a._data, tol=tol))
+
+def qr(a: Tensor, mode='reduced'):
+    Q, R = np.linalg.qr(a._data, mode=mode)
+    return Tensor(Q), Tensor(R)
+
+def cholesky(a: Tensor) -> Tensor:
+    return Tensor(np.linalg.cholesky(a._data))
+
+def pinv(a: Tensor) -> Tensor:
+    return Tensor(np.linalg.pinv(a._data))
+
+def trace(a: Tensor) -> Tensor:
+    return Tensor(np.trace(a._data))
+
+def matrix_power(a: Tensor, n: int) -> Tensor:
+    return Tensor(np.linalg.matrix_power(a._data, n))
+
+def cross(a: Tensor, b: Tensor, dim=-1) -> Tensor:
+    return Tensor(np.cross(a._data, b._data, axis=dim))
+
+def outer(a: Tensor, b: Tensor) -> Tensor:
+    return Tensor(np.outer(a._data, b._data))
+
+def kron(a: Tensor, b: Tensor) -> Tensor:
+    return Tensor(np.kron(a._data, b._data))
+
+def vander(x: Tensor, N=None, increasing=False) -> Tensor:
+    return Tensor(np.vander(x._data, N, increasing))

vectorphile/ml/__init__.py

@@ -0,0 +1,44 @@
+from vectorphile.ml import linear, tree, ensemble, cluster, decomposition, neighbors, naive_bayes, preprocessing, metrics, model_selection, svm
+from vectorphile.ml.linear import LinearRegression, Ridge, Lasso, ElasticNet, LogisticRegression, Perceptron
+from vectorphile.ml.tree import DecisionTreeClassifier, DecisionTreeRegressor
+from vectorphile.ml.ensemble import (
+    RandomForestClassifier, RandomForestRegressor,
+    GradientBoostingClassifier, GradientBoostingRegressor,
+)
+from vectorphile.ml.cluster import KMeans, DBSCAN, AgglomerativeClustering, GaussianMixture
+from vectorphile.ml.decomposition import PCA, TruncatedSVD, NMF, FastICA
+from vectorphile.ml.neighbors import KNeighborsClassifier, KNeighborsRegressor
+from vectorphile.ml.naive_bayes import GaussianNB, MultinomialNB, BernoulliNB
+from vectorphile.ml.svm import SVC, SVR
+from vectorphile.ml.preprocessing import (
+    StandardScaler, MinMaxScaler, RobustScaler,
+    LabelEncoder, OneHotEncoder, PolynomialFeatures,
+)
+from vectorphile.ml.metrics import (
+    accuracy_score, f1_score, precision_score, recall_score, roc_auc_score,
+    confusion_matrix, mse, rmse, mae, r2_score, silhouette_score, log_loss,
+)
+from vectorphile.ml.model_selection import (
+    train_test_split, KFold, StratifiedKFold, cross_val_score,
+    GridSearchCV, RandomizedSearchCV,
+)
+from vectorphile.ml.boost import XGBClassifier, XGBRegressor
+
+__all__ = [
+    'LinearRegression', 'Ridge', 'Lasso', 'ElasticNet', 'LogisticRegression', 'Perceptron',
+    'DecisionTreeClassifier', 'DecisionTreeRegressor',
+    'RandomForestClassifier', 'RandomForestRegressor',
+    'GradientBoostingClassifier', 'GradientBoostingRegressor',
+    'XGBClassifier', 'XGBRegressor',
+    'KMeans', 'DBSCAN', 'AgglomerativeClustering', 'GaussianMixture',
+    'PCA', 'TruncatedSVD', 'NMF', 'FastICA',
+    'KNeighborsClassifier', 'KNeighborsRegressor',
+    'GaussianNB', 'MultinomialNB', 'BernoulliNB',
+    'SVC', 'SVR',
+    'StandardScaler', 'MinMaxScaler', 'RobustScaler',
+    'LabelEncoder', 'OneHotEncoder', 'PolynomialFeatures',
+    'accuracy_score', 'f1_score', 'precision_score', 'recall_score', 'roc_auc_score',
+    'confusion_matrix', 'mse', 'rmse', 'mae', 'r2_score', 'silhouette_score', 'log_loss',
+    'train_test_split', 'KFold', 'StratifiedKFold', 'cross_val_score',
+    'GridSearchCV', 'RandomizedSearchCV',
+]

vectorphile/ml/boost/__init__.py

@@ -0,0 +1,133 @@
+"""XGBoost-style gradient boosting (pure NumPy)."""
+import numpy as np
+from typing import Optional
+from vectorphile.ml.tree import DecisionTreeRegressor
+
+
+class XGBRegressor:
+    """Extreme Gradient Boosting Regressor with second-order statistics."""
+    def __init__(self, n_estimators=100, learning_rate=0.1, max_depth=6,
+                 min_child_weight=1, gamma=0.0, reg_alpha=0.0, reg_lambda=1.0,
+                 subsample=1.0, colsample_bytree=1.0, random_state=None):
+        self.n_estimators = n_estimators
+        self.learning_rate = learning_rate
+        self.max_depth = max_depth
+        self.min_child_weight = min_child_weight
+        self.gamma = gamma
+        self.reg_alpha = reg_alpha
+        self.reg_lambda = reg_lambda
+        self.subsample = subsample
+        self.colsample_bytree = colsample_bytree
+        self.random_state = random_state
+        self.estimators_ = []
+        self.base_score_: float = 0.0
+
+    def fit(self, X, y, eval_set=None, verbose=False) -> 'XGBRegressor':
+        if self.random_state is not None:
+            np.random.seed(self.random_state)
+        X, y = np.array(X, dtype=float), np.array(y, dtype=float)
+        self.base_score_ = y.mean()
+        F = np.full(len(y), self.base_score_)
+        n, p = X.shape
+        for i in range(self.n_estimators):
+            # MSE gradient = -2*(y-F), hessian = 2 (constant for MSE)
+            g = -(y - F)  # negative gradient
+            h = np.ones_like(g)
+            # Subsample rows
+            if self.subsample < 1.0:
+                row_idx = np.random.choice(n, int(n * self.subsample), replace=False)
+                Xs, gs, hs = X[row_idx], g[row_idx], h[row_idx]
+            else:
+                Xs, gs, hs = X, g, h
+            # Subsample cols
+            if self.colsample_bytree < 1.0:
+                col_idx = np.random.choice(p, int(p * self.colsample_bytree), replace=False)
+                Xs = Xs[:, col_idx]
+            # Weight: -g/h for leaf values
+            w = -gs / (hs + self.reg_lambda)
+            tree = DecisionTreeRegressor(max_depth=self.max_depth)
+            tree.fit(Xs, w)
+            update = tree.predict(X[:, col_idx] if self.colsample_bytree < 1.0 else X)
+            F += self.learning_rate * update
+            self.estimators_.append((tree, col_idx if self.colsample_bytree < 1.0 else None))
+            if verbose and (i + 1) % 10 == 0:
+                loss = np.mean((y - F)**2)
+                print(f'[{i+1}] train-rmse={np.sqrt(loss):.4f}')
+        return self
+
+    def predict(self, X) -> np.ndarray:
+        X = np.array(X, dtype=float)
+        F = np.full(len(X), self.base_score_)
+        for tree, col_idx in self.estimators_:
+            Xs = X[:, col_idx] if col_idx is not None else X
+            F += self.learning_rate * tree.predict(Xs)
+        return F
+
+    def score(self, X, y) -> float:
+        y = np.array(y, dtype=float)
+        pred = self.predict(X)
+        ss_res = np.sum((y - pred)**2)
+        ss_tot = np.sum((y - y.mean())**2)
+        return float(1 - ss_res / (ss_tot + 1e-12))
+
+
+class XGBClassifier:
+    """Extreme Gradient Boosting Classifier."""
+    def __init__(self, n_estimators=100, learning_rate=0.1, max_depth=6,
+                 reg_lambda=1.0, subsample=1.0, random_state=None):
+        self.n_estimators = n_estimators
+        self.learning_rate = learning_rate
+        self.max_depth = max_depth
+        self.reg_lambda = reg_lambda
+        self.subsample = subsample
+        self.random_state = random_state
+        self.classes_: Optional[np.ndarray] = None
+        self.estimators_ = []
+        self.base_score_: Optional[np.ndarray] = None
+
+    def _sigmoid(self, x):
+        return 1.0 / (1.0 + np.exp(-np.clip(x, -500, 500)))
+
+    def fit(self, X, y) -> 'XGBClassifier':
+        if self.random_state is not None:
+            np.random.seed(self.random_state)
+        X, y = np.array(X, dtype=float), np.array(y)
+        self.classes_ = np.unique(y)
+        K = len(self.classes_)
+        n = len(X)
+        y_ohe = np.zeros((n, K))
+        for i, c in enumerate(self.classes_):
+            y_ohe[:, i] = (y == c).astype(float)
+        self.base_score_ = np.log(y_ohe.mean(axis=0) + 1e-12)
+        F = np.tile(self.base_score_, (n, 1)).copy()
+        self.estimators_ = []
+        for _ in range(self.n_estimators):
+            probs = self._sigmoid(F)
+            probs /= probs.sum(axis=1, keepdims=True)
+            group = []
+            for k in range(K):
+                g = -(y_ohe[:, k] - probs[:, k])
+                h = probs[:, k] * (1 - probs[:, k]) + 1e-6
+                w = -g / (h + self.reg_lambda)
+                tree = DecisionTreeRegressor(max_depth=self.max_depth)
+                tree.fit(X, w)
+                F[:, k] += self.learning_rate * tree.predict(X)
+                group.append(tree)
+            self.estimators_.append(group)
+        return self
+
+    def predict_proba(self, X) -> np.ndarray:
+        X = np.array(X, dtype=float)
+        F = np.tile(self.base_score_, (len(X), 1)).copy()
+        for group in self.estimators_:
+            for k, tree in enumerate(group):
+                F[:, k] += self.learning_rate * tree.predict(X)
+        probs = self._sigmoid(F)
+        probs /= probs.sum(axis=1, keepdims=True)
+        return probs
+
+    def predict(self, X) -> np.ndarray:
+        return self.classes_[self.predict_proba(X).argmax(axis=1)]
+
+    def score(self, X, y) -> float:
+        return float(np.mean(self.predict(X) == np.array(y)))