Recommender systems básicos

⏱ 12 min·⭐ 50 XP

Pré-requisitos (0/1)0%

⬜⏱️ Time series: ARIMA, Prophet, Neural(Machine Learning Clássico)

Recomendamos completar os pré-requisitos antes de seguir, mas nada te impede de continuar.

Recommender é problema de ranking

Abordagem	Precisa de	Sofre de	Papel na arquitetura
Vizinhança item a item	Histórico de interação	Item novo sem histórico	Base sólida, barata e explicável
Fatoração de matriz	Histórico em volume	Usuário e item novos	Geração de candidatos
Baseada em conteúdo	Atributos do item	Recomendação óbvia demais	Resolve item novo, complementa a colaborativa
Duas torres	Volume e infraestrutura	Custo de treino e de servir	Geração de candidatos em escala
Reordenador com contexto	Sinais de sessão	Custo por item	Só sobre as poucas centenas que sobraram

AbordagemVizinhança item a item

Precisa deHistórico de interação

Sofre deItem novo sem histórico

Papel na arquiteturaBase sólida, barata e explicável

AbordagemFatoração de matriz

Precisa deHistórico em volume

Sofre deUsuário e item novos

Papel na arquiteturaGeração de candidatos

AbordagemBaseada em conteúdo

Precisa deAtributos do item

Sofre deRecomendação óbvia demais

Papel na arquiteturaResolve item novo, complementa a colaborativa

AbordagemDuas torres

Precisa deVolume e infraestrutura

Sofre deCusto de treino e de servir

Papel na arquiteturaGeração de candidatos em escala

AbordagemReordenador com contexto

Precisa deSinais de sessão

Sofre deCusto por item

Papel na arquiteturaSó sobre as poucas centenas que sobraram

O objetivo não é prever o rating exato — é ordenar o catálogo para cada usuário. Métricas principais: Recall@K, Precision@K, NDCG@K, MAP. MSE em rating é indicador fraco: o que importa é se os top-K recomendados foram clicados/consumidos.

Collaborative filtering: user-user e item-item

import numpy as np
from scipy.sparse import csr_matrix
from sklearn.metrics.pairwise import cosine_similarity

# Matriz esparsa user-item (linhas=users, colunas=items)
R = csr_matrix((ratings, (user_ids, item_ids)))

# Item-item similarity (Amazon 2003, ainda dominante em produção)
item_sim = cosine_similarity(R.T, dense_output=False)

def recommend(user_id, top_k=10):
    user_items = R[user_id].toarray().flatten()
    scores = item_sim @ user_items
    scores[user_items &gt; 0] = -np.inf  # mascarar itens já vistos
    return np.argsort(-scores)[:top_k]

💡

Item-item é mais estável que user-user: catálogos mudam menos que usuários. Pré-compute item_sim offline e sirva recomendações em latência de ms.

Matrix factorization com ALS

from implicit.als import AlternatingLeastSquares

# implicit library — ALS para implicit feedback (clicks, views)
model = AlternatingLeastSquares(
    factors=64,              # dim do embedding
    regularization=0.01,
    iterations=20,
    use_gpu=True,
)

# R deve ser user-item com valores = confiança (clicks, tempo, peso)
model.fit(R)

# Recomendação para user_id
ids, scores = model.recommend(user_id, R[user_id], N=10, filter_already_liked_items=True)

⚠️

ALS de implicit feedback difere de SVD em ratings explícitos: não preenche zeros como "não gostou" — trata como observação faltante com peso menor. Usar o modelo errado inverte o sinal e produz recomendações absurdas.

Quiz rápido

Por que o erro na predição da nota é um indicador fraco para um sistema de recomendação?

Content-based e híbrido

from sklearn.feature_extraction.text import TfidfVectorizer
from sklearn.metrics.pairwise import linear_kernel

# Content-based para cold-start de item
tfidf = TfidfVectorizer(max_features=10000, ngram_range=(1, 2))
item_vecs = tfidf.fit_transform(items_df['description'])

def similar_items(item_id, top_k=10):
    sims = linear_kernel(item_vecs[item_id], item_vecs).flatten()
    return np.argsort(-sims)[1:top_k + 1]

