faster-clip 0.1.0__tar.gz

faster_clip-0.1.0/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2026 cnmoro
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

faster_clip-0.1.0/PKG-INFO

@@ -0,0 +1,103 @@
+Metadata-Version: 2.4
+Name: faster-clip
+Version: 0.1.0
+Summary: Dependency-light pure-numpy CPU inference for CLIP embeddings, inference-free SPLADE, and BERT fill-mask — a drop-in replacement for the transformers / sentence-transformers models in a RAG stack (no PyTorch, no ONNX).
+Author: cnmoro
+License: MIT
+Project-URL: Homepage, https://github.com/cnmoro/faster-clip
+Project-URL: Repository, https://github.com/cnmoro/faster-clip
+Keywords: clip,splade,sparse-embeddings,fill-mask,embeddings,rag,numpy,no-torch
+Classifier: Programming Language :: Python :: 3
+Classifier: License :: OSI Approved :: MIT License
+Classifier: Operating System :: OS Independent
+Classifier: Topic :: Scientific/Engineering :: Artificial Intelligence
+Classifier: Intended Audience :: Developers
+Requires-Python: >=3.8
+Description-Content-Type: text/markdown
+License-File: LICENSE
+Requires-Dist: numpy
+Requires-Dist: tokenizers
+Requires-Dist: safetensors
+Requires-Dist: huggingface_hub
+Requires-Dist: pillow
+Dynamic: license-file
+
+# faster-clip
+
+Dependency-light, **pure-numpy** CPU inference for the models a multilingual RAG
+stack typically needs — with **no PyTorch, no transformers, no sentence-transformers,
+no ONNX**. Just `numpy` + `tokenizers` (+ `safetensors` / `huggingface_hub` for
+weights, `pillow` for images).
+
+```bash
+pip install faster-clip
+```
+
+It provides three drop-in replacements, each **numerically matching** the original
+HuggingFace pipeline:
+
+| Class | Replaces | Output |
+|---|---|---|
+| `ClipModel` | `SentenceTransformer('clip-ViT-B-32')` + `clip-ViT-B-32-multilingual-v1` | 512-d CLIP image / text embeddings (cosine ≈ 1.0) |
+| `SparseEncoder` | `SparseEncoder('…inference-free-splade…')` | `{token_id: weight}` sparse dicts (**bit-identical**) |
+| `FillMask` | `pipeline('fill-mask', 'bert-base-uncased' / 'bert-base-portuguese-cased')` | top-k `{token_str, sequence, score}` (**identical strings**) |
+
+Model weights are downloaded from HuggingFace and cached on first use (the SPLADE
+weights, ~120 KB, ship inside the wheel).
+
+## CLIP embeddings
+
+```python
+from faster_clip import ClipModel
+from PIL import Image
+
+clip = ClipModel()  # lazily downloads image / text weights on first use
+
+text_emb = clip.encode_text(["um carro vermelho", "a red car"])   # (2, 512)
+img_emb  = clip.encode_image(Image.open("photo.jpg"))             # (1, 512)
+```
+
+Image and multilingual text land in the **same** 512-d CLIP space, so you can do
+cross-modal search. (Normalize yourself if you need unit vectors.)
+
+## SPLADE sparse encoding (no sparse tensor materialized)
+
+The model is an *inference-free* SPLADE: encoding is a pure token→weight lookup,
+so the result is just a dict of the active dimensions — no dense/sparse vector is
+ever built.
+
+```python
+from faster_clip import SparseEncoder
+
+sparse = SparseEncoder()
+sparse.encode("banco de dados vetorial")
+# -> {'15060': 1.09, '2951': 1.11, '2078': 1.04, ...}   # {token_id: weight}
+```
+
+`encode`, `encode_query`, and `encode_document` are equivalent (the model's query
+route is the default) and accept a string or a list of strings.
+
+## Fill-mask autocomplete
+
+```python
+from faster_clip import FillMask
+
+fm = FillMask()
+fm.predict("the weather is very [MASK]", lang="en")
+# -> [{'token_str': '.', 'sequence': 'the weather is very.', 'score': 0.30}, ...]
+fm.predict("o brasil é um [MASK]", lang="pt")
+# -> [{'token_str': 'lixo', 'sequence': 'o brasil é um lixo', ...}, ...]
+```
+
+`lang` is `"en"` (`bert-base-uncased`) or `"pt"` (`neuralmind/bert-base-portuguese-cased`).
+
+## Model cache
+
+Weights are cached by `huggingface_hub` under `~/.cache/huggingface`. To run
+offline, pre-download the models once (or set `HF_HOME`). CLIP vision/text and the
+BERT MLMs are fetched on first use of each capability.
+
+## License
+
+MIT. Model weights belong to their respective authors (OpenAI / Microsoft /
+sentence-transformers / neuralmind), used under their original licenses.

