Como usar textembedding-gecko@003 para embeddings de vetores

1. Introdução

Última atualização:2024-04-08

Embedding de texto

O embedding de texto refere-se ao processo de transformar dados textuais em representações numéricas. Essas representações numéricas, geralmente vetores, capturam o significado semântico e as relações entre as palavras em um texto. Imagine assim:

O texto é como uma linguagem complexa, cheia de nuances e ambiguidades.

O embedding de texto traduz essa linguagem em um formato matemático mais simples que os computadores podem entender e manipular.

Benefícios do embedding de texto

• Permite o processamento eficiente: as representações numéricas são muito mais rápidas para os computadores processarem em comparação com o texto bruto. Isso é fundamental para tarefas como mecanismos de pesquisa, sistemas de recomendação e tradução automática.
• Captura o significado semântico: os embeddings vão além do significado literal das palavras. Eles capturam o contexto e as relações entre as palavras, permitindo uma análise mais diferenciada.
• Melhora o desempenho do aprendizado de máquina: os embeddings de texto podem ser usados como recursos em modelos de aprendizado de máquina, levando a um melhor desempenho em tarefas como análise de sentimento, classificação de texto e modelagem de tópicos.

Casos de uso do embedding de texto

Os embeddings de texto, ao transformar o texto em representações numéricas, desbloqueiam uma variedade de aplicações no processamento de linguagem natural (PLN). Confira alguns casos de uso importantes:

1. Mecanismos de pesquisa e recuperação de informações :

Os embeddings de texto permitem que os mecanismos de pesquisa entendam o significado semântico por trás das consultas e os correspondam a documentos relevantes, mesmo que as palavras-chave exatas não estejam presentes.

Ao comparar os embeddings de uma consulta de pesquisa com os embeddings de documentos, os mecanismos de pesquisa podem identificar documentos que abordam tópicos ou conceitos semelhantes.

2. Sistemas de recomendação :

Os sistemas de recomendação usam embeddings de texto para analisar o comportamento e as preferências do usuário expressos por avaliações, classificações ou histórico de navegação.

O sistema pode recomendar itens semelhantes comparando os embeddings de produtos, artigos ou outros conteúdos com que o usuário interagiu.

3. Detecção de plágio :

A comparação dos embeddings de dois textos pode ajudar a identificar possíveis plágios, encontrando semelhanças significativas na estrutura semântica deles.

Esses são apenas alguns exemplos, e as possibilidades continuam crescendo à medida que as técnicas de embedding de texto evoluem. À medida que os computadores entendem melhor a linguagem por meio de embeddings, podemos esperar aplicações ainda mais inovadoras no futuro.

textembedding-gecko@003

O textembedding-gecko@003 é uma versão específica de um modelo de embedding de texto pré-treinado oferecido pelo Google Cloud Platform (GCP) pela Vertex AI e pelo conjunto de ferramentas e serviços de IA.

O que você vai criar

Neste codelab, você vai criar um script Python. Esse script fará o seguinte:

• Use a API Vertex para chamar textembedding-gecko@003 e transformar texto em embeddings de texto (vetores).
• Crie um banco de dados simulado de texto e vetores.
• Realize uma consulta ao nosso banco de dados vetorial simulado comparando os vetores e receba a resposta mais provável.

O que você vai aprender

• Como usar o embedding de texto no GCP
• Como chamar textembedding-gecko@003
• Como executar isso no Workbench
• Como usar o Vertex AI Workbench para executar scripts

O que é necessário

• Uma versão recente do Chrome
• Conhecimento de Python
• Um projeto do Google Cloud
• Acesso ao Vertex AI Workbench

2. Etapas da configuração

Criar uma instância do Vertex AI Workbench

1. No console do Google Cloud, na página do seletor de projetos, selecione ou crie um projeto na nuvem.

Observação:se você não pretende manter os recursos criados neste procedimento, crie um projeto novo em vez de selecionar um já existente. Depois de concluir essas etapas, é possível excluir o projeto. Para fazer isso, basta remover todos os recursos associados a ele.

2. Acessar o seletor de projetos
3. Verifique se a cobrança está ativada para o seu projeto do Google Cloud.
4. Ative a API Notebooks.

É possível criar uma instância do Vertex AI Workbench usando o console do Google Cloud, a CLI gcloud ou o Terraform. Para este tutorial, vamos criar usando o console do Google Cloud. Mais informações sobre os outros métodos podem ser encontradas aqui.

