
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

Beheers de vaardigheden die nodig zijn om moderne aanbevelingssystemen en transactionele associatiemodellen te ontwerpen, implementeren en schalen. Ga van het analyseren van ruwe retailtransacties met klassieke algoritmische principes zoals Apriori en FP-Growth naar het bouwen van geavanceerde personalisatiesystemen via collaborative filtering en matrixfactorisatie. Leer hoe je datapijplijnen ontwikkelt die de ontdekking van moderne digitale winkelomgevingen aandrijven en gebruikersbetrokkenheidsstatistieken stimuleren.

Ontdek hoe verborgen relaties binnen enorme transactionele datastructuren kunnen worden gevonden. Leer de kern van wiskundige raamwerken die door retailreuzen worden gebruikt om schapindeling, voorraadstructuren en productbundelstrategieën te optimaliseren.

Wat is een latente eigenschap in de context van aanbevelingssystemen?

Hoe helpt SVD bij het voorspellen van ontbrekende beoordelingen?

Wat geeft een lage gemiddelde kwadratische fout aan?

Welke maatstaf is het beste voor het evalueren van rangschikkingskwaliteit?

Wat is de grootste uitdaging van matrixfactorisatie bij sparse data?

Hoe kan dimensionaliteitsreductie de aanbevelingskwaliteit verbeteren?

Breng je algoritmische kennis naar een hoger niveau door zware zakelijke transactiegegevens te verwerken zonder geheugenproblemen. Beheers hoogpresterende gecomprimeerde bomen en ontdek hoe commerciële ruis uit regelpatronen kan worden geëlimineerd.

Doe praktische ervaring op met het bouwen van aanbevelingssystemen die moderne digitale platforms aandrijven. Leer hoe u verder kunt kijken dan productgroeperingen om historische gebruikersgedragingen, beoordelingen en gedeelde consumentengewoonten in kaart te brengen.

Verdiep u in de wiskundige basisprincipes van geavanceerde machine learning-modellen voor schaarse datasets. Ontdek hoe latente kenmerken in multidimensionale gebruikersfeedbackgegevens kunnen worden blootgelegd om ontbrekende interacties nauwkeurig te voorspellen.

Challenge: Het Berekenen van een SVD

Oplossing