Bei der Bewertung von Empfehlungssystemen ist es entscheidend, sowohl die Genauigkeit der Vorhersage von Nutzerpräferenzen als auch die Qualität der Rangfolge der empfohlenen Artikel zu messen. **Vorhersagegenauigkeitsmetriken** wie der mittlere quadratische Fehler (MSE) quantifizieren den durchschnittlichen quadrierten Unterschied zwischen vorhergesagten und tatsächlichen Bewertungen und bieten eine einfache Messgröße für die Modellleistung. **Ranking-Metriken** hingegen bewerten, wie effektiv das System Empfehlungen so anordnet, dass Nutzer die relevantesten Artikel möglichst weit oben in ihren Empfehlungslisten finden. Zusammen bieten diese Metriken einen umfassenden Überblick über die Stärken und Schwächen einer Empfehlungsmaschine.


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

Beherrschen Sie die Fähigkeiten, die erforderlich sind, um moderne Empfehlungssysteme und transaktionale Assoziationsmodelle zu entwerfen, zu implementieren und zu skalieren. Analysieren Sie Rohdaten aus Einzelhandels-Transaktionen mit klassischen algorithmischen Prinzipien wie Apriori und FP-Growth und entwickeln Sie fortschrittliche Personalisierungssysteme mittels kollaborativem Filtern und Matrixfaktorisierung. Lernen Sie, wie man Datenpipelines entwickelt, die moderne digitale Storefront-Entdeckungsschichten antreiben und Nutzerbindungsmetriken verbessern.

Entdecken Sie, wie verborgene Zusammenhänge in umfangreichen transaktionalen Datenstrukturen aufgedeckt werden können. Lernen Sie die grundlegenden mathematischen Rahmenwerke kennen, die von Einzelhandelsriesen zur Optimierung der Regalplatzierung, der Lagerstrukturen und der Produktbündelungsstrategien verwendet werden.

Was ist ein latentes Merkmal im Kontext von Empfehlungssystemen?

Wie hilft SVD bei der Vorhersage fehlender Bewertungen?

Was zeigt ein niedriger mittlerer quadratischer Fehler an?

Welches Maß eignet sich am besten zur Bewertung der Rangfolgequalität?

Was ist die größte Herausforderung der Matrixfaktorisierung bei spärlichen Daten?

Wie kann Dimensionsreduktion die Empfehlungsqualität verbessern?

Bringen Sie Ihr algorithmisches Wissen auf die nächste Stufe, indem Sie umfangreiche Unternehmens-Transaktionsdaten ohne Speicherabstürze verarbeiten. Beherrschen Sie hochleistungsfähige komprimierte Bäume und entdecken Sie Methoden zur Eliminierung von kommerziellem Rauschen aus Regelmustern.

Sammeln Sie praktische Erfahrungen beim Aufbau von Empfehlungssystemen, die moderne digitale Plattformen antreiben. Lernen Sie, über Produktgruppierungen hinauszublicken, um historische Nutzerverhalten, Bewertungen und gemeinsame Konsumgewohnheiten abzubilden.

Tauchen Sie ein in die mathematischen Grundlagen fortgeschrittener Machine-Learning-Modelle für spärliche Datensätze. Erfahren Sie, wie latente Merkmale in mehrdimensionalen Benutzerfeedback-Daten aufgedeckt werden können, um fehlende Interaktionen präzise vorherzusagen.

Herausforderung: Berechnung von Vorhersagegenauigkeit und Ranking-Metriken

Lösung