Nella valutazione dei sistemi di raccomandazione, è fondamentale misurare sia l'accuratezza con cui il sistema prevede le preferenze degli utenti sia l'efficacia con cui ordina gli elementi raccomandati. **Le metriche di accuratezza predittiva**, come l'errore quadratico medio (MSE), quantificano la differenza quadratica media tra le valutazioni previste e quelle reali, fornendo una misura diretta delle prestazioni del modello. **Le metriche di ranking**, invece, valutano quanto efficacemente il sistema ordina le raccomandazioni affinché gli utenti trovino gli elementi più rilevanti nelle prime posizioni delle loro liste di raccomandazione. Insieme, queste metriche offrono una visione completa dei punti di forza e di debolezza di un motore di raccomandazione.


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

Acquisisci le competenze necessarie per progettare, implementare e scalare motori di raccomandazione moderni e modelli di associazione transazionale. Passa dall'analisi dei dati grezzi delle transazioni retail utilizzando principi algoritmici classici come Apriori e FP-Growth alla costruzione di sistemi avanzati di personalizzazione tramite collaborative filtering e fattorizzazione di matrici. Impara a progettare pipeline di dati che alimentano i livelli di scoperta dei moderni negozi digitali e incrementano le metriche di coinvolgimento degli utenti.

Scopri come individuare relazioni nascoste all'interno di strutture di dati transazionali di grandi dimensioni. Approfondisci i principali modelli matematici utilizzati dai grandi rivenditori per ottimizzare la disposizione degli scaffali, le strutture di inventario e le strategie di bundling dei prodotti.

Che cos'è una caratteristica latente nel contesto dei sistemi di raccomandazione?

In che modo la SVD aiuta a prevedere le valutazioni mancanti?

Cosa indica un errore quadratico medio basso?

Quale metrica è la migliore per valutare la qualità dell'ordinamento?

Qual è la principale sfida della fattorizzazione della matrice su dati sparsi?

In che modo la riduzione della dimensionalità può migliorare la qualità delle raccomandazioni?

Porta le tue conoscenze algoritmiche al livello successivo gestendo grandi quantità di dati transazionali aziendali senza problemi di memoria. Apprendi l'uso di alberi compressi ad alte prestazioni e scopri come eliminare il rumore commerciale dai pattern delle regole.

Acquisire esperienza pratica nella costruzione dei motori di raccomandazione che alimentano le moderne piattaforme digitali. Imparare a superare le semplici aggregazioni di prodotti per mappare i comportamenti storici degli utenti, le valutazioni e le abitudini di consumo condivise.

Approfondimento dei fondamenti matematici dei modelli avanzati di machine learning per dataset sparsi. Analisi delle caratteristiche latenti nascoste nei dati di feedback multidimensionali degli utenti per prevedere con precisione le interazioni mancanti.

Sfida: Calcolo dell'Accuratezza Predittiva e delle Metriche di Ranking

Soluzione