RyanCodrai/turbovec

---

Kho tài liệu 10 triệu cần 31 GB RAM dưới dạng float32. turbovec phù hợp với nó trong 4 GB - và tìm kiếm nó nhanh hơn FAISS.

turbovec là chỉ mục vectơ Rust có liên kết Python, được xây dựng trên Google Research TurboQuant thuật toán - một bộ lượng tử hóa không phân biệt dữ liệu với độ méo gần như tối ưu và không có giai đoạn huấn luyện riêng biệt.

• Nhập trực tuyến. Thêm vectơ, chúng được lập chỉ mục — không có bước huấn luyện, không điều chỉnh tham số, không xây dựng lại khi kho văn bản phát triển.
• Tìm kiếm SIMD nhanh. Hạt nhân viết tay — NEON SDOT/SMMLA trên ARM, AVX-512 VNNI và vpermb trên x86, với AVX2 và dự phòng vô hướng — đánh bại FAISS IndexPQFastScan trong mọi cấu hình được đo, đạt trung bình 3,4× ở 4 bit và 23% ở 2 bit trên tám ô của mỗi chiều rộng, trên cả hai kiến trúc.
• Tiết kiệm gia tăng. sync(path) vẫn giữ nguyên những gì đã thay đổi kể từ lần đồng bộ hóa cuối cùng - một fsync cho mỗi cuộc gọi, an toàn khi xảy ra sự cố ở bất kỳ byte nào và việc xóa hoặc bổ sung nhỏ sẽ tốn một phần nghìn giây cho dù chỉ mục có lớn đến đâu. write/load ở lại để chụp ảnh nhanh toàn bộ tập tin.
• Lọc tại thời điểm tìm kiếm. Chuyển danh sách id cho phép (hoặc bitmask vị trí) tới search() và kernel tôn vinh nó một cách trực tiếp. Bạn luôn thức dậy để k kết quả từ tập hợp được phép - không tìm nạp quá mức, không thu hồi trên các bộ lọc chọn lọc.
• thuần túy địa phương. Không có dịch vụ được quản lý, không có dữ liệu rời khỏi máy hoặc VPC của bạn. Ghép nối với bất kỳ mô hình nhúng nguồn mở nào để có ngăn xếp RAG được phân cách hoàn toàn.

Xây dựng RAG nơi có vấn đề về quyền riêng tư, bộ nhớ hoặc độ trễ? Bạn đang ở đúng nơi.

Python

pip install turbovec

from turbovec import TurboQuantIndex

index = TurboQuantIndex(dim=1536, bit_width=4)
index.add(vectors)
index.add(more_vectors)

scores, indices = index.search(query, k=10)

index.write("my_index.tv")
loaded = TurboQuantIndex.load("my_index.tv")

index.sync("my_index.tv")   # after more changes: durable incremental save

vectors và query là 2-D float32 mảng hình dạng (n, dim) — các dtype khác bị từ chối thay vì được chuyển đổi âm thầm, vì vậy hãy truyền bằng np.asarray(x, dtype=np.float32) đầu tiên nếu cần thiết.

Cần id ổn định có thể tồn tại sau khi xóa? sử dụng IdMapIndex:

import numpy as np
from turbovec import IdMapIndex

index = IdMapIndex(dim=1536, bit_width=4)
index.add_with_ids(vectors, np.array([1001, 1002, 1003], dtype=np.uint64))

scores, ids = index.search(query, k=10)   # ids are your uint64 external ids
index.remove(1002)                         # O(1) by id

index.write("my_index.tvim")
loaded = IdMapIndex.load("my_index.tvim")

index.sync("my_index.tvim")   # durable incremental save, ids included

Truy xuất kết hợp (tìm kiếm có lọc)

Giới hạn kết quả đối với một tập ứng cử viên do hệ thống khác tạo ra (SQL, BM25, ACL, cửa sổ thời gian,…):

import numpy as np
from turbovec import IdMapIndex

idx = IdMapIndex(dim=1536, bit_width=4)
idx.add_with_ids(vectors, ids)

# Stage 1: external system narrows to candidate ids.
allowed = np.array(db.execute("SELECT id FROM docs WHERE tenant=?", (t,)).fetchall(),
                   dtype=np.uint64)

# Stage 2: dense rerank within the candidate set.
scores, ids = idx.search(query, k=10, allowlist=allowed)

