Na avaliação de sistemas de recomendação, é fundamental medir tanto a precisão das previsões das preferências dos usuários quanto a eficácia na ordenação dos itens recomendados. **Métricas de acurácia preditiva**, como o erro quadrático médio (MSE), quantificam a diferença quadrática média entre as avaliações previstas e as reais, fornecendo uma medida direta do desempenho do modelo. **Métricas de ranqueamento**, por outro lado, avaliam o quão eficazmente o sistema ordena as recomendações para que os usuários encontrem os itens mais relevantes próximos ao topo de suas listas de recomendações. Juntas, essas métricas oferecem uma visão abrangente dos pontos fortes e fracos de um mecanismo de recomendação.


import unittest
import user_code
import ast
import re   
import importlib
import csv
import unittest
import user_code
import importlib
import numpy as np

class TestTask(unittest.TestCase):

    def test_precision_at_3(self):
        import user_code
        importlib.reload(user_code)
        predicted = [2.5, 4.0, 3.5, 5.0, 1.0]
        actual = [3.0, 5.0, 2.0, 4.0, 1.0]
        result = user_code.evaluate_predictions(predicted, actual)
        _dynamic_test(
            self,
            result is not None and abs(result[1] - 2/3) < 1e-6,
            "Correct precision@3 for provided example.",
            f"Expected precision@3 0.666..., got {result[1] if result else result}",
        )

    def test_short_lists(self):
        import user_code
        importlib.reload(user_code)
        predicted = [3.0, 4.0]
        actual = [4.0, 2.0]
        result = user_code.evaluate_predictions(predicted, actual)
        # MSE = ((3-4)^2 + (4-2)^2)/2 = (1+4)/2 = 2.5
        # Precision@3: only 2 items, so overlap of top-2/3
        pred_indices = np.argsort(predicted)[::-1][:3]
        actual_indices = np.argsort(actual)[::-1][:3]
        overlap = len(set(pred_indices) & set(actual_indices))
        expected_precision = overlap/3
        _dynamic_test(
            self,
            result is not None and abs(result[0] - 2.5) < 1e-6,
            "Correct MSE for short lists.",
            f"Expected MSE 2.5, got {result[0] if result else result}",
        )
        _dynamic_test(
            self,
            abs(result[1] - expected_precision) < 1e-6,
            "Correct precision@3 for short lists.",
            f"Expected precision@3 {expected_precision}, got {result[1] if result else result}",
        )

def _dynamic_test(test_case, condition, success_message, failure_message):
    if condition:
        test_case._testMethodName = success_message
        test_case.assertTrue(True, success_message)
    else:
        test_case._testMethodName = failure_message
        test_case.fail(failure_message)

def normalize_text(text):
    text = text.lower()
    text = re.sub(r"\\s{2,}", " ", text)
    text = re.sub(r"\\s*([,:?])\\s*", r"\\1 ", text)
    return text.strip()

def change_var(code: str, var_name: str, value: str) -> str:
    tree = ast.parse(code)
    lines = code.splitlines()
    changed = False
    # Collect all assignment nodes to modify
    assign_nodes = [
        (i, node)
        for i, node in enumerate(tree.body)
        if isinstance(node, ast.Assign)
        and any(isinstance(target, ast.Name) and target.id == var_name for target in node.targets)
    ]

    # If nothing to change, return unmodified code
    if not assign_nodes:
        return code

    # Perform replacements for all matching assignments (from last to first to not break line offsets)
    for i, node in reversed(assign_nodes):
        start_line = node.lineno - 1
        line = lines[start_line]
        indent = ' ' * (len(line) - len(line.lstrip()))
        lines[start_line] = f"{indent}{var_name} = {value}"
        next_line = len(lines)
        for next_node in tree.body[i+1:]:
            if hasattr(next_node, 'lineno'):
                next_line = next_node.lineno - 1
                break
        if next_line > start_line + 1:
            lines[start_line+1:next_line] = []
        changed = True

    return '\\n'.join(lines) if changed else code

if __name__ == "__main__":
    unittest.main()


test_main.py

Domine as habilidades necessárias para projetar, implementar e escalar motores de recomendação modernos e modelos de associação transacional. Progrida desde a análise de registros brutos de vendas no varejo utilizando princípios algorítmicos clássicos como Apriori e FP-Growth até a construção de sistemas avançados de personalização por meio de filtragem colaborativa e fatoração de matrizes. Aprenda a desenvolver pipelines de dados que alimentam camadas de descoberta em vitrines digitais modernas e impulsionam métricas de engajamento do usuário.

Descubra como identificar relações ocultas em grandes estruturas de dados transacionais. Aprenda os principais frameworks matemáticos utilizados por grandes varejistas para otimizar a disposição de prateleiras, estruturas de inventário e estratégias de agrupamento de produtos.

O que é uma característica latente no contexto de sistemas de recomendação?

Como o SVD auxilia na previsão de avaliações ausentes?

O que indica um erro quadrático médio baixo?

Qual métrica é melhor para avaliar a qualidade do ranqueamento?

Qual é o principal desafio da fatoração de matrizes em dados esparsos?

Como a redução de dimensionalidade pode melhorar a qualidade das recomendações?

Leve seu conhecimento algorítmico ao próximo nível ao lidar com grandes volumes de dados de transações corporativas sem travamentos de memória. Domine árvores comprimidas de alto desempenho e descubra como eliminar ruídos comerciais dos padrões de regras.

Adquira experiência prática na construção de mecanismos de recomendação que impulsionam as plataformas digitais modernas. Aprenda a ir além dos agrupamentos de produtos para mapear comportamentos históricos dos usuários, avaliações e hábitos de consumo compartilhados.

Aprofunde-se nos fundamentos matemáticos de modelos avançados de machine learning para conjuntos de dados esparsos. Aprenda a descobrir características latentes ocultas em dados multidimensionais de feedback de usuários para prever com precisão interações ausentes.

Desafio: Calculando Precisão Preditiva e Métricas de Ranqueamento

Solução