
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

Domina las habilidades necesarias para diseñar, implementar y escalar motores de recomendación modernos y modelos de asociación transaccional. Avanza desde el análisis de compras minoristas en bruto utilizando principios algorítmicos clásicos como Apriori y FP-Growth hasta la construcción de sistemas avanzados de personalización mediante filtrado colaborativo y factorización de matrices. Aprende a diseñar flujos de datos que impulsan las capas de descubrimiento de escaparates digitales modernos y mejoran los indicadores de participación de los usuarios.

Descubra cómo encontrar relaciones ocultas dentro de estructuras masivas de datos transaccionales. Aprenda los marcos matemáticos fundamentales que utilizan los grandes minoristas para optimizar la colocación en estanterías, las estructuras de inventario y las estrategias de agrupación de productos.

¿Qué representa la métrica de soporte en la minería de reglas de asociación?

¿Qué métrica mide mejor la fuerza de una regla más allá del azar?

En una matriz de cesta de mercado, ¿qué representa típicamente cada fila?

¿Cuál es el propósito principal del algoritmo Apriori?

¿Cómo mejora la eficiencia de Apriori la poda?

¿Qué métrica usaría para identificar reglas que sean tanto frecuentes como fuertes?

Lleva tu conocimiento algorítmico al siguiente nivel gestionando grandes volúmenes de datos transaccionales corporativos sin fallos de memoria. Domina árboles comprimidos de alto rendimiento y descubre cómo eliminar el ruido comercial de los patrones de reglas.

Adquiera experiencia práctica construyendo los motores de recomendación que impulsan las plataformas digitales modernas. Aprenda a ir más allá de los agrupamientos de productos para mapear comportamientos históricos de los usuarios, calificaciones y hábitos de consumo compartidos.

Sumérgete en los fundamentos matemáticos de modelos avanzados de aprendizaje automático para conjuntos de datos dispersos. Aprende a descubrir características latentes ocultas dentro de datos de retroalimentación de usuarios multidimensionales para predecir con precisión interacciones faltantes.

Challenge: Extracción de asociaciones básicas en el punto de venta utilizando mlxtend

Solución