Esta página foi traduzida pela API Cloud Translation.

Gere e faça a gestão de incorporações vetoriais automáticas para tabelas grandes

Pode gerar e gerir incorporações vetoriais para uma coluna de tabela inteira, o que lhe dá uma solução escalável para a criação de incorporações vetoriais em grande escala. Esta solução é particularmente útil para facilitar a pesquisa semântica e a geração aumentada de recuperação (RAG) em conteúdo de texto, incluindo o seguinte:

Criar incorporação de vetores inicial para uma nova tabela
Gerar incorporações após uma importação de dados em grande escala
Atualizar as incorporações após alterações significativas aos dados
Manter as incorporações de forma incremental

Compreenda as incorporações de vetores automáticas

As incorporações de vetores automáticas no AlloyDB oferecem uma forma escalável de automatizar a geração e a manutenção de incorporações de vetores para os seus dados. Em vez de gerar manualmente incorporações para cada novo texto ou texto atualizado, pode configurar as incorporações de vetores automáticas para processar esta tarefa por si. Isto é particularmente útil para aplicações que dependem de incorporações atualizadas para a pesquisa semântica, a geração aumentada de recuperação (RAG) e outras funcionalidades com tecnologia de IA.

Com as incorporações vetoriais automáticas, pode fazer o seguinte:

Inicialize incorporações para uma tabela inteira: gere incorporações para todos os dados existentes numa coluna da tabela com um único comando.
Manter as incorporações sincronizadas: atualize automaticamente as incorporações quando os dados de origem mudarem, garantindo que as suas aplicações de IA funcionam sempre com as informações mais atuais.
Gere incorporações em grande escala: crie incorporações de forma eficiente para tabelas grandes com milhões de linhas.
Configure e faça a gestão de incorporações para várias colunas na mesma tabela chamando as funções de gestão para cada coluna de incorporação.

Esta funcionalidade simplifica o desenvolvimento e a manutenção de aplicações de IA ao abstrair a complexidade da criação e manutenção de incorporações vetoriais.

Antes de começar

Antes de poder gerar e gerir incorporações vetoriais para tabelas grandes, faça o seguinte:

Ligue-se à sua base de dados através do psql ou do AlloyDB for PostgreSQL Studio como utilizador postgres.
Verifique se a extensão google_ml_integration está instalada.
Verifique se a flag google_ml_integration.enable_model_support está definida como on.
Verifique se a extensão google_ml_integration tem a versão 1.5.2 ou superior e se a flag google_ml_integration.enable_faster_embedding_generation está definida como on.

Para verificar a versão da extensão com o seguinte comando:
```
SELECT extversion FROM pg_extension WHERE extname = 'google_ml_integration';
```
Se precisar de atualizar a extensão, use o comando ALTER EXTENSION google_ml_integration UPDATE;.

Nota: se não tiver as autorizações necessárias, contacte o administrador da base de dados para fazer a atualização. Em alternativa, pode aguardar que a nova versão seja implementada automaticamente no seu cluster.
Antes de poder gerar incorporações a partir de uma base de dados do AlloyDB, tem de configurar o AlloyDB para funcionar com o Vertex AI. Para mais informações, consulte o artigo Integre a sua base de dados com o Vertex AI.
Para gerir e monitorizar a geração de incorporação automática, os utilizadores têm Select acesso às tabelas google_ml.embed_gen_progress e google_ml.embed_gen_settings por predefinição.

