
import unittest
import user_code
import ast
import re   
import importlib
import csv
import unittest
import pandas as pd
import importlib

class TestTask(unittest.TestCase):
    def setUp(self):
        self.data = {
            'milk':   [1, 0, 0, 1, 1],
            'bread':  [1, 1, 0, 1, 0],
            'eggs':   [0, 1, 1, 1, 0],
            'butter': [0, 0, 1, 1, 1],
        }
        self.df = pd.DataFrame(self.data)
        self.user_code = importlib.import_module('user_code')

    def test_returns_dataframe(self):
        importlib.reload(self.user_code)
        result = self.user_code.extract_top_lift_rules(self.df, min_support=0.2, min_confidence=0.5, top_n=2)
        _dynamic_test(
            self,
            isinstance(result, pd.DataFrame),
            "Function returns a DataFrame.",
            f"Expected a DataFrame, got {type(result)}."
        )

    def test_confidence_filtering(self):
        importlib.reload(self.user_code)
        result = self.user_code.extract_top_lift_rules(self.df, min_support=0.2, min_confidence=0.8, top_n=5)
        if result is not None and not result.empty:
            all_conf = result['confidence'] >= 0.8
            _dynamic_test(
                self,
                all(all_conf),
                "All rules have confidence >= min_confidence.",
                f"Some rules have confidence below min_confidence: {result['confidence'].tolist()}"
            )
        else:
            _dynamic_test(
                self,
                True,
                "No rules found with high confidence, as expected.",
                "No rules found with high confidence, as expected."
            )

    def test_sorted_by_lift_descending(self):
        importlib.reload(self.user_code)
        result = self.user_code.extract_top_lift_rules(self.df, min_support=0.2, min_confidence=0.5, top_n=4)
        if result is not None and not result.empty:
            lifts = result['lift'].tolist()
            sorted_lifts = sorted(lifts, reverse=True)
            _dynamic_test(
                self,
                lifts == sorted_lifts,
                "Rules are sorted by lift in descending order.",
                f"Rules are not sorted by lift descending: {lifts}"
            )
        else:
            _dynamic_test(
                self,
                True,
                "No rules found to sort, as expected.",
                "No rules found to sort, as expected."
            )

    def test_top_n_rules(self):
        importlib.reload(self.user_code)
        result = self.user_code.extract_top_lift_rules(self.df, min_support=0.2, min_confidence=0.5, top_n=2)
        n_rows = result.shape[0] if result is not None else 0
        _dynamic_test(
            self,
            n_rows <= 2,
            "Returned at most top_n rules.",
            f"Returned more than top_n rules: {n_rows}"
        )

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.

Cosa rappresenta la metrica di supporto nell'analisi delle regole di associazione?

Quale metrica misura meglio la forza di una regola oltre la casualità?

In una matrice market basket, cosa rappresenta tipicamente ogni riga?

Qual è lo scopo principale dell'algoritmo Apriori?

In che modo la potatura migliora l'efficienza di Apriori?

Quale metrica useresti per identificare regole che siano sia frequenti che forti?

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: Estrazione delle associazioni di base alla cassa utilizzando mlxtend

Soluzione