Index vectoriel - MaxCompute - Centre de documentation Alibaba Cloud

Un index vectoriel est un mécanisme d'indexation efficace dans MaxCompute qui accélère les recherches de similarité sur des données vectorielles à grande échelle. Cette rubrique explique comment utiliser les index vectoriels et fournit des exemples.

Notes

Les index vectoriels ne peuvent être créés que sur les Delta Tables.
Déclencheurs de construction d'index
- Génération synchrone : utilisée principalement pour le traitement par lots hors ligne. Après la définition d'un index avec CREATE VECTOR INDEX, les opérations INSERT déclenchent la génération de l'index de manière synchrone.
- Reconstruction complète : si la récupération via l'index est inefficace, reconstruisez l'index sur l'ensemble du jeu de données. Vous pouvez déclencher cette opération manuellement avec la commande REBUILD INDEX ou laisser un processus en arrière-plan le faire automatiquement lorsqu'il détecte une faible efficacité de récupération.
Le système empêche la suppression d'une colonne référencée par un index vectoriel. Pour supprimer la colonne, supprimez d'abord l'index correspondant.
Pour reconstruire un index vectoriel sur une table partitionnée, spécifiez la plage de partitions avec PARTITION (...). Sinon, le système renvoie une erreur d'analyse sémantique.
Vous pouvez supprimer l'index d'une partition spécifique d'une table partitionnée.
Vous ne pouvez créer qu'un seul index par colonne.
Dans une même table, vous pouvez créer des index distincts avec des noms différents pour plusieurs colonnes vectorielles.

Créer un index vectoriel

Créez un index sur une colonne vectorielle pour accélérer les requêtes de récupération. La commande est la suivante :

CREATE VECTOR INDEX <index_name> 
ON <table_name> (<description_embedding>)
IDXPROPERTIES (
  'algorithm' = 'xxx', 
  'distance_type' = 'xxx', 
  'build_params' = 'xxx'
  ...
);

Paramètres

Paramètre	Description
index_name	Nom de l'index.
table_name	Nom de la table sur laquelle construire l'index vectoriel. Seules les Delta Tables sont prises en charge.
description_embedding	Nom de la colonne vectorielle à indexer.
algorithm	Spécifie l'algorithme de construction de l'index vectoriel. Seul l'algorithme `hgraph` est pris en charge.
distance_type	Spécifie la méthode de calcul de la similarité entre les vecteurs. Les types suivants sont pris en charge : `cosine` : similarité cosinus, qui mesure la similarité entre les directions de deux vecteurs. Cette métrique est couramment utilisée pour les vecteurs de caractéristiques textuelles et d'image. `euclidean` : distance euclidienne, qui représente la distance en ligne droite entre deux vecteurs dans l'espace. `dot_product` : produit scalaire (produit intérieur). Cette métrique convient aux vecteurs normalisés, où une valeur plus élevée indique une similarité plus forte.
build_params	Spécifie les paramètres de configuration pour la construction de l'index au format JSON. Exemple : `'{"max_degree": 16, "ef_construction": 128}'`. Ces paramètres contrôlent la qualité de la construction et les performances de l'index. Les paramètres courants incluent : `max_degree` : contrôle le nombre maximal de connexions pour chaque nœud du graphe. Une valeur plus élevée améliore la précision de l'index mais peut augmenter le temps de construction et de requête. `ef_construction` : spécifie la taille de la liste des candidats lors de la phase de construction. Ce paramètre affecte l'efficacité de la construction et la qualité de la recherche. Une valeur plus élevée augmente le temps de construction mais peut améliorer la précision de la recherche. Les index vectoriels prennent également en charge la quantification vectorielle interne. Les paramètres suivants sont liés à la quantification : base_quantization_type : encodage vectoriel utilisé lors de la traversée du graphe et de la récupération des candidats. Les valeurs valides incluent `fp32`, `fp16`, `sq8`, `sq8_uniform` et `rabitq`. use_reorder : spécifie s'il faut réorganiser l'ensemble des candidats récupéré lors de la traversée du graphe en utilisant un calcul de distance haute précision. La valeur par défaut est `false`. Si la réorganisation est activée, l'index doit stocker à la fois les encodages vectoriels de base et de précision. Par conséquent, une quantification de base plus agressive ne se traduit pas nécessairement par une taille d'index finale plus petite. La taille réelle de l'index dépend également du `precise_quantization_type`, des dimensions du vecteur et de la structure HGraph. precise_quantization_type : précision vectorielle utilisée lors de la phase de réorganisation. Ce paramètre prend effet uniquement lorsque `use_reorder` est défini sur `true`. Les valeurs courantes sont `fp16` et `fp32`. Pour plus d'informations sur la configuration de la quantification, consultez Configuration de la quantification des index vectoriels.

Configuration de la quantification des index vectoriels