Para permitir que um utilizador faça a gestão da geração de incorporações automáticas, conceda as autorizações INSERT, UPDATE e DELETE nas tabelas google_ml.embed_gen_progress e google_ml.embed_gen_settings:
```
GRANT INSERT, UPDATE, DELETE ON google_ml.embed_gen_progress TO 'USER_NAME';
```
Substitua o seguinte:
- USER_NAME: o nome do utilizador ao qual as autorizações são concedidas.
Verifique se AUTOCOMMIT está definido como ON no cliente PostgreSQL que usa.
Confirme que o modelo de incorporação que usa tem quota suficiente para incorporações de vetores automáticas. Uma quota insuficiente pode resultar numa operação de incorporação automática lenta ou com falhas. Por exemplo, seguem-se os limites para os modelos de incorporação do Vertex AI:
- Limites de incorporação de texto: cada pedido pode ter até 250 textos de entrada que geram uma incorporação por texto de entrada e 20 000 tokens por pedido. Apenas os primeiros 2048 tokens em cada texto de entrada são usados para calcular as incorporações.
- Pedidos por minuto:
  - base_model : text-embedding : 1500
  - base_model : gemini-embedding : 100000
- Limite de tokens do modelo de incorporação do Gemini: ao contrário de outros modelos de incorporação que eram principalmente limitados por quotas de RPM, a série de modelos de incorporação do Gemini está limitada a 5 000 000 de tokens por minuto por projeto.

Inicialize incorporações para uma tabela

As funções de gestão de incorporações vetoriais automáticas estão disponíveis no esquema ai. Este esquema fornece uma interface para as funcionalidades de IA mais recentes no AlloyDB.

Use a função SQL ai.initialize_embeddings() para gerar incorporações para a coluna de conteúdo de uma tabela. Esta é uma chamada de bloqueio:

Se a função devolver êxito, a criação da incorporação de vetores está concluída.
A função tenta automaticamente recuperar de problemas transitórios, como erros de quota do modelo. Só recebe uma falha se estas tentativas de recuperação não forem bem-sucedidas. Para problemas persistentes, como um batch_size mal configurado que faz com que o pedido exceda os limites de tamanho, ou se a operação foi cancelada manualmente, tem de reemitir manualmente a chamada.

Esta função suporta modelos fornecidos pela Google, por exemplo, o text-embedding-005 do Vertex AI, bem como modelos personalizados que registou.

Antes de gerar incorporações, crie uma coluna content_embeddings na sua tabela. Normalmente, esta coluna tem um tipo vector(DIMENSION) e um valor DEFAULT NULL.

ALTER TABLE user_reviews ADD COLUMN IF NOT EXISTS content_embeddings vector(768) DEFAULT NULL;

Realize a geração em lote

Por predefinição, o AlloyDB usa o processamento em lote para gerar incorporações para várias entradas de texto num único pedido, o que melhora a eficiência. Se não fornecer um tamanho do lote específico, o AlloyDB aplica um valor predefinido determinado automaticamente.

Tamanho do lote de sugestões

O parâmetro batch_size em ai.initialize_embeddings permite-lhe orientar o otimizador de consultas do AlloyDB sugerindo um tamanho de lote preferencial para modelos suportados diretamente. O AlloyDB pode reduzir dinamicamente este tamanho com base nos limites ou nas quotas do modelo, mas a sua sugestão ajuda a influenciar o plano de execução da consulta.

CALL ai.initialize_embeddings(
    model_id => 'text-embedding-005',
    table_name => 'user_reviews',
    content_column => 'content',
    embedding_column => 'content_embeddings',
    batch_size => 50
);

Use um modelo de incorporação personalizado com suporte para processamento em lote

Se quiser usar um modelo personalizado ou suportado externamente que suporte o processamento em lote, defina as funções de transformação em lote e especifique-as como model_batch_in_transform_fn e model_batch_out_transform_fn quando criar um modelo. Também pode especificar um batch_size na chamada initialize_embeddings. Para modelos que suportam o processamento em lote, recomendamos que use um batch_size superior a 1 para um melhor desempenho.

Defina as funções de entrada, saída e transformação em lote do seu modelo personalizado.

