fpembed 0.1.6__tar.gz → 0.1.7__tar.gz

{fpembed-0.1.6/src/fpembed.egg-info → fpembed-0.1.7}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: fpembed
-Version: 0.1.6
+Version: 0.1.7
 Summary: Generalized fingerprint embedding library
 License-Expression: MIT
 Requires-Python: >=3.9
@@ -21,7 +21,7 @@ Dynamic: license-file
 # FPembed - Generalized Molecular Fingerprint Embeddings
 
 [![PyPI version](https://badge.fury.io/py/fpembed.svg)](https://badge.fury.io/py/fpembed)
-[![DOI](https://zenodo.org/badge/1223653010.svg)](https://doi.org/10.5281/zenodo.21447996)
+[![DOI](https://img.shields.io/badge/DOI-10.5281/zenodo.21447996-blue)](https://doi.org/10.5281/zenodo.21447996)
 
 
 A lightweight Python package for generating compressed molecular fingerprint embeddings, backed by [scikit-fingerprints](https://github.com/scikit-fingerprints/scikit-fingerprints). Supports ten binary fingerprint types through a single unified class.
@@ -142,13 +142,13 @@ Block-wise methods (`geometric`, `linear`, `log`, `uniform`) are fast (O(L)) and
 
 All methods produce the same output dimensionality (D = L / compression) but differ in speed and memory:
 
-| Method | Speed                                    | Precomputed Memory                   | Best For |
-|--------|------------------------------------------|--------------------------------------|----------|
-| Block-wise (all four) | Fastest - single vectorized einsum, O(L) | Negligible (C-length weight vector)  | Default choice; large batches |
-| Random projection | Fast - BLAS matmul, O(L D)               | DxL matrix (~2 MB for L=2048, D=128) | Best theoretical guarantees (JL lemma) |
-| Hadamard (SRHT) | Slowest - pure-Python FWHT, O(L log L)   | L-length sign vector (~16 KB)        | Small-scale experiments; future optimization |
+| Method | Speed                                                                              | Precomputed Memory                   | Best For |
+|--------|------------------------------------------------------------------------------------|--------------------------------------|----------|
+| Block-wise (all four) | Fastest - single vectorized einsum, O(L)                                           | Negligible (C-length weight vector)  | Default choice; large batches |
+| Hadamard (SRHT) | Fast - vectorized FWHT (NumPy reshape/broadcast, no Python-level loop), O(L log L) | L-length sign vector (~16 KB)        | Large batches at high compression ratios |
+| Random projection | Fast - BLAS matmul, O(L D)                                                         | DxL matrix (~2 MB for L=2048, D=128) | Best theoretical guarantees (JL lemma) |
 
-Block-wise methods are ~2–5x faster than random projection and orders of magnitude faster than Hadamard in practice. Random projection's memory cost grows quadratically with fingerprint size.
+Block-wise methods remain the fastest choice for large batches. Hadamard's FWHT is vectorized across the whole batch and works much faster now. Random projection's memory cost grows quadratically with fingerprint size.
 
 ## Why Use Embedded Fingerprints?
 

{fpembed-0.1.6 → fpembed-0.1.7}/README.md

@@ -1,7 +1,7 @@
 # FPembed - Generalized Molecular Fingerprint Embeddings
 
 [![PyPI version](https://badge.fury.io/py/fpembed.svg)](https://badge.fury.io/py/fpembed)
-[![DOI](https://zenodo.org/badge/1223653010.svg)](https://doi.org/10.5281/zenodo.21447996)
+[![DOI](https://img.shields.io/badge/DOI-10.5281/zenodo.21447996-blue)](https://doi.org/10.5281/zenodo.21447996)
 
 
 A lightweight Python package for generating compressed molecular fingerprint embeddings, backed by [scikit-fingerprints](https://github.com/scikit-fingerprints/scikit-fingerprints). Supports ten binary fingerprint types through a single unified class.
@@ -122,13 +122,13 @@ Block-wise methods (`geometric`, `linear`, `log`, `uniform`) are fast (O(L)) and
 
 All methods produce the same output dimensionality (D = L / compression) but differ in speed and memory:
 
-| Method | Speed                                    | Precomputed Memory                   | Best For |
-|--------|------------------------------------------|--------------------------------------|----------|
-| Block-wise (all four) | Fastest - single vectorized einsum, O(L) | Negligible (C-length weight vector)  | Default choice; large batches |
-| Random projection | Fast - BLAS matmul, O(L D)               | DxL matrix (~2 MB for L=2048, D=128) | Best theoretical guarantees (JL lemma) |
-| Hadamard (SRHT) | Slowest - pure-Python FWHT, O(L log L)   | L-length sign vector (~16 KB)        | Small-scale experiments; future optimization |
+| Method | Speed                                                                              | Precomputed Memory                   | Best For |
+|--------|------------------------------------------------------------------------------------|--------------------------------------|----------|
+| Block-wise (all four) | Fastest - single vectorized einsum, O(L)                                           | Negligible (C-length weight vector)  | Default choice; large batches |
+| Hadamard (SRHT) | Fast - vectorized FWHT (NumPy reshape/broadcast, no Python-level loop), O(L log L) | L-length sign vector (~16 KB)        | Large batches at high compression ratios |
+| Random projection | Fast - BLAS matmul, O(L D)                                                         | DxL matrix (~2 MB for L=2048, D=128) | Best theoretical guarantees (JL lemma) |
 
-Block-wise methods are ~2–5x faster than random projection and orders of magnitude faster than Hadamard in practice. Random projection's memory cost grows quadratically with fingerprint size.
+Block-wise methods remain the fastest choice for large batches. Hadamard's FWHT is vectorized across the whole batch and works much faster now. Random projection's memory cost grows quadratically with fingerprint size.
 
 ## Why Use Embedded Fingerprints?
 

{fpembed-0.1.6 → fpembed-0.1.7}/pyproject.toml

@@ -4,7 +4,7 @@ build-backend = "setuptools.build_meta"
 
 [project]
 name = "fpembed"
-version = "0.1.6"
+version = "0.1.7"
 description = "Generalized fingerprint embedding library"
 requires-python = ">=3.9"
 dependencies = [

{fpembed-0.1.6 → fpembed-0.1.7}/src/fpembed/__init__.py

@@ -20,7 +20,7 @@ from fpembed.compression import compress_fingerprint
 from fpembed.smiles_utils import parse_smiles, canonicalize_smiles
 from fpembed.hashing import fp_params_hash
 
-__version__ = "0.1.6"
+__version__ = "0.1.7"
 
 __all__ = [
     "EmbeddedFingerprintGenerator",

{fpembed-0.1.6 → fpembed-0.1.7}/src/fpembed/compression_projection.py

@@ -21,34 +21,59 @@ import numpy as np
 import numpy.typing as npt
 
 
-def fwht(x: npt.NDArray[np.float64]) -> npt.NDArray[np.float64]:
-    """In-place Fast Walsh-Hadamard Transform (butterfly algorithm).
+def _fwht_inplace(x: npt.NDArray[np.float64]) -> npt.NDArray[np.float64]:
+    """Vectorized in-place FWHT butterfly, along the last axis.
 
-    Operates in O(L log L) using only additions and subtractions.
+    Works for a single 1-D vector or a 2-D batch (rows, length) — each
+    butterfly level is one NumPy operation over the whole array instead of
+    a Python-level loop over individual index pairs. Mutates *x* in-place
+    via reshape views (no copy of the full array), matching the original
+    per-pair butterfly algorithm exactly.
 
     Parameters
     ----------
     x : ndarray
-        1-D float64 array of length L (must be a power of 2).
+        Float64 array whose last axis has length L (must be a power of 2).
 
     Returns
     -------
     ndarray
         The same array, modified in-place.
     """
-    length = len(x)
+    length = x.shape[-1]
     h = 1
     while h < length:
-        for i in range(0, length, h * 2):
-            for j in range(i, i + h):
-                a = x[j]
-                b = x[j + h]
-                x[j] = a + b
-                x[j + h] = a - b
+        view = x.reshape(*x.shape[:-1], -1, 2, h)
+        a = view[..., 0, :].copy()
+        b = view[..., 1, :].copy()
+        view[..., 0, :] = a + b
+        view[..., 1, :] = a - b
         h *= 2
     return x
 
 
+def fwht(x: npt.NDArray[np.float64]) -> npt.NDArray[np.float64]:
+    """In-place Fast Walsh-Hadamard Transform (butterfly algorithm).
+
+    Operates in O(L log L) using only additions and subtractions. Vectorized
+    via NumPy reshape/broadcast (see `_fwht_inplace`) rather than nested
+    Python loops — benchmarked at ~32x faster than the original per-pair
+    loop implementation for batched Hadamard compression, with identical
+    output (see dev_docs/investigation_compression_acceleration_options.md).
+
+    Parameters
+    ----------
+    x : ndarray
+        1-D float64 array of length L (must be a power of 2).
+
+    Returns
+    -------
+    ndarray
+        The same array, modified in-place.
+    """
+    return _fwht_inplace(x)
+
+
 def build_srht_signs(
     length: int, seed: int
 ) -> npt.NDArray[np.float64]:
@@ -102,14 +127,10 @@ def compress_hadamard(
     output_dim = cols // size
     norm = 1.0 / np.sqrt(cols)
 
-    result = np.empty((rows, output_dim), dtype=np.float64)
-    for i in range(rows):
-        row = vector[i].astype(np.float64) * signs
-        fwht(row)
-        row *= norm
-        result[i] = row[:output_dim]
-
-    return result
+    signed = vector.astype(np.float64) * signs  # broadcasts (rows, cols) * (cols,)
+    transformed = _fwht_inplace(signed)
+    transformed *= norm
+    return transformed[:, :output_dim].copy()
 
 
 def build_rp_matrix(

{fpembed-0.1.6 → fpembed-0.1.7/src/fpembed.egg-info}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: fpembed
-Version: 0.1.6
+Version: 0.1.7
 Summary: Generalized fingerprint embedding library
 License-Expression: MIT
 Requires-Python: >=3.9
@@ -21,7 +21,7 @@ Dynamic: license-file
 # FPembed - Generalized Molecular Fingerprint Embeddings
 
 [![PyPI version](https://badge.fury.io/py/fpembed.svg)](https://badge.fury.io/py/fpembed)
-[![DOI](https://zenodo.org/badge/1223653010.svg)](https://doi.org/10.5281/zenodo.21447996)
+[![DOI](https://img.shields.io/badge/DOI-10.5281/zenodo.21447996-blue)](https://doi.org/10.5281/zenodo.21447996)
 
 
 A lightweight Python package for generating compressed molecular fingerprint embeddings, backed by [scikit-fingerprints](https://github.com/scikit-fingerprints/scikit-fingerprints). Supports ten binary fingerprint types through a single unified class.
@@ -142,13 +142,13 @@ Block-wise methods (`geometric`, `linear`, `log`, `uniform`) are fast (O(L)) and
 
 All methods produce the same output dimensionality (D = L / compression) but differ in speed and memory:
 
-| Method | Speed                                    | Precomputed Memory                   | Best For |
-|--------|------------------------------------------|--------------------------------------|----------|
-| Block-wise (all four) | Fastest - single vectorized einsum, O(L) | Negligible (C-length weight vector)  | Default choice; large batches |
-| Random projection | Fast - BLAS matmul, O(L D)               | DxL matrix (~2 MB for L=2048, D=128) | Best theoretical guarantees (JL lemma) |
-| Hadamard (SRHT) | Slowest - pure-Python FWHT, O(L log L)   | L-length sign vector (~16 KB)        | Small-scale experiments; future optimization |
+| Method | Speed                                                                              | Precomputed Memory                   | Best For |
+|--------|------------------------------------------------------------------------------------|--------------------------------------|----------|
+| Block-wise (all four) | Fastest - single vectorized einsum, O(L)                                           | Negligible (C-length weight vector)  | Default choice; large batches |
+| Hadamard (SRHT) | Fast - vectorized FWHT (NumPy reshape/broadcast, no Python-level loop), O(L log L) | L-length sign vector (~16 KB)        | Large batches at high compression ratios |
+| Random projection | Fast - BLAS matmul, O(L D)                                                         | DxL matrix (~2 MB for L=2048, D=128) | Best theoretical guarantees (JL lemma) |
 
-Block-wise methods are ~2–5x faster than random projection and orders of magnitude faster than Hadamard in practice. Random projection's memory cost grows quadratically with fingerprint size.
+Block-wise methods remain the fastest choice for large batches. Hadamard's FWHT is vectorized across the whole batch and works much faster now. Random projection's memory cost grows quadratically with fingerprint size.
 
 ## Why Use Embedded Fingerprints?