VectorChord

Vecteur

Accueillent sans effort 100 millions de vecteurs à 768 dimensions (250 Go +) sur une instance AWS I4i.xlarge (250 $ / mois), avec 4 VCPU et 32 ​​Go de RAM avec VectorChord.

Docker Pull pour pgvecto.rs:

VectorChord (VCHORD) est une extension postgresql conçue pour la recherche de similitude vectorielle évolutive, haute performance et économe en disque, et sert de successeur à pgvecto.rs.

Avec VectorChord, vous pouvez stocker 400 000 vecteurs pour seulement 1 $, permettant des économies importantes: 6x plus de vecteurs par rapport au stockage optimisé de Pinecone et 26x de plus que pgvector / pgvecto.rs pour le même prix ¹ . Pour plus d'informations, consultez notre article de blog de lancement.

Caractéristiques

VectorChord introduit des améliorations remarquables par rapport à pgvecto.rs et pgvector:

⚡ Performances améliorées : offrir des opérations optimisées avec jusqu'à 5x requêtes plus rapides, 16x débit d'insert plus élevé et 16x plus rapide ² index par rapport à l'implémentation HNSW de PGVector.

? Recherche de vecteurs abordable : requête des vecteurs de dimension de 100m 768 en utilisant seulement 32 Go de mémoire, en réalisant 35 ms P50 latence avec le rappel TOP10 à 95%, vous aidant à réduire les coûts d'infrastructure tout en maintenant une qualité de recherche élevée.

? Intégration transparente : entièrement compatible avec les types de données PGVector et la syntaxe tout en fournissant des paramètres optimaux de la boîte - aucun réglage du paramètre manuel nécessaire. Il suffit de tomber dans VectorChord pour des performances améliorées.

? Bâtiment d'index externe : Levier sur l'effet de FIV pour construire des index à l'extérieur (par exemple, sur GPU) pour le clustering Kmeans plus rapide, combiné avec la compression Rabitq ³ pour stocker efficacement les vecteurs tout en conservant la qualité de recherche grâce à une rediffusion autonome.

? Prise en charge des vecteurs longs : stockage et recherchez des vecteurs jusqu'à 65 535 dimensions, permettant l'utilisation des meilleurs modèles de grande dimension comme le texte-3-3.

Démarrage rapide

Pour les nouveaux utilisateurs, nous vous recommandons d'utiliser l'image Docker pour commencer rapidement.

docker run 
  --name vectorchord-demo 
  -e POSTGRES_PASSWORD=mysecretpassword 
  -p 5432:5432 
  -d tensorchord/vchord-postgres:pg17-v0.1.0

Ensuite, vous pouvez vous connecter à la base de données à l'aide de l'outil de ligne de commande psql . Le nom d'utilisateur par défaut est postgres , et le mot de passe par défaut est mysecretpassword .

psql -h localhost -p 5432 -U postgres

Exécutez le SQL suivant pour s'assurer que l'extension est activée.

CREATE EXTENSION IF NOT EXISTS vchord CASCADE;

Et assurez-vous d'ajouter vchord.so au shared_preload_libraries dans postgresql.conf .

 -- Add vchord and pgvector to shared_preload_libraries --
ALTER SYSTEM SET shared_preload_libraries = ' vchord.so ' ;

Pour créer l'index VectorChord Rabitq (VCHORDRQ), vous pouvez utiliser le SQL suivant.

 -- Set residual_quantization to true and spherical_centroids to false for L2 distance --
CREATE INDEX ON gist_train USING vchordrq (embedding vector_l2_ops) WITH (options = $$
residual_quantization = true
[ build . internal ]
lists = [ 4096 ]
spherical_centroids = false
$$);


-- Set residual_quantization to false and spherical_centroids to true for cos/dot distance --
CREATE INDEX ON laion USING vchordrq (embedding vector_cos_ops) WITH (options = $$
residual_quantization = false
[ build . internal ]
lists = [ 4096 ]
spherical_centroids = true
$$);

Documentation

Requête

L'énoncé de requête est exactement le même que PGVector. VectorChord prend en charge toute opération de filtre et les clauses où / jointer comme pgvecto.rs avec VBase.

 SELECT * FROM items ORDER BY embedding < - > ' [3,1,2] ' LIMIT 5 ;

Les fonctions de distance supportées sont:

• <-> - Distance L2
• <#> - (négatif) produit intérieur
• <=> - Distance du cosinus

Réglage des performances de requête

Vous pouvez affiner les performances de recherche en ajustant les probes et les paramètres epsilon :

 -- Set probes to control the number of lists scanned. 
-- Recommended range: 3%–10% of the total `lists` value.
SET vchordrq . probes = 100 ;

-- Set epsilon to control the reranking precision.
-- Larger value means more rerank for higher recall rate.
-- Don't change it unless you only have limited memory.
-- Recommended range: 1.0–1.9. Default value is 1.9.
SET vchordrq . epsilon = 1 . 9 ;

-- vchordrq relies on a projection matrix to optimize performance.
-- Add your vector dimensions to the `prewarm_dim` list to reduce latency.
-- If this is not configured, the first query will have higher latency as the matrix is generated on demand.
-- Default value: '64,128,256,384,512,768,1024,1536'
-- Note: This setting requires a database restart to take effect.
ALTER SYSTEM SET vchordrq . prewarm_dim = ' 64,128,256,384,512,768,1024,1536 ' ;

