import unittest
import numpy as np
import torch
import torch.nn as nn
import torch.optim as optim
import user_code  # Ð·Ð°Ð¿ÑÑÐºÐ°Ñ ÐºÐ¾Ð´ ÑÑÑÐ´ÐµÐ½ÑÐ° (Ñ Ð½ÑÐ¾Ð¼Ñ Ð²Ð¶Ðµ Ñ ÑÑÐµÐ½ÑÐ²Ð°Ð½Ð½Ñ)

def _dynamic(tc, ok, ok_msg, fail_msg):
    tc._testMethodName = ok_msg if ok else fail_msg
    (tc.assertTrue if ok else tc.fail)(tc._testMethodName)

DELTA = 1e-6
ACC_MIN = 0.65  # Ð½ÐµÐ²Ð¸ÑÐ¾ÐºÐ¸Ð¹ Ð¿Ð¾ÑÑÐ³, ÑÐ¾Ð± ÑÐ½Ð¸ÐºÐ½ÑÑÐ¸ ÑÐ»Ð°ÐºÑÐ²

class TestRNNChallengeCompact(unittest.TestCase):

    def test_standard_model_checks(self):
        reasons = []

        # 1) ÐÑÑÑÑÐµÐºÑÑÑÐ° Ð¼Ð¾Ð´ÐµÐ»Ñ
        model = getattr(user_code, "model", None)
        if not isinstance(model, nn.Module):
            reasons.append("model is not an nn.Module")

        input_size = getattr(user_code, "input_size", None)
        hidden_size = getattr(user_code, "hidden_size", None)
        num_layers = getattr(user_code, "num_layers", None)
        num_classes = getattr(user_code, "num_classes", None)

        rnn = getattr(model, "rnn", None)
        fc = getattr(model, "fc", None)
        if not (isinstance(rnn, nn.RNN) and getattr(rnn, "batch_first", False)):
            reasons.append("nn.RNN with batch_first=True not found")
        else:
            if not (rnn.input_size == input_size and rnn.hidden_size == hidden_size and rnn.num_layers == num_layers):
                reasons.append("RNN hyperparams mismatch")

        if not (isinstance(fc, nn.Linear) and fc.in_features == hidden_size and fc.out_features == num_classes):
            reasons.append("Linear layer (hidden_size -> num_classes) is incorrect")

        # 2) Forward: ÑÐ¾ÑÐ¼Ð° Ð²Ð¸ÑÐ¾Ð´Ñ (batch_size, num_classes)
        try:
            dl = getattr(user_code, "dataloader", None)
            x_batch, _ = next(iter(dl))
            with torch.no_grad():
                logits = model(x_batch)
            if not (isinstance(logits, torch.Tensor) and logits.shape == (x_batch.size(0), num_classes)):
                reasons.append(f"forward output shape expected {(x_batch.size(0), num_classes)}, got {tuple(logits.shape)}")
        except Exception as e:
            reasons.append(f"forward pass failed: {e}")

        _dynamic(self,
                 len(reasons) == 0,
                 "PASS: model & forward are correct",
                 "FAIL: " + "; ".join(reasons))

    def test_training_setup(self):
        reasons = []

        criterion = getattr(user_code, "criterion", None)
        optimizer = getattr(user_code, "optimizer", None)
        learning_rate = getattr(user_code, "learning_rate", None)

        if not isinstance(criterion, nn.CrossEntropyLoss):
            reasons.append("criterion must be nn.CrossEntropyLoss")

        if not isinstance(optimizer, optim.Adam):
            reasons.append("optimizer must be Adam")

        if isinstance(optimizer, optim.Optimizer):
            lr = optimizer.param_groups[0].get("lr", None)
            if not (learning_rate is not None and abs(lr - learning_rate) < 1e-12):
                reasons.append(f"optimizer lr expected {learning_rate}, got {lr}")

            # ÐÐµÑÐµÐ²ÑÑÐºÐ°, ÑÐ¾ Ð¿Ð°ÑÐ°Ð¼ÐµÑÑÐ¸ Ð¼Ð¾Ð´ÐµÐ»Ñ Ð²ÑÐµÑÐµÐ´Ð¸Ð½Ñ Ð¾Ð¿ÑÐ¸Ð¼ÑÐ·Ð°ÑÐ¾ÑÐ°
            model = getattr(user_code, "model", None)
            opt_param_ids = {id(p) for g in optimizer.param_groups for p in g["params"]}
            model_param_ids = {id(p) for p in model.parameters()} if isinstance(model, nn.Module) else set()
            if not (model_param_ids & opt_param_ids):
                reasons.append("optimizer does not contain model parameters")

        _dynamic(self,
                 len(reasons) == 0,
                 "PASS: training setup is correct",
                 "FAIL: " + "; ".join(reasons))

    def test_learning_outcome_vertex_and_accuracy(self):
        """
        ÐÐµÑÐµÐ²ÑÑÑÑ 2 Ð¿ÑÐ½ÐºÑÐ¸ Ð·Ð°Ð´Ð°ÑÑ:
        1) ÐÐ¾Ð´ÐµÐ»Ñ Ð½Ð°Ð²ÑÐ°ÑÑÑÑÑ (ÑÐ¾ÑÐ½ÑÑÑÑ Ð½Ð° Ð²ÑÑÐ¾Ð¼Ñ Ð´Ð°ÑÐ°ÑÐµÑÑ >= ACC_MIN).
        2) ÐÐ¾Ð³ÑÑÐ½Ð° ÐºÐ¾ÑÐµÐºÑÐ½ÑÑÑÑ: forward Ð´Ð°Ñ Ð²Ð°Ð»ÑÐ´Ð½Ñ logits Ð´Ð»Ñ ÐºÐ»Ð°ÑÐ¸ÑÑÐºÐ°ÑÑÑ (Ð¿ÐµÑÐµÐ²ÑÑÑÑÐ¼Ð¾ ÑÐµÑÐµÐ· ÑÐ°ÐºÑÐ¸ÑÐ½Ñ accuracy).
        """
        reasons = []

        # ÐÑÑÐ½ÐºÐ° Ð¼Ð¾Ð´ÐµÐ»Ñ Ð½Ð° Ð²ÑÑÐ¾Ð¼Ñ Ð´Ð°ÑÐ°ÑÐµÑÑ (Ð¿Ð¾Ð²ÑÐ¾ÑÐ½Ð¾, Ð½ÐµÐ·Ð°Ð»ÐµÐ¶Ð½Ð¾ Ð²ÑÐ´ Ð¿ÑÐ¸Ð½ÑÑÐ² ÑÑÑÐ´ÐµÐ½ÑÐ°)
        try:
            model = getattr(user_code, "model", None)
            dataset = getattr(user_code, "dataset", None)
            model.eval()
            with torch.no_grad():
                X, y = dataset[:]
                logits = model(X)
                preds = logits.argmax(dim=1)
                acc = (preds == y).float().mean().item()
        except Exception as e:
            reasons.append(f"evaluation failed: {e}")
            acc = 0.0

        if acc < ACC_MIN:
            reasons.append(f"accuracy {acc:.2f} < {ACC_MIN:.2f}")

        _dynamic(self,
                 len(reasons) == 0,
                 f"PASS: training OK, accuracy {acc:.2f}",
                 "FAIL: " + "; ".join(reasons))

