vectorphile 0.1.0__py3-none-any.whl

vectorphile/__init__.py

@@ -0,0 +1,154 @@
+"""
+vectorphile — Unified ML/DL Python Library
+==========================================
+
+The one library that replaces PyTorch + scikit-learn + NumPy + Pandas + SciPy.
+
+Quick start:
+    import vectorphile as vp
+
+    # Tensors (PyTorch-like)
+    x = vp.tensor([1, 2, 3], dtype='float32')
+    y = vp.randn(3, 4)
+    z = x @ y
+
+    # Neural networks
+    model = vp.nn.Sequential(
+        vp.nn.Linear(4, 128),
+        vp.nn.ReLU(),
+        vp.nn.Linear(128, 10),
+    )
+
+    # ML algorithms
+    clf = vp.ml.RandomForestClassifier(n_estimators=100)
+    clf.fit(X_train, y_train)
+
+    # DataFrames
+    df = vp.data.read_csv('data.csv')
+    df.groupby('category').mean()
+"""
+
+__version__ = '0.1.0'
+__author__ = 'vectorphile'
+__license__ = 'Apache-2.0'
+
+# ── Core tensor operations ───────────────────────────────────────────────────
+from vectorphile.core.tensor import (
+    Tensor,
+    tensor, zeros, ones, eye, arange, linspace, full, empty,
+    rand, randn, randint, from_numpy,
+    zeros_like, ones_like, empty_like,
+    cat, stack, split, chunk, squeeze, unsqueeze, flatten, transpose, permute,
+    matmul, dot, where,
+    exp, log, sqrt, clamp,
+    softmax, log_softmax, sigmoid, relu, tanh, einsum,
+)
+# shadow builtins only in the vp namespace
+from vectorphile.core.tensor import sum as sum
+from vectorphile.core.tensor import mean as mean
+from vectorphile.core.tensor import max as max
+from vectorphile.core.tensor import min as min
+from vectorphile.core.tensor import abs as abs
+
+# ── Autograd ─────────────────────────────────────────────────────────────────
+from vectorphile import autograd
+from vectorphile.autograd import no_grad
+
+# ── Neural network ───────────────────────────────────────────────────────────
+from vectorphile import nn
+
+# ── Optimizers ───────────────────────────────────────────────────────────────
+from vectorphile import optim
+
+# ── Linear algebra ───────────────────────────────────────────────────────────
+from vectorphile import linalg
+
+# ── Statistics ───────────────────────────────────────────────────────────────
+from vectorphile import stats
+
+# ── Random ───────────────────────────────────────────────────────────────────
+from vectorphile import random
+
+# ── FFT ──────────────────────────────────────────────────────────────────────
+from vectorphile import fft
+
+# ── Signal ───────────────────────────────────────────────────────────────────
+from vectorphile import signal
+
+# ── Sparse ───────────────────────────────────────────────────────────────────
+from vectorphile import sparse
+
+# ── Optimization ─────────────────────────────────────────────────────────────
+from vectorphile import optimize
+
+# ── Automatic Mixed Precision ────────────────────────────────────────────────
+from vectorphile import amp
+
+# ── Data (DataFrame/Series) ──────────────────────────────────────────────────
+from vectorphile import data
+
+# ── Machine learning ─────────────────────────────────────────────────────────
+from vectorphile import ml
+
+# ── Utils (DataLoader, Dataset) ──────────────────────────────────────────────
+from vectorphile import utils
+from vectorphile.utils.data import Dataset, TensorDataset, DataLoader
+
+# ── Convenience re-exports ───────────────────────────────────────────────────
+from vectorphile.data import DataFrame, Series, read_csv, read_json
+from vectorphile.ml import (
+    LinearRegression, Ridge, Lasso, ElasticNet, LogisticRegression,
+    DecisionTreeClassifier, DecisionTreeRegressor,
+    RandomForestClassifier, RandomForestRegressor,
+    KMeans, PCA, StandardScaler, MinMaxScaler,
+    train_test_split, accuracy_score,
+)
+
+# Device helpers (Phase 1: always CPU)
+def device(dev: str) -> str:
+    return dev
+
+def is_available() -> bool:
+    """Returns True if CUDA is available (always False in Phase 1)."""
+    return False
+
+cuda = type('cuda', (), {
+    'is_available': staticmethod(lambda: False),
+    'device_count': staticmethod(lambda: 0),
+    'get_device_name': staticmethod(lambda i=0: 'CPU'),
+})()
+
+# Type aliases
+float32 = 'float32'
+float64 = 'float64'
+float16 = 'float16'
+int32 = 'int32'
+int64 = 'int64'
+int8 = 'int8'
+uint8 = 'uint8'
+bool_ = 'bool'
+half = 'float16'
+double = 'float64'
+long = 'int64'
+
+__all__ = [
+    'Tensor', '__version__',
+    'tensor', 'zeros', 'ones', 'eye', 'arange', 'linspace', 'full', 'empty',
+    'rand', 'randn', 'randint', 'from_numpy',
+    'zeros_like', 'ones_like', 'empty_like',
+    'cat', 'stack', 'split', 'chunk', 'squeeze', 'unsqueeze', 'flatten',
+    'transpose', 'permute', 'matmul', 'dot', 'where', 'sum', 'mean', 'max', 'min',
+    'exp', 'log', 'sqrt', 'abs', 'clamp', 'softmax', 'log_softmax', 'sigmoid', 'relu', 'tanh', 'einsum',
+    'autograd', 'no_grad',
+    'nn', 'optim', 'linalg', 'stats', 'random', 'fft', 'signal', 'sparse', 'optimize', 'amp',
+    'data', 'ml', 'utils',
+    'Dataset', 'TensorDataset', 'DataLoader',
+    'DataFrame', 'Series', 'read_csv', 'read_json',
+    'LinearRegression', 'Ridge', 'Lasso', 'ElasticNet', 'LogisticRegression',
+    'DecisionTreeClassifier', 'DecisionTreeRegressor',
+    'RandomForestClassifier', 'RandomForestRegressor',
+    'KMeans', 'PCA', 'StandardScaler', 'MinMaxScaler',
+    'train_test_split', 'accuracy_score',
+    'cuda', 'device', 'is_available',
+    'float32', 'float64', 'float16', 'int32', 'int64', 'int8', 'uint8', 'bool_', 'half', 'double', 'long',
+]

