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

Hallitse taidot, joita tarvitaan nykyaikaisten suositusjärjestelmien ja transaktioihin perustuvien assosiaatiomallien suunnitteluun, toteutukseen ja skaalaamiseen. Siirry raakojen vähittäiskaupan ostotapahtumien analysoinnista klassisten algoritmisten periaatteiden, kuten Apriori- ja FP-Growth-algoritmien, avulla edistyneiden personointijärjestelmien rakentamiseen yhteistyösuodatuksen ja matriisihajotelman keinoin. Opi rakentamaan dataputkia, jotka mahdollistavat nykyaikaisten digitaalisten kauppapaikkojen löytökerrokset ja ohjaavat käyttäjien sitoutumismittareita.

Opi löytämään piilotettuja yhteyksiä laajoista transaktiotietorakenteista. Tutustu keskeisiin matemaattisiin viitekehyksiin, joita vähittäiskaupan jättiläiset käyttävät hyllyjen sijoittelun, varastorakenteiden ja tuotekimppujen optimointiin.

**Mikä on FP-Growthin ensisijainen etu Aprioriin verrattuna?**

Miten FP-Puu tiivistää transaktiodatan?

Mikä on yleinen tapa suodattaa hyödyttömät säännöt pois?

Mikä mittari on hyödyllisin arvokkaiden tuotekokonaisuuksien tunnistamiseen?

Milloin Apriori muuttuu epäkäytännölliseksi suurissa aineistoissa?

Mikä on redundantti sääntö assosiaatiolouhinnassa?

Vie algoritmiosaamisesi uudelle tasolle käsittelemällä suuria yritysten transaktiodatoja ilman muistiongelmia. Hallitse suorituskykyiset pakatut puut ja opi poistamaan kaupallinen kohina sääntökuvioista.

Saat käytännön kokemusta suositusmoottoreiden rakentamisesta, jotka ovat nykyaikaisten digitaalisten alustojen taustalla. Opit tarkastelemaan tuotekategorioiden ohi kartoittaaksesi historiallisia käyttäjätoimintoja, arvioita ja yhteisiä kulutustottumuksia.

Sukella harvalukuisten aineistojen edistyneiden koneoppimismallien matemaattisiin perusteisiin. Opi paljastamaan piilevät ominaisuudet moniulotteisesta käyttäjäpalautedatasta ennustaaksesi puuttuvat vuorovaikutukset tarkasti.

Challenge: Kaikki usein Esiintyvät Tuotteet

Ratkaisu