Quá trình lọc diễn ra bên trong hạt nhân SIMD ở mức độ chi tiết của khối 32 vectơ: các khối không có vị trí được phép sẽ bị ngắt mạch trước bất kỳ công việc tra cứu hoặc ghi điểm LUT nào và các vị trí không được phép riêng lẻ bên trong các khối đã ghi sẽ bị loại bỏ khi chèn đống. Do đó, danh sách cho phép có chọn lọc (một phần nhỏ của chỉ mục được phép) tránh được phần lớn chi phí SIMD thay vì thanh toán và loại bỏ kết quả sau đó.

Độ dài đầu ra là min(k, n_allowed), ở đâu n_allowed đếm khác biệt vectơ được phép - khi có ít vectơ được phép hơn k bạn nhận được chính xác nhiều kết quả thay vì dự phòng được đệm.

Xem docs/api.md để tham khảo đầy đủ.

Tích hợp khung

Các lựa chọn thay thế thả vào cho các kho lưu trữ tài liệu/vectơ tham chiếu trong cây trong mỗi khung. Cùng một bề mặt công khai, cùng một ngữ nghĩa bền vững, cùng một bộ truy xuất và nối dây đường ống - hoán đổi quá trình nhập và giữ đường dẫn của bạn.

• LangChain — pip install turbovec[langchain] · thay thế langchain_core.vectorstores.InMemoryVectorStore
• LlamaIndex — pip install turbovec[llama-index] · thay thế llama_index.core.vector_stores.SimpleVectorStore
• đống cỏ khô — pip install turbovec[haystack] · thay thế haystack.document_stores.in_memory.InMemoryDocumentStore
• Agno — pip install turbovec[agno] · thay thế agno.vectordb.lancedb.LanceDb

Rust

cargo add turbovec

use turbovec::TurboQuantIndex;

let mut index = TurboQuantIndex::new(1536, 4).unwrap();
index.add(&vectors);
let results = index.search(&queries, 10);
index.write("index.tv").unwrap();
let loaded = TurboQuantIndex::load("index.tv").unwrap();

Đối với các id bên ngoài ổn định có thể tồn tại sau khi xóa:

use turbovec::IdMapIndex;

let mut index = IdMapIndex::new(1536, 4).unwrap();
index.add_with_ids(&vectors, &[1001, 1002, 1003]).unwrap();
let (scores, ids) = index.search(&queries, 10);
index.remove(1002);
index.write("index.tvim").unwrap();
let loaded = IdMapIndex::load("index.tvim").unwrap();

thu hồi

TurboQuant vs FAISS IndexPQ (LUT256, nbits=8) — đường cơ sở Mục 4.4 của bài báo. Vectơ 100K, k=64. Số lượng lượng tử hóa phụ FAISS PQ có kích thước phù hợp với tốc độ bit của TurboQuant (m=d/4 ở 2 bit, m=d/2 ở 4 bit).

Biểu đồ được hiệu chỉnh bằng TurboQuant (TQ+). Trên OpenAI d=1536 và d=3072, TQ+ đánh bại FAISS ở R@1 trên ba trong số bốn ô (0,9–2,9 điểm; d=1536 vệt 4 bit với 0,7) và cả hai đều đạt 1,0 x k=8 ( ≥0,997 đã ở mức k≤4). GloVe d=200 là chế độ khó hơn - ở mức độ mờ thấp, giả định Beta tiệm cận sẽ lỏng lẻo hơn. TQ+ vượt lên trước FAISS ở R@1 ở cả hai độ rộng bit (+1,9 ở 4 bit, +0,8 ở 2 bit), trong đó FAISS giữ cạnh mỏng ở 2 bit từ k≈8. Các số chưa được hiệu chỉnh có trong JSON (tq_recalls).

