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

Dive into advanced deep learning techniques for time series analysis. Learn to structure sequential data, design and implement RNN architectures as LSTM and GRU, and build ensemble models to forecast complex temporal patterns. This course focuses on leveraging computational intelligence to capture intricate dependencies and dynamics in time series data.

Explore advanced deep learning methods for time series forecasting, focusing on LSTM architectures, sequence modeling, and ensemble techniques.

Challenge: Implementing the Basic RNN

Solución