Lors de l'évaluation des systèmes de recommandation, il est essentiel de mesurer à la fois la précision des prédictions des préférences des utilisateurs et la qualité du classement des éléments recommandés. Les **mesures de précision prédictive** telles que l'erreur quadratique moyenne (MSE) quantifient la différence quadratique moyenne entre les notes prédites et réelles, offrant une mesure directe des performances du modèle. Les **mesures de classement**, quant à elles, évaluent l'efficacité avec laquelle le système ordonne les recommandations afin que les utilisateurs trouvent les éléments les plus pertinents en haut de leur liste de recommandations. Ensemble, ces mesures offrent une vue d'ensemble des points forts et des limites d'un moteur de recommandation.


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

Maîtrisez les compétences nécessaires pour concevoir, implémenter et mettre à l'échelle des moteurs de recommandation modernes et des modèles d'association transactionnelle. Passez de l'analyse des tickets de caisse bruts à l'aide de principes algorithmiques classiques comme Apriori et FP-Growth à la création de systèmes de personnalisation avancés via le filtrage collaboratif et la factorisation de matrices. Apprenez à concevoir des pipelines de données qui alimentent les couches de découverte des vitrines numériques modernes et stimulent les indicateurs d'engagement des utilisateurs.

Découvrez comment identifier des relations cachées au sein de vastes structures de données transactionnelles. Apprenez les cadres mathématiques fondamentaux utilisés par les géants du commerce de détail pour optimiser l'agencement des rayons, la gestion des stocks et les stratégies de regroupement de produits.

Qu'est-ce qu'une caractéristique latente dans le contexte des systèmes de recommandation ?

Comment la SVD aide-t-elle à prédire les évaluations manquantes ?

Que signifie une faible erreur quadratique moyenne ?

Quelle métrique est la meilleure pour évaluer la qualité du classement ?

Quel est le principal défi de la factorisation de matrice sur des données clairsemées ?

Comment la réduction de dimensionnalité peut-elle améliorer la qualité des recommandations ?

Élevez vos connaissances algorithmiques en gérant de volumineuses données transactionnelles d'entreprise sans plantage de mémoire. Maîtrise des arbres compressés haute performance et découverte des méthodes pour éliminer le bruit commercial des motifs de règles.

Acquérez une expérience pratique dans la création des moteurs de recommandation qui alimentent les plateformes numériques modernes. Apprenez à aller au-delà des regroupements de produits pour cartographier les comportements historiques des utilisateurs, les évaluations et les habitudes de consommation partagées.

Plongez dans les fondamentaux mathématiques des modèles avancés d'apprentissage automatique pour les ensembles de données clairsemés. Découvrez comment révéler les caractéristiques latentes cachées dans des données de rétroaction utilisateur multidimensionnelles afin de prédire avec précision les interactions manquantes.

Défi : Calcul de la Précision Prédictive et des Métriques de Classement

Solution