1. No console do Google Cloud, acesse a página Instâncias, que pode ser acessada no menu Vertex AI, na seção Notebooks, e clique em Workbench.
2. Acesse Instâncias.
3. Clique em Criar nova.
4. Na caixa de diálogo Criar instância, na seção Detalhes, insira as seguintes informações sobre a nova instância:

Nome: forneça um nome para a nova instância. O nome precisa começar com uma letra seguida por até 62 letras minúsculas, números ou hifens (-), mas não pode terminar com um hífen.

Região e zona: selecione uma região e zona para a nova instância. Para ter o melhor desempenho de rede, selecione a região mais próxima de você.

Não é necessário instalar a GPU

Na seção Rede, forneça as seguintes informações:

Rede: ajuste as opções de rede para usar uma rede no projeto atual ou uma rede VPC compartilhada de um projeto host, se houver configurados. Se você estiver usando uma VPC compartilhada no projeto host, também precisará conceder o papel de Usuário de rede do Compute (roles/compute.networkUser) ao Agente de serviço de notebooks do projeto de serviço.

No campo Rede: selecione uma rede. É possível selecionar uma rede VPC, desde que ela tenha o Acesso privado do Google ativado ou possa acessar a Internet.

No campo Sub-rede:selecione a sub-rede que você quer. É possível escolher a opção padrão.

Nas propriedades da instância, você pode deixar a opção padrão, ou seja, um e2-standard-4.

5. Clique em Criar.

O Vertex AI Workbench cria uma instância e a inicia automaticamente. Quando a instância estiver pronta para uso, o Vertex AI Workbench ativa um link Abrir JupyterLab. Clique nele.

Criar um notebook do Python 3

1. No JupyterLab, no acesso rápido, na seção Notebook, clique no ícone com o logotipo do Python que diz Python3.
2. Um notebook do Jupyter é criado com o nome Untitled e a extensão ipynb.
3. É possível renomeá-lo usando a seção do navegador de arquivos no lado esquerdo ou deixá-lo no estado em que se encontra.

Agora, podemos começar a colocar nosso código no notebook.

3. Como importar bibliotecas necessárias

Depois que a instância for criada e o JupyterLab for aberto, precisamos instalar todas as bibliotecas necessárias para o codelab.

Vamos precisar de:

1. numpy
2. pandas
3. TextEmbeddingInput, TextEmbeddingModel de vertexai.language_models

DICA:por padrão, as instâncias do Workbench já têm todas as bibliotecas acima instaladas. Portanto, só precisamos chamá-las.

Copie e cole o código abaixo em uma célula:

from vertexai.language_models import TextEmbeddingInput, TextEmbeddingModel

import numpy as np
import pandas as pd

Ele será parecido com:

4. Criar um banco de dados vetorial simulado

Para testar nosso código, vamos criar um banco de dados de texto e seus respectivos vetores traduzidos usando o modelo de embedding de texto gecko@003.

O objetivo é que os usuários pesquisem um texto, o traduzam para um vetor, o pesquisem no nosso banco de dados e retornem o resultado mais aproximado.

Nosso banco de dados vetorial vai conter três registros. Veja como vamos criá-lo:

Copie e cole o código abaixo em uma nova célula.

DOCUMENT1 = {
    "title": "Operating the Climate Control System",
    "content": "Your Googlecar has a climate control system that allows you to adjust the temperature and airflow in the car. To operate the climate control system, use the buttons and knobs located on the center console.  Temperature: The temperature knob controls the temperature inside the car. Turn the knob clockwise to increase the temperature or counterclockwise to decrease the temperature. Airflow: The airflow knob controls the amount of airflow inside the car. Turn the knob clockwise to increase the airflow or counterclockwise to decrease the airflow. Fan speed: The fan speed knob controls the speed of the fan. Turn the knob clockwise to increase the fan speed or counterclockwise to decrease the fan speed. Mode: The mode button allows you to select the desired mode. The available modes are: Auto: The car will automatically adjust the temperature and airflow to maintain a comfortable level. Cool: The car will blow cool air into the car. Heat: The car will blow warm air into the car. Defrost: The car will blow warm air onto the windshield to defrost it."}