Một lưu ý về đường cơ sở. Chúng tôi so sánh với FAISS IndexPQ (LUT256, nbits=8, float32 LUT) vì đây là PQ cấp sản xuất mặc định mà hầu hết người dùng sẽ hướng tới. Đây là đường cơ sở mạnh hơn PQ u8-LUT tùy chỉnh trong Giấy TurboQuant — FAISS sử dụng LUT có độ chính xác cao hơn tại thời điểm ghi điểm và k-means++ để đào tạo sách mã. Chúng tôi tái tạo các số TurboQuant của bài báo trên OpenAI d=1536 / d=3072 và đạt được các số tương tự với các triển khai tham chiếu cộng đồng khác trên các phần nhúng có độ mờ thấp (xem turboquant-py tại d=384). Trên GloVe (d=200) — chế độ độ sáng thấp trong đó giả định Beta tiệm cận là lỏng lẻo nhất — TurboQuant vượt lên trước FAISS ở 4 bit nhưng bám sát FAISS ở 2 bit; Hiệu chuẩn TQ+ phục hồi mức thâm hụt 2 bit ở R@1 (0,572 so với 0,564 của FAISS), với FAISS giữ cạnh mỏng ở mức k sâu hơn.

Kết quả đầy đủ: d=1536 2-bit, d=1536 4-bit, d=3072 2-bit, d=3072 4-bit, GloVe 2-bit, GloVe 4-bit.

nén

Tốc độ tìm kiếm

Tất cả các điểm chuẩn: vectơ 100K, truy vấn 1K, k=64, trung bình của 5 lần chạy.

ARM (GCP c4a-standard-8, Google Axion, 8 vCPU)

Trên ARM, TurboQuant đánh bại FAISS FastScan ở mọi cấu hình, trung bình 3,5× ở 4 bit (3,4–3,7× trên các ô — hạt nhân sản phẩm chấm SDOT/SMMLA chấm điểm trực tiếp cho bố cục vectơ chính) và 26% ở 2 bit (22–29%).

x86 (Intel Xeon Platinum 8481C / Sapphire Rapids, 8 vCPU)

Trên x86, TurboQuant giành chiến thắng ở mọi cấu hình, trung bình 3,4× ở 4 bit (3,2–3,5× trên các ô — hạt nhân sản phẩm chấm AVX-512 VNNI trên bố cục vectơ chính) và 20% ở 2 bit (5–32%), trong đó vpermb Quét LUT mang vòng lặp tích lũy 2 bit ngắn.

Độ trễ chèn và xóa

Kho dữ liệu tương tự như các ô tìm kiếm: vectơ 100K OpenAI, trung bình của 5 lần chạy, các vòng lặp được tính thời gian bao gồm chi phí cuộc gọi Python mà người gọi thực tế phải trả cho mỗi hoạt động. Các biện pháp chèn trên mỗi vectơ add() độ trễ trên một chỉ mục đông dân, ấm (được xây dựng không tính thời gian) ở mức n=1 - một vectơ đơn add() — và n=100 — một lô 100 vectơ, cho thấy mức độ phân bổ theo đợt của chi phí cho mỗi cuộc gọi — so với add() vào FAISS được đào tạo, đông dân IndexPQFastScan (đào tạo không tính thời gian). Một đĩa đơn add() đạt đến 6,3–19,7 µs tùy thuộc vào ô (nhanh hơn 7,6–13,9× so với một lần thêm FAISS) và một lô 100 vectơ phân bổ TurboQuant thành 4,6–16,3 µs/vector (nhanh hơn 4,6–15,1× so với cùng một đợt vào FAISS). Loại bỏ đo độ trễ loại bỏ theo id theo từng hoạt động ở n=1 (tốc độ mỗi hoạt động ổn định trên 1000 lần xóa) và n=100 (100 lần xóa đầu tiên trên một chỉ mục mới): IdMapIndex.remove(id) — O(1) swap-and-pop cộng với việc ghi sổ bản đồ id - đạt 0,44–1,22 µs và 0,59–1,37 µs mỗi hoạt động trên các ô. Cột FAISS là hoạt động tương tự mà người dùng có thể nhìn thấy, remove_ids trên một IndexIDMap kết thúc IndexPQFastScan, đóng gói lại các mã được lưu trữ trên mỗi lệnh gọi: 0,19–1,02 giây cho mỗi lần xóa ở mức 100K, với chi phí tăng gấp đôi cùng với kích thước mã — đó là lý do tại sao biểu đồ loại bỏ sử dụng trục tỷ lệ log. Biểu đồ hiển thị các ô đơn luồng (RAYON_NUM_THREADS=1); cái _mt các ô cũng được đo và khớp ở mức n=1, vì một lần thêm duy nhất là nối tiếp. Kịch bản: benchmarks/suite/.

ARM (GCP c4a-standard-8, Google Axion, 8 vCPU)

