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

Konzentriert sich ausschließlich auf Rekurrente Neuronale Netze (RNNs) und deren Anwendung zur Sequenzgenerierung. Dieses fortgeschrittene Modul behandelt die grundlegende Theorie der RNNs sowie praxisorientierte Ansätze zur Modellierung sequentieller Daten und bereitet Sie auf die praktische Arbeit mit LSTM- und GRU-Netzen in Python vor.

Herausforderung: Implementierung des Grundlegenden RNN

Lösung