# Híbrido simples: score = alpha * CF + (1 - alpha) * content
final_score = 0.7 * cf_score + 0.3 * content_score

Two-tower neural (o padrão moderno)

# Two-tower: uma torre encoda user, outra encoda item
# Treina com contrastive loss -> embeddings próximos no espaço
import torch
import torch.nn as nn

class TwoTower(nn.Module):
    def __init__(self, n_users, n_items, dim=64):
        super().__init__()
        self.user_tower = nn.Sequential(
            nn.Embedding(n_users, dim),
            nn.Linear(dim, dim), nn.ReLU(), nn.Linear(dim, dim),
        )
        self.item_tower = nn.Sequential(
            nn.Embedding(n_items, dim),
            nn.Linear(dim, dim), nn.ReLU(), nn.Linear(dim, dim),
        )

    def forward(self, u, i):
        return (self.user_tower(u) * self.item_tower(i)).sum(-1)

✅

Em produção (YouTube, Spotify, Netflix), two-tower alimenta candidate generation, depois um ranker downstream (gradient boosting ou DNN) reordena top 500 → top 20 com features contextuais. Essa é a arquitetura canônica de 2026.

Perguntas frequentes

❓ Filtragem colaborativa ou baseada em conteúdo?

Colaborativa quando há histórico de interação suficiente — ela descobre padrão que ninguém descreveu. Baseada em conteúdo quando o item é novo ou o histórico é escasso, porque ela usa atributo do item. Sistema real combina as duas justamente por causa do início frio.

❓ O que é o problema do início frio?

É não ter histórico para recomendar a usuário novo ou item novo. Resolve-se com conteúdo, popularidade e sinal de contexto até o histórico existir. Ignorar isso produz sistema que funciona na avaliação com dado antigo e falha com quem acabou de chegar — que é justamente quem se quer reter.

❓ Como avaliar recomendação sem colocar em produção?

Com métrica de ranqueamento em divisão temporal, olhando também cobertura e diversidade — não só acerto. Otimizar acerto isolado produz recomendação óbvia e repetitiva, que mede bem e não gera descoberta. O teste real continua sendo comparação com tráfego.

Fixando

Quiz rápido

Qual é o erro descrito ao aplicar a fatoração pensada para notas explícitas a dados de clique e visualização?

Quiz rápido

Qual é a arquitetura canônica em produção, e por que ela tem duas etapas?

Terminou de ler?

Marcar como concluído registra o XP, mantém sua sequência e coloca 3 cartas deste módulo na fila de revisão espaçada.

Próximos passos sugeridos

🏁

Capstone: pipeline ML end-to-end

Machine Learning Clássico · 20 min · +85 XP

→

Temas deste módulo

Discussão

Carregando comentários…

Recommender systems básicos

⏱ 12 min·⭐ 50 XP

Pré-requisitos (0/1)0%

⬜⏱️ Time series: ARIMA, Prophet, Neural(Machine Learning Clássico)

Recomendamos completar os pré-requisitos antes de seguir, mas nada te impede de continuar.

Recommender é problema de ranking

Abordagem	Precisa de	Sofre de	Papel na arquitetura
Vizinhança item a item	Histórico de interação	Item novo sem histórico	Base sólida, barata e explicável
Fatoração de matriz	Histórico em volume	Usuário e item novos	Geração de candidatos
Baseada em conteúdo	Atributos do item	Recomendação óbvia demais	Resolve item novo, complementa a colaborativa
Duas torres	Volume e infraestrutura	Custo de treino e de servir	Geração de candidatos em escala
Reordenador com contexto	Sinais de sessão	Custo por item	Só sobre as poucas centenas que sobraram

AbordagemVizinhança item a item

Precisa deHistórico de interação

Sofre deItem novo sem histórico

Papel na arquiteturaBase sólida, barata e explicável

AbordagemFatoração de matriz

Precisa deHistórico em volume

Sofre deUsuário e item novos

Papel na arquiteturaGeração de candidatos

AbordagemBaseada em conteúdo

Precisa deAtributos do item

