vectorphile 0.1.0__py3-none-any.whl

vectorphile/ml/linear.py

@@ -0,0 +1,250 @@
+"""Linear models."""
+import numpy as np
+from typing import Optional
+
+
+class _BaseLinear:
+    def __init__(self):
+        self.coef_: Optional[np.ndarray] = None
+        self.intercept_: float = 0.0
+
+    def predict(self, X) -> np.ndarray:
+        X = np.array(X)
+        return X @ self.coef_ + self.intercept_
+
+    def score(self, X, y) -> float:
+        y = np.array(y)
+        pred = self.predict(X)
+        ss_res = np.sum((y - pred) ** 2)
+        ss_tot = np.sum((y - y.mean()) ** 2)
+        return 1 - ss_res / (ss_tot + 1e-12)
+
+
+class LinearRegression(_BaseLinear):
+    def __init__(self, fit_intercept=True):
+        super().__init__()
+        self.fit_intercept = fit_intercept
+
+    def fit(self, X, y) -> 'LinearRegression':
+        X, y = np.array(X, dtype=float), np.array(y, dtype=float)
+        if self.fit_intercept:
+            X = np.c_[np.ones(len(X)), X]
+        sol, _, _, _ = np.linalg.lstsq(X, y, rcond=None)
+        if self.fit_intercept:
+            self.intercept_, self.coef_ = float(sol[0]), sol[1:]
+        else:
+            self.coef_ = sol
+        return self
+
+
+class Ridge(_BaseLinear):
+    def __init__(self, alpha=1.0, fit_intercept=True):
+        super().__init__()
+        self.alpha = alpha
+        self.fit_intercept = fit_intercept
+
+    def fit(self, X, y) -> 'Ridge':
+        X, y = np.array(X, dtype=float), np.array(y, dtype=float)
+        if self.fit_intercept:
+            X_mean, y_mean = X.mean(0), y.mean()
+            Xc = X - X_mean
+            sol = np.linalg.solve(Xc.T @ Xc + self.alpha * np.eye(Xc.shape[1]), Xc.T @ (y - y_mean))
+            self.coef_ = sol
+            self.intercept_ = float(y_mean - X_mean @ sol)
+        else:
+            sol = np.linalg.solve(X.T @ X + self.alpha * np.eye(X.shape[1]), X.T @ y)
+            self.coef_ = sol
+        return self
+
+
+class Lasso(_BaseLinear):
+    def __init__(self, alpha=1.0, max_iter=1000, tol=1e-4, fit_intercept=True):
+        super().__init__()
+        self.alpha = alpha
+        self.max_iter = max_iter
+        self.tol = tol
+        self.fit_intercept = fit_intercept
+
+    def fit(self, X, y) -> 'Lasso':
+        X, y = np.array(X, dtype=float), np.array(y, dtype=float)
+        if self.fit_intercept:
+            X_mean, y_mean = X.mean(0), y.mean()
+            X, y = X - X_mean, y - y_mean
+        n, p = X.shape
+        coef = np.zeros(p)
+        for _ in range(self.max_iter):
+            coef_old = coef.copy()
+            for j in range(p):
+                r = y - X @ coef + X[:, j] * coef[j]
+                rho = X[:, j] @ r
+                z = X[:, j] @ X[:, j]
+                if rho < -self.alpha * n / 2:
+                    coef[j] = (rho + self.alpha * n / 2) / z
+                elif rho > self.alpha * n / 2:
+                    coef[j] = (rho - self.alpha * n / 2) / z
+                else:
+                    coef[j] = 0.0
+            if np.max(np.abs(coef - coef_old)) < self.tol:
+                break
+        self.coef_ = coef
+        if self.fit_intercept:
+            self.intercept_ = float(y_mean - X_mean @ coef)
+        return self
+
+
+class ElasticNet(_BaseLinear):
+    def __init__(self, alpha=1.0, l1_ratio=0.5, max_iter=1000, tol=1e-4, fit_intercept=True):
+        super().__init__()
+        self.alpha = alpha
+        self.l1_ratio = l1_ratio
+        self.max_iter = max_iter
+        self.tol = tol
+        self.fit_intercept = fit_intercept
+
+    def fit(self, X, y) -> 'ElasticNet':
+        X, y = np.array(X, dtype=float), np.array(y, dtype=float)
+        if self.fit_intercept:
+            X_mean, y_mean = X.mean(0), y.mean()
+            X, y = X - X_mean, y - y_mean
+        n, p = X.shape
+        l1 = self.alpha * self.l1_ratio
+        l2 = self.alpha * (1 - self.l1_ratio)
+        coef = np.zeros(p)
+        for _ in range(self.max_iter):
+            coef_old = coef.copy()
+            for j in range(p):
+                r = y - X @ coef + X[:, j] * coef[j]
+                rho = X[:, j] @ r
+                z = X[:, j] @ X[:, j] + l2 * n
+                thresh = l1 * n / 2
+                if rho < -thresh:
+                    coef[j] = (rho + thresh) / z
+                elif rho > thresh:
+                    coef[j] = (rho - thresh) / z
+                else:
+                    coef[j] = 0.0
+            if np.max(np.abs(coef - coef_old)) < self.tol:
+                break
+        self.coef_ = coef
+        if self.fit_intercept:
+            self.intercept_ = float(y_mean - X_mean @ coef)
+        return self
+
+
+class LogisticRegression:
+    def __init__(self, C=1.0, max_iter=200, tol=1e-4, fit_intercept=True, multi_class='ovr'):
+        self.C = C
+        self.max_iter = max_iter
+        self.tol = tol
+        self.fit_intercept = fit_intercept
+        self.multi_class = multi_class
+        self.coef_: Optional[np.ndarray] = None
+        self.intercept_: Optional[np.ndarray] = None
+        self.classes_: Optional[np.ndarray] = None
+
+    def _sigmoid(self, z):
+        return 1.0 / (1.0 + np.exp(-np.clip(z, -500, 500)))
+
+    def _fit_binary(self, X, y, lr=0.1):
+        n, p = X.shape
+        w = np.zeros(p + (1 if self.fit_intercept else 0))
+        for _ in range(self.max_iter):
+            if self.fit_intercept:
+                z = X @ w[1:] + w[0]
+            else:
+                z = X @ w
+            prob = self._sigmoid(z)
+            error = prob - y
+            if self.fit_intercept:
+                dw = np.concatenate([[error.mean()], X.T @ error / n + w[1:] / (self.C * n)])
+            else:
+                dw = X.T @ error / n + w / (self.C * n)
+            w -= lr * dw
+            if np.max(np.abs(dw)) < self.tol:
+                break
+        return w
+
+    def fit(self, X, y) -> 'LogisticRegression':
+        X, y = np.array(X, dtype=float), np.array(y)
+        self.classes_ = np.unique(y)
+        if len(self.classes_) == 2:
+            y_bin = (y == self.classes_[1]).astype(float)
+            w = self._fit_binary(X, y_bin)
+            if self.fit_intercept:
+                self.coef_ = w[1:][np.newaxis]
+                self.intercept_ = np.array([w[0]])
+            else:
+                self.coef_ = w[np.newaxis]
+                self.intercept_ = np.array([0.0])
+        else:
+            self.coef_ = []
+            self.intercept_ = []
+            for cls in self.classes_:
+                y_bin = (y == cls).astype(float)
+                w = self._fit_binary(X, y_bin)
+                if self.fit_intercept:
+                    self.coef_.append(w[1:])
+                    self.intercept_.append(w[0])
+                else:
+                    self.coef_.append(w)
+                    self.intercept_.append(0.0)
+            self.coef_ = np.array(self.coef_)
+            self.intercept_ = np.array(self.intercept_)
+        return self
+
+    def predict_proba(self, X) -> np.ndarray:
+        X = np.array(X, dtype=float)
+        logits = X @ self.coef_.T + self.intercept_
+        probs = self._sigmoid(logits)
+        if probs.ndim == 1 or probs.shape[1] == 1:
+            p = probs.flatten()
+            return np.c_[1 - p, p]
+        probs = probs / probs.sum(axis=1, keepdims=True)
+        return probs
+
+    def predict(self, X) -> np.ndarray:
+        proba = self.predict_proba(X)
+        return self.classes_[np.argmax(proba, axis=1)]
+
+    def score(self, X, y) -> float:
+        return float(np.mean(self.predict(X) == np.array(y)))
+
+
+class Perceptron:
+    def __init__(self, max_iter=1000, tol=1e-3, eta=1.0, fit_intercept=True):
+        self.max_iter = max_iter
+        self.tol = tol
+        self.eta = eta
+        self.fit_intercept = fit_intercept
+        self.coef_: Optional[np.ndarray] = None
+        self.intercept_: float = 0.0
+
+    def fit(self, X, y) -> 'Perceptron':
+        X, y = np.array(X, dtype=float), np.array(y)
+        classes = np.unique(y)
+        y_bin = np.where(y == classes[0], -1, 1)
+        n, p = X.shape
+        w = np.zeros(p)
+        b = 0.0
+        for _ in range(self.max_iter):
+            errors = 0
+            for xi, yi in zip(X, y_bin):
+                pred = np.sign(np.dot(w, xi) + b)
+                if pred != yi:
+                    w += self.eta * yi * xi
+                    b += self.eta * yi
+                    errors += 1
+            if errors == 0:
+                break
+        self.coef_ = w
+        self.intercept_ = b
+        self.classes_ = classes
+        return self
+
+    def predict(self, X) -> np.ndarray:
+        X = np.array(X, dtype=float)
+        raw = np.sign(X @ self.coef_ + self.intercept_)
+        return np.where(raw <= 0, self.classes_[0], self.classes_[1])
+
+    def score(self, X, y) -> float:
+        return float(np.mean(self.predict(X) == np.array(y)))

