
import unittest
import user_code
import ast
import re   
import importlib
import csv
import unittest
import importlib
import numpy as np

class TestTask(unittest.TestCase):
    def setUp(self):
        import user_code
        self.user_code = user_code
        self.ratings_matrix = np.array([
            [5, 3, 0, 1],
            [4, 0, 0, 1],
            [1, 1, 0, 5],
            [1, 0, 0, 4],
            [0, 1, 5, 4],
        ])

    def test_output_shape(self):
        # Check output shape matches input
        approx = self.user_code.compute_svd_recommendation(self.ratings_matrix, k=2)
        _dynamic_test(
            self,
            approx.shape == self.ratings_matrix.shape,
            "Reconstructed matrix has correct shape",
            f"Expected shape {self.ratings_matrix.shape}, got {approx.shape}"
        )

    def test_rank2_approximation(self):
        # Check that the approximation is close to the original for k=2
        approx = self.user_code.compute_svd_recommendation(self.ratings_matrix, k=2)
        # Should not be exactly same, but should be close for observed values
        observed = self.ratings_matrix != 0
        diff = np.abs(self.ratings_matrix[observed] - approx[observed])
        _dynamic_test(
            self,
            np.all(diff < 2.5),
            "Approximation is reasonably close to original observed ratings",
            f"Differences too large in reconstructed values: {diff}"
        )

    def test_k1_approximation(self):
        # For k=1, the approximation should be lower rank and less accurate
        approx_k1 = self.user_code.compute_svd_recommendation(self.ratings_matrix, k=1)
        approx_k2 = self.user_code.compute_svd_recommendation(self.ratings_matrix, k=2)
        mse_k1 = np.mean((self.ratings_matrix - approx_k1)**2)
        mse_k2 = np.mean((self.ratings_matrix - approx_k2)**2)
        _dynamic_test(
            self,
            mse_k2 < mse_k1,
            "Rank-2 approximation is more accurate than rank-1",
            f"Expected MSE for k=2 ({mse_k2}) < MSE for k=1 ({mse_k1})"
        )

    def test_zero_k(self):
        # For k=0, should return a zero matrix
        approx = self.user_code.compute_svd_recommendation(self.ratings_matrix, k=0)
        _dynamic_test(
            self,
            np.allclose(approx, 0),
            "k=0 returns a zero matrix",
            f"Expected all zeros for k=0, got {approx}"
        )

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 di una SVD

Soluzione