test_code.py

Hallitse toistoverkot ja niiden kehittyneet variantit, kuten LSTM:t ja GRU:t, hyödyntäen PyTorchia. Kartoita käytännön osaamista jaksollisen datan käsittelyssä todellisia sovelluksia varten. Sovella näitä tehokkaita malleja ratkaistaksesi käytännön ongelmia aikasarjojen ennustamisessa ja erilaisissa luonnollisen kielen käsittelyn tehtävissä.

Kattaa perinteisten neuroverkkojen rajoitukset jaksollisen datan käsittelyssä ja esittelee toistuvien neuroverkkojen perusteet. Selittää RNN-arkkitehtuurin, tyypit sekä vaiheittaisen toteutuksen perusesimerkkien ja koodaushaasteen avulla.

Käsittelee yleisiä koulutushaasteita, kuten katoavia ja räjähtäviä gradientteja. Esittelee edistyneet RNN-muunnelmat, kuten LSTM ja GRU, korostaen niiden sisäisiä mekanismeja ja käyttötapauksia sekä tarjoaa käytännön toteutusesimerkkejä kustakin.

Keskittyy aikasarjadatan käsittelyyn ja ennustamiseen RNN-pohjaisilla malleilla. Sisältää datan latauksen, esikäsittelytekniikat, mallin koulutuksen ja suorituskyvyn arvioinnin, painottaen LSTM- ja GRU-arkkitehtuurien vertailua.

Esittelee RNN-mallien soveltamisen tekstiluokittelutehtäviin. Kattaa keskeiset NLP-käsitteet, tekstin koodausmenetelmät, aineiston esikäsittelyvaiheet sekä LSTM-pohjaisen mallin rakentamisen tunnelman ennustamiseen.

Haaste: Perus-RNN:n Toteuttaminen

Ratkaisu

Awesome!

Haaste: Perus-RNN:n Toteuttaminen

Ratkaisu

Awesome!