Ir para o conteúdo principal
Português— Escolher um idioma
Menu

Recomendações Personalizadas

Aula 19 de 22 Atualizada a 29 de julho de 2026 Programador
Nesta página
  1. Objetivos
  2. O Princípio: Similaridade Igual a Recomendação
  3. Recomendação Baseada em Conteúdo
  4. Perfil de Utilizador a Partir do Histórico
  5. Recomendação com Consulta de Texto
  6. Diversificar Recomendações
  7. Pontos-chave

Objetivos

  • Criar um sistema de recomendação baseado em embeddings
  • Implementar recomendações baseadas em conteúdo e em utilizador
  • Gerir o problema do arranque a frio (cold start) e a diversidade

O Princípio: Similaridade Igual a Recomendação

Um motor de recomendação clássico observa o comportamento: «As pessoas que leram este artigo também leram aquele». É necessário muito tráfego antes de poder dizer algo útil — este é o problema do arranque a frio, que afeta tanto catálogos novos como artigos publicados nesta manhã.

A abordagem dos embeddings ignora esta espera. Se um utilizador gostou de um artigo, recomenda os que têm embeddings mais próximos. Esta é uma recomendação baseada em conteúdo: depende do conteúdo, não do comportamento de outros utilizadores. Um artigo publicado há dez minutos, que nenhum leitor abriu ainda, já tem um embedding e torna-se imediatamente recomendável.

Recomendação Baseada em Conteúdo

O catálogo abaixo mistura intencionalmente dois mundos — aprendizagem automática de um lado, engenharia de software do outro — para que os resultados sejam verificáveis. Cada artigo é codificado concatenando o seu título e conteúdo: o título capta o assunto em resumo, o conteúdo fornece o vocabulário, e usar um sem o outro degrada a qualidade dos vizinhos encontrados.

O truque está na linha scores[idx] = -1. Sem ela, o artigo mais semelhante a um artigo seria sempre ele próprio, com uma pontuação de 1,0 — e estaria a recomendar ao leitor aquilo que acabou de terminar.

from openai import OpenAI
import numpy as np

client = OpenAI()

# Catálogo de artigos
articles = [
    {"id": "a1", "titre": "Introduction au machine learning",
     "contenu": "Le ML permet aux machines d'apprendre à partir de données..."},
    {"id": "a2", "titre": "Deep learning avec PyTorch",
     "contenu": "PyTorch est un framework de deep learning flexible..."},
    {"id": "a3", "titre": "Déployer une API REST avec FastAPI",
     "contenu": "FastAPI est un framework Python pour créer des APIs..."},
    {"id": "a4", "titre": "Les bases de PostgreSQL",
     "contenu": "PostgreSQL est un SGBD relationnel open source..."},
    {"id": "a5", "titre": "Réseaux de neurones convolutifs",
     "contenu": "Les CNN sont utilisés pour la vision par ordinateur..."},
    {"id": "a6", "titre": "NLP avec les transformers",
     "contenu": "Les transformers ont révolutionné le traitement du langage..."},
]

# Indexar o catálogo
textes = [f"{a['titre']}. {a['contenu']}" for a in articles]
response = client.embeddings.create(
    input=textes, model="text-embedding-3-large"
)
catalogue_embs = np.array(
    [d.embedding for d in sorted(response.data, key=lambda x: x.index)]
)

def recommander_similaires(
    article_id: str,
    k: int = 3
) -> list[dict]:
    """Recomenda os k artigos mais semelhantes."""
    idx = next(i for i, a in enumerate(articles) if a["id"] == article_id)
    article_emb = catalogue_embs[idx]

    # Similaridade com todos os outros artigos
    scores = catalogue_embs @ article_emb
    scores[idx] = -1  # Excluir o próprio artigo

    top_k = np.argsort(scores)[-k:][::-1]
    return [
        {"article": articles[i], "score": float(scores[i])}
        for i in top_k
    ]

# Um utilizador lê "Introdução ao ML"
recos = recommander_similaires("a1", k=3)
print("Leu: Introduction au machine learning")
print("Recomendações:")
for r in recos:
    print(f"  [{r['score']:.3f}] {r['article']['titre']}")

Perfil de Utilizador a Partir do Histórico

Recomendar com base num único artigo aprisiona rapidamente o leitor. Para ter em conta todo o seu percurso, constrói um vetor de perfil combinando os embeddings dos artigos que visualizou: este ponto médio representa os seus interesses no mesmo espaço do catálogo, e procura então os artigos mais próximos desse ponto.

No entanto, leituras de há seis meses não devem pesar tanto como as de ontem. A ponderação por recenticidade trata disso: o fator 0.5 ** (n - 1 - i) reduz o peso para metade a cada passo para trás no histórico. Um leitor que seguiu aprendizagem automática durante muito tempo, mas que recentemente mudou para APIs, verá as suas recomendações mudar dentro de alguns artigos em vez de ficarem congeladas. A normalização final traz o perfil de volta à esfera unitária, uma condição para que o produto escalar com o catálogo seja uma similaridade de cosseno adequada.

