Como usar textembedding-gecko@003 para embeddings de vetores

1. Introdução

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

Incorporação de texto

A incorporação de texto se refere ao processo de transformação de 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 o seguinte:

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

A incorporação de texto traduz essa linguagem para um formato matemático mais simples que os computadores podem entender e manipular.

Vantagens da incorporação de texto

• Permite um processamento eficiente: as representações numéricas são processadas muito mais rapidamente pelos computadores em comparação com o texto bruto. Isso é crucial 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 sutil.
• Melhora a performance do aprendizado de máquina: as incorporações de texto podem ser usadas como recursos em modelos de aprendizado de máquina, o que leva a uma melhor performance em tarefas como análise de sentimento, classificação de texto e modelagem de tópicos.

Casos de uso de embeddings de texto

Os embeddings de texto, ao transformarem texto em representações numéricas, desbloqueiam uma variedade de aplicativos 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 das consultas e as 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 temas ou conceitos semelhantes.

2. Sistemas de recomendação:

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

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

3. Detecção de plágio:

Comparar os embeddings de dois textos pode ajudar a identificar possíveis casos de plágio ao encontrar 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 incorporação de texto evoluem. À medida que os computadores entendem melhor a linguagem por meio de incorporações, podemos esperar ainda mais aplicações inovadoras no futuro.

textembedding-gecko@003

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).
• Criar um banco de dados simulado feito de texto e vetores
• Faça uma consulta ao nosso banco de dados de vetores simulados comparando os vetores e recebendo a resposta mais provável.

O que você vai aprender

• Como usar a incorporação 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 do Google Cloud.

Observação:se você não pretende manter os recursos criados neste procedimento, crie um projeto novo em vez de selecionar um que já existe. 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 a API usando o Console do Google Cloud. Confira mais informações sobre os outros métodos aqui.

1. No console do Google Cloud, acesse a página "Instâncias", que pode ser acessada no menu da Vertex AI, na seção "Notebooks", e clique em "Workbench".
2. Acesse "Instâncias".
3. Clique em "Criar novo".
4. Na caixa de diálogo "Criar instância", na seção "Detalhes", forneça 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 (-) e não pode terminar com um hífen.

Região e zona: selecione uma região e uma 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 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 da rede do Compute (roles/compute.networkUser) ao agente de serviço de notebooks no projeto de serviço.

No campo "Rede": selecione a rede que você quer. É 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. Você pode escolher o padrão.

Nas propriedades da instância, você pode deixar o padrão, ou seja, 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 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 Jupyter é criado com o nome Untitled e a extensão ipynb.
3. Você pode renomear usando a seção do navegador de arquivos no lado esquerdo ou deixar como está.

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

3. Como importar as 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, basta 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 os respectivos vetores traduzidos usando o modelo de inserção de texto gecko@003.

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

Nosso banco de dados de vetores vai conter três registros. Confira 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 vai ficar assim:

Vamos analisar o código

Nas variáveis DOCUMENT1, DOCUMENT2 e DOCUMENT3, armazenamos um dicionário que vai emular documentos com títulos e conteúdos. Esses "documentos" fazem referência a um manual simulado de um carro fabricado pelo Google.

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

documents = [DOCUMENT1, DOCUMENT2, DOCUMENT3]

Por fim, usando o pandas, criamos um DataFrame com essa 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 gerar uma incorporação 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 vai ficar assim:

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 dos pandas, podemos iterar cada linha no DataFrame, extraindo os valores da coluna Text, 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 o modelo variável, 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, nos embeddings de variáveis, capturamos o vetor do texto enviado 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 com 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 de vetores

Agora que nosso banco de dados contém texto e vetores, podemos fazer uma pergunta e consultar o 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 vai ficar assim:

Vamos analisar o código

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

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

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

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

Na variável de embeddings, chamamos a função model.get_embeddings e transmitimos o texto a ser convertido em vetor. Neste 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. Comparação de vetores

Agora temos uma lista de vetores no nosso banco de dados simulado e uma pergunta transformada em um vetor. Ou seja, 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 à pergunta com mais precisão.

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

No Python, podemos aproveitar 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 até encontrar a distância mais curta.

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

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

Usamos a função numpy linalg.norm para calcular a distância.

Se a distância calculada for menor do que a da variável shortest_distance, ela 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

Sabendo 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 como 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 das embeddings de texto e como usar o modelo gecko003 no GCP Workbench.

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

Qual é a próxima etapa?

Confira alguns destes codelabs:

• Começar a usar embeddings vetoriais com a IA do AlloyDB

Documentos de referência

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