Sofre deRecomendação óbvia demais

Papel na arquiteturaResolve item novo, complementa a colaborativa

AbordagemDuas torres

Precisa deVolume e infraestrutura

Sofre deCusto de treino e de servir

Papel na arquiteturaGeração de candidatos em escala

AbordagemReordenador com contexto

Precisa deSinais de sessão

Sofre deCusto por item

Papel na arquiteturaSó sobre as poucas centenas que sobraram

Collaborative filtering: user-user e item-item

import numpy as np
from scipy.sparse import csr_matrix
from sklearn.metrics.pairwise import cosine_similarity

# Matriz esparsa user-item (linhas=users, colunas=items)
R = csr_matrix((ratings, (user_ids, item_ids)))

# Item-item similarity (Amazon 2003, ainda dominante em produção)
item_sim = cosine_similarity(R.T, dense_output=False)

def recommend(user_id, top_k=10):
    user_items = R[user_id].toarray().flatten()
    scores = item_sim @ user_items
    scores[user_items &gt; 0] = -np.inf  # mascarar itens já vistos
    return np.argsort(-scores)[:top_k]

💡

Item-item é mais estável que user-user: catálogos mudam menos que usuários. Pré-compute item_sim offline e sirva recomendações em latência de ms.

Matrix factorization com ALS

from implicit.als import AlternatingLeastSquares

# implicit library — ALS para implicit feedback (clicks, views)
model = AlternatingLeastSquares(
    factors=64,              # dim do embedding
    regularization=0.01,
    iterations=20,
    use_gpu=True,
)

# R deve ser user-item com valores = confiança (clicks, tempo, peso)
model.fit(R)

# Recomendação para user_id
ids, scores = model.recommend(user_id, R[user_id], N=10, filter_already_liked_items=True)

⚠️

Quiz rápido

Por que o erro na predição da nota é um indicador fraco para um sistema de recomendação?

Content-based e híbrido

from sklearn.feature_extraction.text import TfidfVectorizer
from sklearn.metrics.pairwise import linear_kernel

# Content-based para cold-start de item
tfidf = TfidfVectorizer(max_features=10000, ngram_range=(1, 2))
item_vecs = tfidf.fit_transform(items_df['description'])

def similar_items(item_id, top_k=10):
    sims = linear_kernel(item_vecs[item_id], item_vecs).flatten()
    return np.argsort(-sims)[1:top_k + 1]

# Híbrido simples: score = alpha * CF + (1 - alpha) * content
final_score = 0.7 * cf_score + 0.3 * content_score

Two-tower neural (o padrão moderno)

# Two-tower: uma torre encoda user, outra encoda item
# Treina com contrastive loss -> embeddings próximos no espaço
import torch
import torch.nn as nn

class TwoTower(nn.Module):
    def __init__(self, n_users, n_items, dim=64):
        super().__init__()
        self.user_tower = nn.Sequential(
            nn.Embedding(n_users, dim),
            nn.Linear(dim, dim), nn.ReLU(), nn.Linear(dim, dim),
        )
        self.item_tower = nn.Sequential(
            nn.Embedding(n_items, dim),
            nn.Linear(dim, dim), nn.ReLU(), nn.Linear(dim, dim),
        )

    def forward(self, u, i):
        return (self.user_tower(u) * self.item_tower(i)).sum(-1)

✅

Perguntas frequentes

❓ Filtragem colaborativa ou baseada em conteúdo?

❓ O que é o problema do início frio?

❓ Como avaliar recomendação sem colocar em produção?

Fixando

Quiz rápido

Qual é o erro descrito ao aplicar a fatoração pensada para notas explícitas a dados de clique e visualização?

Quiz rápido

Qual é a arquitetura canônica em produção, e por que ela tem duas etapas?

Terminou de ler?

Marcar como concluído registra o XP, mantém sua sequência e coloca 3 cartas deste módulo na fila de revisão espaçada.

Próximos passos sugeridos

🏁

Capstone: pipeline ML end-to-end

Machine Learning Clássico · 20 min · +85 XP

→

Temas deste módulo

Discussão

Carregando comentários…