Ved evaluering av anbefalingssystemer er det viktig å måle både hvor nøyaktig systemet forutsier brukerpreferanser og hvor godt det rangerer anbefalte elementer. **Prediktive nøyaktighetsmål** som gjennomsnittlig kvadrert feil (MSE) kvantifiserer den gjennomsnittlige kvadrerte forskjellen mellom predikerte og faktiske vurderinger, og gir et enkelt mål på modellens ytelse. **Rangeringsmål** vurderer derimot hvor effektivt systemet sorterer anbefalinger slik at brukerne sannsynligvis finner de mest relevante elementene øverst på anbefalingslisten. Samlet gir disse målene et helhetlig bilde av styrker og svakheter ved en anbefalingsmotor.


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 ferdighetene som trengs for å designe, implementere og skalere moderne anbefalingsmotorer og transaksjonelle assosiasjonsmodeller. Gå fra å analysere rå detaljhandelstransaksjoner ved hjelp av klassiske algoritmiske prinsipper som Apriori og FP-Growth til å bygge avanserte personaliseringssystemer via kollaborativ filtrering og matrisefaktorisering. Lær hvordan du kan utvikle datapipelines som driver moderne digitale butikkers oppdagelseslag og øker brukerengasjement.

Oppdag hvordan du kan finne skjulte sammenhenger i store transaksjonsdatastrukturer. Lær de grunnleggende matematiske rammeverkene som detaljhandelsgiganter bruker for å optimalisere hylleplassering, lagerstrukturer og produktpakkeringsstrategier.

Hva er en latent egenskap i konteksten av anbefalingssystemer?

Hvordan hjelper SVD med å forutsi manglende vurderinger?

Hva indikerer en lav gjennomsnittlig kvadrert feil?

Hvilket mål er best for å evaluere rangeringens kvalitet?

Hva er den største utfordringen med matrisefaktorisering på sparsomme data?

Hvordan kan dimensjonsreduksjon forbedre anbefalingskvaliteten?

Ta algoritmekunnskapen din til neste nivå ved å håndtere store mengder bedriftsdata uten minneproblemer. Bli ekspert på høyytelses komprimerte trær og lær hvordan du kan eliminere kommersiell støy fra regelmønstre.

Få praktisk erfaring med å bygge anbefalingsmotorer som driver moderne digitale plattformer. Lær hvordan du kan se forbi produktgrupperinger for å kartlegge historiske brukerhandlinger, vurderinger og delte forbrukervaner.

Fordyp deg i de matematiske grunnprinsippene for avanserte maskinlæringsmodeller for sparsomme datasett. Lær hvordan man avdekker latente egenskaper skjult i flerdimensjonale brukerresponsdata for å forutsi manglende interaksjoner med høy nøyaktighet.

Challenge: Beregning av prediktiv nøyaktighet og rangeringsmetrikker

Løsning