Bij het evalueren van aanbevelingssystemen is het essentieel om zowel te meten hoe nauwkeurig het systeem gebruikersvoorkeuren voorspelt als hoe goed het aanbevolen items rangschikt. **Voorspellende nauwkeurigheidsmaten** zoals de mean squared error (MSE) kwantificeren het gemiddelde kwadraat van het verschil tussen voorspelde en werkelijke beoordelingen, wat een duidelijke maatstaf biedt voor de modelprestaties. **Rangschikkingsmaten** beoordelen daarentegen hoe effectief het systeem aanbevelingen ordent, zodat gebruikers de meest relevante items bovenaan hun aanbevelingslijsten vinden. Samen bieden deze maten een volledig beeld van de sterke en zwakke punten van een aanbevelingsengine.


import unittest
import user_code
import ast
import re   
import importlib
import csv
import unittest
import user_code
import importlib
import numpy as np

class TestTask(unittest.TestCase):

    def test_precision_at_3(self):
        import user_code
        importlib.reload(user_code)
        predicted = [2.5, 4.0, 3.5, 5.0, 1.0]
        actual = [3.0, 5.0, 2.0, 4.0, 1.0]
        result = user_code.evaluate_predictions(predicted, actual)
        _dynamic_test(
            self,
            result is not None and abs(result[1] - 2/3) < 1e-6,
            "Correct precision@3 for provided example.",
            f"Expected precision@3 0.666..., got {result[1] if result else result}",
        )

    def test_short_lists(self):
        import user_code
        importlib.reload(user_code)
        predicted = [3.0, 4.0]
        actual = [4.0, 2.0]
        result = user_code.evaluate_predictions(predicted, actual)
        # MSE = ((3-4)^2 + (4-2)^2)/2 = (1+4)/2 = 2.5
        # Precision@3: only 2 items, so overlap of top-2/3
        pred_indices = np.argsort(predicted)[::-1][:3]
        actual_indices = np.argsort(actual)[::-1][:3]
        overlap = len(set(pred_indices) & set(actual_indices))
        expected_precision = overlap/3
        _dynamic_test(
            self,
            result is not None and abs(result[0] - 2.5) < 1e-6,
            "Correct MSE for short lists.",
            f"Expected MSE 2.5, got {result[0] if result else result}",
        )
        _dynamic_test(
            self,
            abs(result[1] - expected_precision) < 1e-6,
            "Correct precision@3 for short lists.",
            f"Expected precision@3 {expected_precision}, got {result[1] if result else 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 een latente eigenschap in de context van aanbevelingssystemen?

Hoe helpt SVD bij het voorspellen van ontbrekende beoordelingen?

Wat geeft een lage gemiddelde kwadratische fout aan?

Welke maatstaf is het beste voor het evalueren van rangschikkingskwaliteit?

Wat is de grootste uitdaging van matrixfactorisatie bij sparse data?

Hoe kan dimensionaliteitsreductie de aanbevelingskwaliteit verbeteren?

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 Berekenen van Voorspellende Nauwkeurigheid en Rangschikkingsstatistieken

Oplossing