Ved evaluering af anbefalingssystemer er det afgørende at måle både, hvor præcist systemet forudsiger brugerpræferencer, og hvor godt det rangerer de anbefalede elementer. **Prædiktive nøjagtighedsmetrikker** såsom middel kvadreret fejl (MSE) kvantificerer den gennemsnitlige kvadrerede forskel mellem forudsagte og faktiske vurderinger, hvilket giver et enkelt mål for modellens ydeevne. **Rangeringsmetrikker** vurderer derimod, hvor effektivt systemet sorterer anbefalinger, så brugerne sandsynligvis finder de mest relevante elementer øverst på deres anbefalingslister. Samlet set giver disse metrikker et omfattende billede af en anbefalingsmotors styrker og svagheder.


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

Behersk de nødvendige færdigheder til at designe, implementere og skalere moderne anbefalingsmotorer og transaktionsbaserede associationsmodeller. Gå fra at analysere rå detailkøb ved hjælp af klassiske algoritmiske principper som Apriori og FP-Growth til at opbygge avancerede personaliseringssystemer via kollaborativ filtrering og matrixfaktorisering. Lær at udvikle datapipelines, der driver moderne digitale butiksfacader og øger brugerengagements-målinger.

Opdag, hvordan man finder skjulte relationer i massive transaktionsdatastrukturer. Lær de centrale matematiske rammer, som detailgiganter bruger til at optimere hyldeplacering, lagerstrukturer og produktbundlingsstrategier.

Hvad er en latent egenskab i konteksten af anbefalingssystemer?

Hvordan hjælper SVD med at forudsige manglende vurderinger?

Hvad indikerer en lav gennemsnitlig kvadreret fejl?

Hvilken metrik er bedst til at evaluere rangordningskvalitet?

Hvad er den største udfordring ved matrixfaktorisering på sparsomme data?

Hvordan kan dimensionalitetsreduktion forbedre anbefalingskvaliteten?

Tag din algoritmiske viden til næste niveau ved at håndtere store virksomhedstransaktionsdata uden hukommelsesnedbrud. Opnå ekspertise i højtydende komprimerede træer og lær, hvordan man eliminerer kommerciel støj fra regelmønstre.

Få praktisk erfaring med at opbygge anbefalingsmotorer, der driver moderne digitale platforme. Lær at se ud over produktgrupperinger for at kortlægge historiske brugeradfærd, vurderinger og delte forbrugsvaner.

Dyk ned i de matematiske grundprincipper for avancerede maskinlæringsmodeller til sparsomme datasæt. Lær, hvordan man afdækker latente egenskaber skjult i multidimensionelle brugerfeedbackdata for nøjagtigt at forudsige manglende interaktioner.

Challenge: Beregning af Prædiktiv Nøjagtighed og Rangeringsmetrikker

Løsning