Les index vectoriels prennent en charge la quantification vectorielle interne afin de réduire le stockage de l'index, la mémoire d'exécution et la surcharge d'accès mémoire lors de la récupération. La quantification modifie uniquement l'encodage vectoriel au sein de l'index. Elle n'altère ni les données VECTOR(FLOAT, dimension) d'origine dans la table, ni la manière dont VECTOR_SEARCH est appelé. Les index vectoriels MaxCompute prennent en charge les deux méthodes de récupération suivantes :

Récupération en une seule étape : utilise directement le base_quantization_type pour la traversée du graphe et le calcul de distance. Cette méthode aboutit à une structure d'index plus simple et à une utilisation mémoire réduite.
Récupération en deux étapes : utilise d'abord des vecteurs de base basse précision pour une récupération rapide des candidats, puis utilise des vecteurs précis pour recalculer les distances. Cette méthode offre un compromis entre les performances de récupération et le rappel.

Le tableau suivant décrit les combinaisons courantes de paramètres de quantification.

Configuration	Combinaison de paramètres	Description
FP32	`base_quantization_type=fp32`	Caractéristiques : référence pleine précision avec un rappel stable, mais une consommation mémoire élevée. Cas d'utilisation : scénarios nécessitant une haute précision ou impliquant de petits jeux de données.
FP16	`base_quantization_type=fp16`	Caractéristiques : réduit l'empreinte mémoire des vecteurs à environ 50 % de celle du FP32, avec un rappel quasi identique. Cas d'utilisation : scénarios nécessitant une haute précision ou impliquant de petits jeux de données. Offre un léger compromis sur le rappel par rapport au FP32.
SQ8	`base_quantization_type=sq8`	Caractéristiques : réduit l'empreinte mémoire des vecteurs à environ 25 % de celle du FP32, avec une perte mineure de rappel. Cas d'utilisation : scénarios sensibles à la mémoire où une légère perte de rappel est acceptable.
SQ8 + Réorganisation haute précision	`sq8` + `fp16` ou `fp32` reorder	Caractéristiques : utilise SQ8 pour la traversée du graphe, puis restaure le rappel grâce au recalcul de distance haute précision. Cas d'utilisation : scénarios nécessitant un équilibre entre l'efficacité de la récupération et le rappel.
RaBitQ + Réorganisation haute précision	`rabitq` + `fp16` ou `fp32` reorder	Caractéristiques : utilise un encodage plus compact pour la traversée du graphe et réorganise les résultats candidats en utilisant des vecteurs haute précision. Cas d'utilisation : scénarios avec des reconstructions d'index fréquentes nécessitant un rappel élevé.

La quantification offre les avantages suivants :

Réduit la taille des fichiers d'index et l'empreinte mémoire d'exécution.
Diminue la surcharge de bande passante mémoire lors du chargement et de la récupération de l'index.
Améliore l'utilisation du cache CPU, permettant à un seul worker de charger et traiter davantage de vecteurs.
Permet d'équilibrer les performances de récupération, les coûts des ressources et le rappel en combinant la quantification de base avec une réorganisation haute précision.

Nous recommandons d'utiliser FP16 lors de la création d'un index HGraph. Pour plus d'exemples, consultez Exemple : Créer un index vectoriel avec quantification FP16 et Exemple : Créer un index vectoriel avec traversée basse précision RaBitQ et réorganisation haute précision.

Alimenter les données

INSERT OVERWRITE TABLE <table_name> [PARTITION <partition_spec>]
SELECT ......

Reconstruire un index vectoriel

Utilisez les commandes suivantes pour reconstruire un index vectoriel pour les données existantes.

Reconstruire un index pour une table non partitionnée.

ALTER TABLE <table_name> REBUILD INDEX <index_name> ;

Reconstruire un index pour une table partitionnée. Vous pouvez reconstruire l'index vectoriel pour plusieurs partitions en une seule fois.

ALTER TABLE <table_name> PARTITION 
(<partition_name1=value1>[, partition_name2=value2, ...]) REBUILD INDEX <index_name> ;

ALTER TABLE <table_name> PARTITION(partition_name >=value) REBUILD INDEX <index_name> ;

Lister les index vectoriels d'une table

SHOW INDEXES ON <table_name>;

Afficher les informations d'un index vectoriel

DESC INDEX index_name ON  <table_name> [PARTITION <partition_spec>];

Supprimer un index vectoriel

DROP INDEX [IF EXISTS] index_name ON  <table_name> [PARTITION <partition_spec>];

Exemples

Préparer les données

SET odps.sql.type.system.odps2=true;
SET odps.sql.type.vector.enable=true;

DROP TABLE IF EXISTS vector_test;
DROP VIEW IF EXISTS vector_test;