Kết quả đầy đủ: d=1536 Chèn 2 bit, d=1536 Chèn 4 bit, d=3072 Chèn 2 bit, d=3072 Chèn 4 bit, và sự phù hợp speed_remove_* và _mt tập tin.

x86 (Intel Xeon Platinum 8481C / Sapphire Rapids, 8 vCPU)

Kết quả đầy đủ: d=1536 Chèn 2 bit, d=1536 Chèn 4 bit, d=3072 Chèn 2 bit, d=3072 Chèn 4 bit, và sự phù hợp speed_remove_* và _mt tập tin.

Lưu & Tải

Cùng một kho dữ liệu với các ô tìm kiếm: vectơ 100K OpenAI, trung bình là 5 lần chạy. TurboQuant nối tiếp thành một .tv tập tin có fsync + đổi tên nguyên tử; FAISS là write_index / read_index trên khớp chính xác IndexPQFastScan (số lượng lượng tử phụ khớp với tốc độ bit của TurboQuant, như trong các ô tìm kiếm). Tiết kiệm (ấm áp) là ghi sau khi tìm kiếm đã chạy, do đó bộ đệm bố cục bị chặn sẽ được điền. Tải → tìm kiếm đầu tiên mở một chỉ mục mới và tính thời gian cho truy vấn đầu tiên — tách riêng quá trình khử tuần tự hóa đơn thuần (bộ nhớ đệm của trang được làm ấm xuyên suốt, vì vậy đây là công việc bố cục chứ không phải I/O lưu trữ lạnh) khỏi chi phí truy vấn đầu tiên. Khứ hồi xâu chuỗi chu trình điểm kiểm tra/tiếp tục mà một cửa hàng nhúng thực sự trả tiền - thay đổi vectơ 1K → lưu → mở lại → phục vụ truy vấn đầu tiên; FAISS không có thước đo tương đương cho đường dẫn này nên nó chỉ được hiển thị cho TurboQuant. Trên tải trọng nhỏ hơn, chuyến đi khứ hồi có thể diễn ra bên dưới ghi sau đột biến ("bẩn") bị cô lập: cả hai được tính thời gian theo các bước riêng biệt và ở kích thước tệp nhỏ, bản ghi độc lập fsync trong bước viết bẩn chiếm ưu thế và làm tăng nó - một tạo tác đo lường của dây nịt, không phải là chiến thắng đóng gói lại trong đường dẫn kết hợp. Pin tế bào đơn luồng RAYON_NUM_THREADS=1. Kịch bản: benchmarks/suite/.

ARM (GCP c4a-standard-8, Google Axion, 8 vCPU)

Kết quả đầy đủ: d=1536 ST tồn tại 2 bit, MT, d=1536 ST tồn tại 4 bit, MT, d=3072 ST tồn tại 2 bit, MT, d=3072 ST tồn tại 4 bit, MT.

x86 (Intel Xeon Platinum 8481C / Sapphire Rapids, 8 vCPU)

Kết quả đầy đủ: d=1536 ST tồn tại 2 bit, MT, d=1536 ST tồn tại 4 bit, MT, d=3072 ST tồn tại 2 bit, MT, d=3072 ST tồn tại 4 bit, MT.

Nó hoạt động như thế nào

Mỗi vectơ là một hướng trên một siêu cầu nhiều chiều. TurboQuant nén các hướng này bằng cách sử dụng thông tin chuyên sâu đơn giản: sau khi áp dụng phép xoay ngẫu nhiên, mọi tọa độ đều tuân theo một phân bố đã biết -- bất kể dữ liệu đầu vào là gì.

1. Bình thường hóa. Tách độ dài (chuẩn mực) khỏi mỗi vectơ và lưu nó dưới dạng một phao đơn. Bây giờ mỗi vectơ là một hướng đơn vị trên siêu cầu.

2. Xoay vòng ngẫu nhiên. Nhân tất cả các vectơ với cùng một ma trận trực giao ngẫu nhiên. Sau khi xoay, mỗi tọa độ độc lập tuân theo phân phối Beta hội tụ về Gaussian N(0, 1/d) ở các chiều cao. Điều này áp dụng cho mọi dữ liệu đầu vào -- việc xoay làm cho việc phân phối tọa độ có thể dự đoán được.