-- Scalar input transform functions
CREATE OR REPLACE FUNCTION acme_text_input_transform(model_id TEXT, input TEXT) RETURNS JSON;
CREATE OR REPLACE FUNCTION acme_text_output_transform(model_id TEXT, model_output JSON) RETURNS real[];
CREATE OR REPLACE FUNCTION acme_generate_headers(model_id TEXT, input TEXT) RETURNS JSON;
-- Batch input transform functions
CREATE OR REPLACE FUNCTION acme_text_batch_input_transform(model_id TEXT, input TEXT[]) RETURNS JSON;
CREATE OR REPLACE FUNCTION acme_text_batch_output_transform(model_id TEXT, model_output JSON) RETURNS real[][];

Para criar o modelo, especifique as funções de transformação em lote.

CALL
  ai.create_model(
    model_id => 'custom-embedding-model',
    model_request_url => 'https://acme.com/models/text/embeddings/v1',
    model_type => 'text_embedding',
    model_in_transform_fn => 'acme_text_input_transform',
    model_out_transform_fn => 'acme_text_output_transform',
    generate_headers_fn => 'acme_generate_headers',
    model_batch_in_transform_fn => 'acme_text_batch_input_transform',
    model_batch_out_transform_fn => 'acme_text_batch_output_transform'
  );

Gere incorporações vetoriais com o seu modelo personalizado.

CALL
  ai.initialize_embeddings(
    model_id => 'custom-embedding-model',
    table_name => 'user_reviews',
    content_column => 'content',
    embedding_column => 'content_embeddings',
    batch_size => 10
);

Também pode usar a funcionalidade de incorporação automática com modelos personalizados que não suportam nativamente o processamento em lote. Para tal, tem de definir as funções de transformação em lote model_batch_in_transform_fn e model_batch_out_transform_fn. Para um modelo sem processamento em lote, defina estas funções para processar uma única entrada de cada vez a partir da matriz de entrada. Quando chamar ai.initialize_embeddings para este modelo, defina batch_size como 1.

Atualize as incorporações de forma incremental

Quando atualiza uma incorporação, esta é regenerada com base no valor mais recente na coluna de conteúdo de entrada.

Para lhe dar controlo sobre a consistência e o desempenho, o AlloyDB suporta vários modos para atualizações incrementais de incorporação. Pode selecionar um modo através do argumento de enumeração incremental_refresh_mode em ai.initialize_embeddings(). Segue-se uma lista de possíveis modos:

transactional: as incorporações são atualizadas como parte da transação que atualiza a coluna de conteúdo. Este processo, que usa frequentemente um mecanismo semelhante a um acionador de base de dados para gerar automaticamente incorporações quando a coluna de conteúdo é atualizada, pode introduzir custos gerais e abrandar as operações de atualização. A sobrecarga introduzida é uma compensação para manter a semântica transacional e garantir que as incorporações estão sincronizadas com o conteúdo. Este modo baseia-se nas funções de transformação escalar do seu modelo, pelo que tem de definir model_in_transform_fn e model_out_transform_fn quando cria o modelo. Para usar o modo transactional, tem de ter a função de proprietário na tabela.
```
CALL
  ai.initialize_embeddings(
    model_id => 'text-embedding-005',
    table_name => 'user_reviews',
    content_column => 'content',
    embedding_column => 'content_embeddings',
    batch_size => 10,
    incremental_refresh_mode => 'transactional'
);
```
none: este é o modo predefinido. Neste modo, o AlloyDB não atualiza as incorporações automaticamente. Não existe acompanhamento de alterações incrementais, pelo que chamar a função ai.refresh_embeddings() regenera as incorporações para toda a tabela. Este modo oferece controlo total.

Atualize todas as incorporações de uma tabela

Depois de executar ai.initialize_embeddings() com êxito para uma tabela, pode usar a função ai.refresh_embeddings() para regenerar as incorporações. Pode usar uma operação de atualização para atualizar as incorporações de linhas que são modificadas em simultâneo durante a chamada initialize_embeddings inicial ou para fazer uma atualização completa periódica.

