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

Domina las redes neuronales recurrentes y sus variantes avanzadas como LSTMs y GRUs utilizando PyTorch. Adquiere experiencia práctica procesando datos secuenciales para aplicaciones reales. Aplica estos potentes modelos para abordar desafíos del mundo real en la predicción de series temporales y diversas tareas de procesamiento de lenguaje natural.

Aborda las limitaciones de las redes neuronales tradicionales para datos secuenciales e introduce los fundamentos de las Redes Neuronales Recurrentes. Explica la arquitectura de las RNN, sus tipos y la implementación paso a paso mediante ejemplos básicos y un desafío de codificación.

Explora desafíos comunes de entrenamiento como los gradientes desvanecientes y explosivos. Presenta variantes avanzadas de RNN, incluyendo LSTM y GRU, destacando sus mecanismos internos y casos de uso, con ejemplos prácticos de implementación para cada una.

Se centra en el procesamiento y la predicción de datos de series temporales utilizando modelos basados en RNN. Incluye carga de datos, técnicas de preprocesamiento, entrenamiento de modelos y evaluación del rendimiento, con énfasis en la comparación de las arquitecturas LSTM y GRU.

Demuestra la aplicación de RNN a tareas de clasificación de texto. Cubre conceptos fundamentales de PLN, métodos de codificación de texto, pasos de preparación de datos y construcción de un modelo basado en LSTM para la predicción de sentimientos.

Desafío: Implementación de la RNN Básica

Solución

Awesome!

Desafío: Implementación de la RNN Básica

Solución