
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

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é es una característica latente en el contexto de los sistemas de recomendación?

¿Cómo ayuda SVD a predecir valoraciones faltantes?

¿Qué indica un error cuadrático medio bajo?

¿Qué métrica es la mejor para evaluar la calidad del ranking?

¿Cuál es el principal desafío de la factorización de matrices en datos dispersos?

¿Cómo puede la reducción de dimensionalidad mejorar la calidad de las recomendaciones?

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.

Desafío: Cálculo de una SVD

Solución