🎬 Filtragem Colaborativa baseada em Item

Quando você abre Amazon, Netflix ou Spotify, a tela inicial não é um índice do catálogo — é uma seleção feita para você. Essa seleção não é opcional: sem ela, o produto seria impossível de usar.

Os números acima (lá em cima, no cabeçalho) vão aparecendo conforme a página carrega. O último é o mais impressionante: 35% das vendas da Amazon são atribuídas ao sistema de recomendação (McKinsey, 2013).

Existem quatro abordagens clássicas. Nenhuma é "a melhor" — cada uma brilha num cenário. Clique no botão e veja qual é o foco da nossa aula.

Dentro da filtragem colaborativa existem duas perguntas possíveis. Parecem iguais, mas levam a arquiteturas radicalmente diferentes.

Tudo começa numa matriz: linhas = usuários, colunas = itens, cada célula = rating (ou vazio, se ainda não avaliou).

Esta matriz tem duas leituras:

• 📏 Por linha → cada usuário vira um vetor em ℝ⁵ (quem usa: user-based)
• 📐 Por coluna → cada item vira um vetor em ℝ⁴ (quem usa: item-based, a nossa abordagem)

Cada item é um vetor-coluna. Medir "quão parecidos são os itens i e j?" vira um problema de comparar dois vetores. Três opções:

5.1 Cosseno puro — o mais simples

Problema: todos os ratings são positivos (1 a 5) → todos os vetores caem no mesmo quadrante → parece que tudo é similar a tudo. E pior: cada usuário tem sua escala.

5.2 Adjusted Cosine ⭐ (o que você vai usar)

Resultado entre −1 e +1: +1 gostos idênticos · 0 sem relação · −1 opostos.

5.3 Jaccard — quando não tem nota

Vamos simplificar para 2 dimensões (só Ana e Caio). Clique para ver cada filme aparecer como um vetor:

Olhe esses dois usuários:

O mesmo filme ganha 3 dos dois — mas não é a mesma coisa. Se tratarmos como iguais, perdemos o sinal real.

Vamos calcular a similaridade entre Matrix e Inception usando quem avaliou os dois: Ana e Caio. Cinco passos. Clique e veja a conta aparecer:

Se você calcula todos os pares (i, j) de antemão, obtém uma matriz simétrica S de tamanho |I|×|I| que pode ser cacheada. Cada consulta online vira O(k) — instantâneo.

3 propriedades para a sala lembrar

• Custo: offline caro O(m²·n) uma vez; online barato O(k) a cada requisição.
• Estabilidade: gêneros não saem de moda do dia para a noite. Job batch diário/semanal basta.
• Explicabilidade de graça: "recomendamos Inception porque você viu Matrix (sim 0,92)". Auditável.

Dado que temos S pronta, como prever qual rating o usuário u daria a um item i?

Davi avaliou: Matrix = 5, Titanic = 1, Amelie = 3. Queremos o rating que ele daria a Interstellar.

Similaridades (vindas da matriz S):

• sim(Interstellar, Matrix) = +0,88 — ambos sci-fi cerebral
• sim(Interstellar, Titanic) = −0,72 — gostos opostos
• sim(Interstellar, Amelie) = +0,22 — leve sobreposição

Em janeiro de 2003, Greg Linden, Brent Smith e Jeremy York publicaram no IEEE Internet Computing: "Amazon.com Recommendations: Item-to-Item Collaborative Filtering". O algoritmo rodava em produção na Amazon desde 2001.

Stack do módulo é .NET. A Microsoft mantém uma biblioteca oficial — ML.NET — que implementa isso via Matrix Factorization. Sem Python, sem Docker, sem serviço externo.

Mapeamento teoria ↔ código

Pipeline de treino (esqueleto)

using Microsoft.ML;
using Microsoft.ML.Trainers;

// Schema de cada linha do CSV
public record Rating(float UserId, float ItemId, float Label);

var ctx = new MLContext(seed: 42);

// 1 · Carregar ratings.csv → IDataView
var data = ctx.Data.LoadFromTextFile<Rating>(
    path: "ratings.csv", hasHeader: true, separatorChar: ',');

// 2 · Split 80/20 para validar offline (RMSE, R²)
var split = ctx.Data.TrainTestSplit(data, testFraction: 0.2);

// 3 · Pipeline: IDs → chaves + Matrix Factorization
var pipeline = ctx.Transforms.Conversion
    .MapValueToKey("UserIdEnc", "UserId")
    .Append(ctx.Transforms.Conversion.MapValueToKey("ItemIdEnc", "ItemId"))
    .Append(ctx.Recommendation().Trainers.MatrixFactorization(new MatrixFactorizationTrainer.Options {
        MatrixColumnIndexColumnName = "UserIdEnc",
        MatrixRowIndexColumnName    = "ItemIdEnc",
        LabelColumnName             = "Label",
        ApproximationRank           = 16,    // k fatores latentes
        NumberOfIterations          = 20,
        LearningRate                = 0.05,
        Lambda                      = 0.1     // regularização L2
    }));

// 4 · Treinar, avaliar, salvar
var model   = pipeline.Fit(split.TrainSet);
var preds   = model.Transform(split.TestSet);
var metrics = ctx.Recommendation().Evaluate(preds, labelColumnName: "Label", scoreColumnName: "Score");
Console.WriteLine($"RMSE = {metrics.RootMeanSquaredError:F3} · R² = {metrics.RSquared:F3}");
ctx.Model.Save(model, split.TrainSet.Schema, "model.zip");

Até a Semana 02, o grupo precisa entregar 4 artefatos:

Mão na massa (insumo da entrega 03)

Antes da próxima aula, monte uma planilha simulando o domínio do app:

1. Definir 5 usuários × 5 itens do seu domínio
2. Preencher ratings plausíveis com algumas células vazias (esparsidade real)
3. Calcular R̄_u de cada usuário
4. Calcular adjusted cosine entre 2 itens escolhidos
5. Prever rating de um usuário em um item que ele não avaliou (fórmula ponderada)
6. Comentar criticamente: o resultado faz sentido no domínio?
7. Aplicar o template oficial no repositório do grupo