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

class TestTask(unittest.TestCase):
    def setUp(self):
        self.data = {
            'apple': [1, 0, 1, 0],
            'banana': [1, 1, 0, 0],
            'carrot': [0, 1, 1, 0],
            'donut': [0, 0, 1, 1],
        }
        self.user_item_matrix = pd.DataFrame(self.data, index=['alice', 'bob', 'carol', 'dave'])
        self.module_name = 'user_code'

    def test_returns_list(self):
        import user_code
        importlib.reload(user_code)
        result = user_code.recommend_products(self.user_item_matrix, 'bob', top_n=2)
        _dynamic_test(self, isinstance(result, list), "Function returns a list.", f"Expected list, got {type(result)}.")

    def test_recommendations_are_valid(self):
        import user_code
        importlib.reload(user_code)
        # Bob's vector: [0,1,1,0], most similar is Alice: [1,1,0,0]
        # Alice has apple (1), bob does not (0)
        result = user_code.recommend_products(self.user_item_matrix, 'bob', top_n=2)
        expected = ['apple']
        _dynamic_test(
            self,
            all(item in ['apple'] for item in result),
            "Recommendation is valid and contains only items the similar user has and target does not.",
            f"Recommendation contains unexpected items: {result}"
        )

    def test_top_n_limit(self):
        import user_code
        importlib.reload(user_code)
        # carol: [1,0,1,1], most similar user is alice: [1,1,0,0]
        # Alice has banana (1), carol does not (0)
        result = user_code.recommend_products(self.user_item_matrix, 'carol', top_n=1)
        _dynamic_test(
            self,
            isinstance(result, list) and len(result) <= 1 and (len(result) == 0 or result[0] == 'banana'),
            "Function respects top_n and returns correct recommendation for carol.",
            f"Expected ['banana'] or [], got {result}"
        )

    def test_no_similar_user(self):
        import user_code
        importlib.reload(user_code)
        # Add a new user with all zeros
        df = self.user_item_matrix.copy()
        df.loc['eve'] = [0, 0, 0, 0]
        result = user_code.recommend_products(df, 'eve', top_n=2)
        _dynamic_test(self, result == [], "Returns empty list if no similar user.", f"Expected [], got {result}")

    def test_no_new_items_to_recommend(self):
        import user_code
        importlib.reload(user_code)
        # Bob and dave: dave has only donut, bob has not. But similarity is zero with everyone except alice.
        # Add a user who has all the same items as alice
        df = self.user_item_matrix.copy()
        df.loc['erin'] = [1, 1, 0, 0]
        result = user_code.recommend_products(df, 'erin', top_n=2)
        _dynamic_test(
            self,
            result == [],
            "Returns empty list if most similar user has no new items to recommend.",
            f"Expected [], got {result}"
        )

    def test_handles_different_top_n(self):
        import user_code
        importlib.reload(user_code)
        # alice: [1,1,0,0], most similar user is bob: [0,1,1,0]
        # bob has carrot (1), alice does not (0)
        result = user_code.recommend_products(self.user_item_matrix, 'alice', top_n=5)
        _dynamic_test(
            self,
            result == ['carrot'],
            "Function returns all possible recommendations if top_n > available.",
            f"Expected ['carrot'], got {result}"
        )

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

Hallitse taidot, joita tarvitaan nykyaikaisten suositusjärjestelmien ja transaktioihin perustuvien assosiaatiomallien suunnitteluun, toteutukseen ja skaalaamiseen. Siirry raakojen vähittäiskaupan ostotapahtumien analysoinnista klassisten algoritmisten periaatteiden, kuten Apriori- ja FP-Growth-algoritmien, avulla edistyneiden personointijärjestelmien rakentamiseen yhteistyösuodatuksen ja matriisihajotelman keinoin. Opi rakentamaan dataputkia, jotka mahdollistavat nykyaikaisten digitaalisten kauppapaikkojen löytökerrokset ja ohjaavat käyttäjien sitoutumismittareita.

Opi löytämään piilotettuja yhteyksiä laajoista transaktiotietorakenteista. Tutustu keskeisiin matemaattisiin viitekehyksiin, joita vähittäiskaupan jättiläiset käyttävät hyllyjen sijoittelun, varastorakenteiden ja tuotekimppujen optimointiin.

Mikä on tärkein ero käyttäjäpohjaisen ja kohdepohjaisen kollaboratiivisen suodatuksen välillä?

**Mikä mittari on paras käyttäjäarviovektorien samankaltaisuuden mittaamiseen?**

Mitä tarkoitetaan cold start -ongelmalla?

Miten tuotepohjainen suodatus parantaa skaalautuvuutta?

Milloin käyttäisit Pearsonin korrelaatiota kosinietäisyyden sijaan?

Mitä tarkoittaa naapurusto yhteistoiminnallisessa suodatuksessa?

Vie algoritmiosaamisesi uudelle tasolle käsittelemällä suuria yritysten transaktiodatoja ilman muistiongelmia. Hallitse suorituskykyiset pakatut puut ja opi poistamaan kaupallinen kohina sääntökuvioista.

Saat käytännön kokemusta suositusmoottoreiden rakentamisesta, jotka ovat nykyaikaisten digitaalisten alustojen taustalla. Opit tarkastelemaan tuotekategorioiden ohi kartoittaaksesi historiallisia käyttäjätoimintoja, arvioita ja yhteisiä kulutustottumuksia.

Sukella harvalukuisten aineistojen edistyneiden koneoppimismallien matemaattisiin perusteisiin. Opi paljastamaan piilevät ominaisuudet moniulotteisesta käyttäjäpalautedatasta ennustaaksesi puuttuvat vuorovaikutukset tarkasti.

Haaste: Käyttäjäpohjaisen kollaboratiivisen suodatuskomponentin rakentaminen

Ratkaisu