SimilaritySensitiveHash - Lightning-Fast Cosine Similarity Search

Find similar items in microseconds. This library compresses high-dimensional vectors (embeddings, features, user preferences) into tiny fingerprints that let you estimate cosine similarity 10× faster while using 99% less memory than naive cosine similarity comparison while retaining 95 % accuracy in most production use cases, and within 0.05 absolute error for ≥ 0.7 cosine pairs, but up to 0.15 absolute error below 0.3.

What’s the Problem?

You have 100 000 image vectors and want “similar” ones.

Works for anything vector-shaped:

• Product feature vectors
• Image / text embeddings
• User preference vectors
• Audio fingerprints

How It Works (30-Second Version)

1. Feed your vector into encodeSRP() → get a 32-bit to 512-bit fingerprint. Tiny!
2. Compare fingerprints with estimateSimilarity() → cosine similarity in micro-seconds.
3. Profit.

Trade-off: ~5 % error for an order of magnitude speed-up and massive memory savings.

Bundle Size & Performance

Tiny footprint: Core library is only ~5KB (gzipped: ~2KB).

Works everywhere:

• ✅ Node.js (v14+)
• ✅ Browser (ES modules)
• ✅ Web Workers (thread-safe)

Quick Start

npm install similarity-sensitive-hash

import { encodeSRP, estimateSimilarity } from 'similarity-sensitive-hash';

const productA = [0.8, 0.2, 0.9, /*...etc...*/  0.1, 0.7]; // Big old vectors
const productB = [0.7, 0.3, 0.8, /*...etc...*/ 0.2,  0.6]; // Big old vectors

// 1. Hash once (64 bits)
const fpA = encodeSRP(productA, 64);
const fpB = encodeSRP(productB, 64);

// 2. Compare in <1 μs
const sim = estimateSimilarity(fpA, fpB);
console.log('Similarity ≈', sim); // 0.0 – 1.0

Two Algorithms, One API

Both give ~5 % error; pick based on your hot path.

API Cheatsheet

encodeSRP(vector, bits, seed = 42)
// vector: number[]           – your data
// bits: int                  – fingerprint size
// seed: int                  – reproducibility
// returns: Uint8Array        – compact fingerprint

estimateSimilarity(fpA, fpB)
// fpA, fpB: Uint8Array       – fingerprints
// returns: float 0-1         – cosine similarity estimate

Need raw speed? Use encodeCSSRP(vec, 64) for a flat 64-bit signature.

Real-World Recipes

Product Similarity Search

const catalog = [...];                           // 100 k products
const fps = catalog.map(p => encodeSRP(p.vec, 64);

function findSimilar(target, threshold = 0.7) {
  const tgt = encodeSRP(target, 64);
  return fps
    .map((fp, i) => ({ i, sim: estimateSimilarity(tgt, fp) }))
    .filter(x => x.sim > threshold)
    .sort((a, b) => b.sim - a.sim);
}

Tiered Accuracy

// Phase 1: 16-bit fast filter
const coarse = encodeSRP(vec, 16);
// Phase 2: 256-bit accurate compare
const fine   = encodeSRP(vec, 256);

Benchmarks

Accuracy: 95 % average absolute error < 0.05.

Average Error by Fingerprint Size and Similarity Level

Size Reduction Benefits

Massive memory savings compared to storing full vectors:

Real-world impact:

• 1M product vectors (512-d): 2GB → 8MB (99.6% reduction)
• 10M user vectors (1024-d): 40GB → 80MB (99.8% reduction)
• 100M image vectors (2048-d): 800GB → 800MB (99.9% reduction)

Wait, what's this about 15% Error?

The approximation gets shakey when the two vectors are dissimilar. However, since most use cases concern similarity, and not fine grained ranking of dissimilarity this tends not to matter. Now, if you threshold at 0.5, then it'll be noisy, but so would vanilla cosine similarity in any high dimensional space. This library assumes you are filtering high dimensional space for similarity, and not for finding exact opposites or orthogonal vectors.

When to Use / Not Use

✅ Use for

• large datasets (≥ 10 k items)
• real-time recommendations
• memory-constrained environments
• any cosine-similarity task that can tolerate ~5 % error

❌ Don’t use for

• exact similarity (error must be 0 %)
• Jaccard similarity on sets (use Grouped-OPH)
• Euclidean distance (use DistanceSensitiveHash)
• Edit distance (use WarpDistanceHash)

Academic Roots

Implements Count-Sketch Sign Random Projections (CS-SRP) and Higher-Order Count-Sketch SRP (HCS-SRP) from:

Verma & Pratap, Faster and Space Efficient Indexing for Locality Sensitive Hashing, arXiv:2503.06737

Built on the classic LSH framework (Gionis, Indyk, Motwani, VLDB 1999).

License

MIT