Como usar textembedding-gecko@003 para embeddings de vetores

Como usar textembedding-gecko@003 para embeddings de vetor

Sobre este codelab

subjectÚltimo out. 7, 2024 atualizado
account_circleEscrito por Eduardo Godinez

1. Introdução

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

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 o seguinte:

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

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

Benefícios da incorporação de texto

  • Permite um 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 é crucial para tarefas como mecanismos de pesquisa, sistemas de recomendação e tradução automática.
  • Captura o significado semântico: as incorporações 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 detalhada.
  • Melhora o desempenho 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 da incorporação de texto

Os embeddings de texto, transformando textos em representações numéricas, desbloqueiam várias 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 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 recomendadores usam embeddings de texto para analisar o comportamento e as preferências do usuário expressas em avaliações, notas ou histórico de navegação.

O sistema pode recomendar itens semelhantes comparando as incorporações 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. As possibilidades continuam aumentando à 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 (link em inglês)

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 seu pacote 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 com texto e vetores
  • Realize uma consulta no nosso banco de dados de vetores simulados comparando os vetores e obtenha a resposta mais provável.

O que você vai aprender

  • Como usar a inserçã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 sobre 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.
  1. Acessar o seletor de projetos
  2. Verifique se a cobrança está ativada para o seu projeto do Google Cloud.
  3. 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 criá-lo usando o Console do Google Cloud. Saiba mais sobre os outros métodos neste link.

  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". 56c087d619c464dd.png
  2. Acessar instâncias.
  3. Clique em "Criar novo". 381ff9b895e77641.png
  4. Na caixa de diálogo "Criar instância", na seção "Detalhes", forneça as seguintes informações para 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 de rede para usar uma rede no seu projeto atual ou uma rede VPC compartilhada de um projeto host, se houver uma configurada. 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. Você pode 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, é possível manter o padrão, que é e2-standard-4.

d47bdc2d7f516c46.png

  1. 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 vai ativar um link do Open JupyterLab. Clique nele.

Criar um notebook Python 3

  1. Dentro do JupyterLab, na tela de início, na seção do notebook, clique no ícone com o logotipo do Python, que diz Python3. e16bb118cd28256f.png
  2. Um notebook Jupyter é criado com o nome Untitled e a extensão ipynb. da9bd34cf307156c.png
  3. Você pode renomeá-lo usando a seção do navegador de arquivos no lado esquerdo ou pode deixá-lo como está.

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

3. Como importar bibliotecas obrigató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 e TextEmbeddingModel de vertexai.language_models

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:

6852d323eedcac93.png

4. Criar um banco de dados de vetores simulados

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 contém 3 registros. Vamos criá-lo desta forma:

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

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:

26baa3b876c0605d.png

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" se referem 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 com base nessa lista um DataFrame 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 fazer 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 célula nova:

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      

Ela ficaria assim:

4c4af091c7a82861.png

Vamos analisar o código

Definimos uma função chamada embed_fn que receberá como entrada um dataframe do pandas que contém o texto para realizar a incorporação. 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 todas as linhas no DataFrame, obtendo os valores da coluna Text (que contém as informações manuais do nosso banco de dados simulado).

Para enviar texto regular e retornar seu vetor com o modelo gecko@003, inicializamos o modelo de 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'])])                    

Depois, nos embeddings de variáveis, 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            

Finalmente, 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 de cada linha.

df_embedded_values_db = embed_fn(df_initial_db)
df_embedded_values_db      

6. Como fazer uma pergunta ao banco de dados de vetores

Agora que nosso banco de dados contém texto e seus vetores, podemos continuar a 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 vai ficar assim:

6b7cf9b08e3b4573.png

Vamos analisar o código

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

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

Depois, na variável do modelo, definimos o modelo que queremos usar com a 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. Nesse caso, passamos 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 banco de dados simulado e uma pergunta transformada em um vetor. Ou seja, agora podemos comparar o vetor da pergunta com todos os vetores do nosso banco de dados para descobrir qual deles está mais próximo para 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. 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.

73ea8635c4570bea.png

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:

b70563b50ea86668.png

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 uma repetição "for", iteramos e obtemos a distância entre o vetor da pergunta e cada vetor do banco de dados.

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

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 menor distância entre a pergunta e o banco de dados, podemos exibir 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:

7a0e429171a19afe.png

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:

Documentos de referência