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

class TestTask(unittest.TestCase):
    def setUp(self):
        self.data = {
            'apple': [1, 0, 1, 0],
            'banana': [1, 1, 0, 0],
            'carrot': [0, 1, 1, 0],
            'donut': [0, 0, 1, 1],
        }
        self.user_item_matrix = pd.DataFrame(self.data, index=['alice', 'bob', 'carol', 'dave'])
        self.module_name = 'user_code'

    def test_returns_list(self):
        import user_code
        importlib.reload(user_code)
        result = user_code.recommend_products(self.user_item_matrix, 'bob', top_n=2)
        _dynamic_test(self, isinstance(result, list), "Function returns a list.", f"Expected list, got {type(result)}.")

    def test_recommendations_are_valid(self):
        import user_code
        importlib.reload(user_code)
        # Bob's vector: [0,1,1,0], most similar is Alice: [1,1,0,0]
        # Alice has apple (1), bob does not (0)
        result = user_code.recommend_products(self.user_item_matrix, 'bob', top_n=2)
        expected = ['apple']
        _dynamic_test(
            self,
            all(item in ['apple'] for item in result),
            "Recommendation is valid and contains only items the similar user has and target does not.",
            f"Recommendation contains unexpected items: {result}"
        )

    def test_top_n_limit(self):
        import user_code
        importlib.reload(user_code)
        # carol: [1,0,1,1], most similar user is alice: [1,1,0,0]
        # Alice has banana (1), carol does not (0)
        result = user_code.recommend_products(self.user_item_matrix, 'carol', top_n=1)
        _dynamic_test(
            self,
            isinstance(result, list) and len(result) <= 1 and (len(result) == 0 or result[0] == 'banana'),
            "Function respects top_n and returns correct recommendation for carol.",
            f"Expected ['banana'] or [], got {result}"
        )

    def test_no_similar_user(self):
        import user_code
        importlib.reload(user_code)
        # Add a new user with all zeros
        df = self.user_item_matrix.copy()
        df.loc['eve'] = [0, 0, 0, 0]
        result = user_code.recommend_products(df, 'eve', top_n=2)
        _dynamic_test(self, result == [], "Returns empty list if no similar user.", f"Expected [], got {result}")

    def test_no_new_items_to_recommend(self):
        import user_code
        importlib.reload(user_code)
        # Bob and dave: dave has only donut, bob has not. But similarity is zero with everyone except alice.
        # Add a user who has all the same items as alice
        df = self.user_item_matrix.copy()
        df.loc['erin'] = [1, 1, 0, 0]
        result = user_code.recommend_products(df, 'erin', top_n=2)
        _dynamic_test(
            self,
            result == [],
            "Returns empty list if most similar user has no new items to recommend.",
            f"Expected [], got {result}"
        )

    def test_handles_different_top_n(self):
        import user_code
        importlib.reload(user_code)
        # alice: [1,1,0,0], most similar user is bob: [0,1,1,0]
        # bob has carrot (1), alice does not (0)
        result = user_code.recommend_products(self.user_item_matrix, 'alice', top_n=5)
        _dynamic_test(
            self,
            result == ['carrot'],
            "Function returns all possible recommendations if top_n > available.",
            f"Expected ['carrot'], got {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.

Quelle est la principale différence entre le filtrage collaboratif basé sur l'utilisateur et celui basé sur l'article ?

**Quelle métrique est la plus adaptée pour mesurer la similarité entre les vecteurs de notes des utilisateurs ?**

Qu'est-ce que le problème du démarrage à froid ?

Comment le filtrage basé sur les articles améliore-t-il la scalabilité ?

Quand utiliser la corrélation de Pearson plutôt que la similarité cosinus ?

Qu'est-ce qu'un voisinage dans le filtrage collaboratif ?

É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 : Création d'un composant de filtrage collaboratif basé sur l'utilisateur

Solution