3. Hiệu chuẩn theo tọa độ (TQ+). Phân phối Beta từ bước 2 là tiệm cận — ở kích thước hữu hạn, các tọa độ riêng lẻ lệch khỏi hình dạng chuẩn (đặc biệt là các phần nhúng kiểu bit thấp và vectơ từ). TQ+ khớp với hai đại lượng vô hướng trên mỗi tọa độ — một độ dịch chuyển và một tỷ lệ — ánh xạ các phân vị thực nghiệm của từng tọa độ lên các trọng tâm ngoài cùng của sổ mã. Mức xác suất lấy từ sổ mã nên nó theo dõi độ rộng bit (0,933 ở 2 bit, ~ 0,996 ở 4 bit) thay vì cố định. Sách mã Lloyd-Max sau đó lượng tử hóa dựa vào mục tiêu phân phối nó được thiết kế cho. Sự phù hợp là rõ ràng: gọi index.calibrate(sample) một lần với một mẫu đại diện ngẫu nhiên của các vectơ của bạn (1024 hàng là đủ - một bản vẽ có kích thước đó khớp với toàn bộ kho văn bản) trước khi thêm; sau đó, quá trình hiệu chuẩn được thực hiện và tái sử dụng trong mỗi lần bổ sung — không cần đào tạo lại, không cần xây dựng lại, không có giai đoạn huấn luyện riêng biệt. Một chỉ mục mà bạn không bao giờ hiệu chỉnh là TurboQuant đơn giản. index.calibration_state báo cáo "uncalibrated" hoặc "calibrated". Mức thu hồi: lên đến +2,2pp ở @1 trên các ô trôi nhiều nhất (ví dụ: GloVe ở 2-bit).

4. Lượng tử hóa vô hướng Lloyd-Max. Vì đã biết phân phối nên chúng tôi có thể tính toán trước cách tối ưu để sắp xếp từng tọa độ. Đối với 2 bit, đó là 4 nhóm; cho 4-bit, 16 thùng. các Thuật toán Lloyd-Max tìm ranh giới nhóm và trọng tâm để giảm thiểu sai số bình phương trung bình. Chúng được tính toán một lần từ toán học, không phải từ dữ liệu.

5. Gói bit. Mỗi tọa độ bây giờ là một số nguyên nhỏ (0-3 cho 2 bit, 0-15 cho 4 bit). Đóng gói chúng chặt chẽ thành byte. Vectơ mờ 1536 đi từ 6.144 byte (FP32) đến 384 byte (2 bit). Đó là nén 16x.

6. Tính điểm tái chuẩn hóa theo chiều dài. Lượng tử hóa vô hướng đánh giá thấp các sản phẩm bên trong một cách có hệ thống - hướng đơn vị được tái tạo ngắn hơn một chút so với hướng ban đầu. Chúng tôi tính toán một đại lượng vô hướng trên mỗi vectơ tại thời điểm mã hóa — tích bên trong của vectơ đơn vị được quay với sự tái cấu trúc trọng tâm của chính nó — và lưu trữ ||v|| / ⟨u, x̂⟩ dọc theo mỗi vectơ nén. Hạt nhân tìm kiếm nhân điểm của mỗi ứng viên với số vô hướng này trước khi chèn vùng nhớ heap, biến công cụ ước tính sản phẩm bên trong từ thiên vị xuống thành không thiên vị với chi phí thời gian tìm kiếm bằng 0 và không có dung lượng lưu trữ bổ sung. Độ lợi thu hồi xuất hiện nhiều nhất ở độ rộng bit thấp, trong đó độ co rút lượng tử hóa là lớn nhất.

Chi phí mã hóa: thêm một dtích số chấm chiều trên mỗi vectơ để tính toán ⟨u, x̂⟩. Trên vectơ 1M ở d=1536, đây là phần dưới giây của thời gian mã hóa bổ sung — giá một lần được thanh toán khi nhập, không phải khi truy vấn.

Tìm kiếm. Thay vì giải nén mọi vectơ cơ sở dữ liệu, chúng tôi xoay truy vấn một lần vào cùng một miền và tính điểm trực tiếp theo các giá trị sổ mã. Hạt nhân tính điểm sử dụng nội tại SIMD (NEON trên ARM; AVX-512BW trên x86 hiện đại, quay trở lại AVX2, sau đó chuyển sang đường dẫn vô hướng trên các CPU trước AVX2) với các bảng tra cứu phân chia nhỏ để có thông lượng tối đa.

