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

class TestTask(unittest.TestCase):
    def setUp(self):
        self.transactions = pd.DataFrame({
            "user_id": [1, 2, 1, 3, 2, 3, 4, 4, 1],
            "item_id": ["apple", "banana", "banana", "apple", "carrot", "carrot", "apple", "banana", "carrot"]
        })
        self.user_code = importlib.import_module("user_code")

    def test_returns_list_of_length_top_n(self):
        importlib.reload(self.user_code)
        result = self.user_code.customers_also_bought(self.transactions, "apple", top_n=2)
        _dynamic_test(
            self,
            isinstance(result, list) and len(result) == 2,
            "Returns a list of length equal to top_n.",
            f"Returned value is not a list of length 2: {result}"
        )

    def test_does_not_include_self(self):
        importlib.reload(self.user_code)
        result = self.user_code.customers_also_bought(self.transactions, "banana", top_n=2)
        _dynamic_test(
            self,
            "banana" not in result,
            "Does not include the provided item_id in recommendations.",
            f"Recommendations include the provided item_id: {result}"
        )

    def test_similarity_order(self):
        importlib.reload(self.user_code)
        # For 'banana', 'carrot' is most similar, then 'apple'
        result = self.user_code.customers_also_bought(self.transactions, "banana", top_n=2)
        expected_order = ["carrot", "apple"]
        _dynamic_test(
            self,
            result == expected_order,
            "Recommendations are based on highest cosine similarity.",
            f"Expected order {expected_order}, got {result}"
        )

    def test_multiple_occurrences(self):
        importlib.reload(self.user_code)
        # 'apple' appears multiple times; should still recommend correct items
        result = self.user_code.customers_also_bought(self.transactions, "apple", top_n=2)
        _dynamic_test(
            self,
            set(result) == {"banana", "carrot"},
            "Handles cases where the item appears multiple times.",
            f"Expected recommendations {{'banana', 'carrot'}}, got {result}"
        )

    def test_fewer_than_top_n(self):
        importlib.reload(self.user_code)
        # Only two items in this mini-dataset
        df = pd.DataFrame({"user_id": [1, 2, 1, 2], "item_id": ["x", "y", "y", "x"]})
        result = self.user_code.customers_also_bought(df, "x", top_n=5)
        _dynamic_test(
            self,
            isinstance(result, list) and len(result) == 1 and result[0] == "y",
            "Handles cases with fewer than top_n other items.",
            f"Expected ['y'], 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)

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

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 verschil tussen gebruikersgebaseerde en itemgebaseerde collaboratieve filtering?

**Welke maatstaf is het beste voor het meten van gelijkenis tussen gebruikersbeoordelingsvectoren?**

Hoe verbetert item-gebaseerde filtering de schaalbaarheid?

Wanneer zou je Pearson-correlatie gebruiken in plaats van cosinus-overeenkomst?

Wat is een buurt in collaboratieve filtering?

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: Het Genereren van Aanbevelingen voor Klanten Kocht Ook

Oplossing