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

class TestTask(unittest.TestCase):
    def setUp(self):
        self.data = {
            'milk':   [1, 0, 0, 1, 1],
            'bread':  [1, 1, 0, 1, 0],
            'eggs':   [0, 1, 1, 1, 0],
            'butter': [0, 0, 1, 1, 1],
        }
        self.df = pd.DataFrame(self.data)
        self.user_code = importlib.import_module('user_code')

    def test_returns_dataframe(self):
        importlib.reload(self.user_code)
        result = self.user_code.extract_top_lift_rules(self.df, min_support=0.2, min_confidence=0.5, top_n=2)
        _dynamic_test(
            self,
            isinstance(result, pd.DataFrame),
            "Function returns a DataFrame.",
            f"Expected a DataFrame, got {type(result)}."
        )

    def test_confidence_filtering(self):
        importlib.reload(self.user_code)
        result = self.user_code.extract_top_lift_rules(self.df, min_support=0.2, min_confidence=0.8, top_n=5)
        if result is not None and not result.empty:
            all_conf = result['confidence'] >= 0.8
            _dynamic_test(
                self,
                all(all_conf),
                "All rules have confidence >= min_confidence.",
                f"Some rules have confidence below min_confidence: {result['confidence'].tolist()}"
            )
        else:
            _dynamic_test(
                self,
                True,
                "No rules found with high confidence, as expected.",
                "No rules found with high confidence, as expected."
            )

    def test_sorted_by_lift_descending(self):
        importlib.reload(self.user_code)
        result = self.user_code.extract_top_lift_rules(self.df, min_support=0.2, min_confidence=0.5, top_n=4)
        if result is not None and not result.empty:
            lifts = result['lift'].tolist()
            sorted_lifts = sorted(lifts, reverse=True)
            _dynamic_test(
                self,
                lifts == sorted_lifts,
                "Rules are sorted by lift in descending order.",
                f"Rules are not sorted by lift descending: {lifts}"
            )
        else:
            _dynamic_test(
                self,
                True,
                "No rules found to sort, as expected.",
                "No rules found to sort, as expected."
            )

    def test_top_n_rules(self):
        importlib.reload(self.user_code)
        result = self.user_code.extract_top_lift_rules(self.df, min_support=0.2, min_confidence=0.5, top_n=2)
        n_rows = result.shape[0] if result is not None else 0
        _dynamic_test(
            self,
            n_rows <= 2,
            "Returned at most top_n rules.",
            f"Returned more than top_n rules: {n_rows}"
        )

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: Extraction des Associations de Base lors du Passage en Caisse à l'Aide de mlxtend

Solution