Esta página foi traduzida pela API Cloud Translation.

Gerar e gerenciar embeddings de vetor automáticos para tabelas grandes

É possível gerar e gerenciar embeddings de vetor para uma coluna inteira de uma tabela, o que oferece uma solução escalonável para a criação de embeddings de vetor em grande escala. Essa solução é útil para facilitar a pesquisa semântica e a geração aumentada por recuperação (RAG) em conteúdo de texto, incluindo o seguinte:

Como criar o embedding de vetor inicial para uma nova tabela
Gerar embeddings após uma importação de dados grande
Atualizar embeddings após mudanças significativas nos dados
Manter embeddings de forma incremental

Entender os embeddings de vetor automáticos

Os embeddings de vetores automáticos no AlloyDB oferecem uma maneira escalonável de automatizar a geração e a manutenção de embeddings de vetores para seus dados. Em vez de gerar manualmente embeddings para cada texto novo ou atualizado, você pode configurar embeddings de vetor automáticos para lidar com esse processo. Isso é especialmente útil para aplicativos que dependem de embeddings atualizados para pesquisa semântica, geração aumentada de recuperação (RAG) e outros recursos com tecnologia de IA.

Com os embeddings de vetor automáticos, é possível fazer o seguinte:

Inicializar embeddings para uma tabela inteira: gere embeddings para todos os dados em uma coluna de tabela com um único comando.
Mantenha os embeddings sincronizados: atualize automaticamente os embeddings quando os dados de origem mudarem, garantindo que seus aplicativos de IA sempre trabalhem com as informações mais atuais.
Gerar embeddings em grande escala: crie embeddings com eficiência para tabelas grandes com milhões de linhas.
Configure e gerencie embeddings para várias colunas na mesma tabela chamando as funções de gerenciamento de cada coluna de embedding.

Esse recurso simplifica o desenvolvimento e a manutenção de aplicativos de IA ao abstrair a complexidade da criação e manutenção de incorporações de vetores.

Antes de começar

Antes de gerar e gerenciar embeddings de vetor para tabelas grandes, faça o seguinte:

Conecte-se ao banco de dados usando psql ou o AlloyDB para PostgreSQL Studio como o usuário 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 é a versão 1.5.2 ou mais recente 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 atualizar a extensão, use o comando ALTER EXTENSION google_ml_integration UPDATE;.

Observação: se você não tiver as permissões necessárias, entre em contato com o administrador do banco de dados para fazer a atualização. Como alternativa, aguarde a nova versão ser lançada automaticamente para seu cluster.
Antes de gerar embeddings de um banco de dados do AlloyDB, configure o AlloyDB para trabalhar com a Vertex AI. Para mais informações, consulte Integrar seu banco de dados à Vertex AI.
Para gerenciar e monitorar a geração automática de incorporações, os usuários têm acesso Select às tabelas google_ml.embed_gen_progress e google_ml.embed_gen_settings por padrão.

Para permitir que um usuário gerencie a geração de incorporação automática, conceda as permissõ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:
- USER_NAME: o nome do usuário para quem as permissões são concedidas.
Verifique se AUTOCOMMIT está definido como ON no cliente PostgreSQL que você usa.
Confirme se o modelo de embedding que você usa tem cota suficiente para embeddings vetoriais automáticos. Uma cota insuficiente pode resultar em uma operação de incorporação automática lenta ou com falha. Por exemplo, estes são os limites para modelos de embedding da Vertex AI:
- Limites de incorporação de texto: cada solicitação pode ter até 250 textos de entrada,gerando uma incorporação por texto de entrada e 20.000 tokens por solicitação. Apenas os primeiros 2.048 tokens em cada texto de entrada são usados para calcular os embeddings.
- Solicitações por minuto:
  - base_model : text-embedding : 1500
  - base_model : gemini-embedding : 100000
- Limite de tokens do modelo de embedding do Gemini: ao contrário de outros modelos de embedding, que eram limitados principalmente por cotas de RPM, a série de modelos de embedding do Gemini é limitada a 5.000.000 de tokens por minuto por projeto.

Inicializar embeddings para uma tabela

As funções para gerenciar incorporações de vetores automáticas estão disponíveis no esquema ai. Esse esquema fornece uma interface para os recursos mais recentes de IA no AlloyDB.

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

Se a função retornar sucesso, a criação do embedding de vetor será concluída.
A função tenta se recuperar automaticamente de problemas temporários, como erros de cota do modelo. Uma falha será retornada somente se essas tentativas de recuperação não forem bem-sucedidas. Para problemas persistentes, como um batch_size mal configurado que faz com que a solicitação exceda os limites de tamanho, ou se a operação foi cancelada manualmente, é necessário emitir a chamada novamente de forma manual.

Essa função é compatível com modelos fornecidos pelo Google, como o text-embedding-005 da Vertex AI, e com modelos personalizados registrados.

Antes de gerar embeddings, crie uma coluna content_embeddings na sua tabela. Normalmente, essa 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;

Realizar a geração em lote

Por padrão, o AlloyDB usa o processamento em lote para gerar embeddings de várias entradas de texto em uma única solicitação, o que melhora a eficiência. Se você não fornecer um tamanho de lote específico, o AlloyDB vai aplicar um valor padrão determinado automaticamente.

Tamanho do lote de sugestões