DOCUMENT2 = {
    "title": "Touchscreen",
    "content": "Your Googlecar has a large touchscreen display that provides access to a variety of features, including navigation, entertainment, and climate control. To use the touchscreen display, simply touch the desired icon.  For example, you can touch the \"Navigation\" icon to get directions to your destination or touch the \"Music\" icon to play your favorite songs."}

DOCUMENT3 = {
    "title": "Shifting Gears",
    "content": "Your Googlecar has an automatic transmission. To shift gears, simply move the shift lever to the desired position.  Park: This position is used when you are parked. The wheels are locked and the car cannot move. Reverse: This position is used to back up. Neutral: This position is used when you are stopped at a light or in traffic. The car is not in gear and will not move unless you press the gas pedal. Drive: This position is used to drive forward. Low: This position is used for driving in snow or other slippery conditions."}

documents = [DOCUMENT1, DOCUMENT2, DOCUMENT3]

df_initial_db = pd.DataFrame(documents)
df_initial_db.columns = ['Title', 'Text']
df_initial_db

Ele será parecido com:

Vamos analisar o código

Nas variáveis DOCUMENT1, DOCUMENT2 e DOCUMENT3, estamos armazenando um dicionário que vai emular documentos com títulos e conteúdos. Esses "documentos" estão fazendo referência a um manual simulado de um carro feito pelo Google.

Na próxima linha, criamos uma lista desses três documentos (dicionários).

documents = [DOCUMENT1, DOCUMENT2, DOCUMENT3]

Por fim, usando o pandas, criamos um DataFrame dessa lista que será chamado de df_initial_db.

df_initial_db = pd.DataFrame(documents)
df_initial_db.columns = ['Title', 'Text']
df_initial_db

5. Criar embeddings de texto

Agora vamos receber um embedding de texto usando o modelo gecko@003 para cada registro no nosso banco de dados simulado de documentos.

Copie e cole o código abaixo em uma nova célula:

def embed_fn(df_input):
    list_embedded_values = []
    for index, row in df_input.iterrows():        
        model = TextEmbeddingModel.from_pretrained("textembedding-gecko@003")
        embeddings = model.get_embeddings([(row['Text'])])        
        list_embedded_values.append(embeddings[0].values)
    df_input['Embedded text'] = list_embedded_values
    return df_input        
                                           
df_embedded_values_db = embed_fn(df_initial_db)
df_embedded_values_db      

Ele será parecido com:

Vamos analisar o código

Definimos uma função chamada embed_fn que vai receber como entrada um DataFrame do pandas que contém o texto para realizar o embedding. A função retorna o texto codificado como um vetor.

def embed_fn(df_input):
    list_embedded_values = []
    for index, row in df_input.iterrows():        
        model = TextEmbeddingModel.from_pretrained("textembedding-gecko@003")
        embeddings = model.get_embeddings([(row['Text'])])        
        list_embedded_values.append(embeddings[0].values)
    df_input['Embedded text'] = list_embedded_values
    return df_input             

Na lista chamada list_embedded_values, vamos armazenar e anexar o texto codificado de cada linha.

Usando o método iterrows do pandas, podemos iterar cada linha no DataFrame, recebendo os valores da coluna Texto (que contém as informações manuais do nosso banco de dados simulado).

Para enviar texto normal e retornar o vetor usando o modelo gecko@003, inicializamos a variável model, que é onde definimos o modelo a ser usado chamando a função TextEmbeddingModel.from_pretrained.

model = TextEmbeddingModel.from_pretrained("textembedding-gecko@003")
embeddings = model.get_embeddings([(row['Text'])])                     

Em seguida, na variável embeddings, capturamos o vetor do texto que enviamos pela função model.get_embeddings.

No final da função, criamos uma nova coluna no DataFrame chamada Texto incorporado, que vai conter a lista de vetores criados com base no modelo gecko@003.

df_input['Embedded text'] = list_embedded_values
return df_input             

Por fim, na variável df_embedded_values_db, capturamos o DataFrame que contém nossos dados originais do banco de dados simulado, além de uma nova coluna que contém a lista de vetores para cada linha.

df_embedded_values_db = embed_fn(df_initial_db)
df_embedded_values_db      

6. Fazer uma pergunta ao banco de dados vetorial

Agora que nosso banco de dados contém texto e vetores, podemos fazer uma pergunta e consultar nosso banco de dados para encontrar uma resposta.

Para isso, copie e cole o código abaixo em uma nova célula:

