Memory Compression Ratios for Different Dimensionality Vectors in TurboVec: 2-Bit vs 4-Bit Benchmarks

TurboVec achieves memory compression ratios of approximately 15× for 2-bit quantization and 8× for 4-bit quantization across 200, 1536, and 3072-dimensional vectors, reducing FP32 storage requirements by 8- to 16-fold.

TurboVec is an open-source vector quantization library that compresses floating-point embeddings into highly compact representations. By quantizing each dimension to 2-bit or 4-bit precision, it dramatically reduces the storage footprint required for large-scale similarity search. This analysis examines the specific memory compression ratios for different dimensionality vectors in TurboVec based on the official benchmark suite in the RyanCodrai/turbovec repository.

How TurboVec Calculates Compression Ratios

The compression ratio represents the size of conventional FP32 storage divided by the resulting TurboVec index file size. The benchmark script benchmarks/suite/compression.py computes this ratio using the formula:

ratio = (n × dim × 4 bytes) / index_file_bytes

Where n = 100,000 vectors and dim represents the vector dimensionality. Lines 68-79 in compression.py implement this calculation by measuring fp32_mb, index_mb, and deriving the final ratio after writing vectors to a TurboQuantIndex.

Memory Compression Ratios by Vector Dimensionality

The benchmark results in benchmarks/results/compression.json demonstrate consistent compression performance across varying dimensionalities. The following table summarizes the measured ratios for 2-bit and 4-bit quantization:

Dataset (Dimensions)	Bit-Width	FP32 Size (MiB)	Index Size (MiB)	Compression Ratio
GloVe 200-dim	2-bit	76.3	5.1	14.8×
GloVe 200-dim	4-bit	76.3	9.9	7.7×
OpenAI 1536-dim	2-bit	585.9	37.0	15.8×
OpenAI 1536-dim	4-bit	585.9	73.6	8.0×
OpenAI 3072-dim	2-bit	1171.9	73.6	15.9×
OpenAI 3072-dim	4-bit	1171.9	146.9	8.0×

Higher dimensionalities yield larger absolute memory savings while maintaining similar relative compression ratios. The 2-bit quantization consistently achieves approximately 15× compression, while 4-bit quantization achieves roughly 8× compression regardless of dimensionality.

Bit-Width Configuration and Storage Trade-offs

TurboVec supports configurable bit-widths that directly impact the compression ratio and representation fidelity.

2-Bit Quantization Performance

Using 2-bit quantization, TurboVec compresses 100,000 vectors to approximately 5-74 MiB depending on dimensionality. This configuration yields 14.8× to 15.9× compression ratios, making it ideal for memory-constrained environments where maximum storage reduction is prioritized.

4-Bit Quantization Performance

4-bit quantization doubles the storage requirement per dimension compared to 2-bit, resulting in approximately 7.7× to 8.0× compression ratios. This setting provides increased representation fidelity while still reducing storage by nearly 8-fold compared to FP32 baselines.

Benchmarking Compression in Python

You can reproduce these compression ratios using the TurboQuantIndex class. The following example demonstrates building a 2-bit index for 1536-dimensional vectors, matching the benchmark methodology found in compression.py:

from turbovec import TurboQuantIndex
import numpy as np
import os

# Generate normalized FP32 vectors (1536-dim, 100k vectors)

dim = 1536
n_vectors = 100_000
vectors = np.random.randn(n_vectors, dim).astype(np.float32)
vectors /= np.linalg.norm(vectors, axis=-1, keepdims=True)

# Create 2-bit quantized index

index = TurboQuantIndex(dim=dim, bit_width=2)
index.add(vectors)

# Persist to disk and measure size

index_path = "/tmp/vectors_2bit.tv"
index.write(index_path)
index_mb = os.path.getsize(index_path) / (1024 * 1024)
print(f"Index size: {index_mb:.1f} MiB")  # ~37 MiB for 1536-dim

To query the compressed index after creation:

# Search for nearest neighbors

queries = vectors[:5]
distances, ids = index.search(queries, k=10)
print(f"Top-10 neighbors for first query: {ids[0]}")

The write method in turbovec-python/python/turbovec/_persist.py handles serialization, while the measure_index_size function in benchmarks/suite/compression.py (lines 37-45) demonstrates the complete benchmarking workflow used to generate the published ratios.

Summary

• TurboVec achieves 15× compression with 2-bit quantization and 8× compression with 4-bit quantization across 200, 1536, and 3072-dimensional vectors.
• Compression ratios remain stable across different dimensionalities, meaning higher-dimensional vectors yield proportionally larger absolute memory savings.
• Benchmark data is stored in benchmarks/results/compression.json and generated via benchmarks/suite/compression.py.
• 2-bit storage reduces 100,000 1536-dimensional vectors from 585.9 MiB to approximately 37 MiB.
• 4-bit storage provides a middle ground at approximately 73.6 MiB for the same dataset with improved fidelity.

Frequently Asked Questions

What is the typical compression ratio for 2-bit quantized vectors in TurboVec?

TurboVec consistently achieves approximately 15× compression for 2-bit quantized vectors across different dimensionalities. Specifically, benchmarks show 14.8× for 200-dimensional GloVe vectors and 15.8-15.9× for 1536- and 3072-dimensional OpenAI vectors.

How does vector dimensionality affect compression ratios?

Vector dimensionality has minimal impact on the relative compression ratio, which remains approximately 15× for 2-bit and 8× for 4-bit regardless of dimensions. However, higher dimensionalities produce larger absolute memory savings, compressing 1171.9 MiB of 3072-dimensional FP32 data down to roughly 73.6 MiB.

Where are the compression benchmark results stored in the TurboVec repository?

The official compression ratios are stored in benchmarks/results/compression.json as generated by benchmarks/suite/compression.py. This script creates TurboQuantIndex instances for each configuration, measures the resulting .tv file sizes, and computes the ratios using the formula at lines 68-79.

What is the trade-off between 2-bit and 4-bit quantization in TurboVec?

2-bit quantization provides approximately double the compression ratio (15× vs 8×) but sacrifices some representation fidelity compared to 4-bit quantization. Users should select 2-bit for maximum storage efficiency and 4-bit when query accuracy requires higher precision quantization levels.

{
  "mcpServers": {
    "instagit": {
      "command": "npx",
      "args": ["-y", "instagit@latest"]
    }
  }
}