vectorphile/amp/__init__.py

@@ -0,0 +1,52 @@
+"""Automatic Mixed Precision (AMP) — Phase 2 will add real CUDA fp16 support."""
+from contextlib import contextmanager
+from typing import Optional
+import numpy as np
+from vectorphile.core.tensor import Tensor
+
+
+class GradScaler:
+    """Gradient scaler stub — no-op in Phase 1 (CPU only)."""
+    def __init__(self, init_scale=65536.0, growth_factor=2.0, backoff_factor=0.5,
+                 growth_interval=2000, enabled=True):
+        self.enabled = enabled
+        self._scale = init_scale
+
+    @property
+    def scale(self):
+        return self._scale
+
+    def scale(self, loss):
+        return loss
+
+    def step(self, optimizer):
+        optimizer.step()
+
+    def update(self):
+        pass
+
+    def unscale_(self, optimizer):
+        pass
+
+    def get_scale(self) -> float:
+        return self._scale
+
+    def is_enabled(self) -> bool:
+        return self.enabled
+
+
+@contextmanager
+def autocast(device_type='cpu', dtype=None, enabled=True, cache_enabled=None):
+    """Context manager for automatic mixed precision.
+
+    In Phase 1 (CPU), this is a no-op. Phase 2 will add real fp16/bf16 on CUDA.
+    """
+    yield
+
+
+def is_autocast_enabled() -> bool:
+    return False
+
+
+def get_autocast_dtype() -> str:
+    return 'float32'

vectorphile/autograd/__init__.py

@@ -0,0 +1,13 @@
+from vectorphile.autograd.engine import (
+    backward, no_grad,
+    AddBackward, SubBackward, MulBackward, DivBackward, MatMulBackward,
+    ExpBackward, LogBackward, SqrtBackward, SumBackward, MeanBackward,
+    ReLUBackward, SigmoidBackward, TanhBackward,
+)
+
+__all__ = [
+    'backward', 'no_grad',
+    'AddBackward', 'SubBackward', 'MulBackward', 'DivBackward', 'MatMulBackward',
+    'ExpBackward', 'LogBackward', 'SqrtBackward', 'SumBackward', 'MeanBackward',
+    'ReLUBackward', 'SigmoidBackward', 'TanhBackward',
+]

