
import unittest
import user_code
import ast
import re   
import importlib
import csv
import unittest
import importlib

class TestTask(unittest.TestCase):
    def setUp(self):
        self.transactions = [
            ["milk", "bread", "butter"],
            ["bread", "butter"],
            ["milk", "bread"],
            ["milk", "eggs"],
            ["bread", "eggs"],
            ["milk", "bread", "butter", "eggs"]
        ]
        self.module = importlib.import_module("user_code")

    def test_support_milk_bread(self):
        importlib.reload(self.module)
        func = getattr(self.module, "calculate_association_metrics", None)
        _dynamic_test(
            self,
            callable(func),
            "Function calculate_association_metrics exists",
            "Function calculate_association_metrics does not exist or is not callable."
        )
        result = func(self.transactions, "milk", "bread")
        _dynamic_test(
            self,
            result is not None and isinstance(result, dict),
            "Function returns a dictionary result",
            f"Function did not return a dict: {result}"
        )
        expected_support = 3 / 6  # 3 transactions contain both milk and bread
        actual_support = result.get("support", -1)
        _dynamic_test(
            self,
            abs(actual_support - expected_support) < 1e-6,
            "Correct support for ('milk', 'bread')",
            f"Expected support {expected_support}, got {actual_support}"
        )

    def test_confidence_milk_bread(self):
        importlib.reload(self.module)
        func = getattr(self.module, "calculate_association_metrics", None)
        result = func(self.transactions, "milk", "bread")
        expected_confidence = 3 / 4  # 4 transactions contain milk; 3 of those also contain bread
        actual_confidence = result.get("confidence", -1)
        _dynamic_test(
            self,
            abs(actual_confidence - expected_confidence) < 1e-6,
            "Correct confidence for ('milk', 'bread')",
            f"Expected confidence {expected_confidence}, got {actual_confidence}"
        )

    def test_lift_milk_bread(self):
        importlib.reload(self.module)
        func = getattr(self.module, "calculate_association_metrics", None)
        result = func(self.transactions, "milk", "bread")
        support_b = 5 / 6  # bread appears in 5 transactions
        expected_confidence = 3 / 4
        expected_lift = expected_confidence / support_b
        actual_lift = result.get("lift", -1)
        _dynamic_test(
            self,
            abs(actual_lift - expected_lift) < 1e-6,
            "Correct lift for ('milk', 'bread')",
            f"Expected lift {expected_lift}, got {actual_lift}"
        )

    def test_support_bread_butter(self):
        importlib.reload(self.module)
        func = getattr(self.module, "calculate_association_metrics", None)
        result = func(self.transactions, "bread", "butter")
        expected_support = 3 / 6  # 3 transactions contain both bread and butter
        actual_support = result.get("support", -1)
        _dynamic_test(
            self,
            abs(actual_support - expected_support) < 1e-6,
            "Correct support for ('bread', 'butter')",
            f"Expected support {expected_support}, got {actual_support}"
        )

    def test_confidence_bread_butter(self):
        importlib.reload(self.module)
        func = getattr(self.module, "calculate_association_metrics", None)
        result = func(self.transactions, "bread", "butter")
        expected_confidence = 3 / 5  # bread in 5 transactions, 3 of those also butter
        actual_confidence = result.get("confidence", -1)
        _dynamic_test(
            self,
            abs(actual_confidence - expected_confidence) < 1e-6,
            "Correct confidence for ('bread', 'butter')",
            f"Expected confidence {expected_confidence}, got {actual_confidence}"
        )

    def test_lift_bread_butter(self):
        importlib.reload(self.module)
        func = getattr(self.module, "calculate_association_metrics", None)
        result = func(self.transactions, "bread", "butter")
        support_b = 3 / 6  # butter appears in 3 transactions
        expected_confidence = 3 / 5
        expected_lift = expected_confidence / support_b
        actual_lift = result.get("lift", -1)
        _dynamic_test(
            self,
            abs(actual_lift - expected_lift) < 1e-6,
            "Correct lift for ('bread', 'butter')",
            f"Expected lift {expected_lift}, got {actual_lift}"
        )

    def test_never_appear_together(self):
        importlib.reload(self.module)
        func = getattr(self.module, "calculate_association_metrics", None)
        result = func(self.transactions, "milk", "cheese")
        _dynamic_test(
            self,
            result is not None and isinstance(result, dict),
            "Function returns a dictionary result for never-appear-together case",
            f"Function did not return a dict: {result}"
        )
        _dynamic_test(
            self,
            result["support"] == 0,
            "Support is zero when items never appear together",
            f"Expected support 0, got {result['support']}"
        )
        _dynamic_test(
            self,
            result["confidence"] == 0,
            "Confidence is zero when items never appear together",
            f"Expected confidence 0, got {result['confidence']}"
        )

    def test_item_never_appears(self):
        importlib.reload(self.module)
        func = getattr(self.module, "calculate_association_metrics", None)
        result = func(self.transactions, "cheese", "butter")
        _dynamic_test(
            self,
            result is not None and isinstance(result, dict),
            "Function returns a dictionary result for never-appear-item case",
            f"Function did not return a dict: {result}"
        )
        _dynamic_test(
            self,
            result["support"] == 0,
            "Support is zero when item_a never appears",
            f"Expected support 0, got {result['support']}"
        )
        _dynamic_test(
            self,
            result["confidence"] == 0,
            "Confidence is zero when item_a never appears",
            f"Expected confidence 0, got {result['confidence']}"
        )
        _dynamic_test(
            self,
            result["lift"] == 0,
            "Lift is zero when item_a never appears",
            f"Expected lift 0, got {result['lift']}"
        )

    def test_both_items_never_appear(self):
        importlib.reload(self.module)
        func = getattr(self.module, "calculate_association_metrics", None)
        result = func(self.transactions, "apples", "oranges")
        _dynamic_test(
            self,
            result is not None and isinstance(result, dict),
            "Function returns a dictionary result for both items never appearing",
            f"Function did not return a dict: {result}"
        )
        _dynamic_test(
            self,
            result["support"] == 0,
            "Support is zero when both items never appear",
            f"Expected support 0, got {result['support']}"
        )
        _dynamic_test(
            self,
            result["confidence"] == 0,
            "Confidence is zero when both items never appear",
            f"Expected confidence 0, got {result['confidence']}"
        )
        _dynamic_test(
            self,
            result["lift"] == 0,
            "Lift is zero when both items never appear",
            f"Expected lift 0, got {result['lift']}"
        )

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.

Que représente la métrique de support dans la fouille de règles d'association ?

Quelle métrique mesure le mieux la force d'une règle au-delà du hasard ?

Dans une matrice panier d'achat, que représente généralement chaque ligne ?

Quel est le principal objectif de l'algorithme Apriori ?

Comment l'élagage améliore-t-il l'efficacité d'Apriori ?

Quelle métrique utiliseriez-vous pour identifier des règles à la fois fréquentes et fortes ?

É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.

Challenge: Calcul Manuel des Règles d'Association sur des Registres d'Exemple

Solution