Índice vetorial - MaxCompute: Central de Documentação do Alibaba Cloud

O índice vetorial é um mecanismo de indexação eficiente no MaxCompute que acelera buscas por similaridade em dados vetoriais de grande escala. Este tópico explica como usar índices vetoriais e fornece exemplos.

Observações

Antes de criar um VECTOR INDEX, execute o comando SETPROJECT odps.schema.evolution.enable=true; para ativar a Evolução de Schema.
Atualmente, a criação de índices vetoriais é suportada apenas em Delta Tables.
Acionadores de criação de índice
- Geração síncrona: Usada principalmente para processamento em lote offline. Após definir um índice com CREATE VECTOR INDEX, as operações INSERT acionam a geração do índice sincronamente.
- Reconstrução completa: Se a recuperação do índice for ineficiente, reconstrua-o sobre todo o conjunto de dados. Um processo em segundo plano pode acionar essa ação automaticamente ao detectar baixa eficiência na recuperação, ou você pode acioná-la manualmente com o comando REBUILD INDEX.
O sistema bloqueia a exclusão de colunas referenciadas por um índice vetorial. Para excluir a coluna, exclua primeiro o índice correspondente.
Para reconstruir um índice vetorial em uma tabela particionada, especifique o intervalo de partições com PARTITION (...). Caso contrário, ocorrerá um erro de análise semântica.
É possível excluir o índice de uma partição específica em tabelas particionadas.
Crie apenas um índice por coluna.
Na mesma tabela, crie índices distintos, com nomes diferentes, para múltiplas colunas vetoriais.

Criar um índice vetorial

Crie um índice em uma coluna vetorial para acelerar consultas de recuperação. Use o seguinte comando:

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

Parâmetros

Parâmetro	Descrição
index_name	Nome do índice.
table_name	Nome da tabela onde o índice vetorial será criado. Atualmente, apenas Delta Tables são suportadas.
description_embedding	Nome da coluna vetorial a ser indexada.
algorithm	Define o algoritmo de construção do índice vetorial. No momento, o único algoritmo suportado é `hgraph`.
distance_type	Especifica o método para calcular a similaridade entre vetores. Os seguintes tipos são suportados: `cosine`: Similaridade de cosseno. Mede a similaridade entre as direções de dois vetores. É comum em vetores de características de texto e imagem. `euclidean`: Distância euclidiana. Representa a distância em linha reta entre dois vetores no espaço. `dot_product`: Produto escalar (produto interno). Adequado para vetores normalizados, em que valores maiores indicam maior similaridade.
build_params	Define os parâmetros de configuração para a construção do índice no formato JSON. Exemplo: `'{"max_degree": 16, "ef_construction": 128}'`. Esses parâmetros controlam a qualidade da construção e o desempenho do índice. Os parâmetros comuns incluem: `max_degree`: Controla o número máximo de conexões para cada nó no grafo. Valores mais altos melhoram a precisão do índice, mas podem aumentar o tempo de construção e consulta. `ef_construction`: Especifica o tamanho da lista de candidatos durante a fase de construção. Afeta a eficiência da construção e a qualidade da busca. Valores maiores aumentam o tempo de construção, mas podem melhorar a precisão da busca. Os índices vetoriais também suportam quantização vetorial interna. Os seguintes parâmetros relacionam-se à quantização: base_quantization_type: Codificação vetorial usada durante a travessia do grafo e a recuperação de candidatos. Os valores válidos incluem `fp32`, `fp16`, `sq8`, `sq8_uniform` e `rabitq`. use_reorder: Define se o conjunto de candidatos recuperado da travessia do grafo deve ser reordenado com cálculo de distância de alta precisão. O valor padrão é `false`. Se o reordenamento estiver ativado, o índice deverá armazenar tanto as codificações vetoriais base quanto as precisas. Portanto, uma quantização base mais agressiva não resulta necessariamente em um índice final menor. O tamanho real do índice também depende do `precise_quantization_type`, das dimensões do vetor e da estrutura HGraph. precise_quantization_type: Precisão vetorial usada na fase de reordenamento. Este parâmetro entra em vigor apenas quando `use_reorder` está definido como `true`. Os valores comuns são `fp16` e `fp32`. Para obter mais informações sobre a configuração de quantização, consulte Configurar quantização de índice vetorial.