vectorphile/autograd/engine.py

@@ -0,0 +1,208 @@
+"""Reverse-mode automatic differentiation engine."""
+from __future__ import annotations
+import numpy as np
+from typing import TYPE_CHECKING
+
+if TYPE_CHECKING:
+    from vectorphile.core.tensor import Tensor
+
+
+def _topo_sort(root: 'Tensor'):
+    visited, order = set(), []
+    def visit(node):
+        if id(node) not in visited:
+            visited.add(id(node))
+            if node.grad_fn is not None:
+                for inp in node.grad_fn.inputs:
+                    if hasattr(inp, 'grad_fn'):
+                        visit(inp)
+            order.append(node)
+    visit(root)
+    return reversed(order)
+
+
+def backward(root: 'Tensor', gradient: 'Tensor'):
+    from vectorphile.core.tensor import Tensor
+    root.grad = gradient
+    for node in _topo_sort(root):
+        if node.grad_fn is None:
+            continue
+        grads = node.grad_fn.backward(node.grad)
+        for inp, g in zip(node.grad_fn.inputs, grads):
+            if not isinstance(inp, Tensor) or not inp.requires_grad:
+                continue
+            if g is None:
+                continue
+            if inp.grad is None:
+                inp.grad = Tensor(np.zeros_like(inp._data))
+            # Sum gradient over broadcast dimensions
+            g_data = _sum_to_shape(g._data if isinstance(g, Tensor) else g, inp._data.shape)
+            inp.grad._data += g_data
+
+
+def _sum_to_shape(g: np.ndarray, shape) -> np.ndarray:
+    while g.ndim > len(shape):
+        g = g.sum(axis=0)
+    for i, (gs, s) in enumerate(zip(g.shape, shape)):
+        if s == 1 and gs != 1:
+            g = g.sum(axis=i, keepdims=True)
+    return g
+
+
+class Function:
+    def __init__(self, *inputs):
+        self.inputs = inputs
+
+    def backward(self, grad):
+        raise NotImplementedError
+
+
+class AddBackward(Function):
+    def backward(self, grad):
+        return grad, grad
+
+
+class SubBackward(Function):
+    def backward(self, grad):
+        from vectorphile.core.tensor import Tensor
+        neg = Tensor(-grad._data, device=grad.device)
+        return grad, neg
+
+
+class MulBackward(Function):
+    def __init__(self, a, b):
+        super().__init__(a, b)
+        self.a, self.b = a, b
+
+    def backward(self, grad):
+        from vectorphile.core.tensor import Tensor
+        a_data = self.a._data if hasattr(self.a, '_data') else np.array(self.a)
+        b_data = self.b._data if hasattr(self.b, '_data') else np.array(self.b)
+        return Tensor(grad._data * b_data), Tensor(grad._data * a_data)
+
+
+class DivBackward(Function):
+    def __init__(self, a, b):
+        super().__init__(a, b)
+        self.a, self.b = a, b
+
+    def backward(self, grad):
+        from vectorphile.core.tensor import Tensor
+        a_data = self.a._data if hasattr(self.a, '_data') else np.array(self.a)
+        b_data = self.b._data if hasattr(self.b, '_data') else np.array(self.b)
+        da = grad._data / b_data
+        db = -grad._data * a_data / (b_data ** 2)
+        return Tensor(da), Tensor(db)
+
+
+class MatMulBackward(Function):
+    def __init__(self, a, b):
+        super().__init__(a, b)
+        self.a, self.b = a, b
+
+    def backward(self, grad):
+        from vectorphile.core.tensor import Tensor
+        return Tensor(np.matmul(grad._data, self.b._data.T)), Tensor(np.matmul(self.a._data.T, grad._data))
+
+
+class ExpBackward(Function):
+    def __init__(self, inp, out):
+        super().__init__(inp)
+        self.out = out
+
+    def backward(self, grad):
+        from vectorphile.core.tensor import Tensor
+        return (Tensor(grad._data * self.out._data),)
+
+
+class LogBackward(Function):
+    def __init__(self, inp):
+        super().__init__(inp)
+        self.inp = inp
+
+    def backward(self, grad):
+        from vectorphile.core.tensor import Tensor
+        return (Tensor(grad._data / (self.inp._data + 1e-12)),)
+
+
+class SqrtBackward(Function):
+    def __init__(self, inp, out):
+        super().__init__(inp)
+        self.out = out
+
+    def backward(self, grad):
+        from vectorphile.core.tensor import Tensor
+        return (Tensor(0.5 * grad._data / (self.out._data + 1e-12)),)
+
+
+class SumBackward(Function):
+    def __init__(self, inp, dim, keepdim):
+        super().__init__(inp)
+        self.inp = inp
+        self.dim = dim
+        self.keepdim = keepdim
+
+    def backward(self, grad):
+        from vectorphile.core.tensor import Tensor
+        g = grad._data
+        if self.dim is not None and not self.keepdim:
+            g = np.expand_dims(g, axis=self.dim)
+        return (Tensor(np.broadcast_to(g, self.inp._data.shape).copy()),)
+
+
+class MeanBackward(Function):
+    def __init__(self, inp, dim, keepdim):
+        super().__init__(inp)
+        self.inp = inp
+        self.dim = dim
+        self.keepdim = keepdim
+
+    def backward(self, grad):
+        from vectorphile.core.tensor import Tensor
+        g = grad._data
+        if self.dim is not None and not self.keepdim:
+            g = np.expand_dims(g, axis=self.dim)
+        n = self.inp._data.size if self.dim is None else self.inp._data.shape[self.dim]
+        return (Tensor(np.broadcast_to(g / n, self.inp._data.shape).copy()),)
+
+
+class ReLUBackward(Function):
+    def __init__(self, inp):
+        super().__init__(inp)
+        self.inp = inp
+
+    def backward(self, grad):
+        from vectorphile.core.tensor import Tensor
+        return (Tensor(grad._data * (self.inp._data > 0).astype(np.float32)),)
+
+
+class SigmoidBackward(Function):
+    def __init__(self, inp, out):
+        super().__init__(inp)
+        self.out = out
+
+    def backward(self, grad):
+        from vectorphile.core.tensor import Tensor
+        s = self.out._data
+        return (Tensor(grad._data * s * (1 - s)),)
+
+
+class TanhBackward(Function):
+    def __init__(self, inp, out):
+        super().__init__(inp)
+        self.out = out
+
+    def backward(self, grad):
+        from vectorphile.core.tensor import Tensor
+        return (Tensor(grad._data * (1 - self.out._data ** 2)),)
+
+
+class no_grad:
+    """Context manager to disable gradient tracking."""
+    _enabled = True
+
+    def __enter__(self):
+        no_grad._enabled = False
+
+    def __exit__(self, *args):
+        no_grad._enabled = True

vectorphile/core/__init__.py

@@ -0,0 +1,21 @@
+from vectorphile.core.tensor import (
+    Tensor,
+    tensor, zeros, ones, eye, arange, linspace, full, empty,
+    rand, randn, randint, from_numpy,
+    zeros_like, ones_like, empty_like,
+    cat, stack, split, chunk, squeeze, unsqueeze, flatten, transpose, permute,
+    matmul, dot, where, max, min, sum, mean,
+    exp, log, sqrt, abs, clamp,
+    softmax, log_softmax, sigmoid, relu, tanh, einsum,
+)
+
+__all__ = [
+    'Tensor',
+    'tensor', 'zeros', 'ones', 'eye', 'arange', 'linspace', 'full', 'empty',
+    'rand', 'randn', 'randint', 'from_numpy',
+    'zeros_like', 'ones_like', 'empty_like',
+    'cat', 'stack', 'split', 'chunk', 'squeeze', 'unsqueeze', 'flatten',
+    'transpose', 'permute', 'matmul', 'dot', 'where', 'max', 'min', 'sum', 'mean',
+    'exp', 'log', 'sqrt', 'abs', 'clamp',
+    'softmax', 'log_softmax', 'sigmoid', 'relu', 'tanh', 'einsum',
+]