fpsketch 0.1.0__tar.gz

fpsketch-0.1.0/.github/workflows/publish.yml

@@ -0,0 +1,21 @@
+name: Publish to PyPI
+
+on:
+  push:
+    tags:
+      - 'v*'
+
+jobs:
+  publish:
+    runs-on: ubuntu-latest
+    environment: pypi
+    permissions:
+      id-token: write
+      contents: read  # needed for actions/checkout on a private repo
+    steps:
+      - uses: actions/checkout@v4
+        with:
+          fetch-depth: 0  # required for hatch-vcs to derive the version from tags
+      - uses: astral-sh/setup-uv@v5
+      - run: uv build
+      - uses: pypa/gh-action-pypi-publish@release/v1

fpsketch-0.1.0/.gitignore

@@ -0,0 +1,10 @@
+__pycache__/
+*.pyc
+*.egg-info/
+.pytest_cache/
+.ruff_cache/
+.mypy_cache/
+.venv/
+dist/
+build/
+.uv/

fpsketch-0.1.0/.pre-commit-config.yaml

@@ -0,0 +1,33 @@
+repos:
+  # Misc pre-commit checks
+  - repo: https://github.com/pre-commit/pre-commit-hooks
+    rev: v5.0.0
+    hooks:
+      - id: check-added-large-files
+      - id: check-case-conflict
+      - id: check-merge-conflict
+      - id: check-toml
+      - id: check-yaml
+      - id: debug-statements
+      - id: destroyed-symlinks
+      - id: detect-private-key
+      - id: end-of-file-fixer
+      - id: name-tests-test
+        args: ["--pytest-test-first"]
+        exclude: ^tests/(_reference\.py|data/generate_sample\.py)$
+      - id: trailing-whitespace
+  # Ruff: lint + format + import sorting
+  - repo: https://github.com/astral-sh/ruff-pre-commit
+    rev: v0.7.1
+    hooks:
+      - id: ruff
+        args: [--fix]
+      - id: ruff-format
+  # mypy: static type checking
+  - repo: https://github.com/pre-commit/mirrors-mypy
+    rev: v1.11.2
+    hooks:
+      - id: mypy
+        additional_dependencies: ["numpy>=1.24"]
+        args: ["--config-file=pyproject.toml"]
+        files: ^src/

fpsketch-0.1.0/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2026 the fpsketch contributors
+
+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.

fpsketch-0.1.0/PKG-INFO