Et pour le paramètre de Postgres

 -- If using SSDs, set `effective_io_concurrency` to 200 for faster disk I/O.
SET effective_io_concurrency = 200 ;

-- Disable JIT (Just-In-Time Compilation) as it offers minimal benefit (1–2%) 
-- and adds overhead for single-query workloads.
SET jit = off;

-- Allocate at least 25% of total memory to `shared_buffers`. 
-- For disk-heavy workloads, you can increase this to up to 90% of total memory. You may also want to disable swap with network storage to avoid io hang.
-- Note: A restart is required for this setting to take effect.
ALTER SYSTEM SET shared_buffers = ' 8GB ' ;

Indexation de préchaume

Pour prénommer l'index, vous pouvez utiliser le SQL suivant. Il améliorera considérablement les performances lors de l'utilisation de la mémoire limitée.

 -- vchordrq_prewarm(index_name::regclass) to prewarm the index into the shared buffer
SELECT vchordrq_prewarm( ' gist_train_embedding_idx ' ::regclass) "

Temps de construction d'index

Le bâtiment de l'indice peut paralléliser et avec une précomputation de centroïde externe, le temps total est principalement limité par la vitesse du disque. Optimiser le parallélisme en utilisant les paramètres suivants:

 -- Set this to the number of CPU cores available for parallel operations.
SET max_parallel_maintenance_workers = 8 ;
SET max_parallel_workers = 8 ;

-- Adjust the total number of worker processes. 
-- Note: A restart is required for this setting to take effect.
ALTER SYSTEM SET max_worker_processes = 8 ;

Progrès indexé

Vous pouvez vérifier la progression de l'indexation en interrogeant la vue pg_stat_progress_create_index .

 SELECT phase, round( 100 . 0 * blocks_done / nullif(blocks_total, 0 ), 1 ) AS " % " FROM pg_stat_progress_create_index;

Précomputation de l'indice externe

Contrairement à Pure SQL, une précomputation de l'indice externe fera d'abord de regroupement à l'extérieur et inséra des centroïdes à une table PostgreSQL. Bien que cela puisse être plus compliqué, la construction externe est certainement beaucoup plus rapide sur un ensemble de données plus grand (> 5 m).

Pour commencer, vous devez effectuer un clustering de vecteurs à l'aide faiss , scikit-learn ou toute autre bibliothèque de clustering.

Les centroïdes doivent être prédéfinis dans un tableau de tout nom avec 3 colonnes:

• id (entier): l'identifiant de chaque centroïde, devrait être unique
• parent (entier, nullable): L'ID parent de chaque centroïde, doit être nul pour le clustering normal
• Vector (vecteur): représentation de chaque centroïde, type de vecteur pgvector

Et l'exemple pourrait être comme ceci:

 -- Create table of centroids
CREATE TABLE public .centroids (id integer NOT NULL UNIQUE, parent integer , vector vector( 768 ));
-- Insert centroids into it
INSERT INTO public . centroids (id, parent, vector) VALUES ( 1 , NULL , ' {0.1, 0.2, 0.3, ..., 0.768} ' );
INSERT INTO public . centroids (id, parent, vector) VALUES ( 2 , NULL , ' {0.4, 0.5, 0.6, ..., 0.768} ' );
INSERT INTO public . centroids (id, parent, vector) VALUES ( 3 , NULL , ' {0.7, 0.8, 0.9, ..., 0.768} ' );
-- ...

-- Create index using the centroid table
CREATE INDEX ON gist_train USING vchordrq (embedding vector_l2_ops) WITH (options = $$
[ build . external ]
table = ' public.centroids '
$$);

Pour simplifier le flux de travail, nous fournissons des scripts de bout en bout pour la pré-computation de l'index externe, voir les scripts.

Installation à partir de la source

Installez PGRX selon les instructions de PGRX.

cargo install --locked cargo-pgrx
cargo pgrx init --pg17 $( which pg_config ) # To init with system postgres, with pg_config in PATH
cargo pgrx install --release --sudo # To install the extension into the system postgres with sudo 

Limites

• Clustering Kmeans: Le clustering Kmeans intégré dépend de la construction en mémoire multi-thread et peut nécessiter une mémoire substantielle. Nous recommandons fortement d'utiliser une précomputation de centroïde externe pour une construction d'index efficace.

Licence

Ce logiciel est sous licence dans un modèle à double licence:

1. GNU Affero General Public License V3 (AGPLV3) : Vous pouvez utiliser, modifier et distribuer ce logiciel en vertu des termes de l'AGPLV3.

2. Licence élastique V2 (ELV2) : Vous pouvez également utiliser, modifier et distribuer ce logiciel sous la licence élastique V2, qui a des restrictions spécifiques.

Vous pouvez choisir l'une ou l'autre licence en fonction de vos besoins. Nous nous félicitons de toute collaboration commerciale ou support, veuillez donc nous envoyer un e-mail à [email protected] avec toutes les questions ou demandes concernant les licences.

Notes de bas de page

1. Basé sur une référence MyScale avec des vecteurs 768 dimensionnels et un rappel à 95%. ↩

2. Basé sur la référence MyScale avec des vecteurs 768 dimensions. Veuillez consulter notre article de blog pour plus de détails. ↩

3. Gao, Jianyang et Cheng Long. "Rabitq: quantification des vecteurs de grande dimension avec une erreur théorique à destination de la recherche approximative la plus proche du voisin." Actes de l'ACM sur la gestion des données 2.3 (2024): 1-27. ↩