import unittest
import user_code
import importlib

class TestTask(unittest.TestCase):
    def setUp(self):
        import user_code
        importlib.reload(user_code)
        self.user_code = user_code

    def test_basic_frequency(self):
        transactions = [
            ['a', 'b', 'c'],
            ['b', 'c', 'd'],
            ['a', 'b', 'd'],
            ['a', 'c', 'd', 'e'],
            ['a', 'b', 'c', 'd']
        ]
        min_support = 3
        result = self.user_code.find_frequent_single_items(transactions, min_support)
        expected = [('a', 4), ('b', 4), ('c', 4), ('d', 4)]
        _dynamic_test(
            self,
            isinstance(result, list),
            "Returned value is a list",
            f"Returned value is not a list: {type(result)}"
        )
        _dynamic_test(
            self,
            all(isinstance(x, tuple) and len(x) == 2 for x in result),
            "Each element is a tuple (item, support)",
            f"Result contains non-tuple elements: {result}"
        )
        _dynamic_test(
            self,
            sorted(result) == sorted(expected),
            "Correct frequent items for min_support 3",
            f"Expected {expected}, got {result}"
        )

    def test_sorting(self):
        transactions = [
            ['x', 'y', 'z'],
            ['y', 'z'],
            ['x', 'y'],
            ['y'],
            ['x', 'y', 'z']
        ]
        min_support = 2
        result = self.user_code.find_frequent_single_items(transactions, min_support)
        expected = [('y', 5), ('x', 3), ('z', 3)]
        _dynamic_test(
            self,
            result == expected,
            "Items sorted by support desc, then lexicographically",
            f"Expected {expected}, got {result}"
        )

    def test_min_support(self):
        transactions = [
            ['a'],
            ['b'],
            ['c'],
            ['d'],
            ['e']
        ]
        min_support = 1
        result = self.user_code.find_frequent_single_items(transactions, min_support)
        expected = [('a', 1), ('b', 1), ('c', 1), ('d', 1), ('e', 1)]
        _dynamic_test(
            self,
            sorted(result) == sorted(expected),
            "All items returned when min_support is 1",
            f"Expected {expected}, got {result}"
        )

    def test_empty_result(self):
        transactions = [
            ['a', 'b'],
            ['b', 'c'],
            ['c', 'd']
        ]
        min_support = 5
        result = self.user_code.find_frequent_single_items(transactions, min_support)
        _dynamic_test(
            self,
            result == [],
            "Returns empty list if no items meet min_support",
            f"Expected empty list, got {result}"
        )

    def test_sample_dataset(self):
        transactions = [
            ['milk', 'bread', 'eggs'],
            ['bread', 'butter'],
            ['milk', 'bread', 'butter', 'eggs'],
            ['bread', 'eggs'],
            ['milk', 'bread', 'eggs'],
            ['butter', 'eggs'],
            ['milk', 'bread'],
            ['milk', 'eggs'],
            ['bread', 'butter'],
            ['milk', 'bread', 'eggs', 'butter']
        ]
        min_support = 3
        result = self.user_code.find_frequent_single_items(transactions, min_support)
        expected = [('bread', 8), ('eggs', 7), ('milk', 6), ('butter', 5)]
        _dynamic_test(
            self,
            result == expected,
            "Correct frequent items for sample dataset",
            f"Expected {expected}, 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)


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.

**Quel est l'avantage principal de FP-Growth par rapport à Apriori ?**

Comment un FP-Tree compresse-t-il les données transactionnelles ?

Quelle est une méthode courante pour filtrer les règles non pertinentes ?

Quelle mesure est la plus utile pour identifier des lots de produits à forte valeur ?

Quand l'algorithme Apriori devient-il impraticable pour les grands ensembles de données ?

Qu'est-ce qu'une règle redondante en fouille d'association ?

É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: Tous les Éléments Fréquents

Solution