Implementando Modelos de Recomendação com Python
Neste artigo, vamos explorar como Python pode ser usado para criar modelos de recomendação, passando por conceitos fundamentais, diferentes abordagens e exemplos práticos.
1. O que é um Sistema de Recomendação?
Um sistema de recomendação é um modelo de aprendizado que prevê a preferência de um usuário em relação a um item, com base em dados históricos.
Existem três principais tipos:
Baseado em Popularidade – recomenda os itens mais consumidos.
Baseado em Conteúdo – recomenda itens semelhantes ao que o usuário já gostou.
Filtragem Colaborativa – recomenda itens com base em usuários semelhantes ou preferências conjuntas.
Híbridos – combinam várias abordagens para melhorar a qualidade.
2. Preparando o Ambiente
Instale as bibliotecas necessárias:
pip install pandas numpy scikit-learn surprise matplotlib seaborn
3. Conjunto de Dados
Um dos datasets mais famosos para recomendação é o MovieLens, com milhões de avaliações de filmes.
Para fins de exemplo, vamos usar a versão reduzida (MovieLens 100k).
import pandas as pd
# Carregando os dados MovieLens 100k
url = "https://raw.githubusercontent.com/justmarkham/DAT8/master/data/u.data"
colunas = ["user_id", "item_id", "rating", "timestamp"]
df = pd.read_csv(url, sep="\t", names=colunas)
print(df.head())
4. Recomendação Baseada em Popularidade
A forma mais simples de recomendar é listar os itens mais bem avaliados ou mais consumidos.
# Top filmes mais bem avaliados
top_filmes = df.groupby("item_id")["rating"].mean().sort_values(ascending=False).head(10)
print(top_filmes)
📌 Limitação: todos os usuários recebem a mesma recomendação.
5. Recomendação Baseada em Conteúdo
Aqui, analisamos as características do item (ex.: gênero, descrição, atores) para recomendar itens semelhantes.
5.1 Exemplo com similaridade de vetores
from sklearn.metrics.pairwise import cosine_similarity
from sklearn.feature_extraction.text import TfidfVectorizer
# Exemplo fictício de descrições de filmes
dados = {
"titulo": ["Matrix", "John Wick", "O Senhor dos Anéis", "Harry Potter"],
"descricao": [
"ficção científica ação inteligência artificial",
"ação combate assassino vingança",
"fantasia aventura guerra épica",
"magia fantasia escola bruxaria"
]
}
df_filmes = pd.DataFrame(dados)
# Vetorização com TF-IDF
vetor = TfidfVectorizer()
matriz = vetor.fit_transform(df_filmes["descricao"])
# Similaridade entre filmes
similaridade = cosine_similarity(matriz)
print(similaridade)
📌 Assim, conseguimos recomendar filmes com descrições semelhantes.
6. Filtragem Colaborativa
Na filtragem colaborativa, a ideia é usar preferências de usuários semelhantes.
6.1 Filtragem baseada em usuários
from surprise import Dataset, Reader, KNNBasic
# Carregar dataset MovieLens 100k para Surprise
reader = Reader(rating_scale=(1, 5))
data = Dataset.load_from_df(df[["user_id", "item_id", "rating"]], reader)
# Algoritmo KNN para filtragem colaborativa
trainset = data.build_full_trainset()
sim_options = {"name": "cosine", "user_based": True}
modelo = KNNBasic(sim_options=sim_options)
modelo.fit(trainset)
# Recomendações para um usuário específico
usuario = 10
itens = trainset.all_items()
itens_ids = [trainset.to_raw_iid(i) for i in itens]
predicoes = [modelo.predict(usuario, iid) for iid in itens_ids]
predicoes = sorted(predicoes, key=lambda x: x.est, reverse=True)
print("Top recomendações para o usuário", usuario)
for pred in predicoes[:5]:
print(pred.iid, pred.est)
6.2 Filtragem baseada em itens
sim_options = {"name": "cosine", "user_based": False}
modelo_itens = KNNBasic(sim_options=sim_options)
modelo_itens.fit(trainset)
predicoes = [modelo_itens.predict(usuario, iid) for iid in itens_ids]
predicoes = sorted(predicoes, key=lambda x: x.est, reverse=True)
print("Top recomendações por item para o usuário", usuario)
for pred in predicoes[:5]:
print(pred.iid, pred.est)
📌 Aqui o modelo usa similaridade entre itens em vez de usuários.
7. Modelos Baseados em Fatores Latentes (SVD)
Uma técnica poderosa é decompor a matriz de avaliações em fatores latentes (ex.: gosto por ação, romance, comédia).
from surprise import SVD
from surprise.model_selection import cross_validate
# Modelo SVD
modelo_svd = SVD()
cross_validate(modelo_svd, data, measures=["RMSE", "MAE"], cv=5, verbose=True)
# Treinar e prever
modelo_svd.fit(trainset)
pred = modelo_svd.predict(usuario, 50)
print("Predição para usuário", usuario, "no filme 50:", pred.est)
📌 O SVD é usado em sistemas reais como o Netflix Prize.
8. Avaliação de Sistemas de Recomendação
As principais métricas incluem:
RMSE (Root Mean Squared Error) → mede erro das previsões.
MAE (Mean Absolute Error) → erro absoluto médio.
Precisão, Recall e F1-score → usados em top-N recomendações.
Cobertura → percentual de itens recomendados.
Exemplo com avaliação:
from surprise.model_selection import train_test_split
from surprise import accuracy
trainset, testset = train_test_split(data, test_size=0.2)
modelo_svd.fit(trainset)
predicoes = modelo_svd.test(testset)
accuracy.rmse(predicoes)
9. Construindo um Recomendador Híbrido
Podemos combinar as abordagens:
Popularidade + Colaborativo → garante recomendações iniciais.
Conteúdo + Fatores Latentes → aumenta diversidade.
Ensemble (média ponderada das predições).
# Exemplo híbrido simples
pred_pop = 3.5 # exemplo de baseline popularidade
pred_svd = modelo_svd.predict(usuario, 50).est
pred_final = 0.4 * pred_pop + 0.6 * pred_svd
print("Recomendação híbrida:", pred_final)
10. Conclusão
Os sistemas de recomendação são essenciais no mundo digital, guiando usuários em decisões de consumo e aumentando o engajamento.
Neste artigo, vimos como implementar diferentes tipos de recomendadores com Python:
Popularidade (básico).
Baseado em Conteúdo (TF-IDF + Similaridade).
Filtragem Colaborativa (usuário-item e SVD).
Modelos Híbridos.
Cada abordagem tem pontos fortes e limitações, e o segredo está em combinar métodos para obter maior personalização e qualidade.
Comentários
Postar um comentário