Guia Completo de Embeddings de Texto: Transformando Texto em Números para Busca Avançada e Aplicações de IA
Introdução
Os embeddings de texto representam uma tecnologia fundamental no campo da inteligência artificial e processamento de linguagem natural, permitindo transformar texto em representações numéricas que preservam seu significado semântico. Estas representações vetoriais capturam as relações entre strings de texto, possibilitando que computadores “entendam” similaridades e diferenças entre palavras, frases e documentos. Quando dois textos possuem significados semelhantes, seus vetores de embedding estarão próximos no espaço matemático; quando os significados são diferentes, esses vetores estarão distantes.
A OpenAI desenvolveu modelos avançados de embedding, como o text-embedding-3-small e o text-embedding-3-large, que oferecem desempenho superior com custos reduzidos e melhor capacidade multilíngue em comparação com versões anteriores. Esses modelos são especialmente projetados para converter texto em representações numéricas que preservam significado e contexto, facilitando comparações matemáticas entre diferentes textos.
Neste guia, exploraremos detalhadamente como os embeddings funcionam, como obtê-los através da API da OpenAI, e as diversas aplicações práticas que incluem busca semântica, sistemas de recomendação, agrupamento de textos, detecção de anomalias, medição de diversidade e classificação de texto. Você aprenderá não apenas os fundamentos teóricos, mas também como implementar estas soluções em seus próprios projetos.
Pré-requisitos
Antes de começar a trabalhar com embeddings de texto, certifique-se de ter:
- Conta na OpenAI com acesso à API (necessário para gerar embeddings)
- Conhecimento básico de Python para implementar os exemplos
- Bibliotecas Python instaladas:
- openai
- numpy
- pandas
- scikit-learn (para exemplos de machine learning)
- matplotlib (para visualizações)
- tiktoken (para tokenização)
1. Entendendo os Embeddings de Texto
O que são embeddings e como funcionam
Os embeddings de texto são representações vetoriais (listas de números em ponto flutuante) que capturam o significado semântico de textos. Eles transformam palavras, frases ou documentos em vetores numéricos em um espaço multidimensional. O aspecto mais importante desses vetores é que a distância entre eles representa a similaridade semântica entre os textos correspondentes. Quanto menor a distância entre dois vetores, maior a similaridade entre os textos que eles representam; quanto maior a distância, menor a similaridade.
Esta propriedade faz dos embeddings uma ferramenta extremamente poderosa para diversas aplicações de processamento de linguagem natural. Ao converter texto em números, habilitamos computadores a “compreender” o significado e as relações entre diferentes textos, permitindo operações matemáticas que seriam impossíveis de realizar diretamente com strings de texto. Os modelos de embedding são treinados em vastos corpus de texto, aprendendo padrões linguísticos e semânticos que são codificados nas dimensões do vetor resultante.
A OpenAI oferece dois modelos principais de embedding de terceira geração: o text-embedding-3-small e o text-embedding-3-large. O primeiro gera vetores com 1536 dimensões por padrão, enquanto o segundo produz vetores com 3072 dimensões, capturando ainda mais nuances semânticas. Esses modelos representam um avanço significativo em relação às versões anteriores, oferecendo melhor desempenho multilíngue e custos reduzidos.
Aplicações principais dos embeddings
Os embeddings de texto possibilitam uma ampla gama de aplicações no campo da inteligência artificial e processamento de linguagem natural. Uma das aplicações mais comuns é a busca semântica, onde embeddings permitem encontrar documentos relevantes com base no significado da consulta, em vez de simples correspondência de palavras-chave. Isso resulta em sistemas de busca muito mais precisos e intuitivos, capazes de entender a intenção por trás das consultas dos usuários.
Sistemas de recomendação também se beneficiam enormemente dos embeddings, permitindo sugerir itens similares com base na proximidade semântica. Por exemplo, um sistema pode recomendar artigos, produtos ou conteúdo mídia que compartilham características semânticas com itens que o usuário já demonstrou interesse, mesmo que não compartilhem as mesmas palavras-chave.
Além disso, embeddings são fundamentais para tarefas de agrupamento (clustering), onde textos similares são agrupados automaticamente; detecção de anomalias, identificando textos que desviam significativamente de um padrão esperado; medição de diversidade em conjuntos de textos; e classificação de texto, permitindo categorizar documentos com base em seu conteúdo semântico. Estas aplicações têm revolucionado campos como atendimento ao cliente, análise de mídia social, pesquisa científica e muito mais.
Características dos modelos de embedding da OpenAI
Os modelos de embedding da OpenAI são identificados pelo sufixo “-3” no ID do modelo, indicando que pertencem à terceira geração desta tecnologia. Estes modelos oferecem um equilíbrio entre custo, desempenho e tamanho do vetor resultante. O text-embedding-3-small é otimizado para oferecer excelente desempenho com custo reduzido, enquanto o text-embedding-3-large proporciona o mais alto desempenho para tarefas que exigem máxima precisão semântica.
Uma característica importante destes modelos é a possibilidade de reduzir as dimensões do embedding através do parâmetro “dimensions” na API, permitindo um controle fino sobre o tamanho do vetor resultante. Isso é particularmente útil quando há limitações de armazenamento ou processamento, ou quando se trabalha com bancos de dados vetoriais que têm restrições de dimensionalidade. Mesmo com dimensões reduzidas, os embeddings mantêm grande parte de suas propriedades semânticas.
Os modelos de embedding da OpenAI são precificados por token de entrada, sendo que um token corresponde aproximadamente a 4 caracteres de texto em idiomas baseados em latim. Esta estrutura de preços torna o uso de embeddings acessível mesmo para aplicações que processam grandes volumes de texto. Além disso, estes modelos têm excelente desempenho em múltiplos idiomas, permitindo aplicações globais sem perda significativa de qualidade.
2. Obtendo Embeddings com a API da OpenAI
Configuração inicial e autenticação
Para começar a utilizar a API de embeddings da OpenAI, você precisa configurar sua autenticação e ambiente de desenvolvimento. O primeiro passo é obter uma chave de API válida através da plataforma da OpenAI. Esta chave será utilizada para autenticar suas solicitações ao serviço. É fundamental manter esta chave segura e não compartilhá-la publicamente, pois ela está associada à sua conta e consumo de recursos.
Em um ambiente Python, você precisará instalar a biblioteca oficial da OpenAI utilizando o comando pip install openai. Após a instalação, configure sua chave de API no código. A prática recomendada é armazenar a chave em uma variável de ambiente em vez de inseri-la diretamente no código, especialmente em projetos compartilhados ou de código aberto. Isto pode ser feito da seguinte forma:
import os
import openai
# Configurar a chave da API a partir de variável de ambiente
openai.api_key = os.environ.get("OPENAI_API_KEY")
# Alternativamente, pode-se definir diretamente (não recomendado para produção)
# openai.api_key = "sua-chave-api-aqui"
Uma vez configurada a autenticação, você estará pronto para fazer chamadas à API de embeddings e começar a transformar texto em representações vetoriais.
Fazendo requisições para a API de embeddings
Para obter um embedding de texto, você precisa enviar uma requisição ao endpoint específico da API de embeddings da OpenAI. Esta requisição deve incluir o texto que deseja transformar em embedding e especificar qual modelo de embedding deseja utilizar. A estrutura básica de uma requisição de embedding em Python é a seguinte:
response = openai.Embedding.create(
model="text-embedding-3-small", # O modelo a ser usado
input="Seu texto aqui", # O texto a ser transformado em embedding
encoding_format="float" # O formato de codificação desejado
)
# Extraindo o vetor de embedding da resposta
embedding = response['data'][0]['embedding']
A API aceita tanto strings individuais quanto listas de strings, permitindo processar múltiplos textos em uma única chamada, o que é mais eficiente para processamento em lote. É importante notar que existe um limite para o tamanho do texto que pode ser processado em uma única requisição, determinado pelo número máximo de tokens que o modelo pode processar.
Ao fazer requisições à API, você pode encontrar vários tipos de erros, como problemas de autenticação, excesso de requisições (rate limiting) ou textos muito longos. É importante implementar tratamento adequado de erros para lidar com essas situações, incluindo estratégias de retry com backoff exponencial para casos de limitação temporária.
Compreendendo a resposta da API e extraindo embeddings
Quando você faz uma requisição bem-sucedida à API de embeddings, a resposta retornada contém não apenas o vetor de embedding, mas também metadados adicionais que são importantes para o gerenciamento e processamento dos embeddings. Uma resposta típica tem a seguinte estrutura:
{
"object": "list",
"data": [
{
"object": "embedding",
"embedding": [0.0023064255, -0.009327292, ...], # O vetor de embedding (truncado para brevidade)
"index": 0
}
],
"model": "text-embedding-3-small",
"usage": {
"prompt_tokens": 5,
"total_tokens": 5
}
}
O campo embedding contém o vetor numérico que representa o texto, sendo o elemento mais importante da resposta. O campo usage fornece informações sobre o número de tokens processados, o que é útil para monitorar e gerenciar custos, já que a cobrança é baseada no número de tokens de entrada.
Para utilizar efetivamente os embeddings em aplicações, você geralmente precisará armazená-los em algum tipo de banco de dados. Para pequenos volumes de dados, armazenar em arquivos CSV ou JSON pode ser suficiente. Para aplicações de produção com grandes volumes de dados, é recomendado utilizar bancos de dados vetoriais especializados, como Pinecone, Weaviate, ou Milvus, que são otimizados para armazenar e consultar vetores de alta dimensionalidade de forma eficiente.
3. Gerenciando Dimensões de Embeddings
O papel das dimensões nos embeddings
As dimensões de um embedding representam os diferentes aspectos semânticos capturados pelo modelo. Cada dimensão pode ser interpretada como uma característica ou propriedade do texto, embora não seja possível atribuir um significado específico a cada dimensão individual. O número de dimensões determina a “resolução” do embedding – quanto mais dimensões, mais nuances semânticas podem ser capturadas, mas também maior será o vetor resultante.
O modelo text-embedding-3-small gera por padrão vetores com 1536 dimensões, enquanto o text-embedding-3-large produz vetores com 3072 dimensões. Estas altas dimensionalidades permitem representar com grande fidelidade as complexidades semânticas da linguagem humana, capturando desde relações sintáticas básicas até nuances contextuais e culturais.
A escolha do número de dimensões tem implicações diretas no consumo de recursos computacionais. Embeddings com mais dimensões ocupam mais espaço de armazenamento e exigem mais recursos para processamento. Por exemplo, armazenar um milhão de embeddings do modelo text-embedding-3-large (3072 dimensões) requer significativamente mais espaço do que a mesma quantidade de embeddings do modelo text-embedding-3-small (1536 dimensões).
Técnicas para redução de dimensões
A redução de dimensões é uma técnica poderosa que permite diminuir o tamanho dos vetores de embedding sem perder significativamente suas propriedades semânticas. A OpenAI implementou uma abordagem específica que permite reduzir as dimensões diretamente na API, através do parâmetro dimensions. Esta técnica é baseada em pesquisas avançadas e foi projetada para preservar as características mais importantes do embedding.
Para utilizar esta funcionalidade, basta adicionar o parâmetro dimensions à sua chamada de API, especificando o número desejado de dimensões:
response = openai.Embedding.create(
model="text-embedding-3-small",
input="Seu texto aqui",
dimensions=256 # Reduzindo para 256 dimensões
)
É importante notar que existe um limite mínimo para o número de dimensões (embora a documentação não especifique exatamente qual é), abaixo do qual a qualidade do embedding pode ser significativamente comprometida. A recomendação geral é não reduzir para menos de 256 dimensões se quiser manter uma boa representação semântica.
Alternativamente, se você já possui embeddings de dimensão completa e deseja reduzi-los posteriormente, técnicas como PCA (Principal Component Analysis) ou SVD (Singular Value Decomposition) podem ser aplicadas. No entanto, a OpenAI adverte que estas técnicas geralmente resultam em pior desempenho comparado à redução direta via API.
Impacto da redução de dimensões no desempenho
A redução de dimensões inevitavelmente implica em alguma perda de informação, o que pode afetar o desempenho dos embeddings em diferentes tarefas. No entanto, pesquisas mostram que essa perda pode ser surpreendentemente pequena se a redução for feita de maneira apropriada. A técnica implementada pela OpenAI foi projetada para minimizar o impacto no desempenho, mantendo as características mais importantes do embedding.
Estudos realizados pela OpenAI indicam que embeddings com dimensões reduzidas através da API podem superar embeddings de modelos menores, mesmo quando reduzidos para o mesmo número de dimensões. Por exemplo, o modelo text-embedding-3-small reduzido para 256 dimensões ainda pode superar modelos menores nativamente projetados para essa dimensionalidade.
É importante considerar o trade-off entre tamanho e desempenho para cada aplicação específica. Para tarefas que exigem máxima precisão semântica, como sistemas críticos de busca ou classificação, pode ser preferível manter a dimensionalidade completa. Para aplicações onde o espaço de armazenamento ou a velocidade de processamento são limitações importantes, a redução de dimensões pode oferecer um equilíbrio adequado entre desempenho e eficiência.
4. Aplicações Práticas: Busca Semântica
Princípios da busca baseada em embeddings
A busca semântica baseada em embeddings representa uma evolução significativa em relação aos métodos tradicionais de busca por palavras-chave. Em vez de procurar correspondências exatas de termos, a busca semântica utiliza a similaridade entre vetores de embedding para encontrar documentos cujo significado seja próximo à consulta do usuário, mesmo que utilizem vocabulário diferente.
O princípio fundamental da busca semântica é calcular a similaridade entre o embedding da consulta e os embeddings de cada documento no corpus. A medida de similaridade mais comumente utilizada é a similaridade do cosseno, que mede o cosseno do ângulo entre dois vetores. Valores próximos a 1 indicam alta similaridade (vetores apontando na mesma direção), enquanto valores próximos a 0 indicam baixa similaridade (vetores perpendiculares).
Para implementar um sistema de busca semântica, é necessário primeiro gerar embeddings para todos os documentos no corpus e armazená-los. Quando uma consulta é recebida, seu embedding é calculado e comparado com todos os embeddings armazenados. Os documentos cujos embeddings têm maior similaridade com o embedding da consulta são retornados como resultados, geralmente ordenados por grau de similaridade.
Implementação de busca de texto com embeddings
Para implementar um sistema básico de busca de texto utilizando embeddings, podemos seguir um processo de quatro etapas: preparação dos dados, geração de embeddings, cálculo de similaridade e retorno dos resultados mais relevantes. Vamos utilizar como exemplo um conjunto de avaliações de produtos alimentícios da Amazon:
import numpy as np
import pandas as pd
import openai
# Carregar o conjunto de dados (exemplo com avaliações da Amazon)
reviews = pd.read_csv("amazon_food_reviews.csv")
reviews = reviews.head(1000) # Usando um subconjunto para ilustração
# Gerar embeddings para cada avaliação
def get_embedding(text):
response = openai.Embedding.create(
model="text-embedding-3-small",
input=text
)
return response['data'][0]['embedding']
# Combinar título e texto da avaliação
reviews['combined_text'] = reviews['Summary'] + ": " + reviews['Text']
# Gerar e armazenar embeddings (em produção, considere processamento em lote)
reviews['embedding'] = reviews['combined_text'].apply(get_embedding)
# Função para buscar avaliações similares a uma consulta
def search_reviews(query, reviews_df, top_n=5):
# Obter embedding da consulta
query_embedding = get_embedding(query)
# Calcular similaridade do cosseno entre a consulta e todas as avaliações
reviews_df['similarity'] = reviews_df['embedding'].apply(
lambda x: np.dot(x, query_embedding) /
(np.linalg.norm(x) * np.linalg.norm(query_embedding))
)
# Retornar as top_n avaliações mais similares
results = reviews_df.sort_values('similarity', ascending=False).head(top_n)
return results[['combined_text', 'similarity']]
# Exemplo de uso
results = search_reviews("Delicious chocolate that's not too sweet", reviews)
print(results)
Este código ilustra os princípios básicos da busca semântica, mas para aplicações de produção com grandes volumes de dados, seria necessário utilizar bancos de dados vetoriais especializados que implementam algoritmos de busca aproximada de vizinhos mais próximos (ANN) para eficiência.
Busca de código e outros tipos de conteúdo
A busca semântica não se limita apenas a texto natural, podendo ser aplicada a diversos tipos de conteúdo, incluindo código-fonte. A busca de código baseada em embeddings funciona de maneira similar à busca de texto, mas é especialmente valiosa para encontrar funções ou trechos de código que implementam uma determinada funcionalidade, mesmo que utilizem sintaxe ou abordagens diferentes.
Para implementar busca de código, o processo é semelhante: gerar embeddings para cada função ou trecho de código no repositório, calcular o embedding da consulta (que pode ser uma descrição em linguagem natural da funcionalidade desejada), e encontrar os trechos de código cujos embeddings têm maior similaridade com a consulta.
# Exemplo simplificado de busca de código
def search_code_functions(query, functions_dict):
# Obter embedding da consulta
query_embedding = get_embedding(query)
# Calcular similaridade para cada função
results = []
for func_name, func_code in functions_dict.items():
# Obter embedding do código da função
func_embedding = get_embedding(func_code)
# Calcular similaridade
similarity = np.dot(query_embedding, func_embedding) / (
np.linalg.norm(query_embedding) * np.linalg.norm(func_embedding)
)
results.append((func_name, similarity))
# Ordenar por similaridade e retornar os mais relevantes
results.sort(key=lambda x: x[1], descending=True)
return results[:5]
Além de texto e código, a busca baseada em embeddings pode ser aplicada a outros tipos de conteúdo, como imagens (usando embeddings de imagem), áudio, ou mesmo dados estruturados, desde que existam modelos apropriados para gerar embeddings significativos para esses tipos de dados.
5. Aplicações Práticas: Sistemas de Recomendação
Fundamentos de recomendações baseadas em embeddings
Os sistemas de recomendação baseados em embeddings representam uma abordagem poderosa para sugerir itens relevantes aos usuários, aproveitando a capacidade dos embeddings de capturar similaridades semânticas. O princípio fundamental é que itens com embeddings próximos no espaço vetorial provavelmente serão semanticamente similares e, portanto, interessantes para os mesmos usuários.
Diferentemente dos sistemas de recomendação tradicionais, que muitas vezes dependem de históricos extensos de interações usuário-item, os sistemas baseados em embeddings podem fazer recomendações significativas mesmo com dados limitados, pois capturam o significado intrínseco dos itens. Isso os torna particularmente valiosos para situações de “cold start” (início frio), onde há pouca ou nenhuma informação sobre as preferências de um novo usuário.
Existem várias abordagens para implementar recomendações baseadas em embeddings. Uma abordagem simples é calcular a similaridade entre os embeddings dos itens e recomendar itens similares àqueles com os quais o usuário já interagiu positivamente. Abordagens mais sofisticadas podem envolver a criação de embeddings de usuário (agregando embeddings de itens com os quais o usuário interagiu) e comparar esses embeddings de usuário com embeddings de itens para prever preferências.
Implementando um recomendador básico com embeddings
Vamos implementar um sistema de recomendação básico que sugere itens similares a um item de referência, utilizando a similaridade entre seus embeddings. Esta abordagem é comumente conhecida como “recomendação item-a-item” ou “itens similares”:
import numpy as np
def recommend_similar_items(item_text, items_df, embedding_col='embedding', text_col='text', top_n=5):
"""
Recomenda itens similares a um item de referência.
Args:
item_text: Texto do item de referência
items_df: DataFrame contendo itens e seus embeddings
embedding_col: Nome da coluna que contém os embeddings
text_col: Nome da coluna que contém o texto dos itens
top_n: Número de recomendações a retornar
Returns:
DataFrame com os itens mais similares
"""
# Obter embedding do item de referência
reference_embedding = get_embedding(item_text)
# Criar cópia do DataFrame para não modificar o original
results_df = items_df.copy()
# Calcular similaridade do cosseno
results_df['similarity'] = results_df[embedding_col].apply(
lambda x: np.dot(x, reference_embedding) /
(np.linalg.norm(x) * np.linalg.norm(reference_embedding))
)
# Ordenar por similaridade e retornar os top_n itens mais similares
# Excluir o próprio item se estiver no DataFrame
results_df = results_df.sort_values('similarity', ascending=False)
# Filtrar o próprio item se ele estiver presente
if item_text in results_df[text_col].values:
results_df = results_df[results_df[text_col] != item_text]
return results_df.head(top_n)[[text_col, 'similarity']]
Este código pode ser facilmente adaptado para diferentes tipos de itens, como produtos, artigos, filmes ou músicas. A função recebe o texto de um item de referência, calcula seu embedding, e então compara com os embeddings de todos os outros itens para encontrar os mais similares.
Recomendações personalizadas e modelagem de usuários
Para criar recomendações verdadeiramente personalizadas, podemos ir além da simples recomendação item-a-item e incorporar informações sobre os usuários. Uma abordagem eficaz é criar embeddings de usuário que representem suas preferências e interesses.
Um método comum para criar embeddings de usuário é calcular a média dos embeddings dos itens com os quais o usuário interagiu positivamente. Este embedding agregado captura o “centro de massa” dos interesses do usuário no espaço semântico:
def create_user_embedding(user_items, items_df, embedding_col='embedding'):
"""
Cria um embedding de usuário calculando a média dos embeddings dos itens
com os quais o usuário interagiu.
Args:
user_items: Lista de IDs ou textos dos itens com os quais o usuário interagiu
items_df: DataFrame contendo itens e seus embeddings
embedding_col: Nome da coluna que contém os embeddings
Returns:
Embedding do usuário (vetor numpy)
"""
# Filtrar o DataFrame para incluir apenas os itens do usuário
user_items_df = items_df[items_df['id'].isin(user_items)]
# Extrair os embeddings dos itens do usuário
user_item_embeddings = user_items_df[embedding_col].tolist()
# Calcular a média dos embeddings
if not user_item_embeddings:
return None # Usuário sem interações
user_embedding = np.mean(user_item_embeddings, axis=0)
# Normalizar o embedding resultante
user_embedding = user_embedding / np.linalg.norm(user_embedding)
return user_embedding
Com o embedding do usuário em mãos, podemos recomendar itens calculando a similaridade entre o embedding do usuário e os embeddings de todos os itens disponíveis:
def recommend_items_for_user(user_embedding, items_df, embedding_col='embedding',
text_col='text', already_interacted=[], top_n=5):
"""
Recomenda itens para um usuário com base em seu embedding.
Args:
user_embedding: Embedding do usuário
items_df: DataFrame contendo itens e seus embeddings
embedding_col: Nome da coluna que contém os embeddings
text_col: Nome da coluna que contém o texto dos itens
already_interacted: Lista de IDs de itens com os quais o usuário já interagiu
top_n: Número de recomendações a retornar
Returns:
DataFrame com os itens recomendados
"""
# Criar cópia do DataFrame para não modificar o original
results_df = items_df.copy()
# Calcular similaridade do cosseno
results_df['similarity'] = results_df[embedding_col].apply(
lambda x: np.dot(x, user_embedding) /
(np.linalg.norm(x) * np.linalg.norm(user_embedding))
)
# Excluir itens com os quais o usuário já interagiu
if already_interacted:
results_df = results_df[~results_df['id'].isin(already_interacted)]
# Ordenar por similaridade e retornar os top_n itens
return results_df.sort_values('similarity', ascending=False).head(top_n)
Esta abordagem permite fazer recomendações personalizadas mesmo para novos usuários com poucas interações, um problema conhecido como “cold start” que desafia muitos sistemas de recomendação tradicionais.
6. Aplicações Práticas: Machine Learning com Embeddings
Embeddings como características em modelos de ML
Os embeddings de texto podem ser utilizados como características (features) poderosas em modelos de machine learning tradicionais, oferecendo uma representação rica e densa do conteúdo textual. Esta abordagem combina o poder dos embeddings gerados por modelos de linguagem avançados com a interpretabilidade e eficiência de algoritmos clássicos de machine learning.
Ao utilizar embeddings como características, estamos essencialmente transformando dados textuais não estruturados em representações numéricas estruturadas que preservam o significado semântico. Isto permite que algoritmos de machine learning, que tradicionalmente trabalham apenas com dados numéricos, possam processar e aprender a partir de conteúdo textual de forma eficaz.
Uma vantagem significativa desta abordagem é que ela não requer grandes volumes de dados rotulados para treinamento, pois os embeddings já capturam informações semânticas ricas extraídas durante o pré-treinamento dos modelos de linguagem. Isso torna possível construir modelos de classificação, regressão ou agrupamento eficazes mesmo com conjuntos de dados relativamente pequenos.
Regressão e classificação utilizando embeddings
Vamos explorar como implementar modelos de regressão e classificação utilizando embeddings como características. Primeiro, vejamos um exemplo de regressão, onde o objetivo é prever um valor numérico (como a classificação de estrelas de uma avaliação) a partir do texto:
from sklearn.model_selection import train_test_split
from sklearn.linear_model import Ridge
from sklearn.metrics import mean_absolute_error
# Preparar os dados
X = reviews['embedding'].tolist() # Lista de embeddings
y = reviews['Score'] # Classificação de estrelas (1-5)
# Dividir em conjuntos de treinamento e teste
X_train, X_test, y_train, y_test = train_test_split(X, y, test_size=0.2, random_state=42)
# Treinar um modelo de regressão Ridge
model = Ridge(alpha=1.0)
model.fit(X_train, y_train)
# Avaliar o modelo
y_pred = model.predict(X_test)
mae = mean_absolute_error(y_test, y_pred)
print(f"Erro Absoluto Médio: {mae:.2f}")
Este modelo de regressão é capaz de prever a classificação de estrelas com base apenas no texto da avaliação, convertido em embedding. O Erro Absoluto Médio (MAE) de aproximadamente 0,39 indica que, em média, a previsão está a menos de