@@ -0,0 +1,152 @@
+Metadata-Version: 2.5
+Name: fpsketch
+Version: 0.1.0
+Summary: Compress molecular count fingerprints to a fixed low dimension while preserving Tanimoto similarity as a plain dot product.
+Project-URL: Homepage, https://github.com/AustinT/fpsketch
+Project-URL: Repository, https://github.com/AustinT/fpsketch
+Author: Austin Tripp
+License-Expression: MIT
+License-File: LICENSE
+Keywords: cheminformatics,fingerprint,johnson-lindenstrauss,sketching,tanimoto
+Classifier: Intended Audience :: Science/Research
+Classifier: License :: OSI Approved :: MIT License
+Classifier: Operating System :: OS Independent
+Classifier: Programming Language :: Python :: 3
+Classifier: Topic :: Scientific/Engineering :: Chemistry
+Requires-Python: >=3.10
+Requires-Dist: numpy>=1.24
+Provides-Extra: chem
+Requires-Dist: rdkit>=2023.9; extra == 'chem'
+Description-Content-Type: text/markdown
+
+# fpsketch
+
+Compress molecular count fingerprints to a fixed low dimension while
+(approximately) preserving Tanimoto similarity as a plain dot product.
+
+Given two count fingerprints `x`, `x'` (e.g. Morgan fingerprints with counts,
+`{feature_id: count}`), the standard chemistry similarity metric is the
+min-max Tanimoto:
+
+```
+T_MM(x, x') = sum_i min(x_i, x'_i) / sum_i max(x_i, x'_i)
+```
+
+`T_MM` isn't a dot product, so you can't drop count fingerprints straight into
+models (nearest-neighbor search, GPs, kernel methods, ...) that expect a plain
+inner product. fpsketch sketches count fingerprints into a fixed-width dense
+vector `s = encode(x)` such that
+
+```
+T_DP(s, s') = s.s' / (||s||^2 + ||s'||^2 - s.s')  ≈  T_MM(x, x')
+```
+
+i.e. an ordinary dot product on the sketch approximates `T_MM` on the
+original fingerprints.
+
+## Why this works
+
+A unary encoding turns each count into a set of indicators,
+`psi(x)_{i,k} = 1[x_i > k]` for `k = 0 .. x_i - 1`. Since
+`min(u, v) = sum_k 1[u > k] * 1[v > k]`, this makes `T_DP(psi(x), psi(x'))`
+exactly equal to `T_MM(x, x')` -- no approximation yet, just a reformulation.
+fpsketch then applies a CountSketch (hashing each `(feature_id, level)` pair
+into one of `m` signed buckets) to that unary expansion, which keeps the
+dot product unbiased while collapsing it to a fixed, low dimension.
+
+## Install
+
+```
+pip install fpsketch          # encode_sparse only, numpy-only
+pip install fpsketch[chem]    # + encode_mols, pulls in rdkit
+```
+
+## Quickstart
+
+```python
+from fpsketch import encode_sparse
+
+# Sparse count fingerprints you already have.
+fps = [{1: 1, 2: 2, 3: 3}, {4: 4, 5: 5, 6: 6}]
+sketch = encode_sparse(fps, dim=2048, seed=0)
+
+# T_DP as a plain dot product / normalized similarity.
+G = sketch @ sketch.T
+sq = (sketch**2).sum(axis=1)
+similarity = G / (sq[:, None] + sq[None, :] - G)
+```
+
+```python
+from rdkit import Chem
+from fpsketch import encode_mols
+
+mols = [Chem.MolFromSmiles(s) for s in ["CCO"]]  # your list of SMILES strings
+sketch = encode_mols(mols, dim=2048, seed=0)  # defaults to a Morgan(radius=2) generator
+```
+
+If you already have your counts vectorized as a COO sparse array (molecules x
+features), `encode_coo` skips the per-molecule dict traversal `encode_sparse`
+does internally:
+
+```python
+from scipy.sparse import coo_array
+from fpsketch import encode_coo
+
+counts = coo_array(...)  # shape (n_molecules, n_features)
+sketch = encode_coo(counts, dim=2048, seed=0)
+```
+
+Two sketches are only comparable if built with the same `seed`.
+
+## Choosing `dim` and `num_blocks`
+
+`dim=2048` is a strong default for typical fingerprint settings. For extra
+safety margin, `dim` at 2-4x the fingerprint's effective (unfolded) dimension
+is a reasonable range to sweep. `num_blocks` (default 4) splits `dim` into
+that many disjoint sub-sketches, each an independent CountSketch; a dot
+product on the concatenated output is equivalent to averaging the
+`num_blocks` per-block dot-product estimates. This trades a small amount of
+raw accuracy for better tail concentration across single-draw sketches, which
+matters when a sketch is computed once and fed straight into a downstream
+model (e.g. a GP) rather than averaged over many random seeds.
+
+## The `scale` parameter
+
+By default (`scale=True`), the output is divided by `sqrt(num_blocks)` so
+that raw dot products and squared norms directly approximate the true,
+unnormalized dot product / count mass of the original fingerprints -- useful
+if you compare sketches built with different `num_blocks`, or use the sketch
+for anything beyond the `T_DP` ratio above (cosine similarity, nearest
+neighbors on raw dot product, etc). That factor cancels out of the `T_DP`
+ratio itself, so if you only ever compute Tanimoto similarity through that
+ratio, `scale=False` is equivalent and skips one pass over the output array.
+
+## Performance note
+
+Hashing is vectorized with numpy (a pure-numpy splitmix64 mixer, not
+`hashlib` per element) rather than hashing one `(feature, count-level)` pair
+at a time -- see `src/fpsketch/sketching.py` for details.
+
+## Development
+
+```
+uv sync --extra chem
+uv run pytest
+uv run ruff check .
+uv run ruff format .
+uv run mypy src
+uv run pre-commit install  # run the above automatically on each commit
+```
+
+## Releasing
+
+Versions are derived from git tags (`hatch-vcs`); there is no version to bump
+by hand. Pushing a tag matching `v*` (e.g. `v0.2.0`) triggers
+`.github/workflows/publish.yml`, which builds and publishes to PyPI via
+[Trusted Publishing](https://docs.pypi.org/trusted-publishers/) -- no API
+token needed, but the `pypi` environment must be configured as a trusted
+publisher for this repo in the PyPI project settings first.
+
+## License
+
+MIT, see [LICENSE](LICENSE).

fpsketch-0.1.0/README.md

@@ -0,0 +1,131 @@
+# fpsketch
+
+Compress molecular count fingerprints to a fixed low dimension while
+(approximately) preserving Tanimoto similarity as a plain dot product.
+
+Given two count fingerprints `x`, `x'` (e.g. Morgan fingerprints with counts,
+`{feature_id: count}`), the standard chemistry similarity metric is the
+min-max Tanimoto:
+
+```
+T_MM(x, x') = sum_i min(x_i, x'_i) / sum_i max(x_i, x'_i)
+```
+
+`T_MM` isn't a dot product, so you can't drop count fingerprints straight into
+models (nearest-neighbor search, GPs, kernel methods, ...) that expect a plain
+inner product. fpsketch sketches count fingerprints into a fixed-width dense
+vector `s = encode(x)` such that
+
+```
+T_DP(s, s') = s.s' / (||s||^2 + ||s'||^2 - s.s')  ≈  T_MM(x, x')
+```
+
+i.e. an ordinary dot product on the sketch approximates `T_MM` on the
+original fingerprints.
+
+## Why this works
+
+A unary encoding turns each count into a set of indicators,
+`psi(x)_{i,k} = 1[x_i > k]` for `k = 0 .. x_i - 1`. Since
+`min(u, v) = sum_k 1[u > k] * 1[v > k]`, this makes `T_DP(psi(x), psi(x'))`
+exactly equal to `T_MM(x, x')` -- no approximation yet, just a reformulation.
+fpsketch then applies a CountSketch (hashing each `(feature_id, level)` pair
+into one of `m` signed buckets) to that unary expansion, which keeps the
+dot product unbiased while collapsing it to a fixed, low dimension.
+
+## Install
+
+```
+pip install fpsketch          # encode_sparse only, numpy-only
+pip install fpsketch[chem]    # + encode_mols, pulls in rdkit
+```
+
+## Quickstart
+
+```python
+from fpsketch import encode_sparse
+
+# Sparse count fingerprints you already have.
+fps = [{1: 1, 2: 2, 3: 3}, {4: 4, 5: 5, 6: 6}]
+sketch = encode_sparse(fps, dim=2048, seed=0)
+
+# T_DP as a plain dot product / normalized similarity.
+G = sketch @ sketch.T
+sq = (sketch**2).sum(axis=1)
+similarity = G / (sq[:, None] + sq[None, :] - G)
+```
+
+```python
+from rdkit import Chem
+from fpsketch import encode_mols
+
+mols = [Chem.MolFromSmiles(s) for s in ["CCO"]]  # your list of SMILES strings
+sketch = encode_mols(mols, dim=2048, seed=0)  # defaults to a Morgan(radius=2) generator
+```
+
+If you already have your counts vectorized as a COO sparse array (molecules x
+features), `encode_coo` skips the per-molecule dict traversal `encode_sparse`
+does internally:
+
+```python
+from scipy.sparse import coo_array
+from fpsketch import encode_coo
+
+counts = coo_array(...)  # shape (n_molecules, n_features)
+sketch = encode_coo(counts, dim=2048, seed=0)
+```
+
+Two sketches are only comparable if built with the same `seed`.
+
+## Choosing `dim` and `num_blocks`
+
+`dim=2048` is a strong default for typical fingerprint settings. For extra
+safety margin, `dim` at 2-4x the fingerprint's effective (unfolded) dimension
+is a reasonable range to sweep. `num_blocks` (default 4) splits `dim` into
+that many disjoint sub-sketches, each an independent CountSketch; a dot
+product on the concatenated output is equivalent to averaging the
+`num_blocks` per-block dot-product estimates. This trades a small amount of
+raw accuracy for better tail concentration across single-draw sketches, which
+matters when a sketch is computed once and fed straight into a downstream
+model (e.g. a GP) rather than averaged over many random seeds.
+
+## The `scale` parameter
+
+By default (`scale=True`), the output is divided by `sqrt(num_blocks)` so
+that raw dot products and squared norms directly approximate the true,
+unnormalized dot product / count mass of the original fingerprints -- useful
+if you compare sketches built with different `num_blocks`, or use the sketch
+for anything beyond the `T_DP` ratio above (cosine similarity, nearest
+neighbors on raw dot product, etc). That factor cancels out of the `T_DP`
+ratio itself, so if you only ever compute Tanimoto similarity through that
+ratio, `scale=False` is equivalent and skips one pass over the output array.
+
+## Performance note
+
+Hashing is vectorized with numpy (a pure-numpy splitmix64 mixer, not
+`hashlib` per element) rather than hashing one `(feature, count-level)` pair
+at a time -- see `src/fpsketch/sketching.py` for details.
+
+## Development
+
+```
+uv sync --extra chem
+uv run pytest
+uv run ruff check .
+uv run ruff format .
+uv run mypy src
+uv run pre-commit install  # run the above automatically on each commit
+```
+
+## Releasing
+
+Versions are derived from git tags (`hatch-vcs`); there is no version to bump
+by hand. Pushing a tag matching `v*` (e.g. `v0.2.0`) triggers
+`.github/workflows/publish.yml`, which builds and publishes to PyPI via
+[Trusted Publishing](https://docs.pypi.org/trusted-publishers/) -- no API
+token needed, but the `pypi` environment must be configured as a trusted
+publisher for this repo in the PyPI project settings first.
+
+## License
+
+MIT, see [LICENSE](LICENSE).

fpsketch-0.1.0/examples/similarity_search.py

@@ -0,0 +1,69 @@
+"""Nearest-neighbor search over a handful of molecules using fpsketch, compared
+against RDKit's native Tanimoto similarity.
+
+Run with:
+    uv run --extra chem python examples/similarity_search.py
+"""
+
+from __future__ import annotations
+
+import numpy as np
+from rdkit import Chem, DataStructs
+from rdkit.Chem import rdFingerprintGenerator
+
+from fpsketch import encode_mols
+
+SMILES = [
+    "CC(=O)Oc1ccccc1C(=O)O",  # aspirin
+    "CC(=O)Nc1ccc(O)cc1",  # paracetamol
+    "CC(C)Cc1ccc(cc1)C(C)C(=O)O",  # ibuprofen
+    "c1ccc2c(c1)ccc1ccccc12",  # anthracene
+    "c1ccc2ccccc2c1",  # naphthalene
+    "CCO",  # ethanol
+    "CCCCO",  # butanol
+    "OCC(O)CO",  # glycerol
+    "c1ccccc1",  # benzene
+    "Cc1ccccc1",  # toluene
+    "c1ccc(cc1)c1ccccc1",  # biphenyl
+    "CC(C)(C)c1ccccc1",  # tert-butylbenzene
+    "CN1CCC[C@H]1c1cccnc1",  # nicotine
+    "Cn1cnc2c1c(=O)n(C)c(=O)n2C",  # caffeine
+    "OC(=O)c1ccccc1O",  # salicylic acid
+]
+
+QUERY_IDX = 0  # aspirin
+TOP_K = 5
+
+
+def t_dp(X: np.ndarray) -> np.ndarray:
+    G = X @ X.T
+    sq = np.einsum("ij,ij->i", X, X)
+    return G / np.maximum(sq[:, None] + sq[None, :] - G, 1e-12)
+
+
+def main() -> None:
+    mols = [Chem.MolFromSmiles(s) for s in SMILES]
+
+    sketch = encode_mols(mols, dim=2048, seed=0)
+    k_hat = t_dp(sketch)
+
+    generator = rdFingerprintGenerator.GetMorganGenerator(radius=2)
+    fps = [generator.GetSparseCountFingerprint(m) for m in mols]
+    k_true = np.array([DataStructs.BulkTanimotoSimilarity(fp, fps) for fp in fps])
+
+    query_sims_hat = k_hat[QUERY_IDX]
+    query_sims_true = k_true[QUERY_IDX]
+
+    ranked = sorted(
+        (i for i in range(len(mols)) if i != QUERY_IDX),
+        key=lambda i: -query_sims_hat[i],
+    )[:TOP_K]
+
+    print(f"query: {SMILES[QUERY_IDX]}")
+    print(f"{'SMILES':<40} {'fpsketch T_DP':>15} {'RDKit T_MM':>12}")
+    for i in ranked:
+        print(f"{SMILES[i]:<40} {query_sims_hat[i]:>15.4f} {query_sims_true[i]:>12.4f}")
+
+
+if __name__ == "__main__":
+    main()

fpsketch-0.1.0/pyproject.toml

@@ -0,0 +1,88 @@
+[project]
+name = "fpsketch"
+authors = [
+    {name = "Austin Tripp"},
+]
+description = "Compress molecular count fingerprints to a fixed low dimension while preserving Tanimoto similarity as a plain dot product."
+keywords = ["cheminformatics", "fingerprint", "sketching", "tanimoto", "johnson-lindenstrauss"]
+readme = "README.md"
+requires-python = ">=3.10"
+license = "MIT"
+dynamic = ["version"]  # version is set from git tags, see [tool.hatch.version]
+classifiers = [
+    "Programming Language :: Python :: 3",
+    "License :: OSI Approved :: MIT License",
+    "Operating System :: OS Independent",
+    "Intended Audience :: Science/Research",
+    "Topic :: Scientific/Engineering :: Chemistry",
+]
+dependencies = [
+    "numpy>=1.24",
+]
+
+[project.urls]
+Homepage = "https://github.com/AustinT/fpsketch"
+Repository = "https://github.com/AustinT/fpsketch"
+
+[project.optional-dependencies]
+chem = ["rdkit>=2023.9"]
+
+[dependency-groups]
+dev = [
+    "pytest>=7.0",
+    "rdkit>=2023.9",
+    "ruff>=0.6",
+    "mypy>=1.11",
+    "pre-commit>=3.8",
+]
+
+[build-system]
+requires = ["hatchling", "hatch-vcs"]
+build-backend = "hatchling.build"
+
+[tool.hatch.build.targets.wheel]
+packages = ["src/fpsketch"]
+
+[tool.hatch.version]
+source = "vcs"
+
+[tool.hatch.version.raw-options]
+local_scheme = "no-local-version"  # PyPI rejects local version segments (e.g. +dirty)
+
+[tool.pytest.ini_options]
+testpaths = ["tests"]
+
+[tool.ruff]
+line-length = 100
+target-version = "py310"
+src = ["src"]
+
+[tool.ruff.lint]
+select = ["E", "F", "I", "UP", "B"]
+
+[tool.ruff.lint.isort]
+known-first-party = ["fpsketch"]
+
+[tool.mypy]
+# Pinned to 3.12 (not requires-python's 3.10 floor): numpy's bundled stubs use
+# unconditional PEP 695 `type` aliases that mypy can only parse when targeting
+# >=3.12, regardless of what our own source uses. Our code doesn't use any
+# 3.11+-only syntax, so this only affects stub parsing, not what's accepted.
+python_version = "3.12"
+files = ["src"]
+warn_unused_configs = true
+warn_redundant_casts = true
+warn_unused_ignores = true
+
+[[tool.mypy.overrides]]
+module = "rdkit.*"
+ignore_missing_imports = true
+
+# numpy's operator-overload stubs collapse chained uint64 array arithmetic
+# (xor/shift/mul with scalars) to narrower-than-actual types in these two
+# modules' low-level bit hashing; the errors are stub-inference artifacts, not
+# real bugs. Silencing only the specific noisy codes here keeps real errors
+# (typos, wrong arg types, etc.) caught in the rest of the package.
+[[tool.mypy.overrides]]
+module = ["fpsketch.sketching", "fpsketch._splitmix"]
+disable_error_code = ["index", "operator", "attr-defined", "return-value"]

fpsketch-0.1.0/src/fpsketch/__init__.py

@@ -0,0 +1,19 @@
+"""fpsketch: compress molecular count fingerprints to a fixed low dimension
+while preserving Tanimoto (T_MM) similarity as a plain dot product.
+"""
+
+from importlib.metadata import PackageNotFoundError, version
+
+from .mols import encode_mols
+from .sketching import encode_coo, encode_sparse
+
+__all__ = [
+    "encode_sparse",
+    "encode_coo",
+    "encode_mols",
+]
+
+try:
+    __version__ = version("fpsketch")
+except PackageNotFoundError:  # pragma: no cover - not installed, e.g. running from source
+    __version__ = "unknown"

fpsketch-0.1.0/src/fpsketch/_splitmix.py

@@ -0,0 +1,28 @@
+"""A numpy implementation of splitmix"""
+
+import numpy as np
+
+U64 = np.uint64
+
+# Fixed constants for splitmix
+GAMMA = U64(0x9E3779B97F4A7C15)
+MIX_A = U64(0xBF58476D1CE4E5B9)
+MIX_B = U64(0x94D049BB133111EB)
+
+
+def _splitmix64_hash(x: np.ndarray) -> np.ndarray:
+    """
+    Splitmix64 function- an 64 bit rng/hash which is simple to implement,
+    invertible, and is considered fairly pseudo-random.
+
+    It is not strong enough for cryptography but doesn't need to be:
+    this is just used to encode fingerprints.
+    """
+
+    # Ignore int overflows- this is an intended part of the algorithm
+    with np.errstate(over="ignore"):
+        z = x + GAMMA
+        z = (z ^ (z >> U64(30))) * MIX_A
+        z = (z ^ (z >> U64(27))) * MIX_B
+        z = z ^ (z >> U64(31))
+    return z

fpsketch-0.1.0/src/fpsketch/mols.py

@@ -0,0 +1,46 @@
+"""RDKit molecule entry point. Requires the ``chem`` extra (``pip install fpsketch[chem]``)."""
+
+from __future__ import annotations
+
+from collections.abc import Sequence
+from typing import Any
+
+import numpy as np
+
+from .sketching import encode_sparse
+
+
+def encode_mols(
+    mols: Sequence[Any],
+    dim: int = 2048,
+    generator: Any | None = None,
+    num_blocks: int = 4,
+    seed: int = 0,
+    scale: bool = True,
+) -> np.ndarray:
+    """Sketch RDKit molecules into a dense ``(len(mols), dim)`` array.
+
+    Args:
+        mols: RDKit ``ROMol`` objects.
+        dim: output sketch width.
+        generator: an ``rdFingerprintGenerator`` generator (Morgan, RDKitFP,
+            AtomPair, TopologicalTorsion, ...). Defaults to
+            ``GetMorganGenerator(radius=2)`` if not given. Any generator
+            exposing ``GetSparseCountFingerprint`` works.
+        num_blocks: see ``encode_sparse``.
+        seed: hash seed; two sketches are only dot-product-comparable if built
+            with the same seed.
+        scale: see ``encode_sparse``.
+    """
+    try:
+        from rdkit.Chem import rdFingerprintGenerator
+    except ImportError as e:
+        raise ImportError(
+            "encode_mols requires rdkit. Install it with `pip install fpsketch[chem]`."
+        ) from e
+
+    if generator is None:
+        generator = rdFingerprintGenerator.GetMorganGenerator(radius=2)
+
+    fps = [generator.GetSparseCountFingerprint(mol).GetNonzeroElements() for mol in mols]
+    return encode_sparse(fps, dim=dim, num_blocks=num_blocks, seed=seed, scale=scale)