def creer_profil_utilisateur(
    articles_consultes: list[str],
    poids_recency: bool = True
) -> np.ndarray:
    """Cria um vetor de perfil a partir do histórico."""
    indices = [
        i for i, a in enumerate(articles)
        if a["id"] in articles_consultes
    ]

    if not indices:
        return np.zeros(catalogue_embs.shape[1])

    embs = catalogue_embs[indices]

    if poids_recency:
        # Artigos recentes contam mais
        n = len(indices)
        poids = np.array([0.5 ** (n - 1 - i) for i in range(n)])
        poids /= poids.sum()
        profil = np.average(embs, axis=0, weights=poids)
    else:
        profil = np.mean(embs, axis=0)

    # Normalizar
    profil /= np.linalg.norm(profil)
    return profil

def recommander_pour_utilisateur(
    articles_consultes: list[str],
    k: int = 3
) -> list[dict]:
    """Recomenda artigos com base no perfil do utilizador."""
    profil = creer_profil_utilisateur(articles_consultes)

    scores = catalogue_embs @ profil
    # Excluir artigos já visualizados
    for i, a in enumerate(articles):
        if a["id"] in articles_consultes:
            scores[i] = -1

    top_k = np.argsort(scores)[-k:][::-1]
    return [
        {"article": articles[i], "score": float(scores[i])}
        for i in top_k
    ]

# Utilizador que leu ML e deep learning
recos = recommander_pour_utilisateur(["a1", "a2"], k=3)
print("Histórico: ML + PyTorch")
print("Recomendações:")
for r in recos:
    print(f"  [{r['score']:.3f}] {r['article']['titre']}")

Recomendação com Consulta de Texto

O perfil comportamental ignora uma coisa que o utilizador conhece melhor do que si: o que procura hoje. Como o catálogo já está codificado, basta codificar uma frase de texto livre para consultar o mesmo espaço. «Quero aprender a criar APIs» faz aparecer o artigo sobre FastAPI, mesmo que o histórico do leitor contenha apenas aprendizagem automática. Esta é também a única opção disponível para um visitante sobre o qual não sabe nada.

def recommander_par_interet(
    description: str,
    k: int = 3
) -> list[dict]:
    """Recomenda artigos com base numa descrição de interesse."""
    query_emb = client.embeddings.create(
        input=description,
        model="text-embedding-3-large"
    ).data[0].embedding

    scores = catalogue_embs @ np.array(query_emb)
    top_k = np.argsort(scores)[-k:][::-1]

    return [
        {"article": articles[i], "score": float(scores[i])}
        for i in top_k
    ]

# "Quero aprender a criar APIs web em Python"
recos = recommander_par_interet("créer des APIs web en Python")
for r in recos:
    print(f"  [{r['score']:.3f}] {r['article']['titre']}")

Diversificar Recomendações

Ordenar por similaridade pura produz um defeito visível em produção: as cinco recomendações parecem-se todas. Um leitor do artigo sobre CNN recebe cinco variantes de visão por computador, quando a segunda ou terceira sugestão poderia ter aberto a porta aos transformers.

O MMR (Maximal Marginal Relevance) corrige isto selecionando artigos um a um: a cada volta, escolhe o que maximiza a relevância para a consulta, menos a redundância máxima com o que já foi selecionado. O lambda_param define o equilíbrio — a 1,0 obtém uma ordenação clássica, a 0,5 favorece fortemente a variedade, e o valor padrão de 0,7 dá uma lista relevante que respira.

def recommander_divers(
    query_emb: np.ndarray,
    k: int = 5,
    lambda_param: float = 0.7
) -> list[int]:
    """MMR: equilibra relevância e diversidade."""
    scores = catalogue_embs @ query_emb
    candidats = list(range(len(articles)))
    selectionnes = []

    for _ in range(k):
        if not candidats:
            break

        meilleur_score = -float("inf")
        meilleur_idx = -1

        for idx in candidats:
            # Relevância
            pertinence = scores[idx]

            # Redundância máxima com os já selecionados
            if selectionnes:
                sims_selectionnes = [
                    float(np.dot(catalogue_embs[idx], catalogue_embs[s]))
                    for s in selectionnes
                ]
                redondance = max(sims_selectionnes)
            else:
                redondance = 0

            # Pontuação MMR
            mmr_score = (
                lambda_param * pertinence
                - (1 - lambda_param) * redondance
            )

            if mmr_score > meilleur_score:
                meilleur_score = mmr_score
                meilleur_idx = idx

        selectionnes.append(meilleur_idx)
        candidats.remove(meilleur_idx)

    return selectionnes

Pontos-chave

  • Os embeddings permitem recomendação por similaridade de conteúdo
  • O perfil do utilizador é construído pela média dos embeddings visualizados
  • A ponderação por recenticidade dá mais peso às visualizações recentes
  • O MMR diversifica as recomendações penalizando a redundância