Sách mã Lloyd-Max đạt được độ méo trong phạm vi hệ số 2,7 lần giới hạn dưới lý thuyết thông tin (giới hạn tốc độ méo của Shannon); bước tái chuẩn hóa độ dài sẽ loại bỏ độ lệch dư mà sổ mã Lloyd-Max đưa vào chính bộ ước lượng tích trong.

tòa nhà

Python (thông qua trưởng thành)

pip install maturin
cd turbovec-python
maturin build --release
pip install target/wheels/*.whl

Rust

cargo build --release

Tất cả mục tiêu xây dựng x86_64 x86-64-v2 (Đường cơ sở SSE4.2, Nehalem 2008+) qua .cargo/config.toml, do đó, mọi x86-64-v2 CPU đều có thể chạy toàn bộ thùng. Hạt nhân AVX-512 và AVX2 là #[target_feature]-gated và được chọn khi chạy thông qua is_x86_feature_detected!, do đó, họ bắt đầu sử dụng phần cứng hỗ trợ họ bất kể đường cơ sở biên dịch; CPU không chạy dự phòng vô hướng.

Chạy điểm chuẩn

Tải xuống bộ dữ liệu:

python3 benchmarks/download_data.py all            # all datasets
python3 benchmarks/download_data.py glove          # GloVe d=200
python3 benchmarks/download_data.py openai-1536    # OpenAI DBpedia d=1536
python3 benchmarks/download_data.py openai-3072    # OpenAI DBpedia d=3072

Mỗi điểm chuẩn là một tập lệnh độc lập trong benchmarks/suite/. Chạy bất kỳ cái nào riêng lẻ:

python3 benchmarks/suite/speed_d1536_2bit_arm_mt.py
python3 benchmarks/suite/recall_d1536_2bit.py
python3 benchmarks/suite/compression.py

Chạy tất cả các điểm chuẩn cho một danh mục:

for f in benchmarks/suite/speed_*arm*.py; do python3 "$f"; done    # all ARM speed
for f in benchmarks/suite/speed_*x86*.py; do python3 "$f"; done    # all x86 speed
for f in benchmarks/suite/recall_*.py; do python3 "$f"; done       # all recall
python3 benchmarks/suite/compression.py                            # compression

Kết quả được lưu dưới dạng JSON thành benchmarks/results/. Tạo lại biểu đồ:

python3 benchmarks/create_diagrams.py

Khai thác nhanh cho công việc tối ưu hóa

Bộ phần mềm trên là nguồn của mọi số được xuất bản — phần nhúng thực, bộ so sánh FAISS, hình dạng cố định, chạy trên hai môi trường chính thức. Đối với vòng lặp bên trong của thẻ tối ưu hóa, cũng có một khai thác Rust tái tạo bốn số liệu đột biến (thêm số lượng lớn nguội, nối thêm ấm, thêm đơn, xóa) trên các vectơ tổng hợp xác định, do đó, một giả thuyết có thể được đo bằng giây trên bất kỳ máy nào không có tập dữ liệu và không có FAISS:

cargo run --release --example insert_bench -- --dim 1536 --bits 2
RAYON_NUM_THREADS=1 cargo run --release --example insert_bench

Nó là một công cụ sàng lọc, không phải là nguồn số liệu được công bố.

examples/encode_hash in hàm băm theo từng giai đoạn của đường dẫn mã hóa cho đầu vào cố định; CI chạy nó trên mọi hệ điều hành trong ma trận và không thành công nếu chúng không đồng ý, đó là cách kiểm tra nhận dạng byte đa nền tảng của mã hóa.

Tài liệu tham khảo

• TurboQuant: Lượng tử hóa vectơ trực tuyến với tốc độ biến dạng gần như tối ưu (ICLR 2026) -- bài báo thực hiện
• RaBitQ: Lượng tử hóa các vectơ chiều cao với giới hạn lỗi lý thuyết để tìm kiếm lân cận gần nhất (SIGMOD 2024) -- nguồn của hiệu chỉnh tái chuẩn hóa độ dài trên mỗi vectơ được điều chỉnh ở bước 5
• FAISS Tích lũy nhanh mã PQ và AQ -- hạt nhân SIMD x86 của turbovec điều chỉnh bố cục gói, tính điểm nibble-LUT và chiến lược tích lũy u16 của FastScan