vectorphile/ml/metrics.py

@@ -0,0 +1,148 @@
+"""Evaluation metrics."""
+import numpy as np
+from typing import Optional
+
+
+def accuracy_score(y_true, y_pred, normalize=True) -> float:
+    y_true, y_pred = np.array(y_true), np.array(y_pred)
+    correct = (y_true == y_pred).sum()
+    return float(correct / len(y_true)) if normalize else int(correct)
+
+
+def confusion_matrix(y_true, y_pred, labels=None) -> np.ndarray:
+    y_true, y_pred = np.array(y_true), np.array(y_pred)
+    classes = labels if labels is not None else np.unique(np.concatenate([y_true, y_pred]))
+    K = len(classes)
+    cm = np.zeros((K, K), dtype=int)
+    class_map = {c: i for i, c in enumerate(classes)}
+    for t, p in zip(y_true, y_pred):
+        cm[class_map[t], class_map[p]] += 1
+    return cm
+
+
+def precision_score(y_true, y_pred, average='binary', labels=None, zero_division=0) -> float:
+    y_true, y_pred = np.array(y_true), np.array(y_pred)
+    classes = labels or np.unique(np.concatenate([y_true, y_pred]))
+    precisions = []
+    for c in classes:
+        tp = ((y_pred == c) & (y_true == c)).sum()
+        fp = ((y_pred == c) & (y_true != c)).sum()
+        denom = tp + fp
+        precisions.append(tp / denom if denom > 0 else zero_division)
+    if average == 'micro':
+        tps = sum((y_pred == c) & (y_true == c) for c in classes).sum()
+        fps = sum((y_pred == c) & (y_true != c) for c in classes).sum()
+        return float(tps / (tps + fps)) if (tps + fps) > 0 else zero_division
+    if average == 'macro':
+        return float(np.mean(precisions))
+    if average == 'weighted':
+        weights = [(y_true == c).sum() for c in classes]
+        return float(np.average(precisions, weights=weights))
+    return float(precisions[0]) if len(precisions) == 1 else float(precisions[-1])
+
+
+def recall_score(y_true, y_pred, average='binary', labels=None, zero_division=0) -> float:
+    y_true, y_pred = np.array(y_true), np.array(y_pred)
+    classes = labels or np.unique(np.concatenate([y_true, y_pred]))
+    recalls = []
+    for c in classes:
+        tp = ((y_pred == c) & (y_true == c)).sum()
+        fn = ((y_pred != c) & (y_true == c)).sum()
+        denom = tp + fn
+        recalls.append(tp / denom if denom > 0 else zero_division)
+    if average == 'macro':
+        return float(np.mean(recalls))
+    if average == 'weighted':
+        weights = [(y_true == c).sum() for c in classes]
+        return float(np.average(recalls, weights=weights))
+    return float(recalls[-1])
+
+
+def f1_score(y_true, y_pred, average='binary', labels=None, zero_division=0) -> float:
+    p = precision_score(y_true, y_pred, average=average, labels=labels, zero_division=zero_division)
+    r = recall_score(y_true, y_pred, average=average, labels=labels, zero_division=zero_division)
+    return float(2 * p * r / (p + r)) if (p + r) > 0 else zero_division
+
+
+def roc_auc_score(y_true, y_score, average='macro') -> float:
+    y_true, y_score = np.array(y_true), np.array(y_score)
+    if y_score.ndim == 1:
+        return _roc_auc_binary(y_true, y_score)
+    classes = np.unique(y_true)
+    aucs = [_roc_auc_binary((y_true == c).astype(int), y_score[:, i]) for i, c in enumerate(classes)]
+    return float(np.mean(aucs))
+
+
+def _roc_auc_binary(y_true, y_score) -> float:
+    pos = y_true.sum()
+    neg = len(y_true) - pos
+    if pos == 0 or neg == 0:
+        return 0.5
+    order = np.argsort(y_score)[::-1]
+    y_sorted = y_true[order]
+    tpr = np.cumsum(y_sorted) / pos
+    fpr = np.cumsum(1 - y_sorted) / neg
+    tpr = np.concatenate([[0], tpr])
+    fpr = np.concatenate([[0], fpr])
+    return float(np.trapz(tpr, fpr))
+
+
+def mse(y_true, y_pred) -> float:
+    y_true, y_pred = np.array(y_true, dtype=float), np.array(y_pred, dtype=float)
+    return float(np.mean((y_true - y_pred)**2))
+
+
+def rmse(y_true, y_pred) -> float:
+    return float(np.sqrt(mse(y_true, y_pred)))
+
+
+def mae(y_true, y_pred) -> float:
+    y_true, y_pred = np.array(y_true, dtype=float), np.array(y_pred, dtype=float)
+    return float(np.mean(np.abs(y_true - y_pred)))
+
+
+def r2_score(y_true, y_pred) -> float:
+    y_true, y_pred = np.array(y_true, dtype=float), np.array(y_pred, dtype=float)
+    ss_res = np.sum((y_true - y_pred)**2)
+    ss_tot = np.sum((y_true - y_true.mean())**2)
+    return float(1 - ss_res / (ss_tot + 1e-12))
+
+
+def mean_absolute_percentage_error(y_true, y_pred) -> float:
+    y_true, y_pred = np.array(y_true, dtype=float), np.array(y_pred, dtype=float)
+    mask = y_true != 0
+    return float(np.mean(np.abs((y_true[mask] - y_pred[mask]) / y_true[mask])))
+
+
+def silhouette_score(X, labels) -> float:
+    X, labels = np.array(X, dtype=float), np.array(labels)
+    n = len(X)
+    unique_labels = np.unique(labels)
+    scores = []
+    for i in range(n):
+        same = X[labels == labels[i]]
+        a = np.mean(np.linalg.norm(same - X[i], axis=1)) if len(same) > 1 else 0.0
+        b_vals = []
+        for c in unique_labels:
+            if c == labels[i]:
+                continue
+            other = X[labels == c]
+            if len(other) > 0:
+                b_vals.append(np.mean(np.linalg.norm(other - X[i], axis=1)))
+        b = min(b_vals) if b_vals else 0.0
+        s = (b - a) / max(a, b) if max(a, b) > 0 else 0.0
+        scores.append(s)
+    return float(np.mean(scores))
+
+
+def log_loss(y_true, y_pred, eps=1e-15) -> float:
+    y_true = np.array(y_true)
+    y_pred = np.clip(np.array(y_pred, dtype=float), eps, 1 - eps)
+    if y_pred.ndim == 1:
+        return float(-np.mean(y_true * np.log(y_pred) + (1 - y_true) * np.log(1 - y_pred)))
+    n = len(y_true)
+    classes = np.unique(y_true)
+    y_ohe = np.zeros((n, len(classes)))
+    for i, c in enumerate(classes):
+        y_ohe[:, i] = (y_true == c)
+    return float(-np.mean(np.sum(y_ohe * np.log(y_pred), axis=1)))