O parâmetro batch_size em ai.initialize_embeddings permite orientar o otimizador de consultas do AlloyDB sugerindo um tamanho de lote preferido para modelos com suporte direto. O AlloyDB pode reduzir dinamicamente esse tamanho com base em limites ou cotas do modelo, mas sua dica 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
);

Usar um modelo de embedding personalizado com suporte a lote

Se quiser usar um modelo personalizado ou com suporte externo que aceite 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 ao criar um modelo. Também é possível especificar um batch_size na chamada initialize_embeddings. Para modelos que oferecem suporte ao agrupamento em lotes, recomendamos usar um batch_size maior que 1 para melhorar a performance.

Defina as funções de entrada, saída e transformação em lote do 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 embeddings de vetor com 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 é possível usar o recurso de incorporação automática com modelos personalizados que não oferecem suporte nativo ao agrupamento em lote. Para fazer isso, ainda é necessário definir as funções de transformação em lote model_batch_in_transform_fn e model_batch_out_transform_fn. Para um modelo sem agrupamento em lote, defina essas funções para processar uma entrada por vez da matriz de entrada. Ao chamar ai.initialize_embeddings para esse modelo, defina batch_size como 1.

Atualizar embeddings de forma incremental

Quando você atualiza uma incorporação, ela é regenerada com base no valor mais recente da coluna de conteúdo de entrada.

Para oferecer controle sobre consistência e desempenho, o AlloyDB é compatível com vários modos de atualizações incrementais de embedding. É possível selecionar um modo usando o argumento de enumeração incremental_refresh_mode em ai.initialize_embeddings(). Confira abaixo uma lista de modos possíveis:

transactional: os embeddings são atualizados como parte da transação que atualiza a coluna de conteúdo. Esse processo, que geralmente usa um mecanismo semelhante a um gatilho de banco de dados para gerar incorporações automaticamente quando a coluna de conteúdo é atualizada, pode gerar sobrecarga e diminuir a velocidade das operações de atualização. A sobrecarga introduzida é uma troca para manter a semântica transacional e garantir que os embeddings estejam sincronizados com o conteúdo. Esse modo depende das funções de transformação escalar do seu modelo. Portanto, você precisa definir model_in_transform_fn e model_out_transform_fn ao criar o modelo. Para usar o modo transactional, é necessário ter o papel 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 padrão. Nesse modo, o AlloyDB não atualiza os embeddings automaticamente. Não há rastreamento de mudanças incrementais. Portanto, chamar a função ai.refresh_embeddings() regenera incorporações para toda a tabela. Esse modo oferece controle total.

Atualizar todos os embeddings de uma tabela

Depois de executar ai.initialize_embeddings() em uma tabela, use a função ai.refresh_embeddings() para regenerar os embeddings. Você pode usar uma operação de atualização para atualizar os embeddings de linhas modificadas simultaneamente durante a chamada inicial de initialize_embeddings ou para fazer uma atualização completa periódica.

A função de atualização reutiliza as configurações da chamada inicial. Portanto, você só precisa especificar a tabela e a coluna de incorporação. Você também pode fornecer um batch_size opcional para substituir o valor padrão.

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

Trabalhar com dados de tabela durante a criação de embeddings vetoriais

Embora ai.initialize_embeddings() seja uma chamada de bloqueio para a sessão em que é executada, outras conexões podem continuar funcionando com a tabela. O processo de embedding de vetor automático atualiza as linhas em lotes, o que envolve o bloqueio padrão no nível da linha. Isso significa que operações DML simultâneas, como UPDATE ou DELETE, só serão bloqueadas brevemente se tentarem modificar as mesmas linhas que o processo de incorporação está atualizando. Consultas de outras conexões não são bloqueadas. O initialize_embeddings ignora linhas que são modificadas simultaneamente. Se incremental_refresh_mode for none, os encodings dessas linhas modificadas não serão atualizados até que uma atualização subsequente seja chamada.

-- 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 você cancelar initialize_embeddings usando pg_cancel ou se initialize_embeddings falhar devido a um erro interno, um status de falha será retornado. Os embeddings vetoriais criados com sucesso não são revertidos. Para se recuperar da falha e concluir a criação do encadeamento de vetores, primeiro limpe a configuração usando a função ai.drop_embedding_config() e depois reemita a chamada ai.initialize_embeddings().

Para atualizar incorporações de linhas modificadas simultaneamente, chame ai.refresh_embeddings após a conclusão da chamada ai.initialize_embeddings. Essa chamada de atualização regenera os embeddings de toda a tabela.

Excluir configurações de embedding de vetor automático

Se você precisar remover a configuração de embedding de vetor automático para uma combinação específica de tabela e coluna de embedding, use a função ai.drop_embedding_config(). Essa função pode ser útil para limpeza ou quando você reconfigura o gerenciamento de incorporações para uma coluna.

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

Exemplos de como gerar embeddings automaticamente

Nesta seção, mostramos exemplos de como gerar embeddings automaticamente usando endpoints de modelo registrados.

Modelo de embedding da OpenAI

Para gerar embeddings usando o endpoint de modelo text-embedding-3-small registrado fornecido pela OpenAI, execute a seguinte instrução:

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

Modelos de embedding personalizados

Para modelos próprios ou com suporte externo, você precisa definir funções de transformação de entrada e saída e registrá-las com ai.create_model. Se você planeja usar o recurso de incorporação automática, especifique as funções de transformação escalar (por exemplo, acme_text_input_transform, acme_text_output_transform) e em lote (por exemplo, acme_text_batch_input_transform, acme_text_batch_output_transform).