CREATE TABLE IF NOT EXISTS vector_test(
  c0 int,
  c1 vector(float, 2),
  c2 vector(float, 3)
) STORED AS aliorc 
TBLPROPERTIES (
  'table.format.version'='2', 
  'acid.data.retain.hours'='24',
  'columnar.nested.type'='true', 
  'transactional'='true'
);


INSERT OVERWRITE vector_test SELECT 1, vector(1.1F,2.2F), vector(1.1F,2.2F,3.3F) UNION ALL 
SELECT 2, vector(2.2F,3.3F), vector(2.2F,3.3F,4.4F) 
UNION ALL 
SELECT 3, vector(3.3F,4.4F), vector(3.3F,4.4F,5.5F);

Exemple : Créer un index vectoriel et insérer des données

CREATE VECTOR INDEX c2_vector_index 
ON vector_test (c2) 
IDXPROPERTIES (
  'algorithm' = 'hgraph', 
  'distance_type' = 'cosine', 
  'build_params' = '{"max_degree": 16, "ef_construction": 128}');


ALTER TABLE vector_test REBUILD INDEX c2_vector_index; 


INSERT OVERWRITE vector_test SELECT 1, vector(1.1F,2.2F), vector(1.1F,2.2F,3.3F) 
UNION ALL  
SELECT 2, vector(2.2F,3.3F), vector(2.2F,3.3F,4.4F) 
UNION ALL 
SELECT 3, vector(3.3F,4.4F), vector(3.3F,4.4F,5.5F) 
UNION ALL 
SELECT 4, vector(4.4F,5.5F), vector(4.4F,5.5F,6.6F) 
UNION ALL 
SELECT 5, vector(5.5F,6.6F), vector(5.5F,6.6F,7.7F);

Exemple : Reconstruire un index vectoriel

ALTER TABLE vector_test REBUILD INDEX c2_vector_index; 

SELECT * FROM vector_test; 
-- The following result is returned:
+------+------+------+
| c0   | c1   | c2   |
+------+------+------+
| 1    | [1.1, 2.2] | [1.1, 2.2, 3.3] |
| 2    | [2.2, 3.3] | [2.2, 3.3, 4.4] |
| 3    | [3.3, 4.4] | [3.3, 4.4, 5.5] |
| 4    | [4.4, 5.5] | [4.4, 5.5, 6.6] |
| 5    | [5.5, 6.6] | [5.5, 6.6, 7.7] |
+------+------+------+

Exemple : Lister les index vectoriels

SHOW INDEXES ON vector_test;
-- The following result is returned:
{"Indexes": [{
            "createTime": 1779900024105,
            "id": "512d520**45e1c7ba8",
            "indexColumns": [{"name": "c2"}],
            "name": "c2_vector_index",
            "properties": {
                "algorithm": "hgraph",
                "build_params": "{\"max_degree\": 16, \"ef_construction\": 128}",
                "distance_type": "cosine"},
            "type": "VECTOR"}]}

Exemple : Afficher les informations d'un index vectoriel

DESC INDEX c2_vector_index ON vector_test;

-- The following result is returned:
+------------------------------------------------------------------------------------+
| Index Detail                                                                       |
+------------------------------------------------------------------------------------+
| name:                     c2_vector_index                                          |
| id:                       512d520**e1c7ba8                         |
| index_type:               VECTOR                                                   |
| index_columns:            c2                                                       |
| status:                   ACTIVE                                                   |
| coverage_percentage:      100%                                                     |
| storage_size_bytes:       6940                                                     |
| properties:               build_params={"max_degree": 16, "ef_construction": 128}, distance_type=cosine, algorithm=hgraph |
+------------------------------------------------------------------------------------+

Exemple : Supprimer un index vectoriel

DROP INDEX c2_vector_index ON vector_test;

-- The following result is returned:
{"Indexes": []}

Exemple : Créer un index vectoriel avec quantification FP16

CREATE VECTOR INDEX doc_vector_index
ON doc_table (embedding)
IDXPROPERTIES (
  'algorithm' = 'hgraph',
  'distance_type' = 'dot_product',
  'build_params' = '{
    "max_degree":48,
    "ef_construction":400,
    "base_quantization_type":"fp16"
  }'
);

-- After you create the index, you must rebuild it for existing data.
ALTER TABLE doc_table PARTITION (pt='20260730') REBUILD INDEX doc_vector_index;

Exemple : Créer un index vectoriel avec RaBitQ et réorganisation

CREATE VECTOR INDEX doc_vector_index
ON doc_table (embedding)
IDXPROPERTIES (
  'algorithm' = 'hgraph',
  'distance_type' = 'dot_product',
  'build_params' ='{
    "max_degree":48,
    "ef_construction":400,
    "base_quantization_type":"rabitq",
    "use_reorder":true,
    "precise_quantization_type":"fp32"
  }'
);