
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

Master the skills needed to design, implement, and scale modern recommendation engines and transactional association models. Go from analyzing raw retail checkouts using classic algorithmic principles like Apriori and FP-Growth to building advanced personalization systems via collaborative filtering and matrix factorization. Learn how to engineer data pipelines that power modern digital storefront discovery layers and drive user engagement metrics.

Discover how to find hidden relationships within massive transactional data structures. Learn the core mathematical frameworks retail giants use to optimize shelf placement, inventory structures, and product bundling strategies.

What is a latent feature in the context of recommendation systems?

How does SVD help in predicting missing ratings?

What does a low mean squared error indicate?

Which metric is best for evaluating ranking quality?

What is the main challenge of matrix factorization on sparse data?

How can dimensionality reduction improve recommendation quality?

Take your algorithmic knowledge to the next level by handling heavy corporate transaction data without memory crashes. Master high-performance compressed trees and discover how to eliminate commercial noise from rule patterns.

Get hands-on experience building the recommendation engines that power modern digital platforms. Learn how to look past product groupings to map historical user behaviors, ratings, and shared consumer habits.

Dive into the mathematical fundamentals of advanced machine learning models for sparse datasets. Learn how to uncover latent features hidden inside multi-dimensional user feedback data to accurately predict missing interactions.

Challenge: Computing an SVD

Solution