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

> Discover TurboVec memory compression ratios for 2-bit and 4-bit quantization. See performance gains up to 15x for vectors up to 3072 dimensions.

- Repository: [Ryan Codrai/turbovec](https://github.com/RyanCodrai/turbovec)
- Tags: performance
- Published: 2026-06-16

---

**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`](https://github.com/RyanCodrai/turbovec/blob/main/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`](https://github.com/RyanCodrai/turbovec/blob/main/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`](https://github.com/RyanCodrai/turbovec/blob/main/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`](https://github.com/RyanCodrai/turbovec/blob/main/compression.py):

```python
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:

```python

# 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`](https://github.com/RyanCodrai/turbovec/blob/main/turbovec-python/python/turbovec/_persist.py) handles serialization, while the `measure_index_size` function in [`benchmarks/suite/compression.py`](https://github.com/RyanCodrai/turbovec/blob/main/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`](https://github.com/RyanCodrai/turbovec/blob/main/benchmarks/results/compression.json) and generated via [`benchmarks/suite/compression.py`](https://github.com/RyanCodrai/turbovec/blob/main/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`](https://github.com/RyanCodrai/turbovec/blob/main/benchmarks/results/compression.json) as generated by [`benchmarks/suite/compression.py`](https://github.com/RyanCodrai/turbovec/blob/main/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.