faster-clip 0.1.0__py3-none-any.whl

faster_clip/__init__.py

@@ -0,0 +1,17 @@
+"""faster-clip — dependency-light CPU replacements (pure numpy) for the
+transformers / sentence-transformers models used in the RAG stack:
+
+* :class:`ClipModel`      — CLIP image + multilingual-text embeddings (512-d).
+* :class:`SparseEncoder`  — inference-free SPLADE sparse ``{token_id: weight}`` dicts.
+* :class:`FillMask`       — BERT masked-LM autocomplete (en / pt).
+
+No PyTorch, no transformers, no ONNX — just numpy + tokenizers (+ safetensors,
+huggingface_hub for weights, pillow for images).
+"""
+
+from .clip import ClipModel
+from .fillmask import FillMask
+from .sparse import SparseEncoder
+
+__all__ = ["ClipModel", "SparseEncoder", "FillMask"]
+__version__ = "0.1.0"

faster_clip/_nn.py

@@ -0,0 +1,51 @@
+"""Minimal numpy neural-net primitives shared by the encoders."""
+
+import numpy as np
+
+
+def layer_norm(x, w, b, eps=1e-5):
+    mu = x.mean(-1, keepdims=True)
+    var = x.var(-1, keepdims=True)  # population variance (ddof=0), matches torch
+    return (x - mu) / np.sqrt(var + eps) * w + b
+
+
+def quick_gelu(x):
+    return x * (1.0 / (1.0 + np.exp(-1.702 * x)))
+
+
+def _erf(x):
+    # Abramowitz & Stegun 7.1.26, |error| < 1.5e-7
+    s = np.sign(x)
+    x = np.abs(x)
+    t = 1.0 / (1.0 + 0.3275911 * x)
+    y = 1.0 - (((((1.061405429 * t - 1.453152027) * t) + 1.421413741) * t
+               - 0.284496736) * t + 0.254829592) * t * np.exp(-x * x)
+    return s * y
+
+
+def gelu(x):
+    return 0.5 * x * (1.0 + _erf(x / np.sqrt(2.0)))
+
+
+def softmax(x, axis=-1):
+    x = x - x.max(axis=axis, keepdims=True)
+    e = np.exp(x)
+    return e / e.sum(axis=axis, keepdims=True)
+
+
+def multi_head_attention(x, wq, bq, wk, bk, wv, bv, wo, bo, n_heads):
+    """Self-attention over a single (seq, dim) sequence. Weights are torch [out, in]."""
+    seq, dim = x.shape
+    hd = dim // n_heads
+    q = (x @ wq.T + bq).reshape(seq, n_heads, hd).transpose(1, 0, 2)
+    k = (x @ wk.T + bk).reshape(seq, n_heads, hd).transpose(1, 0, 2)
+    v = (x @ wv.T + bv).reshape(seq, n_heads, hd).transpose(1, 0, 2)
+    scores = q @ k.transpose(0, 2, 1) / np.sqrt(hd)
+    ctx = softmax(scores, -1) @ v  # (h, seq, hd)
+    ctx = ctx.transpose(1, 0, 2).reshape(seq, dim)
+    return ctx @ wo.T + bo
+
+
+def linear(x, w, b=None):
+    y = x @ w.T
+    return y if b is None else y + b