vectorphile/ml/model_selection.py

@@ -0,0 +1,171 @@
+"""Model selection and validation utilities."""
+import numpy as np
+from typing import Any, Callable, Dict, List, Optional, Tuple, Union
+
+
+def train_test_split(*arrays, test_size=0.2, random_state=None, shuffle=True, stratify=None):
+    if random_state is not None:
+        np.random.seed(random_state)
+    n = len(arrays[0])
+    n_test = int(n * test_size)
+    if shuffle:
+        idx = np.random.permutation(n)
+    else:
+        idx = np.arange(n)
+    test_idx = idx[:n_test]
+    train_idx = idx[n_test:]
+    result = []
+    for arr in arrays:
+        arr = np.array(arr)
+        result.append(arr[train_idx])
+        result.append(arr[test_idx])
+    return result
+
+
+class KFold:
+    def __init__(self, n_splits=5, shuffle=False, random_state=None):
+        self.n_splits = n_splits
+        self.shuffle = shuffle
+        self.random_state = random_state
+
+    def split(self, X, y=None):
+        X = np.array(X)
+        n = len(X)
+        idx = np.arange(n)
+        if self.shuffle:
+            if self.random_state is not None:
+                np.random.seed(self.random_state)
+            np.random.shuffle(idx)
+        fold_sizes = np.full(self.n_splits, n // self.n_splits, dtype=int)
+        fold_sizes[:n % self.n_splits] += 1
+        current = 0
+        for fold_size in fold_sizes:
+            start, stop = current, current + fold_size
+            test_idx = idx[start:stop]
+            train_idx = np.concatenate([idx[:start], idx[stop:]])
+            yield train_idx, test_idx
+            current = stop
+
+    def get_n_splits(self):
+        return self.n_splits
+
+
+class StratifiedKFold:
+    def __init__(self, n_splits=5, shuffle=False, random_state=None):
+        self.n_splits = n_splits
+        self.shuffle = shuffle
+        self.random_state = random_state
+
+    def split(self, X, y):
+        X, y = np.array(X), np.array(y)
+        classes, y_indices = np.unique(y, return_inverse=True)
+        rng = np.random.RandomState(self.random_state) if self.random_state else np.random.RandomState()
+        folds = [[] for _ in range(self.n_splits)]
+        for cls_idx in range(len(classes)):
+            class_indices = np.where(y_indices == cls_idx)[0]
+            if self.shuffle:
+                rng.shuffle(class_indices)
+            for i, idx in enumerate(class_indices):
+                folds[i % self.n_splits].append(idx)
+        for fold_i in range(self.n_splits):
+            test_idx = np.array(folds[fold_i])
+            train_idx = np.concatenate([np.array(folds[j]) for j in range(self.n_splits) if j != fold_i])
+            yield train_idx, test_idx
+
+
+def cross_val_score(estimator, X, y, cv=5, scoring='accuracy') -> np.ndarray:
+    X, y = np.array(X), np.array(y)
+    kf = KFold(n_splits=cv, shuffle=True, random_state=42)
+    scores = []
+    for train_idx, test_idx in kf.split(X):
+        X_train, X_test = X[train_idx], X[test_idx]
+        y_train, y_test = y[train_idx], y[test_idx]
+        estimator.fit(X_train, y_train)
+        if scoring == 'accuracy' or scoring == 'r2':
+            scores.append(estimator.score(X_test, y_test))
+        else:
+            scores.append(estimator.score(X_test, y_test))
+    return np.array(scores)
+
+
+class GridSearchCV:
+    def __init__(self, estimator, param_grid: Dict, cv=5, scoring='accuracy', refit=True, n_jobs=1):
+        self.estimator = estimator
+        self.param_grid = param_grid
+        self.cv = cv
+        self.scoring = scoring
+        self.refit = refit
+        self.n_jobs = n_jobs
+        self.best_params_: Optional[Dict] = None
+        self.best_score_: float = -np.inf
+        self.best_estimator_ = None
+        self.cv_results_: Dict = {}
+
+    def _param_combinations(self):
+        from itertools import product
+        keys = list(self.param_grid.keys())
+        values = list(self.param_grid.values())
+        for combo in product(*values):
+            yield dict(zip(keys, combo))
+
+    def fit(self, X, y) -> 'GridSearchCV':
+        X, y = np.array(X), np.array(y)
+        results = []
+        for params in self._param_combinations():
+            est = type(self.estimator)(**{**self.estimator.__dict__, **params})
+            scores = cross_val_score(est, X, y, cv=self.cv, scoring=self.scoring)
+            mean_score = scores.mean()
+            results.append({'params': params, 'mean_test_score': mean_score, 'std_test_score': scores.std()})
+            if mean_score > self.best_score_:
+                self.best_score_ = mean_score
+                self.best_params_ = params
+        self.cv_results_ = {k: [r[k] for r in results] for k in results[0]}
+        if self.refit:
+            self.best_estimator_ = type(self.estimator)(**{**self.estimator.__dict__, **self.best_params_})
+            self.best_estimator_.fit(X, y)
+        return self
+
+    def predict(self, X) -> np.ndarray:
+        return self.best_estimator_.predict(X)
+
+    def score(self, X, y) -> float:
+        return self.best_estimator_.score(X, y)
+
+
+class RandomizedSearchCV:
+    def __init__(self, estimator, param_distributions: Dict, n_iter=10, cv=5,
+                 scoring='accuracy', refit=True, random_state=None):
+        self.estimator = estimator
+        self.param_distributions = param_distributions
+        self.n_iter = n_iter
+        self.cv = cv
+        self.scoring = scoring
+        self.refit = refit
+        self.random_state = random_state
+        self.best_params_: Optional[Dict] = None
+        self.best_score_: float = -np.inf
+        self.best_estimator_ = None
+
+    def fit(self, X, y) -> 'RandomizedSearchCV':
+        if self.random_state is not None:
+            np.random.seed(self.random_state)
+        X, y = np.array(X), np.array(y)
+        for _ in range(self.n_iter):
+            params = {k: np.random.choice(v) if isinstance(v, (list, np.ndarray))
+                      else float(np.random.uniform(*v)) for k, v in self.param_distributions.items()}
+            try:
+                est = type(self.estimator)(**{**self.estimator.__dict__, **params})
+                scores = cross_val_score(est, X, y, cv=self.cv, scoring=self.scoring)
+                mean_score = scores.mean()
+                if mean_score > self.best_score_:
+                    self.best_score_ = mean_score
+                    self.best_params_ = params
+            except Exception:
+                continue
+        if self.refit and self.best_params_ is not None:
+            self.best_estimator_ = type(self.estimator)(**{**self.estimator.__dict__, **self.best_params_})
+            self.best_estimator_.fit(X, y)
+        return self
+
+    def predict(self, X) -> np.ndarray:
+        return self.best_estimator_.predict(X)

vectorphile/ml/naive_bayes.py

@@ -0,0 +1,113 @@
+"""Naive Bayes classifiers."""
+import numpy as np
+from typing import Optional
+
+
+class GaussianNB:
+    def __init__(self, var_smoothing=1e-9):
+        self.var_smoothing = var_smoothing
+        self.classes_: Optional[np.ndarray] = None
+        self.theta_: Optional[np.ndarray] = None
+        self.var_: Optional[np.ndarray] = None
+        self.class_prior_: Optional[np.ndarray] = None
+
+    def fit(self, X, y) -> 'GaussianNB':
+        X, y = np.array(X, dtype=float), np.array(y)
+        self.classes_ = np.unique(y)
+        self.theta_ = np.array([X[y == c].mean(axis=0) for c in self.classes_])
+        self.var_ = np.array([X[y == c].var(axis=0) for c in self.classes_])
+        max_var = self.var_.max()
+        self.var_ += self.var_smoothing * max_var
+        counts = np.array([(y == c).sum() for c in self.classes_])
+        self.class_prior_ = counts / len(y)
+        return self
+
+    def _log_likelihood(self, X):
+        log_probs = []
+        for k in range(len(self.classes_)):
+            log_prior = np.log(self.class_prior_[k])
+            diff = X - self.theta_[k]
+            log_lk = -0.5 * np.sum(np.log(2 * np.pi * self.var_[k]) + diff**2 / self.var_[k], axis=1)
+            log_probs.append(log_prior + log_lk)
+        return np.array(log_probs).T
+
+    def predict(self, X) -> np.ndarray:
+        return self.classes_[self._log_likelihood(np.array(X, dtype=float)).argmax(axis=1)]
+
+    def predict_proba(self, X) -> np.ndarray:
+        log_probs = self._log_likelihood(np.array(X, dtype=float))
+        log_probs -= log_probs.max(axis=1, keepdims=True)
+        probs = np.exp(log_probs)
+        return probs / probs.sum(axis=1, keepdims=True)
+
+    def score(self, X, y) -> float:
+        return float(np.mean(self.predict(X) == np.array(y)))
+
+
+class MultinomialNB:
+    def __init__(self, alpha=1.0):
+        self.alpha = alpha
+        self.classes_: Optional[np.ndarray] = None
+        self.feature_log_prob_: Optional[np.ndarray] = None
+        self.class_log_prior_: Optional[np.ndarray] = None
+
+    def fit(self, X, y) -> 'MultinomialNB':
+        X, y = np.array(X, dtype=float), np.array(y)
+        self.classes_ = np.unique(y)
+        K, p = len(self.classes_), X.shape[1]
+        smoothed = np.array([X[y == c].sum(axis=0) + self.alpha for c in self.classes_])
+        self.feature_log_prob_ = np.log(smoothed / smoothed.sum(axis=1, keepdims=True))
+        counts = np.array([(y == c).sum() for c in self.classes_])
+        self.class_log_prior_ = np.log(counts / len(y))
+        return self
+
+    def predict(self, X) -> np.ndarray:
+        X = np.array(X, dtype=float)
+        log_probs = X @ self.feature_log_prob_.T + self.class_log_prior_
+        return self.classes_[log_probs.argmax(axis=1)]
+
+    def predict_proba(self, X) -> np.ndarray:
+        X = np.array(X, dtype=float)
+        log_probs = X @ self.feature_log_prob_.T + self.class_log_prior_
+        log_probs -= log_probs.max(axis=1, keepdims=True)
+        probs = np.exp(log_probs)
+        return probs / probs.sum(axis=1, keepdims=True)
+
+    def score(self, X, y) -> float:
+        return float(np.mean(self.predict(X) == np.array(y)))
+
+
+class BernoulliNB:
+    def __init__(self, alpha=1.0, binarize=0.0):
+        self.alpha = alpha
+        self.binarize = binarize
+        self.classes_: Optional[np.ndarray] = None
+        self.feature_log_prob_: Optional[np.ndarray] = None
+        self.class_log_prior_: Optional[np.ndarray] = None
+
+    def fit(self, X, y) -> 'BernoulliNB':
+        X = np.array(X, dtype=float)
+        if self.binarize is not None:
+            X = (X > self.binarize).astype(float)
+        y = np.array(y)
+        self.classes_ = np.unique(y)
+        K = len(self.classes_)
+        smoothed_pos = np.array([X[y == c].sum(axis=0) + self.alpha for c in self.classes_])
+        smoothed_tot = np.array([(y == c).sum() + 2 * self.alpha for c in self.classes_])
+        prob = smoothed_pos / smoothed_tot[:, None]
+        self.feature_log_prob_ = np.log(prob)
+        self._feature_log_prob_neg = np.log(1 - prob)
+        counts = np.array([(y == c).sum() for c in self.classes_])
+        self.class_log_prior_ = np.log(counts / len(y))
+        return self
+
+    def predict(self, X) -> np.ndarray:
+        X = np.array(X, dtype=float)
+        if self.binarize is not None:
+            X = (X > self.binarize).astype(float)
+        log_probs = (X @ self.feature_log_prob_.T +
+                     (1 - X) @ self._feature_log_prob_neg.T + self.class_log_prior_)
+        return self.classes_[log_probs.argmax(axis=1)]
+
+    def score(self, X, y) -> float:
+        return float(np.mean(self.predict(X) == np.array(y)))