A função de atualização reutiliza as definições da chamada inicial, pelo que só tem de especificar a tabela e a coluna de incorporação. Também pode fornecer um batch_size opcional para substituir o valor predefinido.

CALL ai.refresh_embeddings(
    table_name => 'user_reviews',
    embedding_column => 'content_embeddings',
    batch_size => 50  -- Optional override
);

Trabalhe com dados de tabelas durante a criação de incorporações vetoriais

Embora ai.initialize_embeddings() seja uma chamada de bloqueio para a sessão em que é executada, outras ligações podem continuar a funcionar com a tabela. O processo de incorporação de vetores automático atualiza as linhas em lotes, o que envolve o bloqueio padrão ao nível da linha. Isto significa que as operações DML simultâneas, como UPDATE ou DELETE, só são bloqueadas brevemente se tentarem modificar as mesmas linhas que o processo de incorporação está a atualizar. As consultas de outras ligações não são bloqueadas. Tenha em atenção que initialize_embeddings ignora as linhas que são modificadas em simultâneo. Se incremental_refresh_mode for none, as incorporações destas linhas modificadas não são atualizadas até ser feita uma atualização subsequente.

-- connection1 (starts embedding generation)
SELECT
  ai.initialize_embeddings(
    model_id => 'text-embedding-005',
    table_name => 'user_reviews',
    content_column => 'content',
    embedding_column => 'content_embeddings'
  );

-- connection2 (performs DMLs/queries without blocking)
INSERT INTO user_reviews(id, review_time, is_edited, content)
VALUES (48290, now(), false, 'I really liked the product functionality, but wish it came in orange color');

UPDATE user_reviews
SET is_edited = TRUE, content = 'Changing to 5 star. My issue is resolved by the support'
WHERE id = 700;

Se cancelar initialize_embeddings através de pg_cancel ou se initialize_embeddings falhar devido a um erro interno, devolve um estado de falha. As incorporações de vetores criadas com êxito não são revertidas. Para recuperar da falha e concluir a criação da incorporação de vetores, primeiro, tem de limpar a configuração com a função ai.drop_embedding_config() e, em seguida, emitir novamente a chamada ai.initialize_embeddings().

Para atualizar as incorporações de linhas modificadas em simultâneo, chame ai.refresh_embeddings após a conclusão da chamada ai.initialize_embeddings. Esta chamada de atualização regenera as incorporações para toda a tabela.

Elimine as definições de incorporação de vetores automáticas

Se precisar de remover a configuração de incorporação de vetores automática para uma combinação específica de tabela e coluna de incorporação, use a função ai.drop_embedding_config(). Esta função pode ser útil para a limpeza ou quando reconfigura a gestão da incorporação de uma coluna.

CALL
  ai.drop_embedding_config(
    table_name => 'user_reviews',
    embedding_column => 'content_embeddings');

Exemplos de geração de incorporações no setor automóvel

Esta secção fornece exemplos de geração de incorporações no modo automático através de pontos finais de modelos registados.

Modelo de incorporação da OpenAI

Para gerar incorporações através do ponto final do modelo text-embedding-3-small registado fornecido pela OpenAI, execute a seguinte declaração:

CALL ai.initialize_embeddings(
    model_id => 'text-embedding-3-small',
    table_name => 'user_reviews',
    chunk_column => 'content',
    embedding_column => 'content_embeddings'
);

Modelos de incorporação personalizados

Para os seus próprios modelos ou modelos suportados externamente, tem de definir funções de transformação de entrada e saída e registá-las com ai.create_model. Se planeia usar a funcionalidade de incorporação automática, tem de especificar as funções de transformação escalar (por exemplo, acme_text_input_transform e acme_text_output_transform) e as funções de transformação em lote (por exemplo, acme_text_batch_input_transform e acme_text_batch_output_transform).