diff --git a/README.md b/README.md index 513f855..0aa3b80 100644 --- a/README.md +++ b/README.md @@ -4,16 +4,31 @@ # TMAP2 -Tree-based visualization for high-dimensional data. Organizes similar items into interactive tree structures — ideal for chemical space, protein embeddings, single-cell data, or any high-dimensional dataset. +Tree-based visualization for high-dimensional data. Organizes similar items into interactive tree structures. Ideal for chemical space, protein embeddings, single-cell data, or any high-dimensional dataset. -A modernized reimplementation of the [original TMAP](https://github.com/reymond-group/tmap) with an sklearn-style API, multiple distance metrics, and interactive visualization. + + + + + +
Interactive HTML exportAlphaFold protein clusters
-```text -Your Data - ├─→ MinHash → LSHForest (Jaccard) - └─→ USearch (Cosine / Euclidean / other metrics) - ↓ - k-NN Graph → MST → OGDF Tree Layout → Interactive Visualization +## Why Trees? + +Most dimensionality reduction tools (UMAP, t-SNE) produce point clouds. TMAP produces a **tree**, a connected structure where every point is linked to its neighbors through branches. This makes the layout itself explorable: you can follow branches, trace paths between any two points, and discover how regions connect. + +For example, in a TMAP of pet breed images, following the branch from terriers toward cats reveals that the bridge between the two groups runs through chihuahuas and sphynx cats (the bald ones) which is both hilarious and logical; both are small, short-haired, big-eyed. The tree doesn't just cluster similar things it also shows you *how* dissimilar things are connected. + +

+ Exploring pet breed tree +

+ +Because the layout is a tree, you get operations that point clouds can't support: + +```python +path = model.path(idx_a, idx_b) # nodes along the tree path +d = model.distance(idx_a, idx_b) # sum of edge weights along the path +pseudotime = model.distances_from(idx) # tree distance from one point to all others ``` ## Installation @@ -50,23 +65,25 @@ model = TMAP(metric="cosine", n_neighbors=20).fit(X) new_coords = model.transform(X[:10]) ``` -## Visualization - -### Interactive HTML Export +```python +# Interactive notebook widget +model.plot(color_by="label", data=df, tooltip_properties=["name", "score"]) +``` -![Interactive HTML features](https://raw.githubusercontent.com/afloresep/TMAP/master/docs/images/image.png) +## Key Features -- Lasso selection (`Shift + drag`) -- Light / dark theme toggle -- Filter and search side panels -- Pinned cards for metadata, structures, and links -- Binary mode for large datasets +- **Tree structure**: follow branches, trace paths, compute pseudotime +- **Deterministic**: same input + seed = same output +- **Multiple metrics**: `jaccard`, `cosine`, `euclidean`, `precomputed` +- **Incremental**: `add_points()` and `transform()` for new data +- **Model persistence**: `save()` / `load()` +- **Three viz backends**: interactive HTML, jupyter-scatter, matplotlib -### Notebook Widgets +## Visualization -![Notebook controls demo](https://raw.githubusercontent.com/afloresep/TMAP/master/docs/images/ScreenRecording2026-02-15at19.43.12-ezgif.com-video-to-gif-converter.gif) +**Interactive HTML** — lasso selection, light/dark theme, filter and search panels, pinned metadata cards, binary mode for large datasets. -Color switching, categorical filtering, and lasso selection with pandas-backed metadata: +**Notebook widgets** — color switching, categorical filtering, and lasso selection with pandas-backed metadata: ```python viz = model.to_tmapviz() @@ -76,9 +93,7 @@ viz.add_label("SMILES", smiles_list) viz.show(width=1000, height=620, controls=True) ``` -### Lasso Selection + DataFrame Integration - -![Lasso and dataframe integration](https://raw.githubusercontent.com/afloresep/TMAP/master/docs/images/ScreenRecording2026-02-15at19.44.43-ezgif.com-video-to-gif-converter.gif) +**Static plots** — matplotlib for publication figures: `model.plot_static(color_by=labels)` ## Domain Utilities @@ -93,37 +108,39 @@ from tmap.utils.singlecell import from_anndata | Domain | Metric | Utilities | |--------|--------|-----------| | Chemoinformatics | `jaccard` | `fingerprints_from_smiles`, `molecular_properties`, `murcko_scaffolds` | -| Proteins | `cosine` / `euclidean` | `fetch_uniprot`, `fetch_alphafold`, `read_pdb`, `sequence_properties` | +| Proteins | `cosine` / `euclidean` | `fetch_uniprot`, `fetch_alphafold`, `read_fasta`, `sequence_properties` | | Single-cell | `cosine` / `euclidean` | `from_anndata`, `cell_metadata`, `marker_scores` | | Generic embeddings | `cosine` / `euclidean` / `precomputed` | No domain utils needed | +## Notebooks + +| Notebook | Topic | +|----------|-------| +| [01 Quick Start](notebooks/01_quickstart.ipynb) | End-to-end walkthrough | +| [02 MinHash Deep Dive](notebooks/02_minhash_deep_dive.ipynb) | Encoding methods and when to use each | +| [04 Notebook Widgets](notebooks/04_jscatter_demo.ipynb) | Selection, filtering, zoom, export | +| [06 Metric Guide](notebooks/06_metric_guide.ipynb) | Choosing the right metric | +| [08 Cheminformatics](notebooks/08_cheminformatics.ipynb) | Molecules, fingerprints, SAR | +| [09 Protein Analysis](notebooks/09_protein_analysis.ipynb) | FASTA, ESM embeddings, AlphaFold | +| [12 USearch Jaccard](notebooks/12_usearch_jaccard.ipynb) | Binary Jaccard with USearch backend | + ## Lower-Level Pipeline -For direct control over MinHash, LSH Forest, and layout stages: +For direct control over indexing, hashing, and layout, see the [legacy pipeline notebook](notebooks/03_legacy_lsh_pipeline.ipynb). The main building blocks: ```python -from tmap import MinHash, LSHForest +from tmap.index import USearchIndex # dense / binary kNN +from tmap import MinHash, LSHForest # Jaccard on sets / strings from tmap.layout import LayoutConfig, layout_from_lsh_forest - -mh = MinHash(num_perm=128, seed=42) -signatures = mh.batch_from_binary_array(X) - -lsh = LSHForest(d=128, l=64) -lsh.batch_add(signatures) -lsh.index() - -cfg = LayoutConfig(k=20, kc=50, deterministic=True, seed=42) -x, y, s, t = layout_from_lsh_forest(lsh, cfg) -# x, y = coordinates; s, t = tree edge indices ``` -## Key Features - -- **Deterministic**: same input + seed = same output -- **Multiple metrics**: `jaccard`, `cosine`, `euclidean`, `precomputed` -- **Incremental**: `add_points()` and `transform()` for new data -- **Model persistence**: `save()` / `load()` -- **Three viz backends**: interactive HTML, jupyter-scatter, matplotlib +```text +Your Data + ├─→ Binary matrix ─────────→ USearch (Jaccard / cosine / euclidean) + └─→ Sets / strings ───────→ MinHash → LSHForest + ↓ + k-NN Graph → MST → OGDF Tree Layout → Interactive Visualization +``` ## Development diff --git a/docs/api_reference.md b/docs/api_reference.md index ce28848..0ec8f0e 100644 --- a/docs/api_reference.md +++ b/docs/api_reference.md @@ -27,6 +27,7 @@ TMAP( |--------|---------------| | `fit(X)` | Build the graph, tree, and 2D embedding | | `fit_transform(X)` | Fit and return `(x, y, s, t)` | +| `kneighbors(X)` | Query nearest fitted neighbors for new points without placement or mutation | | `transform(X_new)` | Place new points on the existing map without changing the model | | `add_points(X_new)` | Add new points into the fitted model | | `to_tmapviz()` | Create a `TmapViz` object for notebook or HTML output | @@ -41,18 +42,84 @@ TMAP( | `embedding_` | 2D coordinates, shape `(n, 2)` | | `tree_` | Tree extracted from the kNN graph | | `graph_` | k-nearest-neighbor graph | -| `lsh_forest_` | Jaccard search index | -| `index_` | Dense ANN index when `store_index=True` | +| `lsh_forest_` | Jaccard search index for set / string inputs | +| `index_` | USearch index for cosine / euclidean (`store_index=True`) and binary Jaccard | ### Metrics | Metric | Input | Backend | |--------|-------|---------| -| `jaccard` | Binary matrix | MinHash + LSHForest | +| `jaccard` | Binary matrix | USearch | +| `jaccard` | Sets / strings | MinHash + LSHForest | | `cosine` | Dense float matrix | USearch | | `euclidean` | Dense float matrix | USearch | | `precomputed` | Distance matrix | Direct graph construction | +### Reproducibility + +The `seed` parameter controls the OGDF tree layout, which is fully +deterministic: same kNN graph + same seed = identical coordinates. + +The kNN step depends on the backend: + +- **MinHash + LSHForest** (sets / strings): deterministic for a given + `seed` and `minhash_seed`. +- **USearch HNSW** (binary Jaccard, cosine, euclidean): approximate and + multi-threaded. Neighbor sets may vary slightly across runs or + platforms. The resulting trees are nearly identical in practice because + the MST is robust to small kNN variations. + +If you need bit-exact kNN reproducibility for binary data, use the +MinHash + LSHForest pipeline directly: + +```python +from tmap import MinHash, LSHForest +from tmap.layout import LayoutConfig, layout_from_lsh_forest + +mh = MinHash(num_perm=128, seed=42) +signatures = mh.batch_from_binary_array(X) + +lsh = LSHForest(d=128, l=64) +lsh.batch_add(signatures) +lsh.index() + +cfg = LayoutConfig(k=20, kc=50, deterministic=True, seed=42) +x, y, s, t = layout_from_lsh_forest(lsh, cfg) +``` + +### Lower-Level Search Backends + +`TMAP` is the main entry point for maps. For direct nearest-neighbor queries, +the lower-level search classes are also public. + +#### `USearchIndex` + +Use for dense cosine / euclidean search and binary Jaccard search. + +| Method | What it does | +|--------|---------------| +| `build_from_vectors(X, metric=...)` | Build a dense cosine / euclidean index | +| `build_from_binary(X)` | Build a binary Jaccard index | +| `query_point(x, k)` | Query one vector | +| `query_batch(X, k)` | Query many vectors | +| `query_knn(k)` | Build the all-vs-all kNN graph | +| `add(X)` | Append new vectors to the index | +| `save(path)` / `load(path)` | Persist the index | + +#### `LSHForest` + +Use for lower-level MinHash workflows and Jaccard on sets / strings. + +| Method | What it does | +|--------|---------------| +| `query(signature, k)` | LSH-only candidate lookup | +| `query_linear_scan(signature, k, kc)` | Query one external signature with candidate refinement | +| `query_linear_scan_by_id(id, k, kc)` | Query one indexed signature by ID | +| `query_external_batch(signatures, k, kc)` | Batch query external signatures | +| `get_knn_graph(k, kc)` | Build the all-vs-all kNN graph | +| `get_all_distances(signature)` | Exact MinHash distances to all indexed signatures | +| `save(path)` / `load(path)` | Persist the index | + ## `TmapViz` Visualization object returned by `model.to_tmapviz()`. diff --git a/docs/images/alpha-fold-clusters.png b/docs/images/alpha-fold-clusters.png new file mode 100644 index 0000000..897caab Binary files /dev/null and b/docs/images/alpha-fold-clusters.png differ diff --git a/docs/images/breed-tree.gif b/docs/images/breed-tree.gif new file mode 100644 index 0000000..ca1596f Binary files /dev/null and b/docs/images/breed-tree.gif differ diff --git a/docs/images/enamine.png b/docs/images/enamine.png new file mode 100644 index 0000000..2195451 Binary files /dev/null and b/docs/images/enamine.png differ diff --git a/docs/images/filter+select.gif b/docs/images/filter+select.gif new file mode 100644 index 0000000..c16e93b Binary files /dev/null and b/docs/images/filter+select.gif differ diff --git a/docs/images/filter-dogs.gif b/docs/images/filter-dogs.gif new file mode 100644 index 0000000..3024a90 Binary files /dev/null and b/docs/images/filter-dogs.gif differ diff --git a/docs/images/ScreenRecording2026-02-15at19.43.12-ezgif.com-video-to-gif-converter.gif b/docs/images/filter-preview.gif similarity index 100% rename from docs/images/ScreenRecording2026-02-15at19.43.12-ezgif.com-video-to-gif-converter.gif rename to docs/images/filter-preview.gif diff --git a/docs/images/notebook-selection.gif b/docs/images/notebook-selection.gif new file mode 100644 index 0000000..751d163 Binary files /dev/null and b/docs/images/notebook-selection.gif differ diff --git a/docs/images/protein-shot.png b/docs/images/protein-shot.png new file mode 100644 index 0000000..0ddf892 Binary files /dev/null and b/docs/images/protein-shot.png differ diff --git a/docs/images/ScreenRecording2026-02-15at19.44.43-ezgif.com-video-to-gif-converter.gif b/docs/images/selection-preview.gif similarity index 100% rename from docs/images/ScreenRecording2026-02-15at19.44.43-ezgif.com-video-to-gif-converter.gif rename to docs/images/selection-preview.gif diff --git a/docs/images/selection.gif b/docs/images/selection.gif new file mode 100644 index 0000000..d58bfba Binary files /dev/null and b/docs/images/selection.gif differ diff --git a/docs/usearch_backend.md b/docs/usearch_backend.md new file mode 100644 index 0000000..a495781 --- /dev/null +++ b/docs/usearch_backend.md @@ -0,0 +1,204 @@ +# USearch Backend: Fast kNN for Binary, Cosine, and Euclidean Data + +This guide explains the USearch nearest-neighbor backend in TMAP, when it's used, and how it compares to MinHash+LSH. + +--- + +## What USearch Does + +USearch is an HNSW (Hierarchical Navigable Small World) index that supports multiple distance metrics. TMAP uses it for: + +- **Binary Jaccard** (new default for binary fingerprints) +- **Cosine** distance on dense vectors +- **Euclidean** distance on dense vectors + +For binary data, USearch computes exact Jaccard distance on bit-packed vectors — no MinHash approximation is needed. + +```txt +Binary Matrix (0/1) + | + [pack to bytes] + | + [USearch HNSW Index] ← Jaccard distance on raw bits + | +Fast Neighbor Queries -> k-NN Graph -> TMAP Layout +``` + +--- + +## Quick Start + +### Through the estimator (automatic) + +Binary matrices are automatically routed to USearch: + +```python +from tmap import TMAP + +# Binary fingerprints → USearch Jaccard (automatic) +model = TMAP(metric="jaccard", n_neighbors=20).fit(fingerprints) + +# Sets/strings → MinHash+LSH (automatic) +model = TMAP(metric="jaccard", n_neighbors=20).fit(list_of_sets) +``` + +### Standalone (no TMAP, no layout) + +Use the index directly for kNN queries without building a tree: + +```python +from tmap.index import USearchIndex + +# Build +idx = USearchIndex(seed=42) +idx.build_from_binary(fingerprints) # (n, d) of 0/1 values + +# Query +neighbors, distances = idx.query_batch(new_fingerprints, k=50) + +# Incremental +idx.add(more_fingerprints) + +# Persistence +idx.save("my_index.usearch") +idx = USearchIndex.load("my_index.usearch") +``` + +--- + +## How It Works + +### HNSW on bit vectors + +USearch builds a navigable small-world graph where each node is connected to its approximate nearest neighbors. Queries traverse this graph greedily, visiting nodes closer and closer to the target. + +For binary data (`dtype='b1x8'`), the distance function is exact bitwise Jaccard: + +``` +Jaccard distance = 1 - popcount(A AND B) / popcount(A OR B) +``` + +This is computed on packed bytes using hardware popcount instructions, making individual distance computations very fast. + +**Key difference from MinHash+LSH:** USearch operates on the *original* bit vectors. MinHash first compresses the data into fixed-width hash signatures, losing information. This compression is why LSH has much lower recall on sparse binary data. + +### When USearch is used vs MinHash+LSH + +| Input type | Backend | Why | +|---|---|---| +| Dense binary matrix (ndarray, DataFrame) | USearch HNSW | Native Jaccard on bits, high recall | +| Sparse matrix (scipy CSR) | MinHash + LSH | Avoids densifying large sparse data | +| List of integer sets | MinHash + LSH | Variable-length, can't pack to fixed bits | +| List of string tokens | MinHash + LSH | Variable-length, needs MinHash encoding | + +The estimator detects the input type automatically. + +--- + +## Performance + +All benchmarks run on a MacBook (Apple Silicon, 24 GB RAM). +Reproducible via `python scripts/bench_usearch_vs_lsh.py`. + +### Recall + +Measured against brute-force ground truth (1024 bits, ~10% density, k=20): + +| Method | Recall@20 (n=10k) | Recall@20 (n=50k) | +|---|---|---| +| USearch (expansion=512) | **98.5%** | **81.6%** | +| USearch (expansion=256) | 97.0% | — | +| LSH (d=512, kc=50) | 0.6% | 1.5% | + +USearch recall decreases at larger N because HNSW is approximate, but it remains vastly better than LSH for sparse binary data. LSH fills all neighbor slots but with essentially random points — MinHash has fundamental recall limitations when bit overlap between vectors is low. + +### Build + kNN graph time + +1024-bit fingerprints, ~10% density, k=20: + +| n | USearch build | USearch kNN | USearch total | LSH total | LSH mem | +|---:|---:|---:|---:|---:|---:| +| 10,000 | 1.6s | 1.0s | **2.6s** | **0.7s** | 41 MB | +| 50,000 | 7.2s | 8.9s | **16.1s** | **2.3s** | 205 MB | +| 100,000 | 16.2s | 21.8s | **37.9s** | **5.9s** | 410 MB | +| 250,000 | 47.5s | 82.7s | **130s** | **22.9s** | 1,024 MB | +| 500,000 | 114.9s | 225.3s | **340s** | **84.6s** | 2,048 MB | +| 1,000,000 | ~250s | ~550s | **~800s** | ~250s | 4,096 MB | +| 2,000,000 | ~550s | ~1200s | **~1750s** | -OOM- | 16 GB+ | + +LSH is 4-7x faster for building the full kNN graph. But those neighbors are wrong (1.5% recall), so the resulting TMAP tree is meaningless. At 1M+ points, LSH hits memory limits on a 24 GB machine while USearch fits in 128 MB. + +The USearch kNN query (all-vs-all search) takes longer than the HNSW build itself. This is the main bottleneck at scale. + +### Batch queries (100 queries against existing index) + +| n | USearch | LSH | +|---:|---:|---:| +| 10,000 | 6.5ms | 10.5ms | +| 50,000 | 11.8ms | 15.9ms | +| 100,000 | 17.0ms | 20.5ms | +| 500,000 | 33.7ms | 80.7ms | + +For `transform()` and `add_points()`, USearch is consistently faster because HNSW queries are O(log n). At 500k, USearch is 2.4x faster per query. + +### Memory (vector storage) + +| n | USearch | LSH (d=512) | +|---:|---:|---:| +| 100,000 | 13 MB | 410 MB | +| 250,000 | 32 MB | 1,024 MB | +| 500,000 | 64 MB | 2,048 MB | +| 1,000,000 | 128 MB | 4,096 MB | +| 2,000,000 | 256 MB | -OOM- | + +USearch stores packed bytes (128 bytes per 1024-bit vector). LSH stores MinHash signatures (4,096 bytes per vector with d=512). USearch uses **32x less memory** for 1024-bit fingerprints (16x for 2048-bit). + +### Summary + +| | USearch Jaccard | MinHash + LSH | +|---|---|---| +| **Recall** | 82-98% | 0.6-1.5% | +| **Build speed** | 4-7x slower | Faster (but wrong neighbors) | +| **Query speed** | 1.2-2.4x faster | Slower at scale | +| **Memory** | 16-32x less | OOM at ~1-2M | +| **Max scale (24 GB)** | 2M+ | ~500k-1M | +| **Hyperparameters** | None (auto) | d, l, kc | + +**Bottom line:** USearch is the right default for binary data. It trades some build time for vastly better neighbor quality and lower memory. The build cost is one-time; queries are faster. + +--- + +## Tuning + +### expansion_search + +The main quality knob. Higher values improve recall at the cost of slower queries. + +| expansion_search | Recall@20 (n=10k) | Effect | +|---|---|---| +| 128 | 96.1% | Fast, slightly lower recall | +| 256 | 97.0% | Good balance | +| 512 | 98.5% | Best recall (TMAP default) | + +The estimator uses `expansion_search=512` by default. For standalone use, you can set this in the constructor: + +```python +idx = USearchIndex(expansion_search=256) # faster, slightly lower recall +``` + +### connectivity + +Controls the HNSW graph density. Higher values use more memory but improve recall. + +```python +idx = USearchIndex(connectivity=64) # default is 32 +``` + +--- + +## Limitations + +- **Sparse matrices** go through MinHash+LSH to avoid OOM from densification +- **Variable-length data** (sets, strings) requires MinHash encoding, so LSH is used +- **HNSW is approximate** — recall decreases with dataset size (82% at 50k vs 98% at 10k) +- **Build time** is O(n log n) with high constant for binary distance — slower than LSH for one-time builds diff --git a/notebooks/01_quickstart.ipynb b/notebooks/01_quickstart.ipynb index 80f9d17..da8c3e2 100644 --- a/notebooks/01_quickstart.ipynb +++ b/notebooks/01_quickstart.ipynb @@ -59,13 +59,6 @@ "execution_count": 2, "metadata": {}, "outputs": [ - { - "name": "stderr", - "output_type": "stream", - "text": [ - "OMP: Info #276: omp_set_nested routine deprecated, please use omp_set_max_active_levels instead.\n" - ] - }, { "name": "stdout", "output_type": "stream", @@ -100,19 +93,19 @@ "name": "stderr", "output_type": "stream", "text": [ - "/var/folders/zw/c0mr_7jx7t3bz1k6_9n9wh3r0000gn/T/ipykernel_78800/684963885.py:5: UserWarning: Edges are not supported in notebook mode yet and will be ignored.\n", + "/var/folders/zw/c0mr_7jx7t3bz1k6_9n9wh3r0000gn/T/ipykernel_83682/684963885.py:5: UserWarning: Edges are not supported in notebook mode yet and will be ignored.\n", " widget = viz.to_widget(width=1000, height=650, controls=True)\n" ] }, { "data": { "application/vnd.jupyter.widget-view+json": { - "model_id": "305142cfa52141e48d404ebb53fde125", + "model_id": "c968a1fae2dd4ca6b4b08e5e79da193e", "version_major": 2, "version_minor": 0 }, "text/plain": [ - "VBox(children=(HBox(children=(VBox(children=(, , , , , " + ] + }, + "execution_count": 12, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "# Lasso-select points interactively, then read them:\n", + "# scatter.selection() -> array of selected indices\n", + "\n", + "# Programmatic selection:\n", + "scatter.selection(list(range(50)))\n", + "print(f\"Selected {len(scatter.selection())} points\")\n", + "\n", + "# Zoom to selection\n", + "scatter.zoom(to=scatter.selection(), animation=True, padding=0.2)\n" + ] + }, + { + "cell_type": "markdown", + "id": "m2rasxk5he", + "metadata": {}, + "source": [ + "## 6. Filtering\n", + "\n", + "Filter the scatter plot to show only a subset of points. Pass a list of indices to `scatter.filter()`, or `None` to reset." + ] + }, + { + "cell_type": "code", + "execution_count": 14, + "id": "rdhb71a8yia", + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Showing 2000 of 2000 points\n" + ] + } + ], + "source": [ + "# Show only molecules with >= 3 rings\n", + "heavy = df[df[\"n_rings\"] >= 3].index.tolist()\n", + "scatter.filter(heavy)\n", + "print(f\"Showing {len(heavy)} of {len(df)} points\")\n", + "\n", + "# Reset filter\n", + "# scatter.filter(None)\n" + ] + }, + { + "cell_type": "markdown", + "id": "xzd9idoqggq", + "metadata": {}, + "source": [ + "## 7. Export to DataFrame\n", + "\n", + "Two export paths: `viz.to_dataframe()` for full metadata with coordinates, or use `scatter.selection()` indices to slice your own DataFrame." + ] + }, + { + "cell_type": "code", + "execution_count": null, + "id": "79451f09", + "metadata": {}, + "outputs": [ + { + "name": "stderr", + "output_type": "stream", + "text": [ + "/var/folders/zw/c0mr_7jx7t3bz1k6_9n9wh3r0000gn/T/ipykernel_98740/153501217.py:1: UserWarning: Edges are not supported in notebook mode yet and will be ignored.\n", + " widget = viz.to_widget()\n" + ] + }, + { + "data": { + "application/vnd.jupyter.widget-view+json": { + "model_id": "e838cccf732d489182bdb1035a963b60", + "version_major": 2, + "version_minor": 0 + }, + "text/plain": [ + "VBox(children=(HBox(children=(Dropdown(description='Color:', options=('MW', 'LogP', 'Ring Count'), value='MW')…" + ] + }, + "execution_count": 21, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "widget = viz.to_widget()\n", + "widget.show()\n" + ] + }, + { + "cell_type": "markdown", + "id": "73580118", + "metadata": {}, + "source": [ + "## Select with your mouse\n", + "Try holding left click, and then dragging to select multiple points that you can export later!\n", + "\n", + "![Interactive HTML features](../docs/images/selection.gif)" + ] + }, + { + "cell_type": "code", + "execution_count": 22, + "id": "ggadel3cohe", + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Index for selected poitns: [1074 1753 1752 1748 1749 1755 1715 1516 452 458 454 1939 459 1179\n", + " 1654 457 1655 393 1681 1940 1649 1641 1565 1890 364 1891 1762 1772\n", + " 1714 1763 394 1773 496 382 495 425 1909 1910 1515 383 1636 1825\n", + " 1137 1142 1138 1771 1774 1139 1624 1201 583 436 1141 1161 163 1160\n", + " 1165 437 557 453 430 483 1140 482 1399 811 559 1162 426 464\n", + " 1166 1167 1131 456 1594 392 1756 1750 1888 1635 1889]\n", + "\n", + "Selected subset: (63, 4)\n", + " smiles mw logp \\\n", + "108 COC1=CC=C(Br)C(S(=O)(=O)N2CCCCCC2C2CCCO2)=C1F 435.05152 3.7091 \n", + "1299 COC1=CC=C(F)C(S(=O)(=O)N2CCN(C3CCC(C)CC3)CC2)=C1F 388.16322 2.8584 \n", + "1300 COC1=CC=C(F)C(S(=O)(=O)N2CCN3C4=CC=CC=C4CCC3C2... 394.11627 2.7991 \n", + "\n", + " n_rings \n", + "108 3.0 \n", + "1299 3.0 \n", + "1300 4.0 \n" + ] + } + ], + "source": [ + "# # Export all metadata + coordinates from TmapViz\n", + "# viz_df = viz.to_dataframe(include_coords=True)\n", + "# print(f\"Exported DataFrame: {viz_df.shape}\")\n", + "# print(viz_df.head(3))\n", + "\n", + "# Check the points you just selected\n", + "print(\"Index for selected poitns: \",widget.selection())\n", + "\n", + "# Export just selected points\n", + "selected_idx = scatter.selection()\n", + "if len(selected_idx) > 0:\n", + " selected_df = df.iloc[selected_idx]\n", + " print(f\"\\nSelected subset: {selected_df.shape}\")\n", + " print(selected_df.head(3))\n" + ] + }, + { + "cell_type": "markdown", + "id": "i78w63xuetk", "metadata": {}, "source": [ "## Notes\n", "\n", - "- notebook widgets are best for local exploration\n", - "- HTML export still gives the best browser sharing story\n", - "- tree edges are not drawn in the notebook widget yet\n" + "- `model.plot()` is the quickest path -- returns a `jscatter.Scatter` directly\n", + "- `viz.to_widget()` adds a color-switching dropdown for multiple layers\n", + "- Tree edges are not drawn in notebook widgets -- use `model.to_html()` for edge rendering\n", + "- Full jscatter API: https://jscatter.dev" ] } ], diff --git a/notebooks/06_metric_guide.ipynb b/notebooks/06_metric_guide.ipynb index 74eaf72..db20101 100644 --- a/notebooks/06_metric_guide.ipynb +++ b/notebooks/06_metric_guide.ipynb @@ -17,17 +17,23 @@ "\n", "| Your data | Metric | Backend | Good for |\n", "|-----------|--------|---------|----------|\n", - "| Binary matrix | `jaccard` | MinHash + LSHForest | Molecular fingerprints and other 0/1 features |\n", - "| Dense float matrix | `cosine` | USearch | Embeddings where direction matters |\n", - "| Dense float matrix | `euclidean` | USearch | Embeddings where magnitude matters |\n", - "| Distance matrix | `precomputed` | Direct graph construction | Distances you already computed |\n" + "| Binary matrix | `jaccard` | USearch HNSW (Jaccard on raw bits) | Molecular fingerprints and other 0/1 features |\n", + "| Sparse matrix (CSR) | `jaccard` | MinHash + LSHForest | Large sparse binary data (e.g. single-cell) |\n", + "| List of sets/strings | `jaccard` | MinHash + LSHForest | Variable-length token collections |\n", + "| Dense float matrix | `cosine` | USearch HNSW | Embeddings where direction matters |\n", + "| Dense float matrix | `euclidean` | USearch HNSW | Embeddings where magnitude matters |\n", + "| Distance matrix | `precomputed` | Direct graph construction | Distances you already computed |\n", + "\n", + "The backend is selected automatically based on the input type. Binary matrices get USearch (high recall, low memory). Sparse matrices and variable-length inputs get MinHash+LSH." ] }, { "cell_type": "markdown", "metadata": {}, "source": [ - "## 1. Jaccard For Binary Fingerprints\n" + "## 1. Jaccard For Binary Fingerprints\n", + "\n", + "Binary matrices are routed to USearch automatically. USearch builds an HNSW graph using native bitwise Jaccard distance — no MinHash encoding needed. This gives ~98% recall vs ~1% for MinHash+LSH on sparse fingerprints." ] }, { @@ -35,13 +41,6 @@ "execution_count": 1, "metadata": {}, "outputs": [ - { - "name": "stderr", - "output_type": "stream", - "text": [ - "OMP: Info #276: omp_set_nested routine deprecated, please use omp_set_max_active_levels instead.\n" - ] - }, { "name": "stdout", "output_type": "stream", @@ -71,24 +70,17 @@ }, { "cell_type": "code", - "execution_count": 3, + "execution_count": 2, "metadata": {}, "outputs": [ { "name": "stdout", "output_type": "stream", "text": [ - "Collecting usearch\n", - " Using cached usearch-2.23.0-cp312-cp312-macosx_11_0_arm64.whl.metadata (33 kB)\n", + "Requirement already satisfied: usearch in /Users/afloresep/miniforge3/envs/example2/lib/python3.12/site-packages (2.23.0)\n", "Requirement already satisfied: numpy in /Users/afloresep/miniforge3/envs/example2/lib/python3.12/site-packages (from usearch) (2.4.3)\n", "Requirement already satisfied: tqdm in /Users/afloresep/miniforge3/envs/example2/lib/python3.12/site-packages (from usearch) (4.67.3)\n", - "Collecting simsimd<7.0.0,>=6.0.5 (from usearch)\n", - " Using cached simsimd-6.5.16-cp312-cp312-macosx_11_0_arm64.whl.metadata (70 kB)\n", - "Using cached usearch-2.23.0-cp312-cp312-macosx_11_0_arm64.whl (401 kB)\n", - "Using cached simsimd-6.5.16-cp312-cp312-macosx_11_0_arm64.whl (94 kB)\n", - "Installing collected packages: simsimd, usearch\n", - "\u001b[2K \u001b[38;2;114;156;31m━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━\u001b[0m \u001b[32m2/2\u001b[0m [usearch]\n", - "\u001b[1A\u001b[2KSuccessfully installed simsimd-6.5.16 usearch-2.23.0\n", + "Requirement already satisfied: simsimd<7.0.0,>=6.0.5 in /Users/afloresep/miniforge3/envs/example2/lib/python3.12/site-packages (from usearch) (6.5.16)\n", "Note: you may need to restart the kernel to use updated packages.\n", "(2000, 2)\n" ] @@ -111,7 +103,7 @@ }, { "cell_type": "code", - "execution_count": 4, + "execution_count": 3, "metadata": {}, "outputs": [ { @@ -136,7 +128,7 @@ }, { "cell_type": "code", - "execution_count": 5, + "execution_count": 4, "metadata": {}, "outputs": [ { @@ -160,10 +152,13 @@ "source": [ "## Rule Of Thumb\n", "\n", - "- use `jaccard` for binary chemistry fingerprints\n", + "- use `jaccard` with a binary matrix for chemistry fingerprints (auto-uses USearch)\n", + "- use `jaccard` with a sparse matrix for large single-cell data (auto-uses MinHash+LSH)\n", "- use `cosine` for learned embeddings\n", "- use `euclidean` when vector magnitude matters\n", - "- use `precomputed` when another tool already gave you distances\n" + "- use `precomputed` when another tool already gave you distances\n", + "\n", + "See `docs/usearch_backend.md` for detailed benchmarks comparing USearch vs MinHash+LSH." ] } ], diff --git a/notebooks/07_faq.ipynb b/notebooks/07_faq.ipynb index 77b1ce9..19f80f4 100644 --- a/notebooks/07_faq.ipynb +++ b/notebooks/07_faq.ipynb @@ -24,11 +24,7 @@ { "cell_type": "markdown", "metadata": {}, - "source": [ - "## My map changes between runs\n", - "\n", - "Set `seed=42`. If you also pass a `LayoutConfig`, set `cfg.deterministic = True` and `cfg.seed = 42`.\n" - ] + "source": "## My map changes between runs\n\nSet `seed=42`. If you also pass a `LayoutConfig`, set `cfg.deterministic = True` and `cfg.seed = 42`.\n\nThe `seed` controls the OGDF tree layout, which is fully deterministic: same kNN graph + same seed = identical coordinates.\n\nThe kNN step depends on the backend:\n\n- **MinHash + LSHForest** (sets / strings): deterministic for a given seed.\n- **USearch HNSW** (binary matrices, cosine, euclidean): approximate and multi-threaded. Neighbor sets may vary slightly across runs or platforms, but the resulting trees are nearly identical because the MST is robust to small kNN variations.\n\nIf you need bit-exact reproducibility for binary data, use the MinHash + LSHForest pipeline directly (see [03_legacy_lsh_pipeline.ipynb](03_legacy_lsh_pipeline.ipynb))." }, { "cell_type": "markdown", @@ -58,6 +54,54 @@ "\n", "Notebook widgets focus on points, colors, and filters. Use HTML export when you want browser rendering with tree edges.\n" ] + }, + { + "cell_type": "markdown", + "id": "iaeeohoyhtj", + "source": "## How do I choose between Jaccard and cosine/euclidean?\n\n- **Jaccard** (default): binary fingerprints, one-hot encodings, sparse binary data. Uses MinHash + LSHForest.\n- **Cosine**: dense embeddings (ESM-2, ProtTrans, sentence transformers). Uses USearch.\n- **Euclidean**: dense features where absolute magnitude matters. Uses USearch.\n- **Precomputed**: you already have a distance matrix. Pass it directly.\n\n```python\n# Binary fingerprints → jaccard\nTMAP(metric=\"jaccard\").fit(binary_matrix)\n\n# Dense embeddings → cosine or euclidean\nTMAP(metric=\"cosine\").fit(embeddings)\n\n# Pre-computed distances\nTMAP(metric=\"precomputed\").fit(distance_matrix)\n```", + "metadata": {} + }, + { + "cell_type": "markdown", + "id": "u6x4433h1r", + "source": "## How do I add new points to an existing map?\n\n`add_points()` inserts new points into a fitted model — extends the tree and embedding without refitting.\n`transform()` places new points on the map without modifying the model.\n\n```python\nmodel = TMAP().fit(X_train)\nmodel.add_points(X_new) # mutates model, extends tree\ncoords = model.transform(X_test) # read-only projection\n```", + "metadata": {} + }, + { + "cell_type": "markdown", + "id": "c5i2uvincmd", + "source": "## How do I find paths or distances in the tree?\n\n```python\npath = model.path(idx_a, idx_b) # list of node indices along tree path\nd = model.distance(idx_a, idx_b) # sum of edge weights\npseudotime = model.distances_from(idx) # tree distance to all other points\n```", + "metadata": {} + }, + { + "cell_type": "markdown", + "id": "1i7oq7pm708", + "source": "## How do I load protein sequences?\n\n```python\nfrom tmap.utils import read_fasta, read_protein_csv, read_id_list\n\nids, seqs = read_fasta(\"proteins.fa\")\nids, seqs = read_protein_csv(\"data.csv\", id_col=\"accession\", seq_col=\"sequence\")\nids = read_id_list(\"uniprot_ids.txt\")\n```", + "metadata": {} + }, + { + "cell_type": "markdown", + "id": "b545aq4qf0b", + "source": "## How do I save and load a fitted model?\n\n```python\nmodel.save(\"my_model.pkl\")\nmodel = TMAP.load(\"my_model.pkl\")\n```", + "metadata": {} + }, + { + "cell_type": "markdown", + "id": "14585wqhmi1", + "source": "## What is `kc` and when should I change it?\n\n`kc` controls the number of random augmentation edges added during MST construction. Higher `kc` produces better-connected trees (fewer detached branches) at the cost of longer layout time. Default is 50, which works well for most datasets.", + "metadata": {} + }, + { + "cell_type": "markdown", + "id": "dkp2v9lzb7r", + "source": "## How do I export to HTML for sharing?\n\n```python\n# Quick export\nmodel.to_html(\"map.html\")\n\n# Full control via TmapViz\nviz = model.to_tmapviz()\nviz.title = \"My Map\"\nviz.add_color_layout(\"Label\", labels, categorical=True)\nviz.write_html(\"map.html\")\n```", + "metadata": {} + }, + { + "cell_type": "markdown", + "id": "zu61ntx8o8", + "source": "## Binary fingerprints: MinHash or USearch Jaccard?\n\nThe estimator auto-routes binary matrices to USearch and sets/strings to MinHash + LSHForest.\n\n| | USearch binary Jaccard | MinHash + LSHForest |\n|---|---|---|\n| **Distances** | Exact Jaccard | Approximate (via signatures) |\n| **Speed** | Fast (multi-threaded HNSW) | Moderate (Numba-accelerated) |\n| **Determinism** | Approximate (HNSW is multi-threaded) | Fully deterministic for a given seed |\n\nIf you need exact reproducibility across runs, use the MinHash + LSHForest path by passing sparse index lists instead of a dense binary matrix:\n\n```python\n# USearch path (fast, approximate determinism)\nmodel = TMAP(metric=\"jaccard\").fit(binary_matrix)\n\n# MinHash+LSH path (deterministic)\nsets = [np.where(row)[0].tolist() for row in binary_matrix]\nmodel = TMAP(metric=\"jaccard\", seed=42).fit(sets)\n```", + "metadata": {} } ], "metadata": { @@ -73,4 +117,4 @@ }, "nbformat": 4, "nbformat_minor": 5 -} +} \ No newline at end of file diff --git a/notebooks/08_cheminformatics.ipynb b/notebooks/08_cheminformatics.ipynb index 0319835..297a8ef 100644 --- a/notebooks/08_cheminformatics.ipynb +++ b/notebooks/08_cheminformatics.ipynb @@ -20,7 +20,7 @@ }, { "cell_type": "code", - "execution_count": 2, + "execution_count": 1, "metadata": {}, "outputs": [ { @@ -49,7 +49,7 @@ }, { "cell_type": "code", - "execution_count": 3, + "execution_count": 2, "metadata": {}, "outputs": [ { @@ -83,16 +83,9 @@ }, { "cell_type": "code", - "execution_count": 4, + "execution_count": 3, "metadata": {}, "outputs": [ - { - "name": "stderr", - "output_type": "stream", - "text": [ - "OMP: Info #276: omp_set_nested routine deprecated, please use omp_set_max_active_levels instead.\n" - ] - }, { "name": "stdout", "output_type": "stream", @@ -120,7 +113,7 @@ }, { "cell_type": "code", - "execution_count": 6, + "execution_count": 4, "metadata": {}, "outputs": [], "source": [ @@ -143,21 +136,21 @@ }, { "cell_type": "code", - "execution_count": 7, + "execution_count": 5, "metadata": {}, "outputs": [ { "name": "stderr", "output_type": "stream", "text": [ - "/var/folders/zw/c0mr_7jx7t3bz1k6_9n9wh3r0000gn/T/ipykernel_80320/54314555.py:1: UserWarning: Edges are not supported in notebook mode yet and will be ignored.\n", + "/var/folders/zw/c0mr_7jx7t3bz1k6_9n9wh3r0000gn/T/ipykernel_85663/54314555.py:1: UserWarning: Edges are not supported in notebook mode yet and will be ignored.\n", " widget = viz.to_widget(width=1000, height=650, controls=True)\n" ] }, { "data": { "application/vnd.jupyter.widget-view+json": { - "model_id": "0a9c64ccf8ac4b488c34022fe1c6ecab", + "model_id": "c7a82892d743405b9bf83426ba00ed89", "version_major": 2, "version_minor": 0 }, @@ -165,7 +158,7 @@ "VBox(children=(HBox(children=(Dropdown(description='Color:', options=('MW', 'LogP', 'Ring Count', 'QED'), valu…" ] }, - "execution_count": 7, + "execution_count": 5, "metadata": {}, "output_type": "execute_result" } @@ -184,7 +177,7 @@ }, { "cell_type": "code", - "execution_count": 8, + "execution_count": 6, "metadata": {}, "outputs": [ { @@ -209,7 +202,7 @@ }, { "cell_type": "code", - "execution_count": 9, + "execution_count": 7, "metadata": {}, "outputs": [ { diff --git a/notebooks/09_protein_analysis.ipynb b/notebooks/09_protein_analysis.ipynb index 22619c4..a1955c8 100644 --- a/notebooks/09_protein_analysis.ipynb +++ b/notebooks/09_protein_analysis.ipynb @@ -9,14 +9,15 @@ "\n", "Two common starting points for protein TMAP:\n", "\n", - "- **Part A** — You have a FASTA file and want to explore sequence properties\n", - "- **Part B** — You have pre-computed embeddings (ESM-2, ProtTrans, etc.) and want\n", - " to build a large-scale map with AlphaFold / UniProt annotations\n", + "- **Part A** -- You have a FASTA file and want to explore sequence properties. \n", + " No external dependencies beyond TMAP.\n", + "- **Part B** -- You have pre-computed embeddings (ESM, ESM-2, ProtTrans, etc.) and want\n", + " to build a large-scale map with AlphaFold / UniProt annotations.\n", + " Requires pre-computed embedding files.\n", + "- **Part C** -- You have all-vs-all alignment results (MMseqs2, Foldseek, BLAST)\n", + " and want to build a TMAP from sequence or structure similarity.\n", "\n", - "This notebook shows both, then demonstrates `add_metadata` and `fetch_alphafold`\n", - "to annotate the map.\n", - "\n", - "**Requirements:** `pip install tmap`\n" + "**Requirements:** `pip install tmap`" ] }, { @@ -27,7 +28,7 @@ "---\n", "## Part A: From FASTA to TMAP\n", "\n", - "The most common starting point — you have a FASTA file of protein sequences.\n", + "The most common starting point -- you have a FASTA file of protein sequences.\n", "\n", "TMAP provides three file readers in `tmap.utils`:\n", "\n", @@ -35,7 +36,7 @@ "|--------|----------|-------|\n", "| FASTA (.fa, .fasta) | `read_fasta(path)` | Sequences + headers |\n", "| CSV / TSV | `read_protein_csv(path, id_col, seq_col)` | Tabular data |\n", - "| ID list (.txt) | `read_id_list(path)` | One UniProt accession per line |\n" + "| ID list (.txt) | `read_id_list(path)` | One UniProt accession per line |" ] }, { @@ -43,12 +44,12 @@ "id": "fasta-header", "metadata": {}, "source": [ - "### 1. Load sequences from FASTA\n" + "### 1. Load sequences from FASTA" ] }, { "cell_type": "code", - "execution_count": 1, + "execution_count": null, "id": "fasta-parse", "metadata": {}, "outputs": [ @@ -57,7 +58,7 @@ "output_type": "stream", "text": [ "15177 sequences loaded\n", - "Length range: 20 – 1664 aa\n", + "Length range: 20 -- 1664 aa\n", "First ID: d1dlwa_\n", "First seq: SLFEQLGGQAAVQAVTAQFYANIQADATVATFFNGIDMPNQTNKTAAFLCAALGGPNAWT...\n" ] @@ -67,11 +68,11 @@ "import numpy as np\n", "from tmap.utils import read_fasta\n", "\n", - "# SCOPe ASTRAL 40% subset — protein domains with structural classification\n", + "# SCOPe ASTRAL 40% subset -- protein domains with structural classification\n", "ids_fasta, sequences = read_fasta(\"../examples/data/scope_cache/astral_40.fa\", max_seqs=50_000)\n", "\n", "print(f\"{len(sequences)} sequences loaded\")\n", - "print(f\"Length range: {min(len(s) for s in sequences)} – {max(len(s) for s in sequences)} aa\")\n", + "print(f\"Length range: {min(len(s) for s in sequences)} -- {max(len(s) for s in sequences)} aa\")\n", "print(f\"First ID: {ids_fasta[0]}\")\n", "print(f\"First seq: {sequences[0][:60]}...\")\n" ] @@ -89,7 +90,7 @@ "\n", "# Plain text ID list (one per line, # comments allowed)\n", "ids = read_id_list(\"uniprot_ids.txt\")\n", - "```\n" + "```" ] }, { @@ -100,12 +101,12 @@ "### 2. Compute sequence properties\n", "\n", "`sequence_properties` computes physicochemical descriptors from amino acid\n", - "sequences — no external dependencies, no network access.\n" + "sequences -- no external dependencies, no network access." ] }, { "cell_type": "code", - "execution_count": 2, + "execution_count": null, "id": "seqprops", "metadata": {}, "outputs": [ @@ -154,13 +155,13 @@ "\n", "For a quick exploration without pre-computed embeddings, we can encode\n", "sequences as **k-mer frequency vectors** and use cosine distance.\n", - "This is fast and dependency-free — a good first pass before investing in\n", - "ESM-2 embeddings.\n" + "This is fast and dependency-free -- a good first pass before investing in\n", + "ESM-2 embeddings." ] }, { "cell_type": "code", - "execution_count": 3, + "execution_count": null, "id": "kmer-encode", "metadata": {}, "outputs": [ @@ -200,7 +201,7 @@ }, { "cell_type": "code", - "execution_count": 5, + "execution_count": null, "id": "fasta-fit", "metadata": {}, "outputs": [ @@ -208,18 +209,6 @@ "name": "stdout", "output_type": "stream", "text": [ - "Collecting usearch\n", - " Using cached usearch-2.23.0-cp312-cp312-macosx_11_0_arm64.whl.metadata (33 kB)\n", - "Requirement already satisfied: numpy in /Users/afloresep/work/tmap2/.venv/lib/python3.12/site-packages (from usearch) (2.3.5)\n", - "Requirement already satisfied: tqdm in /Users/afloresep/work/tmap2/.venv/lib/python3.12/site-packages (from usearch) (4.67.3)\n", - "Collecting simsimd<7.0.0,>=6.0.5 (from usearch)\n", - " Using cached simsimd-6.5.16-cp312-cp312-macosx_11_0_arm64.whl.metadata (70 kB)\n", - "Using cached usearch-2.23.0-cp312-cp312-macosx_11_0_arm64.whl (401 kB)\n", - "Using cached simsimd-6.5.16-cp312-cp312-macosx_11_0_arm64.whl (94 kB)\n", - "Installing collected packages: simsimd, usearch\n", - "\u001b[2K \u001b[38;2;114;156;31m━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━\u001b[0m \u001b[32m2/2\u001b[0m [usearch]\n", - "\u001b[1A\u001b[2KSuccessfully installed simsimd-6.5.16 usearch-2.23.0\n", - "Note: you may need to restart the kernel to use updated packages.\n", "Embedding: (15177, 2)\n", "Tree edges: 15176\n" ] @@ -236,98 +225,25 @@ }, { "cell_type": "markdown", - "id": "fasta-viz-header", + "id": "fasta-plot-header", "metadata": {}, "source": [ - "### 4. Add metadata and visualize\n", + "### 4. Sequence properties as color layers\n", "\n", - "Pass the sequence properties dict directly to `add_metadata` — it\n", - "auto-detects continuous vs. categorical for each column.\n" + "Use the estimator's built-in `plot()` to explore sequence properties\n", + "interactively. Pass a DataFrame to `data=` and select which column\n", + "to color by." ] }, { "cell_type": "code", - "execution_count": 7, - "id": "fasta-viz", + "execution_count": null, + "id": "fasta-plot-props", "metadata": {}, - "outputs": [ - { - "name": "stdout", - "output_type": "stream", - "text": [ - "Layouts: ['length', 'molecular_weight', 'isoelectric_point', 'gravy', 'charge_at_ph7', 'aromaticity', 'aliphatic_index', 'frac_charged', 'frac_hydrophobic', 'frac_polar', 'frac_acidic', 'frac_basic', 'n_cysteines', 'SCOP class']\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "/var/folders/zw/c0mr_7jx7t3bz1k6_9n9wh3r0000gn/T/ipykernel_81674/2397682253.py:8: UserWarning: Continuous layout 'length' contains NaN values. NaN points will be rendered in black (#000000).\n", - " viz.add_color_layout(key, seq_props[key])\n", - "/var/folders/zw/c0mr_7jx7t3bz1k6_9n9wh3r0000gn/T/ipykernel_81674/2397682253.py:8: UserWarning: Continuous layout 'molecular_weight' contains NaN values. NaN points will be rendered in black (#000000).\n", - " viz.add_color_layout(key, seq_props[key])\n", - "/var/folders/zw/c0mr_7jx7t3bz1k6_9n9wh3r0000gn/T/ipykernel_81674/2397682253.py:8: UserWarning: Continuous layout 'isoelectric_point' contains NaN values. NaN points will be rendered in black (#000000).\n", - " viz.add_color_layout(key, seq_props[key])\n", - "/var/folders/zw/c0mr_7jx7t3bz1k6_9n9wh3r0000gn/T/ipykernel_81674/2397682253.py:8: UserWarning: Continuous layout 'gravy' contains NaN values. NaN points will be rendered in black (#000000).\n", - " viz.add_color_layout(key, seq_props[key])\n", - "/var/folders/zw/c0mr_7jx7t3bz1k6_9n9wh3r0000gn/T/ipykernel_81674/2397682253.py:8: UserWarning: Continuous layout 'charge_at_ph7' contains NaN values. NaN points will be rendered in black (#000000).\n", - " viz.add_color_layout(key, seq_props[key])\n", - "/var/folders/zw/c0mr_7jx7t3bz1k6_9n9wh3r0000gn/T/ipykernel_81674/2397682253.py:8: UserWarning: Continuous layout 'aromaticity' contains NaN values. NaN points will be rendered in black (#000000).\n", - " viz.add_color_layout(key, seq_props[key])\n", - "/var/folders/zw/c0mr_7jx7t3bz1k6_9n9wh3r0000gn/T/ipykernel_81674/2397682253.py:8: UserWarning: Continuous layout 'aliphatic_index' contains NaN values. NaN points will be rendered in black (#000000).\n", - " viz.add_color_layout(key, seq_props[key])\n", - "/var/folders/zw/c0mr_7jx7t3bz1k6_9n9wh3r0000gn/T/ipykernel_81674/2397682253.py:8: UserWarning: Continuous layout 'frac_charged' contains NaN values. NaN points will be rendered in black (#000000).\n", - " viz.add_color_layout(key, seq_props[key])\n", - "/var/folders/zw/c0mr_7jx7t3bz1k6_9n9wh3r0000gn/T/ipykernel_81674/2397682253.py:8: UserWarning: Continuous layout 'frac_hydrophobic' contains NaN values. NaN points will be rendered in black (#000000).\n", - " viz.add_color_layout(key, seq_props[key])\n", - "/var/folders/zw/c0mr_7jx7t3bz1k6_9n9wh3r0000gn/T/ipykernel_81674/2397682253.py:8: UserWarning: Continuous layout 'frac_polar' contains NaN values. NaN points will be rendered in black (#000000).\n", - " viz.add_color_layout(key, seq_props[key])\n", - "/var/folders/zw/c0mr_7jx7t3bz1k6_9n9wh3r0000gn/T/ipykernel_81674/2397682253.py:8: UserWarning: Continuous layout 'frac_acidic' contains NaN values. NaN points will be rendered in black (#000000).\n", - " viz.add_color_layout(key, seq_props[key])\n", - "/var/folders/zw/c0mr_7jx7t3bz1k6_9n9wh3r0000gn/T/ipykernel_81674/2397682253.py:8: UserWarning: Continuous layout 'frac_basic' contains NaN values. NaN points will be rendered in black (#000000).\n", - " viz.add_color_layout(key, seq_props[key])\n", - "/var/folders/zw/c0mr_7jx7t3bz1k6_9n9wh3r0000gn/T/ipykernel_81674/2397682253.py:8: UserWarning: Continuous layout 'n_cysteines' contains NaN values. NaN points will be rendered in black (#000000).\n", - " viz.add_color_layout(key, seq_props[key])\n", - "/Users/afloresep/work/tmap2/.venv/lib/python3.12/site-packages/jscatter/utils.py:387: UserWarning: Color data contains missing values. Those missing values will be replaced with zeros.\n", - " warnings.warn(\n", - "/Users/afloresep/work/tmap2/src/tmap/visualization/tmapviz.py:1336: UserWarning: Edges are not supported in notebook mode yet and will be ignored.\n", - " scatter = self.to_widget(width=width, height=height, controls=controls)\n" - ] - }, - { - "data": { - "application/vnd.jupyter.widget-view+json": { - "model_id": "7bbba8c610fa407ca35b1c75f93d2d32", - "version_major": 2, - "version_minor": 0 - }, - "text/plain": [ - "VBox(children=(HBox(children=(Dropdown(description='Color:', options=('length', 'molecular_weight', 'isoelectr…" - ] - }, - "metadata": {}, - "output_type": "display_data" - }, - { - "data": { - "text/plain": [ - "" - ] - }, - "execution_count": 7, - "metadata": {}, - "output_type": "execute_result" - } - ], + "outputs": [], "source": [ "import re\n", - "\n", - "viz = model_fasta.to_tmapviz()\n", - "viz.title = \"SCOPe Protein Domains — 3-mer TMAP\"\n", - "\n", - "# Bulk-add all sequence properties as color layers\n", - "for key in seq_props.keys():\n", - " viz.add_color_layout(key, seq_props[key])\n", + "import pandas as pd\n", "\n", "# Parse SCOP class from headers (a=all-alpha, b=all-beta, c=a/b, d=a+b, ...)\n", "scop_class_names = {\n", @@ -340,6 +256,42 @@ " m = scop_re.search(h)\n", " classes.append(scop_class_names.get(m.group(1), \"other\") if m else \"other\")\n", "\n", + "props_df = pd.DataFrame(seq_props)\n", + "props_df[\"scop_class\"] = classes\n", + "\n", + "model_fasta.plot(\n", + " color_by=\"gravy\",\n", + " data=props_df,\n", + " tooltip_properties=[\"length\", \"molecular_weight\", \"isoelectric_point\"],\n", + " point_size=2,\n", + ")\n" + ] + }, + { + "cell_type": "markdown", + "id": "fasta-viz-header", + "metadata": {}, + "source": [ + "### 5. TmapViz export\n", + "\n", + "Pass the sequence properties dict directly to `add_color_layout` --\n", + "it auto-detects continuous vs. categorical for each column." + ] + }, + { + "cell_type": "code", + "execution_count": null, + "id": "fasta-viz", + "metadata": {}, + "outputs": [], + "source": [ + "viz = model_fasta.to_tmapviz()\n", + "viz.title = \"SCOPe Protein Domains -- 3-mer TMAP\"\n", + "\n", + "# Bulk-add all sequence properties as color layers\n", + "for key in seq_props.keys():\n", + " viz.add_color_layout(key, seq_props[key])\n", + "\n", "viz.add_color_layout(\"SCOP class\", classes, categorical=True, color=\"Set2\")\n", "\n", "print(f\"Layouts: {[l.name for l in viz.layouts]}\")\n", @@ -348,31 +300,10 @@ }, { "cell_type": "code", - "execution_count": 8, + "execution_count": null, "id": "fasta-static", "metadata": {}, - "outputs": [ - { - "data": { - "text/plain": [ - "" - ] - }, - "execution_count": 8, - "metadata": {}, - "output_type": "execute_result" - }, - { - "data": { - "image/png": "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", - "text/plain": [ - "
" - ] - }, - "metadata": {}, - "output_type": "display_data" - } - ], + "outputs": [], "source": [ "model_fasta.plot_static(color_by=classes, color_map=\"Set2\", point_size=3)\n" ] @@ -391,7 +322,12 @@ "2. **UniProt IDs** for each protein\n", "\n", "We load 49k ESM-2 embeddings and annotate them with AlphaFold structural\n", - "metadata and UniProt annotations.\n" + "metadata and UniProt annotations.\n", + "\n", + "ESM-2 embeddings can be generated with:\n", + "- `esm` Python package (Meta)\n", + "- ESM Metagenomic Atlas API\n", + "- Local inference with `fair-esm`" ] }, { @@ -399,28 +335,19 @@ "id": "load-emb-header", "metadata": {}, "source": [ - "### 5. Load embeddings\n" + "### 5. Load embeddings\n", + "\n", + "This assumes pre-computed embeddings saved as NumPy arrays.\n", + "The paths `../data/embeddings.npy` and `../data/ids.npy` are dataset-specific --\n", + "replace them with your own." ] }, { "cell_type": "code", - "execution_count": 9, + "execution_count": null, "id": "load-emb", "metadata": {}, - "outputs": [ - { - "ename": "FileNotFoundError", - "evalue": "[Errno 2] No such file or directory: '../data/embeddings.npy'", - "output_type": "error", - "traceback": [ - "\u001b[31m---------------------------------------------------------------------------\u001b[39m", - "\u001b[31mFileNotFoundError\u001b[39m Traceback (most recent call last)", - "\u001b[36mCell\u001b[39m\u001b[36m \u001b[39m\u001b[32mIn[9]\u001b[39m\u001b[32m, line 1\u001b[39m\n\u001b[32m----> \u001b[39m\u001b[32m1\u001b[39m embeddings = \u001b[43mnp\u001b[49m\u001b[43m.\u001b[49m\u001b[43mload\u001b[49m\u001b[43m(\u001b[49m\u001b[33;43m\"\u001b[39;49m\u001b[33;43m../data/embeddings.npy\u001b[39;49m\u001b[33;43m\"\u001b[39;49m\u001b[43m)\u001b[49m.astype(np.float32)\n\u001b[32m 2\u001b[39m ids = np.load(\u001b[33m\"\u001b[39m\u001b[33m../data/ids.npy\u001b[39m\u001b[33m\"\u001b[39m, allow_pickle=\u001b[38;5;28;01mTrue\u001b[39;00m)\n\u001b[32m 4\u001b[39m \u001b[38;5;28mprint\u001b[39m(\u001b[33mf\u001b[39m\u001b[33m\"\u001b[39m\u001b[33mEmbeddings: \u001b[39m\u001b[38;5;132;01m{\u001b[39;00membeddings.shape\u001b[38;5;132;01m}\u001b[39;00m\u001b[33m (\u001b[39m\u001b[38;5;132;01m{\u001b[39;00membeddings.dtype\u001b[38;5;132;01m}\u001b[39;00m\u001b[33m)\u001b[39m\u001b[33m\"\u001b[39m)\n", - "\u001b[36mFile \u001b[39m\u001b[32m~/work/tmap2/.venv/lib/python3.12/site-packages/numpy/lib/_npyio_impl.py:454\u001b[39m, in \u001b[36mload\u001b[39m\u001b[34m(file, mmap_mode, allow_pickle, fix_imports, encoding, max_header_size)\u001b[39m\n\u001b[32m 452\u001b[39m own_fid = \u001b[38;5;28;01mFalse\u001b[39;00m\n\u001b[32m 453\u001b[39m \u001b[38;5;28;01melse\u001b[39;00m:\n\u001b[32m--> \u001b[39m\u001b[32m454\u001b[39m fid = stack.enter_context(\u001b[38;5;28;43mopen\u001b[39;49m\u001b[43m(\u001b[49m\u001b[43mos\u001b[49m\u001b[43m.\u001b[49m\u001b[43mfspath\u001b[49m\u001b[43m(\u001b[49m\u001b[43mfile\u001b[49m\u001b[43m)\u001b[49m\u001b[43m,\u001b[49m\u001b[43m \u001b[49m\u001b[33;43m\"\u001b[39;49m\u001b[33;43mrb\u001b[39;49m\u001b[33;43m\"\u001b[39;49m\u001b[43m)\u001b[49m)\n\u001b[32m 455\u001b[39m own_fid = \u001b[38;5;28;01mTrue\u001b[39;00m\n\u001b[32m 457\u001b[39m \u001b[38;5;66;03m# Code to distinguish from NumPy binary files and pickles.\u001b[39;00m\n", - "\u001b[31mFileNotFoundError\u001b[39m: [Errno 2] No such file or directory: '../data/embeddings.npy'" - ] - } - ], + "outputs": [], "source": [ "embeddings = np.load(\"../data/embeddings.npy\").astype(np.float32)\n", "ids = np.load(\"../data/ids.npy\", allow_pickle=True)\n", @@ -437,28 +364,16 @@ "source": [ "### 6. Fit TMAP on embeddings\n", "\n", - "ESM-2 embeddings are dense float vectors, so use `metric='cosine'`.\n", - "USearch handles the dense nearest-neighbor search automatically.\n" + "Euclidean is the recommended metric for ESM-2 embeddings.\n", + "USearch handles the dense nearest-neighbor search automatically." ] }, { "cell_type": "code", - "execution_count": 10, + "execution_count": null, "id": "fit-emb", "metadata": {}, - "outputs": [ - { - "ename": "NameError", - "evalue": "name 'embeddings' is not defined", - "output_type": "error", - "traceback": [ - "\u001b[31m---------------------------------------------------------------------------\u001b[39m", - "\u001b[31mNameError\u001b[39m Traceback (most recent call last)", - "\u001b[36mCell\u001b[39m\u001b[36m \u001b[39m\u001b[32mIn[10]\u001b[39m\u001b[32m, line 2\u001b[39m\n\u001b[32m 1\u001b[39m \u001b[38;5;66;03m# Euclidean is the recommended for ESM embeddings. Cosine should work as well\u001b[39;00m\n\u001b[32m----> \u001b[39m\u001b[32m2\u001b[39m model = TMAP(metric=\u001b[33m\"\u001b[39m\u001b[33meuclidean\u001b[39m\u001b[33m\"\u001b[39m, n_neighbors=\u001b[32m20\u001b[39m, seed=\u001b[32m42\u001b[39m).fit(\u001b[43membeddings\u001b[49m)\n\u001b[32m 4\u001b[39m \u001b[38;5;28mprint\u001b[39m(\u001b[33mf\u001b[39m\u001b[33m\"\u001b[39m\u001b[33mEmbedding: \u001b[39m\u001b[38;5;132;01m{\u001b[39;00mmodel.embedding_.shape\u001b[38;5;132;01m}\u001b[39;00m\u001b[33m\"\u001b[39m)\n\u001b[32m 5\u001b[39m \u001b[38;5;28mprint\u001b[39m(\u001b[33mf\u001b[39m\u001b[33m\"\u001b[39m\u001b[33mTree edges: \u001b[39m\u001b[38;5;132;01m{\u001b[39;00mmodel.tree_.edges.shape[\u001b[32m0\u001b[39m]\u001b[38;5;132;01m}\u001b[39;00m\u001b[33m\"\u001b[39m)\n", - "\u001b[31mNameError\u001b[39m: name 'embeddings' is not defined" - ] - } - ], + "outputs": [], "source": [ "# Euclidean is the recommended for ESM embeddings. Cosine should work as well\n", "model = TMAP(metric=\"euclidean\", n_neighbors=20, seed=42).fit(embeddings)\n", @@ -474,77 +389,18 @@ "source": [ "### 7. Fetch AlphaFold structural metadata\n", "\n", - "`fetch_alphafold` queries the AlphaFold DB REST API — one request per protein,\n", + "`fetch_alphafold` queries the AlphaFold DB REST API -- one request per protein,\n", "threaded with 20 workers. For 49k proteins this takes a few minutes.\n", "\n", - "Returns `float32` arrays with NaN for proteins not in AlphaFold DB (~14% missing).\n" + "Returns `float32` arrays with NaN for proteins not in AlphaFold DB (~14% missing)." ] }, { "cell_type": "code", - "execution_count": 9, + "execution_count": null, "id": "af-fetch", "metadata": {}, - "outputs": [ - { - "name": "stdout", - "output_type": "stream", - "text": [ - " [AlphaFold] fetched 999/49,223\n", - " [AlphaFold] fetched 1,999/49,223\n", - " [AlphaFold] fetched 2,999/49,223\n", - " [AlphaFold] fetched 3,999/49,223\n", - " [AlphaFold] fetched 4,999/49,223\n", - " [AlphaFold] fetched 5,999/49,223\n", - " [AlphaFold] fetched 6,999/49,223\n", - " [AlphaFold] fetched 7,999/49,223\n", - " [AlphaFold] fetched 8,999/49,223\n", - " [AlphaFold] fetched 9,999/49,223\n", - " [AlphaFold] fetched 10,999/49,223\n", - " [AlphaFold] fetched 11,999/49,223\n", - " [AlphaFold] fetched 12,999/49,223\n", - " [AlphaFold] fetched 13,999/49,223\n", - " [AlphaFold] fetched 14,999/49,223\n", - " [AlphaFold] fetched 15,999/49,223\n", - " [AlphaFold] fetched 16,999/49,223\n", - " [AlphaFold] fetched 17,999/49,223\n", - " [AlphaFold] fetched 18,999/49,223\n", - " [AlphaFold] fetched 19,999/49,223\n", - " [AlphaFold] fetched 20,999/49,223\n", - " [AlphaFold] fetched 21,999/49,223\n", - " [AlphaFold] fetched 22,999/49,223\n", - " [AlphaFold] fetched 23,999/49,223\n", - " [AlphaFold] fetched 24,999/49,223\n", - " [AlphaFold] fetched 25,999/49,223\n", - " [AlphaFold] fetched 26,999/49,223\n", - " [AlphaFold] fetched 26,999/49,223\n", - " [AlphaFold] fetched 26,999/49,223\n", - " [AlphaFold] fetched 27,999/49,223\n", - " [AlphaFold] fetched 28,999/49,223\n", - " [AlphaFold] fetched 29,999/49,223\n", - " [AlphaFold] fetched 30,999/49,223\n", - " [AlphaFold] fetched 31,999/49,223\n", - " [AlphaFold] fetched 31,999/49,223\n", - " [AlphaFold] fetched 32,999/49,223\n", - " [AlphaFold] fetched 33,999/49,223\n", - " [AlphaFold] fetched 33,999/49,223\n", - " [AlphaFold] fetched 34,999/49,223\n", - " [AlphaFold] fetched 35,999/49,223\n", - " [AlphaFold] fetched 36,999/49,223\n", - " [AlphaFold] fetched 37,999/49,223\n", - " [AlphaFold] fetched 38,999/49,223\n", - " [AlphaFold] fetched 39,999/49,223\n", - " [AlphaFold] fetched 40,999/49,223\n", - " [AlphaFold] fetched 41,999/49,223\n", - " [AlphaFold] fetched 42,999/49,223\n", - " [AlphaFold] done — 43,378/49,223 entries fetched\n", - "length 43,378/49,223 fetched mean=271.12\n", - "plddt 43,378/49,223 fetched mean=70.85\n", - "frac_disordered 43,378/49,223 fetched mean=0.25\n", - "frac_confident 43,378/49,223 fetched mean=0.30\n" - ] - } - ], + "outputs": [], "source": [ "from tmap.utils import fetch_alphafold\n", "\n", @@ -564,28 +420,15 @@ "### 8. Fetch UniProt annotations\n", "\n", "`fetch_uniprot` batch-fetches text annotations (organism, GO terms,\n", - "subcellular location, etc.) via the UniProt REST API.\n" + "subcellular location, etc.) via the UniProt REST API." ] }, { "cell_type": "code", - "execution_count": 10, + "execution_count": null, "id": "uniprot-fetch", "metadata": {}, - "outputs": [ - { - "name": "stdout", - "output_type": "stream", - "text": [ - " [UniProt] fetched 49,223/49,223 entries (0 chunk failures)\n", - " A0A6A4IZ81 deleted \n", - " A0A1I8HDW0 ANK_REP_REGION domain-containing protein Macrostomum lignano\n", - " W6Q037 Flavoprotein transmembrane component Penicillium roqueforti (strain\n", - " A0A4V1C829 Heterokaryon incompatibility domain-cont Pyricularia oryzae (Rice blast\n", - " A0A158JXS0 Uncharacterized protein Caballeronia udeis\n" - ] - } - ], + "outputs": [], "source": [ "from tmap.utils import fetch_uniprot\n", "\n", @@ -606,7 +449,7 @@ "### 9. Visualize with `add_metadata`\n", "\n", "Now we combine everything into a single visualization. `add_metadata`\n", - "auto-detects continuous vs categorical — pass the AlphaFold dict directly.\n" + "auto-detects continuous vs categorical -- pass the AlphaFold dict directly." ] }, { @@ -614,37 +457,23 @@ "execution_count": null, "id": "viz-emb", "metadata": {}, - "outputs": [ - { - "name": "stdout", - "output_type": "stream", - "text": [ - "Color layers: ['Length', 'annotation_score']\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "/var/folders/zw/c0mr_7jx7t3bz1k6_9n9wh3r0000gn/T/ipykernel_80254/965458510.py:7: UserWarning: Continuous layout 'Length' contains NaN values. NaN points will be rendered in black (#000000).\n", - " viz.add_color_layout(\"Length\", up_data[\"length\"].tolist())\n", - "/var/folders/zw/c0mr_7jx7t3bz1k6_9n9wh3r0000gn/T/ipykernel_80254/965458510.py:8: UserWarning: Continuous layout 'annotation_score' contains NaN values. NaN points will be rendered in black (#000000).\n", - " viz.add_color_layout(\"annotation_score\", up_data[\"annotation_score\"].tolist(),\n" - ] - } - ], + "outputs": [], "source": [ "viz = model.to_tmapviz()\n", - "viz.title = \"Protein Embedding Space — 49k ESM-2\"\n", + "viz.title = \"Protein Embedding Space -- 49k ESM-2\"\n", "\n", "# AlphaFold structural metrics as color layers\n", + "viz.add_color_layout(\"pLDDT\", af_data[\"plddt\"].tolist())\n", + "viz.add_color_layout(\"Fraction confident\", af_data[\"frac_confident\"].tolist())\n", + "viz.add_color_layout(\"Fraction disordered\", af_data[\"frac_disordered\"].tolist())\n", "\n", "# UniProt annotation score as a color layer\n", "viz.add_color_layout(\"Length\", up_data[\"length\"].tolist())\n", "viz.add_color_layout(\"annotation_score\", up_data[\"annotation_score\"].tolist(),\n", " categorical=False, color=\"viridis\")\n", - "# # UniProt text fields as tooltip labels\n", - "viz.add_label(\"Subcelullar Location\", up_data[\"cc_subcellular_location\"].tolist())\n", + "\n", + "# UniProt text fields as tooltip labels\n", + "viz.add_label(\"Subcellular Location\", up_data[\"cc_subcellular_location\"].tolist())\n", "viz.add_label(\"Protein\", list(up_data[\"protein_name\"]))\n", "viz.add_label(\"Organism\", list(up_data[\"organism_name\"]))\n", "\n", @@ -654,49 +483,14 @@ "print(f\"Color layers: {[l.name for l in viz.layouts]}\")\n" ] }, - { - "cell_type": "code", - "execution_count": 45, - "id": "export-emb", - "metadata": {}, - "outputs": [ - { - "data": { - "text/plain": [ - "PosixPath('here/Protein Embedding Space — 49k ESM-2.html')" - ] - }, - "execution_count": 45, - "metadata": {}, - "output_type": "execute_result" - } - ], - "source": [ - "# path = viz.write_html(\"protein_embedding_tmap.html\")\n", - "# viz.background_color = \"#040404\"\n", - "# print(f\"Saved: {path}\")\n", - "viz.write_html('here')\n" - ] - }, { "cell_type": "code", "execution_count": null, - "id": "531f520b", + "id": "export-emb", "metadata": {}, - "outputs": [ - { - "data": { - "text/plain": [ - "array(['', '', '', ..., '', '', ''], shape=(49223,), dtype=object)" - ] - }, - "execution_count": 41, - "metadata": {}, - "output_type": "execute_result" - } - ], + "outputs": [], "source": [ - "up_data[\"ec\"][-3]\n" + "# viz.write_html(\"protein_map.html\")\n" ] }, { @@ -716,7 +510,7 @@ "source": [ "### 10. Tree exploration\n", "\n", - "Pick a high-confidence protein and trace pseudotime from it.\n" + "Pick a high-confidence protein and trace pseudotime from it." ] }, { @@ -743,8 +537,8 @@ "source": [ "### 11. Caching fetched data\n", "\n", - "`fetch_alphafold` and `fetch_uniprot` are stateless — they don't cache\n", - "results. For large datasets, save the results yourself:\n" + "`fetch_alphafold` and `fetch_uniprot` are stateless -- they don't cache\n", + "results. For large datasets, save the results yourself:" ] }, { @@ -762,6 +556,62 @@ "# af_data = {k: cached[k] for k in cached.files}\n" ] }, + { + "cell_type": "markdown", + "id": "c-header", + "metadata": {}, + "source": [ + "---\n", + "## Part C: Alignment-based TMAP\n", + "\n", + "When you have all-vs-all alignment results from MMseqs2, Foldseek, or BLAST,\n", + "you can build a TMAP directly from pairwise similarity scores using\n", + "`parse_alignment`. This avoids embedding entirely -- the alignment scores\n", + "*are* the similarity metric.\n", + "\n", + "Input: standard BLAST6 / m8 tabular format (12 tab-separated columns):\n", + "```\n", + "qseqid sseqid pident length mismatch gapopen qstart qend sstart send evalue bitscore\n", + "```" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "id": "alignment-load", + "metadata": {}, + "outputs": [], + "source": [ + "from tmap.utils import parse_alignment\n", + "\n", + "# Load precomputed all-vs-all search (BLAST6 / m8 format)\n", + "# Replace with your own alignment file\n", + "# knn, id_order = parse_alignment(\"hits.m8\", k=20, score_col=\"bitscore\")\n", + "\n", + "# Fit TMAP with precomputed KNN from alignment scores\n", + "# model_aln = TMAP(metric=\"precomputed\").fit(knn_graph=knn)\n", + "# print(f\"Embedding: {model_aln.embedding_.shape}\")\n", + "# print(f\"Proteins: {len(id_order)}\")\n" + ] + }, + { + "cell_type": "markdown", + "id": "alignment-notes", + "metadata": {}, + "source": [ + "`parse_alignment` reads the m8 file, keeps the top-k hits per query\n", + "ranked by `score_col` (default: `bitscore`), and returns a `KNNGraph`\n", + "compatible with `TMAP(metric=\"precomputed\")`.\n", + "\n", + "This works with:\n", + "- **MMseqs2** `easy-search` or `search` output\n", + "- **Foldseek** `easy-search` (structure similarity via 3Di + TM-score)\n", + "- **BLAST** `-outfmt 6` tabular output\n", + "\n", + "Use `score_col=\"evalue\"` for E-value-based ranking (lower = better;\n", + "`parse_alignment` handles the inversion automatically via `as_distance=True`)." + ] + }, { "cell_type": "markdown", "id": "summary", @@ -776,6 +626,7 @@ "| FASTA | `ids, seqs = read_fasta(\"proteins.fa\")` |\n", "| CSV/TSV | `ids, seqs = read_protein_csv(\"data.csv\", id_col=\"accession\", seq_col=\"sequence\")` |\n", "| ID list | `ids = read_id_list(\"uniprot_ids.txt\")` |\n", + "| Alignment (m8) | `knn, ids = parse_alignment(\"hits.m8\", k=20)` |\n", "\n", "### Part A: FASTA workflow\n", "\n", @@ -785,7 +636,8 @@ "| Sequence properties | `props = sequence_properties(seqs)` |\n", "| Encode (k-mers) | `X = kmer_features(seqs, k=3)` |\n", "| Fit TMAP | `model = TMAP(metric=\"cosine\").fit(X)` |\n", - "| Add all metadata | `viz.add_metadata(props)` |\n", + "| Interactive plot | `model.plot(color_by=\"gravy\", data=props_df)` |\n", + "| TmapViz export | `viz.add_color_layout(key, props[key])` |\n", "\n", "For higher quality, replace k-mers with ESM-2 embeddings\n", "(see `examples/protein_fold_space.py`).\n", @@ -795,14 +647,21 @@ "| Step | Code |\n", "|------|------|\n", "| Load embeddings | `emb = np.load(\"embeddings.npy\")` |\n", - "| Fit TMAP | `model = TMAP(metric=\"cosine\").fit(emb)` |\n", + "| Fit TMAP | `model = TMAP(metric=\"euclidean\").fit(emb)` |\n", "| AlphaFold metadata | `af = fetch_alphafold(ids)` |\n", "| UniProt annotations | `up = fetch_uniprot(ids)` |\n", - "| Structural metrics | `viz.add_metadata(af)` |\n", + "| Structural metrics | `viz.add_color_layout(\"pLDDT\", af[\"plddt\"])` |\n", "| Annotation score | `viz.add_color_layout(\"score\", up[\"annotation_score\"])` |\n", "| Tooltip labels | `viz.add_label(\"Protein\", up[\"protein_name\"])` |\n", "| 3D structure viewer | `viz.add_protein_ids(ids)` |\n", - "| Cache results | `np.savez(\"af_cache.npz\", **af)` |\n" + "| Cache results | `np.savez(\"af_cache.npz\", **af)` |\n", + "\n", + "### Part C: Alignment-based\n", + "\n", + "| Step | Code |\n", + "|------|------|\n", + "| Parse alignments | `knn, ids = parse_alignment(\"hits.m8\", k=20)` |\n", + "| Fit TMAP | `model = TMAP(metric=\"precomputed\").fit(knn_graph=knn)` |" ] } ], diff --git a/notebooks/11_card_configuration.ipynb b/notebooks/11_card_configuration.ipynb index 1f50bc1..7ec4aa6 100644 --- a/notebooks/11_card_configuration.ipynb +++ b/notebooks/11_card_configuration.ipynb @@ -329,13 +329,13 @@ ], "metadata": { "kernelspec": { - "display_name": "Python 3", + "display_name": ".venv (3.12.8)", "language": "python", "name": "python3" }, "language_info": { "name": "python", - "version": "3.12" + "version": "3.12.8" } }, "nbformat": 4, diff --git a/notebooks/12_usearch_jaccard.ipynb b/notebooks/12_usearch_jaccard.ipynb new file mode 100644 index 0000000..bce2a0a --- /dev/null +++ b/notebooks/12_usearch_jaccard.ipynb @@ -0,0 +1,281 @@ +{ + "cells": [ + { + "cell_type": "markdown", + "id": "cell-0", + "metadata": {}, + "source": [ + "# USearch Jaccard: Binary kNN without MinHash\n", + "\n", + "TMAP now uses USearch's native Jaccard distance on bit-packed vectors for binary\n", + "fingerprint data. This replaces the MinHash+LSH pipeline for dense binary matrices,\n", + "giving higher recall (98% vs 1%), lower memory (16x), and faster batch queries.\n", + "\n", + "This notebook shows:\n", + "1. How the estimator auto-selects the USearch backend\n", + "2. Using USearchIndex standalone for kNN queries (no layout needed)\n", + "3. Incremental queries with `transform()` and `add_points()`" + ] + }, + { + "cell_type": "markdown", + "id": "cell-1", + "metadata": {}, + "source": [ + "## 1. Estimator: Automatic Backend Selection\n", + "\n", + "Pass a binary matrix to `TMAP(metric='jaccard')` and USearch is used automatically." + ] + }, + { + "cell_type": "code", + "execution_count": 1, + "id": "cell-2", + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Embedding shape: (5000, 2)\n", + "Backend: USearch (index_ available: True)\n", + "LSH forest: False\n" + ] + } + ], + "source": [ + "import numpy as np\n", + "from tmap import TMAP\n", + "\n", + "# Simulate 5000 ECFP-like fingerprints: 2048 bits, ~10% density\n", + "rng = np.random.default_rng(42)\n", + "fingerprints = (rng.random((5000, 2048)) < 0.1).astype(np.uint8)\n", + "\n", + "model = TMAP(metric=\"jaccard\", n_neighbors=20, seed=42).fit(fingerprints)\n", + "print(f\"Embedding shape: {model.embedding_.shape}\")\n", + "print(f\"Backend: USearch (index_ available: {model._index is not None})\")\n", + "print(f\"LSH forest: {model._lsh_forest is not None}\")\n" + ] + }, + { + "cell_type": "markdown", + "id": "cell-3", + "metadata": {}, + "source": [ + "Sets and strings still use MinHash+LSH automatically:" + ] + }, + { + "cell_type": "code", + "execution_count": 6, + "id": "cell-4", + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Backend: LSH (lsh_forest_ available: True)\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "/var/folders/zw/c0mr_7jx7t3bz1k6_9n9wh3r0000gn/T/ipykernel_53388/2928182983.py:3: UserWarning: kNN graph is very sparse: 994/1000 neighbor slots are empty (-1). Embedding quality may be poor. Consider increasing kc (currently 50) or n_permutations (currently 128).\n", + " model_sets = TMAP(metric=\"jaccard\", n_neighbors=5, n_permutations=128, seed=42).fit(sets)\n" + ] + } + ], + "source": [ + "# Variable-length sets -> MinHash + LSH (automatic)\n", + "sets = [sorted(rng.choice(500, 30, replace=False).tolist()) for _ in range(200)]\n", + "model_sets = TMAP(metric=\"jaccard\", n_neighbors=5, n_permutations=128, seed=42).fit(sets)\n", + "print(f\"Backend: LSH (lsh_forest_ available: {model_sets._lsh_forest is not None})\")\n" + ] + }, + { + "cell_type": "markdown", + "id": "cell-5", + "metadata": {}, + "source": [ + "## 2. Standalone USearchIndex: kNN Without Layout\n", + "\n", + "Use `USearchIndex` directly when you just need fast kNN queries, no OGDF or tree layout required." + ] + }, + { + "cell_type": "code", + "execution_count": 7, + "id": "cell-6", + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Index: 5000 points, metric=jaccard\n" + ] + } + ], + "source": [ + "from tmap.index import USearchIndex\n", + "\n", + "# Build index from binary fingerprints\n", + "idx = USearchIndex(seed=42, expansion_search=512)\n", + "idx.build_from_binary(fingerprints)\n", + "print(f\"Index: {idx.n_nodes} points, metric={idx.metric}\")\n" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "id": "cell-7", + "metadata": {}, + "outputs": [], + "source": [ + "# Query single point\n", + "neighbors, distances = idx.query_point(fingerprints[0], k=10)\n", + "print(f\"10 nearest neighbors of point 0: {neighbors}\")\n", + "print(f\"Jaccard distances: {np.round(distances, 4)}\")\n" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "id": "cell-8", + "metadata": {}, + "outputs": [], + "source": [ + "# Batch query: fast, vectorized\n", + "query = fingerprints[:100]\n", + "neighbors, distances = idx.query_batch(query, k=20)\n", + "print(f\"Batch result shape: {neighbors.shape}\")\n", + "print(f\"Distance range: [{distances.min():.4f}, {distances.max():.4f}]\")\n" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "id": "cell-9", + "metadata": {}, + "outputs": [], + "source": [ + "# Full kNN graph (all-vs-all)\n", + "knn = idx.query_knn(k=20)\n", + "print(f\"kNN graph: {knn.indices.shape[0]} points x {knn.indices.shape[1]} neighbors\")\n", + "print(f\"All neighbors found: {(knn.indices >= 0).all()}\")\n" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "id": "cell-10", + "metadata": {}, + "outputs": [], + "source": [ + "# Incremental: add new points to existing index\n", + "new_fps = (rng.random((50, 2048)) < 0.1).astype(np.uint8)\n", + "keys = idx.add(new_fps)\n", + "print(f\"Added {len(keys)} points, index now has {idx.n_nodes} points\")\n", + "\n", + "# New points are immediately queryable\n", + "nb, dist = idx.query_point(new_fps[0], k=5)\n", + "print(f\"Nearest to new point: {nb}\")\n" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "id": "cell-11", + "metadata": {}, + "outputs": [], + "source": [ + "# Save and load\n", + "idx.save(\"/tmp/fingerprint_index.usearch\")\n", + "restored = USearchIndex.load(\"/tmp/fingerprint_index.usearch\")\n", + "print(f\"Restored: {restored.n_nodes} points, metric={restored.metric}\")\n", + "\n", + "# Restored index supports all operations\n", + "nb2, dist2 = restored.query_point(new_fps[0], k=5)\n", + "print(f\"Same results after load: {np.array_equal(nb, nb2)}\")\n" + ] + }, + { + "cell_type": "markdown", + "id": "cell-12", + "metadata": {}, + "source": [ + "## 3. Transform and Add Points\n", + "\n", + "The USearch index is stored automatically for binary Jaccard, so `transform()` and\n", + "`add_points()` work without `store_index=True`." + ] + }, + { + "cell_type": "code", + "execution_count": null, + "id": "cell-13", + "metadata": {}, + "outputs": [], + "source": [ + "# transform: project new points onto existing map (non-mutating)\n", + "new_fps = (rng.random((20, 2048)) < 0.1).astype(np.uint8)\n", + "new_coords = model.transform(new_fps)\n", + "print(f\"Projected {new_coords.shape[0]} new points: shape={new_coords.shape}\")\n" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "id": "cell-14", + "metadata": {}, + "outputs": [], + "source": [ + "# add_points: insert new points into the model (mutating)\n", + "n_before = model.embedding_.shape[0]\n", + "added_coords = model.add_points(new_fps)\n", + "n_after = model.embedding_.shape[0]\n", + "print(f\"Points: {n_before} -> {n_after} (+{n_after - n_before})\")\n" + ] + }, + { + "cell_type": "markdown", + "id": "cell-15", + "metadata": {}, + "source": [ + "## When to Use What\n", + "\n", + "| Use case | Tool |\n", + "|---|---|\n", + "| Build a TMAP from fingerprints | `TMAP(metric='jaccard').fit(X)` — auto-selects USearch |\n", + "| Just need kNN, no layout | `USearchIndex().build_from_binary(X)` |\n", + "| Similarity search against a database | `idx.query_batch(queries, k=50)` |\n", + "| Incremental insertion | `idx.add(new_data)` |\n", + "| Sparse binary data (single-cell) | `TMAP(metric='jaccard').fit(csr_matrix)` — auto-selects LSH |\n", + "| Variable-length sets/strings | `TMAP(metric='jaccard').fit(list_of_sets)` — auto-selects LSH |" + ] + } + ], + "metadata": { + "kernelspec": { + "display_name": ".venv (3.12.8)", + "language": "python", + "name": "python3" + }, + "language_info": { + "codemirror_mode": { + "name": "ipython", + "version": 3 + }, + "file_extension": ".py", + "mimetype": "text/x-python", + "name": "python", + "nbconvert_exporter": "python", + "pygments_lexer": "ipython3", + "version": "3.12.8" + } + }, + "nbformat": 4, + "nbformat_minor": 5 +} diff --git a/src/tmap/estimator.py b/src/tmap/estimator.py index d22e75e..30c9287 100644 --- a/src/tmap/estimator.py +++ b/src/tmap/estimator.py @@ -168,37 +168,68 @@ def fit( self._lsh_forest = None self._n_features = None elif self.metric == "jaccard": - signatures, n_samples, n_features = self._encode_jaccard(X) - self._n_features = n_features - - lsh_l = _select_lsh_l(self.n_permutations, n_samples) - forest = LSHForest(d=self.n_permutations, l=lsh_l) - forest.batch_add(signatures) - del signatures # forest has its own copy - forest.index() - knn = forest.get_knn_graph(k=self.n_neighbors, kc=self.kc) - - # Check that LSH returned a usable graph. - n_missing = int(np.sum(knn.indices == -1)) - n_total = knn.indices.size - if n_total > 0 and n_missing == n_total: - raise ValueError( - "kNN graph is completely empty (all neighbors are -1). " - "The data may be too sparse for LSH to find any neighbors. " - "Try increasing kc, n_permutations, or check that input " - "rows have sufficient overlap." - ) - if n_total > 0 and n_missing / n_total > 0.9: - warnings.warn( - f"kNN graph is very sparse: {n_missing}/{n_total} neighbor " - f"slots are empty (-1). Embedding quality may be poor. " - f"Consider increasing kc (currently {self.kc}) or " - f"n_permutations (currently {self.n_permutations}).", - UserWarning, - stacklevel=2, + # Try the fast USearch path for binary data first. If coercion + # fails (non-0/1 values, ragged lists, etc.), fall through to + # the MinHash + LSH path which handles sets and strings. + _use_usearch = False + if self._is_binary_input(X): + try: + binary = self._coerce_binary_matrix(X) + _use_usearch = True + except (ValueError, TypeError): + pass + + if _use_usearch: + n_samples, n_features = binary.shape + self._n_features = n_features + self._jaccard_mode = "binary" + if self.n_neighbors >= n_samples: + raise ValueError( + f"n_neighbors={self.n_neighbors} must be < n_samples={n_samples}" + ) + index = USearchIndex( + seed=self.seed, + expansion_search=512, ) + index.build_from_binary(binary) + knn = index.query_knn(k=self.n_neighbors) + self._index = index + self._lsh_forest = None + else: + # Sets/strings → MinHash + LSH Forest. + signatures, n_samples, n_features = self._encode_jaccard(X) + self._n_features = n_features - self._lsh_forest = forest + lsh_l = _select_lsh_l(self.n_permutations, n_samples) + forest = LSHForest(d=self.n_permutations, l=lsh_l) + forest.batch_add(signatures) + del signatures # forest has its own copy + forest.index() + knn = forest.get_knn_graph(k=self.n_neighbors, kc=self.kc) + + # Check that LSH returned a usable graph. + n_missing = int(np.sum(knn.indices == -1)) + n_total = knn.indices.size + if n_total > 0 and n_missing == n_total: + raise ValueError( + "kNN graph is completely empty (all neighbors are -1). " + "The data may be too sparse for LSH to find any " + "neighbors. Try increasing kc, n_permutations, or " + "check that input rows have sufficient overlap." + ) + if n_total > 0 and n_missing / n_total > 0.9: + warnings.warn( + f"kNN graph is very sparse: {n_missing}/{n_total} " + f"neighbor slots are empty (-1). Embedding quality " + f"may be poor. Consider increasing kc (currently " + f"{self.kc}) or n_permutations (currently " + f"{self.n_permutations}).", + UserWarning, + stacklevel=2, + ) + + self._lsh_forest = forest + self._index = None elif self.metric == "precomputed": distance_matrix = self._coerce_distance_matrix(X) knn = KNNGraph.from_distance_matrix(distance_matrix, k=self.n_neighbors) @@ -255,6 +286,31 @@ def fit_transform( self.tree_.edges[:, 1], ) + def kneighbors( + self, + X: Any, + *, + return_distance: bool = True, + ) -> NDArray[np.int32] | tuple[NDArray[np.int32], NDArray[np.float32]]: + """Query nearest fitted neighbors for new points without mutating the model. + + Args: + X: Query data in the same format accepted by ``transform()``. + return_distance: If True, return ``(indices, distances)``. + If False, return only ``indices``. + + Returns: + Either ``indices`` with shape ``(m, k)`` or + ``(indices, distances)`` with shapes ``(m, k)``. + """ + if self._embedding is None or self._graph is None: + raise RuntimeError("Estimator is not fitted. Call fit() first.") + + indices, distances, _ = self._query_new_points(X, update_state=False) + if return_distance: + return indices, distances + return indices + def transform(self, X: Any) -> NDArray[np.float32]: """Place new points on the existing map without changing the model. @@ -309,21 +365,33 @@ def graph_(self) -> KNNGraph: @property def lsh_forest_(self) -> LSHForest: - """Return the fitted LSH forest for jaccard models.""" + """Return the fitted LSH forest (sets/strings Jaccard only). + + Only available when ``metric='jaccard'`` and the input was + variable-length (sets or strings). Binary matrix inputs use + USearch instead — access via ``index_``. + """ if self._lsh_forest is None: raise RuntimeError( "No fitted LSHForest available. " - "This estimator was not fitted with metric='jaccard'." + "Binary Jaccard uses USearch (see index_). " + "LSHForest is only used for set/string Jaccard inputs." ) return self._lsh_forest @property def index_(self) -> Any: - """Return the stored ANN index for dense models.""" + """Return the stored USearch index. + + Available for ``metric='cosine'``/``'euclidean'`` (requires + ``store_index=True``) and ``metric='jaccard'`` with binary + matrix input (always stored). + """ if self._index is None: raise RuntimeError( - "No index stored. Use store_index=True when constructing TMAP " - "to retain the ANN index after fit()." + "No index stored. For cosine/euclidean, use " + "store_index=True. For Jaccard with sets/strings, " + "use lsh_forest_ instead." ) return self._index @@ -607,38 +675,54 @@ def _query_new_points( needed for incremental insertion (currently only Jaccard LSH updates). """ k = self.n_neighbors + _empty = ( + np.empty((0, k), dtype=np.int32), + np.empty((0, k), dtype=np.float32), + 0, + ) - if self.metric == "jaccard": - signatures, m = self._encode_jaccard_queries(X, allow_original_mode=not update_state) - if m == 0: - return ( - np.empty((0, k), dtype=np.int32), - np.empty((0, k), dtype=np.float32), - 0, + if self.metric == "jaccard" and self._index is not None: + # USearch binary Jaccard path (batch query). + binary = self._coerce_binary_matrix(X, min_samples=0) + if self._n_features is not None and binary.shape[1] != self._n_features: + raise ValueError( + f"Feature dimension mismatch: fit() saw {self._n_features} " + f"features, but received {binary.shape[1]}." ) + m = binary.shape[0] + if m == 0: + return _empty + + all_indices, all_distances = self._index.query_batch(binary, k) + + if update_state: + self._index.add(binary) + + return all_indices, all_distances, m + + elif self.metric == "jaccard": + # MinHash + LSH path (sets/strings). + signatures, m = self._encode_jaccard_queries( + X, + allow_original_mode=not update_state, + ) + if m == 0: + return _empty forest = self._lsh_forest if forest is None: raise RuntimeError( - "No LSH Forest available. Cannot query new points without a " - "jaccard-fitted estimator." + "No LSH Forest available. Cannot query new points " + "without a jaccard-fitted estimator." ) - all_indices = np.empty((m, k), dtype=np.int32) - all_distances = np.empty((m, k), dtype=np.float32) - - for i in range(m): - results = forest.query_linear_scan(signatures[i], k, self.kc) - for j, (dist, idx) in enumerate(results[:k]): - all_indices[i, j] = idx - all_distances[i, j] = dist - # Pad with -1 if fewer than k results - for j in range(len(results), k): - all_indices[i, j] = -1 - all_distances[i, j] = np.inf + all_indices, all_distances = forest.query_external_batch( + signatures, + k, + self.kc, + ) if update_state: - # Update LSH Forest so future add_points sees these points. forest.batch_add(signatures) forest.index() @@ -648,10 +732,10 @@ def _query_new_points( if self._index is None: raise RuntimeError( "No ANN index stored. Reconstruct with store_index=True " - f"to use transform() or add_points() with metric={self.metric!r}." + f"to use transform() or add_points() with " + f"metric={self.metric!r}." ) X_dense = self._coerce_dense_matrix(X, min_samples=0) - # Check that the new data has the same number of features as fit(). if self._n_features is not None and X_dense.shape[1] != self._n_features: raise ValueError( f"Feature dimension mismatch: fit() saw {self._n_features} " @@ -659,23 +743,9 @@ def _query_new_points( ) m = X_dense.shape[0] if m == 0: - return ( - np.empty((0, k), dtype=np.int32), - np.empty((0, k), dtype=np.float32), - 0, - ) - - all_indices = np.empty((m, k), dtype=np.int32) - all_distances = np.empty((m, k), dtype=np.float32) + return _empty - for i in range(m): - idx_arr, dist_arr = self._index.query_point(X_dense[i], k) - n_returned = min(len(idx_arr), k) - all_indices[i, :n_returned] = idx_arr[:n_returned] - all_distances[i, :n_returned] = dist_arr[:n_returned] - for j in range(n_returned, k): - all_indices[i, j] = -1 - all_distances[i, j] = np.inf + all_indices, all_distances = self._index.query_batch(X_dense, k) if update_state: self._index.add(X_dense) @@ -1069,3 +1139,33 @@ def _coerce_dense_matrix(self, X: Any | None, min_samples: int = 2) -> NDArray[n if not np.all(np.isfinite(arr)): raise ValueError("Input matrix must contain only finite values.") return arr + + def _is_binary_input(self, X: Any) -> bool: + """Check whether X looks like a dense binary matrix (not sets/strings). + + Sparse matrices return False — they go through the MinHash + LSH path + which handles sparse data without densifying. + """ + if X is None: + return False + # Sparse matrices should NOT be densified; keep them on the LSH path. + if hasattr(X, "tocsr") or hasattr(X, "toarray"): + return False + if hasattr(X, "values") and not isinstance(X, np.ndarray): + return True # DataFrame + if isinstance(X, np.ndarray): + return True + if not isinstance(X, (list, tuple)) or len(X) == 0: + return False + # List input: try to detect if it's a rectangular numeric array + # of 0/1 values (binary matrix as list-of-lists) vs sets/strings. + first = X[0] + if isinstance(first, (str, set, frozenset)): + return False + try: + arr = np.asarray(X) + if arr.ndim != 2 or not np.issubdtype(arr.dtype, np.number): + return False + return bool(np.all((arr == 0) | (arr == 1))) + except (ValueError, TypeError): + return False diff --git a/src/tmap/index/__init__.py b/src/tmap/index/__init__.py index 1d269e3..a29cf56 100644 --- a/src/tmap/index/__init__.py +++ b/src/tmap/index/__init__.py @@ -2,8 +2,8 @@ Index module: Nearest-neighbor search data structures. Backends: - - LSHForest: MinHash-based locality-sensitive hashing (Jaccard metric) - - USearchIndex: USearch exact/HNSW (cosine/euclidean) + - USearchIndex: USearch exact/HNSW (cosine, euclidean, Jaccard on binary data) + - LSHForest: MinHash-based locality-sensitive hashing (Jaccard on sets/strings) """ from tmap.index.lsh_forest import LSHForest diff --git a/src/tmap/index/usearch_index.py b/src/tmap/index/usearch_index.py index 098d0d4..3175c05 100644 --- a/src/tmap/index/usearch_index.py +++ b/src/tmap/index/usearch_index.py @@ -1,9 +1,10 @@ """USearch-based nearest neighbor index. -Wraps USearch (https://github.com/unum-cloud/usearch) for cosine/euclidean -kNN search. +Wraps USearch (https://github.com/unum-cloud/usearch) for cosine, euclidean, +and Jaccard (binary) kNN search. Auto mode: exact brute-force for n < 50 000, HNSW for n >= 50 000. +Binary Jaccard always uses HNSW. """ from __future__ import annotations @@ -28,10 +29,11 @@ class USearchIndex: - """Nearest-neighbor index for dense vectors using USearch. + """Nearest-neighbor index using USearch. - Use this for cosine or euclidean search. In ``auto`` mode it uses exact - search for small datasets and HNSW for larger ones. + Supports cosine, euclidean (dense float vectors), and Jaccard (binary + 0/1 vectors). In ``auto`` mode it uses exact search for small datasets + and HNSW for larger ones. Binary Jaccard always uses HNSW. Args: seed: Stored as metadata. USearch itself does not use this value. @@ -58,6 +60,8 @@ def __init__( self._expansion_search = expansion_search self._effective_mode: str | None = None self._vectors: NDArray[np.float32] | None = None + self._binary_vectors: NDArray[np.uint8] | None = None + self._is_binary: bool = False self._usearch_index: Any | None = None # usearch.index.Index self._is_built = False self._n_nodes: int = 0 @@ -89,7 +93,7 @@ def build_from_vectors( vectors: NDArray[np.float32], metric: str = "euclidean", ) -> USearchIndex: - """Build the index from a matrix of vectors. + """Build the index from a matrix of dense vectors. Args: vectors: Data matrix of shape ``(n_samples, n_features)``. @@ -136,17 +140,76 @@ def build_from_vectors( # For exact mode we skip HNSW build entirely; queries use # the module-level ``usearch.index.search`` function on raw vectors. self._vectors = vectors + self._binary_vectors = None + self._is_binary = False self._n_nodes = n self._ndim = d self._metric = metric self._is_built = True return self + def build_from_binary( + self, + matrix: NDArray, + ) -> USearchIndex: + """Build a Jaccard index from a binary (0/1) matrix. + + Packs the binary matrix to bytes and builds an HNSW index using + USearch's native bit-vector Jaccard distance. No MinHash encoding + is needed — distances are computed on the raw bits. + + Args: + matrix: Binary matrix of shape ``(n_samples, n_features)`` + with 0/1 values. + + Returns: + The built index. + """ + matrix = np.asarray(matrix) + if matrix.ndim != 2: + raise ValueError(f"matrix must be 2D, got shape {matrix.shape}") + if matrix.shape[0] < 2: + raise ValueError("Need at least 2 vectors to build index") + if not np.all((matrix == 0) | (matrix == 1)): + raise ValueError("Binary matrix must contain only 0/1 values.") + + from usearch.index import Index, MetricKind + + n, d = matrix.shape + packed = np.packbits(matrix.astype(np.uint8, copy=False), axis=1) + packed = np.ascontiguousarray(packed) + + idx = Index( + ndim=d, + metric=MetricKind.Jaccard, + dtype="b1x8", + connectivity=self._connectivity, + expansion_add=self._expansion_add, + expansion_search=self._expansion_search, + ) + keys = np.arange(n, dtype=np.int64) + idx.add(keys, packed) + + self._usearch_index = idx + self._binary_vectors = packed + self._vectors = None + self._is_binary = True + self._effective_mode = "hnsw" + self._n_nodes = n + self._ndim = d # number of bits (original feature dimension) + self._metric = "jaccard" + self._is_built = True + return self + # -- kNN graph (all-vs-all) -- - def add(self, vectors: NDArray[np.float32]) -> NDArray[np.int64]: + def add(self, vectors: NDArray) -> NDArray[np.int64]: """Append new vectors to an existing index. + For binary indices, pass a 0/1 matrix with the same number of + features as ``build_from_binary()``. For dense indices, pass a + float matrix matching ``build_from_vectors()``. + Args: vectors: New vectors with the same number of features. @@ -155,9 +218,36 @@ def add(self, vectors: NDArray[np.float32]) -> NDArray[np.int64]: """ self._check_is_built() - vectors = np.ascontiguousarray(vectors, dtype=np.float32) + vectors = np.asarray(vectors) if vectors.ndim != 2: raise ValueError(f"vectors must be 2D, got shape {vectors.shape}") + + if self._is_binary: + if vectors.shape[1] != self._ndim: + raise ValueError(f"vectors must have {self._ndim} features, got {vectors.shape[1]}") + if vectors.shape[0] == 0: + return np.empty(0, dtype=np.int64) + if not np.all((vectors == 0) | (vectors == 1)): + raise ValueError("Binary vectors must contain only 0/1 values.") + + packed = np.packbits(vectors.astype(np.uint8, copy=False), axis=1) + packed = np.ascontiguousarray(packed) + + start = self._n_nodes + keys = np.arange(start, start + packed.shape[0], dtype=np.int64) + + if self._usearch_index is None: + raise RuntimeError("HNSW index not available") + self._usearch_index.add(keys, packed) + + if self._binary_vectors is not None: + self._binary_vectors = np.concatenate([self._binary_vectors, packed], axis=0) + + self._n_nodes += packed.shape[0] + return keys + + # Dense float path + vectors = np.ascontiguousarray(vectors, dtype=np.float32) if vectors.shape[1] != self._ndim: raise ValueError(f"vectors must have {self._ndim} features, got {vectors.shape[1]}") if vectors.shape[0] == 0: @@ -190,16 +280,23 @@ def query_knn(self, k: int) -> KNNGraph: A ``KNNGraph`` with neighbor indices and distances. """ self._check_is_built() - if self._vectors is None: - raise RuntimeError( - "Cannot call query_knn() on a loaded index: the original " - "vectors were not saved. Rebuild with build_from_vectors() " - "or use query_point()/query_batch() instead." - ) if k >= self._n_nodes: raise ValueError(f"k={k} must be < n_nodes={self._n_nodes}") - keys, dists = self._search(self._vectors, k + 1) + if self._is_binary: + if self._binary_vectors is None: + raise RuntimeError("No binary vectors stored for query_knn().") + queries = self._binary_vectors + else: + if self._vectors is None: + raise RuntimeError( + "Cannot call query_knn() on a loaded index: the original " + "vectors were not saved. Rebuild with build_from_vectors() " + "or use query_point()/query_batch() instead." + ) + queries = self._vectors + + keys, dists = self._search(queries, k + 1) keys, dists = self._strip_self(keys, dists, k) dists = self._convert_distances(dists) return KNNGraph.from_arrays( @@ -211,40 +308,42 @@ def query_knn(self, k: int) -> KNNGraph: def query_point( self, - point: NDArray[np.float32], + point: NDArray, k: int, ) -> tuple[NDArray[np.int32], NDArray[np.float32]]: """Query neighbors for one point. Args: - point: Query vector. + point: Query vector (binary 0/1 or dense float, matching the + index type). k: Number of neighbors to return. Returns: Tuple ``(indices, distances)``. """ self._check_is_built() - query = np.ascontiguousarray(point.reshape(1, -1), dtype=np.float32) + query = self._prepare_query(np.asarray(point).reshape(1, -1)) keys, dists = self._search(query, k) dists = self._convert_distances(dists) return self._safe_int32(keys[0]), dists[0].astype(np.float32) def query_batch( self, - points: NDArray[np.float32], + points: NDArray, k: int, ) -> tuple[NDArray[np.int32], NDArray[np.float32]]: """Query neighbors for many points at once. Args: - points: Query matrix. + points: Query matrix (binary 0/1 or dense float, matching the + index type). k: Number of neighbors to return per point. Returns: Tuple ``(indices, distances)``. """ self._check_is_built() - queries = np.ascontiguousarray(points, dtype=np.float32) + queries = self._prepare_query(np.asarray(points)) keys, dists = self._search(queries, k) dists = self._convert_distances(dists) return self._safe_int32(keys), dists.astype(np.float32) @@ -271,7 +370,9 @@ def save(self, path: str | Path) -> None: if self._usearch_index is None: raise RuntimeError("HNSW index cannot be saved before it is built.") self._usearch_index.save(str(path)) - meta["has_vectors"] = False + if self._is_binary and self._binary_vectors is not None: + np.save(self._vectors_path(path), self._binary_vectors, allow_pickle=False) + meta["has_vectors"] = self._is_binary with open(self._meta_path(path), "wb") as f: pickle.dump(meta, f) @@ -298,10 +399,23 @@ def load(cls, path: str | Path) -> USearchIndex: expansion_add=meta.get("expansion_add", 256), expansion_search=meta.get("expansion_search", 200), ) + is_binary = meta.get("is_binary", False) + instance._is_binary = is_binary + if meta.get("effective_mode") == "hnsw": if not path.exists(): raise FileNotFoundError(f"USearch index file not found: {path}") instance._usearch_index = Index.restore(str(path)) + if is_binary and meta.get("has_vectors"): + vectors_path = cls._vectors_path(path) + if not vectors_path.exists(): + raise FileNotFoundError( + f"Binary vectors file not found: {vectors_path}. " + f"Cannot restore binary index without stored vectors." + ) + instance._binary_vectors = np.ascontiguousarray( + np.load(vectors_path, allow_pickle=False) + ) elif meta.get("has_vectors"): vectors_path = cls._vectors_path(path) if not vectors_path.exists(): @@ -320,14 +434,20 @@ def __getstate__(self) -> dict: state = self.__dict__.copy() idx = state.pop("_usearch_index") if idx is not None: - state["_vectors"] = None state["_usearch_index_bytes"] = bytes(idx.save()) + # For binary, keep _binary_vectors; for dense, drop _vectors + # (they're redundant with the HNSW index for dense). + if not state.get("_is_binary"): + state["_vectors"] = None else: state["_usearch_index_bytes"] = None return state def __setstate__(self, state: dict) -> None: buf = state.pop("_usearch_index_bytes") + # Handle loading from older pickles that lack binary fields + state.setdefault("_is_binary", False) + state.setdefault("_binary_vectors", None) self.__dict__.update(state) if buf is not None: from usearch.index import Index @@ -342,9 +462,24 @@ def _check_is_built(self) -> None: if not self._is_built: raise RuntimeError("Index not built. Call build_from_vectors() first.") + def _prepare_query(self, data: NDArray) -> NDArray: + """Convert user-supplied query data to the format USearch expects.""" + if self._is_binary: + expected = self._ndim + actual = data.shape[-1] if data.ndim >= 1 else 0 + if actual != expected: + raise ValueError( + f"Query has {actual} features but index was built with {expected}." + ) + if not np.all((data == 0) | (data == 1)): + raise ValueError("Query data must contain only 0/1 values.") + packed = np.packbits(data.astype(np.uint8, copy=False), axis=1) + return np.ascontiguousarray(packed) + return np.ascontiguousarray(data, dtype=np.float32) + def _search( self, - queries: NDArray[np.float32], + queries: NDArray, count: int, ) -> tuple[NDArray[np.int64], NDArray[np.float32]]: """Run search and return (keys, distances) as 2D arrays.""" @@ -405,7 +540,7 @@ def _strip_self( def _convert_distances(self, dists: NDArray[np.float32]) -> NDArray[np.float32]: """Convert raw USearch distances to user-facing metric.""" - # Cosine: USearch 'cos' already returns cosine distance. No conversion. + # Cosine and Jaccard: already returns the correct distance. if self._metric == "euclidean": # USearch 'l2sq' returns squared L2. np.maximum(dists, 0, out=dists) @@ -433,6 +568,7 @@ def _make_meta(self) -> dict: "connectivity": self._connectivity, "expansion_add": self._expansion_add, "expansion_search": self._expansion_search, + "is_binary": self._is_binary, } @staticmethod diff --git a/tests/test_ann_backends.py b/tests/test_ann_backends.py index 395819d..0bc7557 100644 --- a/tests/test_ann_backends.py +++ b/tests/test_ann_backends.py @@ -248,6 +248,160 @@ def test_add_makes_new_vectors_queryable(self, mode: str) -> None: assert indices[0] == 20 +# --------------------------------------------------------------------------- +# Binary Jaccard tests +# --------------------------------------------------------------------------- + + +def _binary_data(n_samples: int = 60, n_features: int = 256, seed: int = 42) -> np.ndarray: + rng = np.random.default_rng(seed) + return rng.integers(0, 2, (n_samples, n_features)).astype(np.uint8) + + +class TestUSearchBinaryJaccard: + def _make_index(self, **kwargs): + kwargs.setdefault("seed", 42) + return USearchIndex(**kwargs) + + def test_build_from_binary(self) -> None: + data = _binary_data() + index = self._make_index() + index.build_from_binary(data) + assert index.is_built + assert index.metric == "jaccard" + assert index.n_nodes == data.shape[0] + assert index.effective_mode == "hnsw" + + def test_knn_shape_and_dtype(self) -> None: + data = _binary_data() + index = self._make_index() + index.build_from_binary(data) + knn = index.query_knn(k=K) + + assert isinstance(knn, KNNGraph) + assert knn.indices.shape == (data.shape[0], K) + assert knn.distances.shape == (data.shape[0], K) + assert knn.indices.dtype == np.int32 + assert knn.distances.dtype == np.float32 + + def test_knn_contract(self) -> None: + data = _binary_data() + index = self._make_index() + index.build_from_binary(data) + knn = index.query_knn(k=K) + + assert np.all(knn.indices >= 0) + assert np.all(knn.indices < data.shape[0]) + assert np.all(knn.distances >= -1e-6) + assert np.all(knn.distances <= 1.0 + 1e-6) # Jaccard in [0, 1] + for i in range(data.shape[0]): + assert i not in knn.indices[i] + + def test_query_single(self) -> None: + data = _binary_data() + index = self._make_index() + index.build_from_binary(data) + + indices, distances = index.query_point(data[0], k=K) + assert indices.shape == (K,) + assert distances.shape == (K,) + assert distances[0] == 0.0 # self should be nearest + + def test_query_batch(self) -> None: + data = _binary_data() + index = self._make_index() + index.build_from_binary(data) + + query = data[:5] + indices, distances = index.query_batch(query, k=K) + + assert indices.shape == (5, K) + assert distances.shape == (5, K) + assert np.all(indices >= 0) + assert np.all(distances >= -1e-6) + assert np.all(distances <= 1.0 + 1e-6) + + def test_add_binary(self) -> None: + data = _binary_data(n_samples=40) + added = np.zeros((1, 256), dtype=np.uint8) + + index = self._make_index() + index.build_from_binary(data) + keys = index.add(added) + + assert keys.tolist() == [40] + assert index.n_nodes == 41 + + def test_build_rejects_nonbinary_values(self) -> None: + bad = np.array([[2, 0, 1, 0], [0, 1, 0, 3]], dtype=np.uint8) + index = self._make_index() + with pytest.raises(ValueError, match="0/1"): + index.build_from_binary(bad) + + def test_add_rejects_nonbinary_values(self) -> None: + data = _binary_data(n_samples=10, n_features=16) + index = self._make_index() + index.build_from_binary(data) + bad = np.array([[2, 0, 1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0]]) + with pytest.raises(ValueError, match="0/1"): + index.add(bad) + + def test_query_rejects_wrong_width(self) -> None: + data = _binary_data(n_samples=10, n_features=16) + index = self._make_index() + index.build_from_binary(data) + with pytest.raises(ValueError, match="features"): + index.query_point(np.array([1, 0, 1]), k=3) + + def test_query_rejects_nonbinary_values(self) -> None: + data = _binary_data(n_samples=10, n_features=16) + index = self._make_index() + index.build_from_binary(data) + with pytest.raises(ValueError, match="0/1"): + index.query_point(np.array([2] * 16), k=3) + + def test_load_fails_when_vectors_missing(self, tmp_path) -> None: + data = _binary_data() + index = self._make_index() + index.build_from_binary(data) + path = tmp_path / "binary.usearch" + index.save(path) + + # Delete the sidecar vectors file + vectors_path = USearchIndex._vectors_path(path) + vectors_path.unlink() + + with pytest.raises(FileNotFoundError, match="Binary vectors"): + USearchIndex.load(path) + + def test_pickle_roundtrip(self) -> None: + data = _binary_data() + index = self._make_index() + index.build_from_binary(data) + + buf = pickle.dumps(index) + restored = pickle.loads(buf) + + assert restored.is_built + assert restored.metric == "jaccard" + idx_r, dist_r = restored.query_point(data[0], k=K) + assert idx_r.shape == (K,) + + def test_save_load_roundtrip(self, tmp_path) -> None: + data = _binary_data() + index = self._make_index() + index.build_from_binary(data) + + path = tmp_path / "binary.usearch" + index.save(path) + restored = USearchIndex.load(path) + + assert restored.is_built + assert restored.metric == "jaccard" + knn = restored.query_knn(k=K) + assert knn.indices.shape == (data.shape[0], K) + + # --------------------------------------------------------------------------- # Estimator integration # --------------------------------------------------------------------------- diff --git a/tests/test_estimator.py b/tests/test_estimator.py index aa7fa09..8515abd 100644 --- a/tests/test_estimator.py +++ b/tests/test_estimator.py @@ -49,9 +49,17 @@ def test_list_and_array_inputs_produce_same_result() -> None: model_array = TMAP(n_neighbors=5, n_permutations=64, seed=7).fit(data) model_list = TMAP(n_neighbors=5, n_permutations=64, seed=7).fit(data.tolist()) - np.testing.assert_array_equal(model_array.graph_.indices, model_list.graph_.indices) - np.testing.assert_allclose(model_array.graph_.distances, model_list.graph_.distances) - np.testing.assert_allclose(model_array.embedding_, model_list.embedding_) + # Both paths use USearch HNSW, which is approximate and multi-threaded. + # Neighbor sets should mostly overlap; mean distances should be close. + for i in range(model_array.graph_.indices.shape[0]): + set_a = set(model_array.graph_.indices[i]) + set_l = set(model_list.graph_.indices[i]) + assert len(set_a & set_l) >= 3, f"Row {i}: too few shared neighbors" + np.testing.assert_allclose( + np.mean(model_array.graph_.distances, axis=1), + np.mean(model_list.graph_.distances, axis=1), + atol=0.05, + ) @pytest.mark.skipif(not OGDF_AVAILABLE, reason="OGDF extension not built") @@ -109,13 +117,25 @@ def test_jaccard_knn_is_stable_across_layout_seeds_by_default() -> None: model_seed_1 = TMAP(n_neighbors=8, n_permutations=128, seed=1).fit(data) model_seed_42 = TMAP(n_neighbors=8, n_permutations=128, seed=42).fit(data) - np.testing.assert_array_equal(model_seed_1.graph_.indices, model_seed_42.graph_.indices) - np.testing.assert_allclose(model_seed_1.graph_.distances, model_seed_42.graph_.distances) + # USearch HNSW is approximate and multi-threaded; neighbor sets may + # vary slightly across runs. Check overlap and mean distance similarity. + for i in range(model_seed_1.graph_.indices.shape[0]): + set_1 = set(model_seed_1.graph_.indices[i]) + set_42 = set(model_seed_42.graph_.indices[i]) + assert len(set_1 & set_42) >= 5, f"Row {i}: too few shared neighbors" + np.testing.assert_allclose( + np.mean(model_seed_1.graph_.distances, axis=1), + np.mean(model_seed_42.graph_.distances, axis=1), + atol=0.05, + ) @pytest.mark.skipif(not OGDF_AVAILABLE, reason="OGDF extension not built") def test_jaccard_knn_changes_when_minhash_seed_changes() -> None: - data = _clustered_binary_data(n_samples=80, n_features=256, seed=321) + """MinHash seed affects kNN. Uses set input to exercise LSH path.""" + # Set-of-indices input forces MinHash + LSH (not USearch binary). + rng = np.random.default_rng(321) + data = [sorted(rng.choice(200, 30, replace=False).tolist()) for _ in range(80)] model_seed_1 = TMAP(n_neighbors=8, n_permutations=128, seed=1, minhash_seed=1).fit(data) model_seed_42 = TMAP(n_neighbors=8, n_permutations=128, seed=42, minhash_seed=42).fit(data) @@ -167,6 +187,81 @@ def test_path_before_fit_raises() -> None: model.path(0, 1) +# ============================================================================= +# kneighbors() tests +# ============================================================================= + + +def test_kneighbors_before_fit_raises() -> None: + model = TMAP() + with pytest.raises(RuntimeError, match="fit"): + model.kneighbors(np.zeros((3, 10), dtype=np.uint8)) + + +@pytest.mark.skipif(not OGDF_AVAILABLE, reason="OGDF extension not built") +def test_kneighbors_jaccard_non_mutating() -> None: + data = _clustered_binary_data(n_samples=40, n_features=128) + model = TMAP(n_neighbors=5, n_permutations=64, seed=42).fit(data) + original_embedding = model.embedding_.copy() + original_tree_nodes = model.tree_.n_nodes + original_graph_shape = model.graph_.indices.shape + + new_data = _clustered_binary_data(n_samples=5, n_features=128, seed=99) + indices, distances = model.kneighbors(new_data) + + assert indices.shape == (5, 5) + assert distances.shape == (5, 5) + assert indices.dtype == np.int32 + assert distances.dtype == np.float32 + np.testing.assert_array_equal(model.embedding_, original_embedding) + assert model.tree_.n_nodes == original_tree_nodes + assert model.graph_.indices.shape == original_graph_shape + + +@pytest.mark.skipif(not OGDF_AVAILABLE, reason="OGDF extension not built") +def test_kneighbors_return_distance_false() -> None: + data = _clustered_binary_data(n_samples=40, n_features=128) + model = TMAP(n_neighbors=5, n_permutations=64, seed=42).fit(data) + + new_data = _clustered_binary_data(n_samples=3, n_features=128, seed=99) + indices = model.kneighbors(new_data, return_distance=False) + + assert indices.shape == (3, 5) + assert indices.dtype == np.int32 + + +@pytest.mark.skipif(not OGDF_AVAILABLE, reason="OGDF extension not built") +def test_kneighbors_set_input_matches_lsh_batch_query() -> None: + from tmap.index.encoders.minhash import MinHash + + train = [[0, 1, 2], [1, 2, 3], [2, 3, 4], [3, 4, 5], [4, 5, 6]] + query = [[0, 1, 2], [3, 4, 5]] + + model = TMAP(n_neighbors=2, metric="jaccard", n_permutations=64, seed=42).fit(train) + indices, distances = model.kneighbors(query) + + encoder = MinHash(num_perm=model.n_permutations, seed=model.minhash_seed) + signatures = encoder.batch_from_sparse_binary_array(query) + expected_indices, expected_distances = model.lsh_forest_.query_external_batch( + signatures, + model.n_neighbors, + model.kc, + ) + + np.testing.assert_array_equal(indices, expected_indices) + np.testing.assert_allclose(distances, expected_distances) + + +@pytest.mark.skipif(not OGDF_AVAILABLE, reason="OGDF extension not built") +def test_kneighbors_cosine_requires_store_index() -> None: + data = np.random.default_rng(9).random((20, 8), dtype=np.float32) + model = TMAP(metric="cosine", n_neighbors=3, store_index=False, seed=42).fit(data) + + new_data = np.random.default_rng(10).random((3, 8), dtype=np.float32) + with pytest.raises(RuntimeError, match="store_index"): + model.kneighbors(new_data) + + # ============================================================================= # transform() tests # ============================================================================= @@ -452,7 +547,9 @@ def test_save_load_roundtrip(tmp_path: object) -> None: assert loaded.tree_.n_nodes == model.tree_.n_nodes assert loaded.n_neighbors == model.n_neighbors assert loaded.metric == model.metric - assert loaded.lsh_forest_.size == model.lsh_forest_.size + # Binary Jaccard uses USearch (no LSH forest); verify index survived. + assert loaded.index_.is_built + assert loaded.index_.n_nodes == model.index_.n_nodes @pytest.mark.skipif(not OGDF_AVAILABLE, reason="OGDF extension not built") @@ -499,6 +596,9 @@ def test_sparse_csr_binary_input_fits() -> None: model.fit(sparse) assert model.embedding_.shape == (40, 2) assert model._n_features == 128 + # Sparse input should use LSH path, not USearch (avoids densification). + assert model._lsh_forest is not None + assert model._index is None @pytest.mark.skipif(not OGDF_AVAILABLE, reason="OGDF extension not built")