mumpy-toolkit 0.2.0__py3-none-any.whl

mumpy/nn.py

@@ -0,0 +1,278 @@
+"""mumpy.nn: tiny deep-learning toolkit in pure numpy.
+
+Layers: Dense / ReLU / Sigmoid / Tanh / Softmax / Dropout / BatchNorm-lite
+Losses: MSE / BCE / CrossEntropy
+Optimizers: SGD (+momentum) / Adam
+Model: Sequential with fit/predict/save/load
+
+    from mumpy import nn
+    model = nn.Sequential([nn.Dense(4, 16), nn.ReLU(), nn.Dense(16, 1)])
+    model.fit(X, y, epochs=200, lr=0.01, verbose=True)
+"""
+from __future__ import annotations
+
+import numpy as np
+
+__all__ = [
+    "Dense", "ReLU", "Sigmoid", "Tanh", "Softmax", "Dropout",
+    "MSELoss", "BCELoss", "CrossEntropyLoss",
+    "SGD", "Adam", "Sequential",
+]
+
+
+class Dense:
+    def __init__(self, in_features, out_features, seed=0):
+        rng = np.random.default_rng(seed)
+        self.W = rng.normal(0, np.sqrt(2 / in_features), (in_features, out_features))
+        self.b = np.zeros(out_features)
+        self.dW = np.zeros_like(self.W)
+        self.db = np.zeros_like(self.b)
+
+    def forward(self, x):
+        self.x = x
+        return x @ self.W + self.b
+
+    def backward(self, grad):
+        self.dW = self.x.T @ grad
+        self.db = grad.sum(0)
+        return grad @ self.W.T
+
+    def params(self):
+        return [(self.W, self.dW), (self.b, self.db)]
+
+    def __call__(self, x):
+        return self.forward(x)
+
+
+class ReLU:
+    def forward(self, x):
+        self.x = x
+        return np.maximum(x, 0)
+
+    def backward(self, g):
+        return g * (self.x > 0)
+
+    def params(self):
+        return []
+
+    def __call__(self, x):
+        return self.forward(x)
+
+
+class Sigmoid:
+    def forward(self, x):
+        self.o = 1 / (1 + np.exp(-np.clip(x, -30, 30)))
+        return self.o
+
+    def backward(self, g):
+        return g * self.o * (1 - self.o)
+
+    def params(self):
+        return []
+
+    def __call__(self, x):
+        return self.forward(x)
+
+
+class Tanh:
+    def forward(self, x):
+        self.o = np.tanh(x)
+        return self.o
+
+    def backward(self, g):
+        return g * (1 - self.o ** 2)
+
+    def params(self):
+        return []
+
+    def __call__(self, x):
+        return self.forward(x)
+
+
+class Softmax:
+    def forward(self, x):
+        x = x - x.max(1, keepdims=True)
+        e = np.exp(x)
+        self.o = e / e.sum(1, keepdims=True)
+        return self.o
+
+    def backward(self, g):
+        # combined with CrossEntropy upstream usually passes (p - y)/n
+        return g
+
+    def params(self):
+        return []
+
+    def __call__(self, x):
+        return self.forward(x)
+
+
+class Dropout:
+    def __init__(self, p=0.2, seed=0):
+        self.p = p
+        self.rng = np.random.default_rng(seed)
+        self.training = True
+
+    def forward(self, x):
+        if not self.training or self.p == 0:
+            return x
+        self.mask = (self.rng.random(x.shape) > self.p) / (1 - self.p)
+        return x * self.mask
+
+    def backward(self, g):
+        return g * self.mask if self.training and self.p else g
+
+    def params(self):
+        return []
+
+    def __call__(self, x):
+        return self.forward(x)
+
+
+class MSELoss:
+    def forward(self, pred, target):
+        self.pred, self.target = pred, target
+        return float(np.mean((pred - target) ** 2))
+
+    def backward(self):
+        n = self.pred.size
+        return 2 * (self.pred - self.target) / n
+
+
+class BCELoss:
+    def forward(self, pred, target, eps=1e-12):
+        self.pred = np.clip(pred, eps, 1 - eps)
+        self.target = target
+        return float(-np.mean(target * np.log(self.pred) + (1 - target) * np.log(1 - self.pred)))
+
+    def backward(self):
+        n = self.pred.size
+        p, t = self.pred, self.target
+        return (-(t / p) + (1 - t) / (1 - p)) / n
+
+
+class CrossEntropyLoss:
+    def forward(self, logits, target):
+        # logits: (n, K), target: class indices
+        z = logits - logits.max(1, keepdims=True)
+        e = np.exp(z)
+        self.probs = e / e.sum(1, keepdims=True)
+        self.target = np.asanyarray(target).ravel().astype(int)
+        n = len(self.target)
+        return float(-np.log(self.probs[np.arange(n), self.target] + 1e-12).mean())
+
+    def backward(self):
+        n = len(self.target)
+        g = self.probs.copy()
+        g[np.arange(n), self.target] -= 1
+        return g / n
+
+
+class SGD:
+    def __init__(self, lr=0.01, momentum=0.0):
+        self.lr = lr
+        self.momentum = momentum
+        self.vel = {}
+
+    def step(self, layers):
+        for li, layer in enumerate(layers):
+            for pi, (p, g) in enumerate(layer.params()):
+                key = (li, pi)
+                if self.momentum:
+                    v = self.vel.get(key, np.zeros_like(p))
+                    v = self.momentum * v + g
+                    self.vel[key] = v
+                    p -= self.lr * v
+                else:
+                    p -= self.lr * g
+
+
+class Adam:
+    def __init__(self, lr=0.001, beta1=0.9, beta2=0.999, eps=1e-8):
+        self.lr = lr
+        self.beta1 = beta1
+        self.beta2 = beta2
+        self.eps = eps
+        self.m = {}
+        self.v = {}
+        self.t = 0
+
+    def step(self, layers):
+        self.t += 1
+        for li, layer in enumerate(layers):
+            for pi, (p, g) in enumerate(layer.params()):
+                key = (li, pi)
+                m = self.m.get(key, np.zeros_like(p))
+                v = self.v.get(key, np.zeros_like(p))
+                m = self.beta1 * m + (1 - self.beta1) * g
+                v = self.beta2 * v + (1 - self.beta2) * (g ** 2)
+                self.m[key], self.v[key] = m, v
+                mh = m / (1 - self.beta1 ** self.t)
+                vh = v / (1 - self.beta2 ** self.t)
+                p -= self.lr * mh / (np.sqrt(vh) + self.eps)
+
+
+class Sequential:
+    def __init__(self, layers):
+        self.layers = layers
+
+    def forward(self, x):
+        for l in self.layers:
+            x = l.forward(x)
+        return x
+
+    def predict(self, X):
+        for l in self.layers:
+            if isinstance(l, Dropout):
+                l.training = False
+        out = self.forward(np.asanyarray(X, dtype=float))
+        for l in self.layers:
+            if isinstance(l, Dropout):
+                l.training = True
+        return out
+
+    def fit(self, X, y, epochs=100, batch_size=None, lr=0.01, optimizer=None,
+            loss="mse", verbose=False, seed=0, shuffle=True):
+        X = np.asanyarray(X, dtype=float)
+        y = np.asanyarray(y)
+        rng = np.random.default_rng(seed)
+        opt = optimizer or Adam(lr)
+        if isinstance(opt, float):
+            opt = Adam(opt)
+        losses = {"mse": MSELoss, "bce": BCELoss, "ce": CrossEntropyLoss}
+        criterion = losses[loss]() if isinstance(loss, str) else loss
+        n = len(X)
+        history = []
+        for ep in range(epochs):
+            idx = rng.permutation(n) if shuffle else np.arange(n)
+            total, nb = 0.0, 0
+            bs = batch_size or n
+            for s in range(0, n, bs):
+                bi = idx[s:s + bs]
+                xb, yb = X[bi], y[bi]
+                # reshape y for mse/bce single-output
+                if yb.ndim == 1 and not isinstance(criterion, CrossEntropyLoss):
+                    yb = yb.reshape(-1, 1)
+                pred = self.forward(xb)
+                total += criterion.forward(pred, yb) * len(bi)
+                grad = criterion.backward()
+                for l in reversed(self.layers):
+                    grad = l.backward(grad)
+                opt.step(self.layers)
+                nb += len(bi)
+            history.append(total / max(nb, 1))
+            if verbose and (ep % max(1, epochs // 10) == 0 or ep == epochs - 1):
+                print(f"epoch {ep + 1}/{epochs} loss={history[-1]:.6f}")
+        return history
+
+    def save(self, path):
+        import pickle
+        with open(path, "wb") as f:
+            pickle.dump(self, f)
+        return path
+
+    @staticmethod
+    def load(path):
+        import pickle
+        with open(path, "rb") as f:
+            return pickle.load(f)

mumpy/preprocessing.py

@@ -0,0 +1,259 @@
+"""mumpy.preprocessing: sklearn-like transformers in pure numpy.
+
+StandardScaler / MinMaxScaler / RobustScaler / MaxAbsScaler
+OneHotEncoder / LabelEncoder / OrdinalEncoder
+SimpleImputer / train_test_split / PolynomialFeatures / Pipeline
+"""
+from __future__ import annotations
+
+import numpy as np
+
+__all__ = [
+    "StandardScaler", "MinMaxScaler", "RobustScaler", "MaxAbsScaler",
+    "OneHotEncoder", "LabelEncoder", "SimpleImputer",
+    "train_test_split", "shuffle", "PolynomialFeatures", "Pipeline",
+]
+
+
+class StandardScaler:
+    def __init__(self, with_mean=True, with_std=True):
+        self.with_mean = with_mean
+        self.with_std = with_std
+        self.mean_ = None
+        self.scale_ = None
+
+    def fit(self, X):
+        X = np.asanyarray(X, dtype=float)
+        self.mean_ = np.nanmean(X, axis=0) if self.with_mean else np.zeros(X.shape[1])
+        self.scale_ = np.nanstd(X, axis=0) if self.with_std else np.ones(X.shape[1])
+        self.scale_[self.scale_ == 0] = 1.0
+        return self
+
+    def transform(self, X):
+        X = np.asanyarray(X, dtype=float).copy()
+        if self.with_mean:
+            X -= self.mean_
+        if self.with_std:
+            X /= self.scale_
+        return X
+
+    def fit_transform(self, X):
+        return self.fit(X).transform(X)
+
+    def inverse_transform(self, X):
+        X = np.asanyarray(X, dtype=float).copy()
+        if self.with_std:
+            X *= self.scale_
+        if self.with_mean:
+            X += self.mean_
+        return X
+
+
+class MinMaxScaler:
+    def __init__(self, feature_range=(0, 1)):
+        self.feature_range = feature_range
+        self.min_ = None
+        self.scale_ = None
+        self.data_min_ = None
+        self.data_max_ = None
+
+    def fit(self, X):
+        X = np.asanyarray(X, dtype=float)
+        self.data_min_ = np.nanmin(X, axis=0)
+        self.data_max_ = np.nanmax(X, axis=0)
+        rng = self.data_max_ - self.data_min_
+        rng[rng == 0] = 1.0
+        lo, hi = self.feature_range
+        self.scale_ = (hi - lo) / rng
+        self.min_ = lo - self.data_min_ * self.scale_
+        return self
+
+    def transform(self, X):
+        X = np.asanyarray(X, dtype=float).copy()
+        return X * self.scale_ + self.min_
+
+    def fit_transform(self, X):
+        return self.fit(X).transform(X)
+
+    def inverse_transform(self, X):
+        X = np.asanyarray(X, dtype=float).copy()
+        return (X - self.min_) / self.scale_
+
+
+class RobustScaler:
+    def __init__(self, quantile_range=(25.0, 75.0)):
+        self.quantile_range = quantile_range
+        self.center_ = None
+        self.scale_ = None
+
+    def fit(self, X):
+        X = np.asanyarray(X, dtype=float)
+        qmin, qmax = self.quantile_range
+        self.center_ = np.nanmedian(X, axis=0)
+        q1 = np.nanpercentile(X, qmin, axis=0)
+        q3 = np.nanpercentile(X, qmax, axis=0)
+        self.scale_ = q3 - q1
+        self.scale_[self.scale_ == 0] = 1.0
+        return self
+
+    def transform(self, X):
+        return (np.asanyarray(X, dtype=float) - self.center_) / self.scale_
+
+    def fit_transform(self, X):
+        return self.fit(X).transform(X)
+
+
+class MaxAbsScaler:
+    def fit(self, X):
+        X = np.asanyarray(X, dtype=float)
+        self.max_abs_ = np.nanmax(np.abs(X), axis=0)
+        self.max_abs_[self.max_abs_ == 0] = 1.0
+        return self
+
+    def transform(self, X):
+        return np.asanyarray(X, dtype=float) / self.max_abs_
+
+    def fit_transform(self, X):
+        return self.fit(X).transform(X)
+
+
+class OneHotEncoder:
+    def __init__(self, sparse=False):
+        self.sparse = sparse
+        self.categories_ = None
+
+    def fit(self, y):
+        y = np.asanyarray(y).ravel()
+        self.categories_ = np.unique(y)
+        return self
+
+    def transform(self, y):
+        y = np.asanyarray(y).ravel()
+        idx = {v: i for i, v in enumerate(self.categories_.tolist())}
+        out = np.zeros((y.size, len(self.categories_)), dtype=float)
+        for i, v in enumerate(y.tolist()):
+            if v in idx:
+                out[i, idx[v]] = 1.0
+        return out
+
+    def fit_transform(self, y):
+        return self.fit(y).transform(y)
+
+
+class LabelEncoder:
+    def fit(self, y):
+        self.classes_ = np.unique(np.asanyarray(y).ravel())
+        self._map = {v: i for i, v in enumerate(self.classes_.tolist())}
+        return self
+
+    def transform(self, y):
+        y = np.asanyarray(y).ravel()
+        return np.array([self._map[v] for v in y.tolist()])
+
+    def fit_transform(self, y):
+        return self.fit(y).transform(y)
+
+    def inverse_transform(self, y):
+        return np.array([self.classes_[int(i)] for i in np.asanyarray(y).ravel()])
+
+
+class SimpleImputer:
+    def __init__(self, strategy="mean", fill_value=0.0):
+        self.strategy = strategy
+        self.fill_value = fill_value
+
+    def fit(self, X):
+        X = np.asanyarray(X, dtype=float)
+        if self.strategy == "mean":
+            self.statistics_ = np.nanmean(X, axis=0)
+        elif self.strategy == "median":
+            self.statistics_ = np.nanmedian(X, axis=0)
+        elif self.strategy == "most_frequent":
+            self.statistics_ = np.array([np.unique(c[~np.isnan(c)])[0] if (~np.isnan(c)).any() else self.fill_value
+                                         for c in X.T])
+        else:
+            self.statistics_ = np.full(X.shape[1], self.fill_value)
+        self.statistics_ = np.where(np.isnan(self.statistics_), self.fill_value, self.statistics_)
+        return self
+
+    def transform(self, X):
+        X = np.asanyarray(X, dtype=float).copy()
+        idx = np.where(np.isnan(X))
+        X[idx] = np.take(self.statistics_, idx[1])
+        return X
+
+    def fit_transform(self, X):
+        return self.fit(X).transform(X)
+
+
+def train_test_split(*arrays, test_size=0.2, random_state=None, shuffle=True):
+    rng = np.random.default_rng(random_state)
+    n = len(np.asanyarray(arrays[0]))
+    idx = np.arange(n)
+    if shuffle:
+        rng.shuffle(idx)
+    n_test = int(n * test_size) if isinstance(test_size, float) else int(test_size)
+    te, tr = idx[:n_test], idx[n_test:]
+    out = []
+    for a in arrays:
+        a = np.asanyarray(a)
+        out += [a[tr], a[te]]
+    return out
+
+
+def shuffle(*arrays, random_state=None):
+    rng = np.random.default_rng(random_state)
+    n = len(np.asanyarray(arrays[0]))
+    idx = np.arange(n)
+    rng.shuffle(idx)
+    return [np.asanyarray(a)[idx] for a in arrays]
+
+
+class PolynomialFeatures:
+    def __init__(self, degree=2, include_bias=True):
+        self.degree = degree
+        self.include_bias = include_bias
+
+    def fit(self, X):
+        return self
+
+    def transform(self, X):
+        from itertools import combinations_with_replacement
+        X = np.asanyarray(X, dtype=float)
+        n, d = X.shape
+        feats = [np.ones((n, 1))] if self.include_bias else []
+        for deg in range(1, self.degree + 1):
+            for combo in combinations_with_replacement(range(d), deg):
+                feats.append(np.prod(X[:, combo], axis=1, keepdims=True))
+        return np.hstack(feats)
+
+    def fit_transform(self, X):
+        return self.fit(X).transform(X)
+
+
+class Pipeline:
+    def __init__(self, steps):
+        self.steps = steps  # [(name, transformer/estimator)]
+
+    def fit(self, X, y=None):
+        Xt = X
+        for _, s in self.steps[:-1]:
+            Xt = s.fit_transform(Xt) if y is None else s.fit(Xt, y).transform(Xt) if hasattr(s, "transform") else s.fit(Xt, y)
+        name, est = self.steps[-1]
+        if y is None:
+            est.fit(Xt)
+        else:
+            est.fit(Xt, y)
+        return self
+
+    def predict(self, X):
+        Xt = X
+        for _, s in self.steps[:-1]:
+            Xt = s.transform(Xt)
+        return self.steps[-1][1].predict(Xt)
+
+    def transform(self, X):
+        Xt = X
+        for _, s in self.steps:
+            Xt = s.transform(Xt)
+        return Xt

mumpy/random.py

@@ -0,0 +1,99 @@
+"""mumpy.random: numpy.random-compatible API over np.random.Generator (PCG64)."""
+from __future__ import annotations
+
+import numpy as np
+
+__all__ = ["default_rng", "rand", "randn", "randint", "random", "choice",
+           "shuffle", "permutation", "normal", "uniform", "seed", "Generator",
+           "integers", "exponential", "poisson", "binomial", "multivariate_normal",
+           "beta", "gamma", "multinomial", "standard_cauchy", "laplace"]
+
+_global_rng = np.random.default_rng()
+
+
+def default_rng(seed=None):
+    return np.random.default_rng(seed)
+
+
+def seed(s=None):
+    global _global_rng
+    _global_rng = np.random.default_rng(s)
+
+
+def rand(*args):
+    return _global_rng.random(args if args else None)
+
+
+def random(size=None):
+    return _global_rng.random(size)
+
+
+def randn(*args):
+    return _global_rng.standard_normal(args if args else None)
+
+
+def randint(low, high=None, size=None, dtype=int):
+    return _global_rng.integers(low, high, size=size, dtype=dtype, endpoint=False)
+
+
+def integers(low, high=None, size=None, dtype=np.int64, endpoint=False):
+    return _global_rng.integers(low, high, size=size, dtype=dtype, endpoint=endpoint)
+
+
+def choice(a, size=None, replace=True, p=None):
+    return _global_rng.choice(a, size=size, replace=replace, p=p)
+
+
+def shuffle(x):
+    return _global_rng.shuffle(x)
+
+
+def permutation(x):
+    return _global_rng.permutation(x)
+
+
+def normal(loc=0.0, scale=1.0, size=None):
+    return _global_rng.normal(loc, scale, size)
+
+
+def uniform(low=0.0, high=1.0, size=None):
+    return _global_rng.uniform(low, high, size)
+
+
+def exponential(scale=1.0, size=None):
+    return _global_rng.exponential(scale, size)
+
+
+def poisson(lam=1.0, size=None):
+    return _global_rng.poisson(lam, size)
+
+
+def binomial(n, p, size=None):
+    return _global_rng.binomial(n, p, size)
+
+
+def multivariate_normal(mean, cov, size=None):
+    return _global_rng.multivariate_normal(mean, cov, size)
+
+
+def beta(a, b, size=None):
+    return _global_rng.beta(a, b, size)
+
+
+def gamma(shape, scale=1.0, size=None):
+    return _global_rng.gamma(shape, scale, size)
+
+
+def multinomial(n, pvals, size=None):
+    return _global_rng.multinomial(n, pvals, size)
+
+
+def standard_cauchy(size=None):
+    return _global_rng.standard_cauchy(size)
+
+
+def laplace(loc=0.0, scale=1.0, size=None):
+    return _global_rng.laplace(loc, scale, size)
+
+
+Generator = np.random.Generator