question='How do you shift gears in the Google car?'
model = TextEmbeddingModel.from_pretrained("textembedding-gecko@003")
embeddings = model.get_embeddings([(question)])        
text_to_search=embeddings[0].values
len(text_to_search)

O resultado será parecido com este:

Vamos analisar o código

Semelhante à função da etapa anterior, primeiro inicializamos a variável de pergunta com o que pretendemos perguntar ao nosso banco de dados.

question='How do you shift gears in the Google car?'

Em seguida, na variável model, definimos o modelo que queremos usar pela função TextEmbeddingModel.from_pretrained, que, nesse caso, é o modelo gecko@003.

model = TextEmbeddingModel.from_pretrained("textembedding-gecko@003")

Na variável embeddings, chamamos a função model.get_embeddings e transmitimos o texto a ser convertido em vetor. Nesse caso, transmitimos a pergunta a ser feita.

embeddings = model.get_embeddings([(question)])        

Por fim, a variável text_to_search contém a lista de vetores traduzidos da pergunta.

Imprimimos o comprimento do vetor apenas como referência.

text_to_search=embeddings[0].values
len(text_to_search)

7. Comparar vetores

Agora temos uma lista de vetores no nosso banco de dados simulado e uma pergunta transformada em vetor. Isso significa que agora podemos comparar o vetor da pergunta com todos os vetores no nosso banco de dados para descobrir qual deles está mais próximo de responder à nossa pergunta com mais precisão.

Para isso, vamos medir a distância entre o vetor da pergunta e cada vetor do banco de dados. Há várias técnicas para medir distâncias entre vetores. Para este codelab específico, vamos usar a distância euclidiana ou a norma L2.

Em Python, podemos usar a função numpy para fazer isso.

Copie e cole o código abaixo em uma nova célula:

list_embedded_text_from_db = df_embedded_values_db['Embedded text']
shortest_distance=1
for position, embedded_value in enumerate(list_embedded_text_from_db):
    distance=np.linalg.norm((np.array(embedded_value) - np.array(text_to_search)), ord = 2)
    print(distance)
    if distance<shortest_distance:
        shortest_distance=distance
        shortest_position=position
        
print(f'The shortest distance is {shortest_distance} and the position of that value is {shortest_position}')

O resultado ficará assim:

Vamos analisar o código

Começamos convertendo a coluna que contém o texto incorporado ou os vetores do nosso banco de dados em uma lista e armazenando-a em list_embedded_text_from_db.

Também inicializamos a variável shortest_distance como 1 para continuar atualizando-a até encontrarmos a distância mais curta real.

list_embedded_text_from_db = df_embedded_values_db['Embedded text']
shortest_distance=1

Em seguida, usando um loop for, iteramos e recebemos a distância entre o vetor da pergunta e cada vetor no banco de dados.

Usando a função numpy linalg.norm, calculamos a distância.

Se a distância calculada for menor que a da variável shortest_distance, a distância calculada será definida como essa variável.

Em seguida, capturamos a distância mais curta e a posição na lista em que ela foi encontrada. Nas variáveis shortest_distance e shortest_position.

for position, embedded_value in enumerate(list_embedded_text_from_db):
    distance=np.linalg.norm((np.array(embedded_value) - np.array(text_to_search)), ord = 2)
    print(distance)
    if distance<shortest_distance:
        shortest_distance=distance
        shortest_position=position

8. Resultados

Conhecendo a posição na lista do vetor que contém a distância mais curta entre a pergunta e o banco de dados, podemos imprimir os resultados.

Copie e cole o código abaixo em uma nova célula:

print("Your question was:\n "+question+ " \nAnd our answer is:\n "+
      df_embedded_values_db.at[shortest_position, 'Title']+": "+
      df_embedded_values_db.at[shortest_position, 'Text'])

Depois de executar, você vai receber algo parecido com isto:

9. Parabéns

Parabéns! Você criou seu primeiro aplicativo usando o modelo textembedding-gecko@003 em um caso de uso real.

Você aprendeu os fundamentos dos embeddings de texto e como usar o modelo gecko003 no GCP Workbench.

Agora você sabe as principais etapas necessárias para continuar aplicando seu conhecimento a mais casos de uso.

Qual é a próxima etapa?

Confira alguns destes codelabs:

• Introdução às embedding de vetor com a IA do AlloyDB

Documentos de referência

• Embeddings de texto
• Introdução ao Vertex AI Workbench
• Pesquisa de documentos com embeddings