Implementando Modelos de Recomendação com Python
Os modelos de recomendação são sistemas de Machine Learning que analisam dados de comportamento e preferências de usuários para sugerir itens relevantes. Eles são fundamentais para empresas que lidam com grandes catálogos de produtos e conteúdos.
Neste artigo, vamos explorar como implementar sistemas de recomendação em Python, desde os fundamentos até modelos colaborativos e baseados em conteúdo.
1. Tipos de Sistemas de Recomendação
Antes da implementação, precisamos entender os principais tipos:
Baseados em Popularidade (mais simples)
Recomendam os itens mais populares ou mais vendidos.
Exemplo: lista de "mais assistidos" da Netflix.
Baseados em Conteúdo (Content-Based)
Recomendam itens semelhantes ao que o usuário já gostou.
Usam descrições, tags e atributos dos itens.
Filtragem Colaborativa (Collaborative Filtering)
Recomendam itens baseados no comportamento de outros usuários semelhantes.
Pode ser user-based (usuários parecidos) ou item-based (itens relacionados).
Híbridos
Combinam técnicas de conteúdo, colaborativas e popularidade.
Mais usados em sistemas modernos como Spotify e Netflix.
2. Preparando os Dados
Vamos usar um dataset fictício de avaliações de filmes:
import pandas as pd
# Dados fictícios: usuário, filme e nota
dados = pd.DataFrame({
"usuario": [1,1,1,2,2,3,3,4,4,5],
"filme": ["A", "B", "C", "A", "C", "B", "D", "C", "D", "A"],
"nota": [5, 4, 3, 4, 5, 2, 5, 3, 4, 4]
})
print(dados)
3. Recomendação Baseada em Popularidade
populares = dados.groupby("filme")["nota"].mean().sort_values(ascending=False)
print("Filmes mais recomendados (popularidade):")
print(populares)
Esse modelo é simples, mas não personalizado — todos recebem as mesmas recomendações.
4. Recomendação Baseada em Conteúdo
Suponha que temos descrições dos filmes. Podemos usar TF-IDF (Term Frequency-Inverse Document Frequency) para medir similaridade textual.
from sklearn.feature_extraction.text import TfidfVectorizer
from sklearn.metrics.pairwise import linear_kernel
# Exemplo de descrições dos filmes
descricoes = {
"A": "aventura ação fantasia",
"B": "romance drama",
"C": "comédia família",
"D": "ação ficção científica"
}
df_descricoes = pd.DataFrame(descricoes.items(), columns=["filme", "descricao"])
# Vetorização TF-IDF
tfidf = TfidfVectorizer()
matriz = tfidf.fit_transform(df_descricoes["descricao"])
# Similaridade entre filmes
cosine_sim = linear_kernel(matriz, matriz)
# Função de recomendação baseada em similaridade
indices = pd.Series(df_descricoes.index, index=df_descricoes["filme"])
def recomendar_conteudo(filme, n=2):
idx = indices[filme]
sim_scores = list(enumerate(cosine_sim[idx]))
sim_scores = sorted(sim_scores, key=lambda x: x[1], reverse=True)
sim_scores = sim_scores[1:n+1]
filmes_similares = [df_descricoes["filme"].iloc[i[0]] for i in sim_scores]
return filmes_similares
print("Filmes semelhantes a A:", recomendar_conteudo("A"))
5. Filtragem Colaborativa com Python
A filtragem colaborativa usa a interação entre usuários e itens. Vamos implementar a abordagem user-item.
5.1 Criando a matriz usuário-item
matriz = dados.pivot_table(index="usuario", columns="filme", values="nota").fillna(0)
print(matriz)
5.2 Similaridade entre usuários
from sklearn.metrics.pairwise import cosine_similarity
sim_usuarios = cosine_similarity(matriz)
sim_df = pd.DataFrame(sim_usuarios, index=matriz.index, columns=matriz.index)
print(sim_df)
5.3 Recomendação baseada em vizinhos
def recomendar_usuario(usuario, n=2):
similaridade = sim_df[usuario].sort_values(ascending=False)[1:]
usuario_mais_proximo = similaridade.index[0]
# Itens avaliados pelo usuário similar e não pelo atual
filmes_usuario = set(dados[dados["usuario"] == usuario]["filme"])
filmes_similar = set(dados[dados["usuario"] == usuario_mais_proximo]["filme"])
recomendacoes = filmes_similar - filmes_usuario
return list(recomendacoes)[:n]
print("Recomendações para o usuário 1:", recomendar_usuario(1))
6. Recomendação com Bibliotecas Específicas
Existem bibliotecas prontas para sistemas de recomendação. Uma das mais usadas é a Surprise.
from surprise import Dataset, Reader, SVD
from surprise.model_selection import cross_validate
# Preparando dados
reader = Reader(rating_scale=(1, 5))
data = Dataset.load_from_df(dados[["usuario", "filme", "nota"]], reader)
# Modelo SVD (Matrix Factorization)
model = SVD()
cross_validate(model, data, measures=["RMSE", "MAE"], cv=3, verbose=True)
Esse modelo é poderoso e escalável, usado em sistemas reais.
7. Visualizando Recomendações
import matplotlib.pyplot as plt
populares.plot(kind="bar", color="skyblue")
plt.title("Filmes mais recomendados por popularidade")
plt.ylabel("Nota média")
plt.show()
8. Boas Práticas em Sistemas de Recomendação
Híbridos são mais eficientes: combine conteúdo + colaborativo + popularidade.
Atualização constante: dados mudam rápido, especialmente em redes sociais e e-commerce.
Avalie corretamente: use métricas como RMSE, Precision@K, Recall@K, NDCG.
Explique as recomendações: usuários confiam mais quando entendem o motivo.
Escalabilidade: sistemas reais precisam lidar com milhões de usuários e itens.
9. Conclusão
Modelos de recomendação são parte essencial da experiência digital moderna.
Com Python, conseguimos implementar desde modelos básicos (popularidade, conteúdo) até sistemas mais avançados com filtragem colaborativa e fatoração matricial.
Bibliotecas como Scikit-learn, Surprise e até TensorFlow permitem escalar esses sistemas para aplicações reais.
No futuro, os sistemas de recomendação devem evoluir para se tornarem ainda mais contextuais e personalizados, considerando tempo, localização, emoções e histórico em múltiplas plataformas.
Comentários
Postar um comentário