Configurar quantização de índice vetorial

Os índices vetoriais suportam quantização vetorial interna para reduzir o armazenamento do índice, a memória em tempo de execução e a sobrecarga de acesso à memória durante a recuperação. A quantização altera apenas a codificação vetorial dentro do índice. Ela não modifica os dados originais VECTOR(FLOAT, dimension) na tabela nem a forma como VECTOR_SEARCH é chamado. Os índices vetoriais do MaxCompute suportam os dois métodos de recuperação a seguir:

Recuperação em estágio único: Usa diretamente o base_quantization_type para travessia do grafo e cálculo de distância. Esse método resulta em uma estrutura de índice mais simples e menor uso de memória.
Recuperação em dois estágios: Primeiro usa vetores base de baixa precisão para recuperação rápida de candidatos e, em seguida, usa vetores precisos para recalcular as distâncias. Esse método equilibra o desempenho da recuperação e o recall.

A tabela a seguir descreve combinações comuns de parâmetros de quantização.

Configuração

Combinação de parâmetros

Descrição

FP32

base_quantization_type=fp32

Características: Linha de base de precisão total com recall estável, mas alto uso de memória.

Caso de uso: Cenários que exigem alta precisão ou envolvem pequenos conjuntos de dados.

FP16

base_quantization_type=fp16

Características: Reduz o consumo de memória vetorial para cerca de 50% do FP32, com recall quase idêntico.

Caso de uso: Cenários que exigem alta precisão ou envolvem pequenos conjuntos de dados. Oferece uma pequena perda de recall em comparação ao FP32.

SQ8

base_quantization_type=sq8

Características: Reduz o consumo de memória vetorial para cerca de 25% do FP32, com uma perda menor no recall.

Caso de uso: Cenários sensíveis à memória em que uma pequena perda no recall é aceitável.

SQ8 + Reordenamento de Alta Precisão

sq8 + fp16 ou fp32 reorder

Características: Usa SQ8 para travessia do grafo e depois recupera o recall por meio do recálculo de distância de alta precisão.

Caso de uso: Cenários que precisam equilibrar eficiência de recuperação e recall.

RaBitQ + Reordenamento de Alta Precisão

rabitq + fp16 ou fp32 reorder

Características: Usa uma codificação mais compacta para travessia do grafo e reordena os resultados candidatos usando vetores de alta precisão.

Caso de uso: Cenários com reconstruções frequentes de índice que exigem alto recall.

A quantização oferece os seguintes benefícios:

Reduz o tamanho do arquivo de índice e o consumo de memória em tempo de execução.
Diminui a sobrecarga de largura de banda de memória durante o carregamento e a recuperação do índice.
Melhora a utilização do cache da CPU, permitindo que um único worker carregue e processe mais vetores.
Permite equilibrar o desempenho de recuperação, os custos de recursos e o recall combinando a quantização base com o reordenamento de alta precisão.

Recomendamos o uso de FP16 ao criar um índice HGraph. Para mais exemplos, consulte Exemplo: Criar um índice vetorial com quantização FP16 e Exemplo: Criar um índice vetorial com RaBitQ e reordenamento.

Popular dados

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

Reconstruir um índice vetorial

Use os comandos a seguir para reconstruir um índice vetorial para dados existentes.

Reconstrua um índice para uma tabela não particionada.

ALTER TABLE <table_name> REBUILD INDEX <index_name> ;

Reconstrua um índice para uma tabela particionada. É possível reconstruir o índice vetorial para várias partições simultaneamente.

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> ;

Listar índices vetoriais de uma tabela

SHOW INDEXES ON <table_name>;

Visualize informações do índice vetorial

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

Exclua um índice vetorial

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

Exemplos

Preparar dados

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);

Exemplo: Crie um índice vetorial e inserir dados

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);

Exemplo: Reconstruir um índice vetorial

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] |
+------+------+------+

Exemplo: Listar índices vetoriais

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"}]}

Exemplo: Visualize informações do índice vetorial

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 |
+------------------------------------------------------------------------------------+

Exemplo: Exclua um índice vetorial

DROP INDEX c2_vector_index ON vector_test;

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

Exemplo: Crie um índice vetorial com quantização 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;

Exemplo: Crie um índice vetorial com RaBitQ e reordenamento

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"
  }'
);