Vid utvärdering av rekommendationssystem är det viktigt att mäta både hur exakt systemet förutspår användarpreferenser och hur väl det rangordnar rekommenderade objekt. **Prediktiva noggrannhetsmått** såsom medelkvadratiskt fel (MSE) kvantifierar den genomsnittliga kvadratiska skillnaden mellan förutsagda och faktiska betyg, vilket ger ett tydligt mått på modellens prestanda. **Rangordningsmått** å andra sidan bedömer hur effektivt systemet ordnar rekommendationer så att användarna sannolikt hittar de mest relevanta objekten högst upp i sina rekommendationslistor. Tillsammans ger dessa mått en heltäckande bild av en rekommendationsmotors styrkor och svagheter.


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

Behärska de färdigheter som krävs för att designa, implementera och skala moderna rekommendationsmotorer och transaktionsbaserade associationsmodeller. Gå från att analysera råa butikskvitton med klassiska algoritmiska principer som Apriori och FP-Growth till att bygga avancerade personaliseringssystem med hjälp av kollaborativ filtrering och matrisfaktorisering. Lär dig att konstruera datapipelines som driver moderna digitala butikslager och ökar användarengagemang.

Upptäck hur man hittar dolda samband inom massiva transaktionsdatabaser. Lär dig de grundläggande matematiska ramverken som detaljhandelsjättar använder för att optimera hyllplacering, lagerstrukturer och produktpaketeringsstrategier.

Vad är en latent egenskap i rekommendationssystem?

Hur hjälper SVD till att förutsäga saknade betyg?

Vad indikerar ett lågt medelkvadratiskt fel?

Vilken metrik är bäst för att utvärdera rankningskvalitet?

Vad är den största utmaningen med matrixfaktorisering på gles data?

Hur kan dimensionalitetsreduktion förbättra rekommendationskvaliteten?

Ta din algoritmiska kunskap till nästa nivå genom att hantera omfattande företagsdata utan minneskrascher. Behärska högpresterande komprimerade träd och upptäck hur du eliminerar kommersiellt brus från regelmönster.

Få praktisk erfarenhet av att bygga rekommendationsmotorer som driver moderna digitala plattformar. Lär dig att se bortom produktgrupperingar för att kartlägga historiska användarbeteenden, betyg och gemensamma konsumentvanor.

Fördjupa dig i de matematiska grunderna för avancerade maskininlärningsmodeller för glesa datamängder. Lär dig hur man identifierar latenta egenskaper som är dolda i multidimensionella användarfeedbackdata för att noggrant förutsäga saknade interaktioner.

Challenge: Beräkning av prediktiv noggrannhet och rankningsmått

Lösning