faster_clip-0.1.0/README.md

@@ -0,0 +1,79 @@
+# faster-clip
+
+Dependency-light, **pure-numpy** CPU inference for the models a multilingual RAG
+stack typically needs — with **no PyTorch, no transformers, no sentence-transformers,
+no ONNX**. Just `numpy` + `tokenizers` (+ `safetensors` / `huggingface_hub` for
+weights, `pillow` for images).
+
+```bash
+pip install faster-clip
+```
+
+It provides three drop-in replacements, each **numerically matching** the original
+HuggingFace pipeline:
+
+| Class | Replaces | Output |
+|---|---|---|
+| `ClipModel` | `SentenceTransformer('clip-ViT-B-32')` + `clip-ViT-B-32-multilingual-v1` | 512-d CLIP image / text embeddings (cosine ≈ 1.0) |
+| `SparseEncoder` | `SparseEncoder('…inference-free-splade…')` | `{token_id: weight}` sparse dicts (**bit-identical**) |
+| `FillMask` | `pipeline('fill-mask', 'bert-base-uncased' / 'bert-base-portuguese-cased')` | top-k `{token_str, sequence, score}` (**identical strings**) |
+
+Model weights are downloaded from HuggingFace and cached on first use (the SPLADE
+weights, ~120 KB, ship inside the wheel).
+
+## CLIP embeddings
+
+```python
+from faster_clip import ClipModel
+from PIL import Image
+
+clip = ClipModel()  # lazily downloads image / text weights on first use
+
+text_emb = clip.encode_text(["um carro vermelho", "a red car"])   # (2, 512)
+img_emb  = clip.encode_image(Image.open("photo.jpg"))             # (1, 512)
+```
+
+Image and multilingual text land in the **same** 512-d CLIP space, so you can do
+cross-modal search. (Normalize yourself if you need unit vectors.)
+
+## SPLADE sparse encoding (no sparse tensor materialized)
+
+The model is an *inference-free* SPLADE: encoding is a pure token→weight lookup,
+so the result is just a dict of the active dimensions — no dense/sparse vector is
+ever built.
+
+```python
+from faster_clip import SparseEncoder
+
+sparse = SparseEncoder()
+sparse.encode("banco de dados vetorial")
+# -> {'15060': 1.09, '2951': 1.11, '2078': 1.04, ...}   # {token_id: weight}
+```
+
+`encode`, `encode_query`, and `encode_document` are equivalent (the model's query
+route is the default) and accept a string or a list of strings.
+
+## Fill-mask autocomplete
+
+```python
+from faster_clip import FillMask
+
+fm = FillMask()
+fm.predict("the weather is very [MASK]", lang="en")
+# -> [{'token_str': '.', 'sequence': 'the weather is very.', 'score': 0.30}, ...]
+fm.predict("o brasil é um [MASK]", lang="pt")
+# -> [{'token_str': 'lixo', 'sequence': 'o brasil é um lixo', ...}, ...]
+```
+
+`lang` is `"en"` (`bert-base-uncased`) or `"pt"` (`neuralmind/bert-base-portuguese-cased`).
+
+## Model cache
+
+Weights are cached by `huggingface_hub` under `~/.cache/huggingface`. To run
+offline, pre-download the models once (or set `HF_HOME`). CLIP vision/text and the
+BERT MLMs are fetched on first use of each capability.
+
+## License
+
+MIT. Model weights belong to their respective authors (OpenAI / Microsoft /
+sentence-transformers / neuralmind), used under their original licenses.

faster_clip-0.1.0/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-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