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

Beheers de vaardigheden die nodig zijn om moderne aanbevelingssystemen en transactionele associatiemodellen te ontwerpen, implementeren en schalen. Ga van het analyseren van ruwe retailtransacties met klassieke algoritmische principes zoals Apriori en FP-Growth naar het bouwen van geavanceerde personalisatiesystemen via collaborative filtering en matrixfactorisatie. Leer hoe je datapijplijnen ontwikkelt die de ontdekking van moderne digitale winkelomgevingen aandrijven en gebruikersbetrokkenheidsstatistieken stimuleren.

Ontdek hoe verborgen relaties binnen enorme transactionele datastructuren kunnen worden gevonden. Leer de kern van wiskundige raamwerken die door retailreuzen worden gebruikt om schapindeling, voorraadstructuren en productbundelstrategieën te optimaliseren.

**Wat is het belangrijkste voordeel van FP-Growth ten opzichte van Apriori?**

Hoe comprimeert een FP-Tree transactiedata?

Wat is een gangbare methode om niet-bruikbare regels te filteren?

Welke maatstaf is het meest bruikbaar voor het identificeren van waardevolle productbundels?

Wanneer wordt Apriori onpraktisch voor grote datasets?

Wat is een redundante regel in associatieregelmijnbouw?

Breng je algoritmische kennis naar een hoger niveau door zware zakelijke transactiegegevens te verwerken zonder geheugenproblemen. Beheers hoogpresterende gecomprimeerde bomen en ontdek hoe commerciële ruis uit regelpatronen kan worden geëlimineerd.

Doe praktische ervaring op met het bouwen van aanbevelingssystemen die moderne digitale platforms aandrijven. Leer hoe u verder kunt kijken dan productgroeperingen om historische gebruikersgedragingen, beoordelingen en gedeelde consumentengewoonten in kaart te brengen.

Verdiep u in de wiskundige basisprincipes van geavanceerde machine learning-modellen voor schaarse datasets. Ontdek hoe latente kenmerken in multidimensionale gebruikersfeedbackgegevens kunnen worden blootgelegd om ontbrekende interacties nauwkeurig te voorspellen.

Uitdaging: Alle Frequente Items

Oplossing