import unittest, ast, importlib.util, types
import torch
import torch.nn as nn

# ---------- tiny utils ----------
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)

def _load_user_source():
    spec = importlib.util.find_spec("user_code")
    if spec is None or not spec.origin:
        raise FileNotFoundError("Cannot locate user_code module file")
    with open(spec.origin, "r", encoding="utf-8") as f:
        return f.read()

def _extract_class(src, name):
    tree = ast.parse(src)
    for node in tree.body:
        if isinstance(node, ast.ClassDef) and node.name == name:
            return node
    return None

def _compile_class(class_node):
    mod = types.ModuleType("isolated_user_lstm")
    mod.torch = torch
    mod.nn = nn
    m = ast.Module(body=[class_node], type_ignores=[])
    ast.fix_missing_locations(m)
    code = compile(m, filename="<isolated>", mode="exec")
    exec(code, mod.__dict__)
    return mod

def _attr_chain(node):
    parts = []
    while isinstance(node, ast.Attribute):
        parts.append(node.attr)
        node = node.value
    if isinstance(node, ast.Name):
        parts.append(node.id)
    return ".".join(reversed(parts)) if parts else None

def _find_assign_calls(src, targets):
    tree = ast.parse(src)
    found = {}
    for node in ast.walk(tree):
        if isinstance(node, ast.Assign) and isinstance(node.value, ast.Call):
            callee = _attr_chain(node.value.func)
            for t in node.targets:
                if isinstance(t, ast.Name) and t.id in targets:
                    found[t.id] = callee
    return found

# ---------- tests ----------
class TestSentimentLSTM_NoImport(unittest.TestCase):

    def test_architecture_and_forward(self):
        reasons = []
        try:
            src = _load_user_source()
        except Exception as e:
            _dynamic(self, False, "", f"Cannot read user_code: {e}")
            return

        cls = _extract_class(src, "SentimentLSTM")
        if cls is None:
            _dynamic(self, False, "", "Class SentimentLSTM is not defined")
            return

        try:
            iso = _compile_class(cls)
            Model = getattr(iso, "SentimentLSTM")
            # Expected hyperparams from task
            vocab_size = 1000
            embedding_dim = 100
            hidden_size = 128
            num_layers = 1
            output_size = 1

            model = Model(vocab_size, embedding_dim, hidden_size, num_layers, output_size)

            # Layer checks
            emb = getattr(model, "embedding", None)
            lstm = getattr(model, "lstm", None)
            fc   = getattr(model, "fc", None)

            if not isinstance(emb, nn.Embedding):
                reasons.append("embedding layer must be nn.Embedding")
            else:
                if emb.num_embeddings != vocab_size:
                    reasons.append(f"embedding.num_embeddings {emb.num_embeddings} â  {vocab_size}")
                if emb.embedding_dim != embedding_dim:
                    reasons.append(f"embedding.embedding_dim {emb.embedding_dim} â  {embedding_dim}")

            if not isinstance(lstm, nn.LSTM):
                reasons.append("lstm layer must be nn.LSTM")
            else:
                if not getattr(lstm, "batch_first", False):
                    reasons.append("lstm must use batch_first=True")
                if lstm.input_size != embedding_dim:
                    reasons.append(f"lstm.input_size {lstm.input_size} â  {embedding_dim}")
                if lstm.hidden_size != hidden_size:
                    reasons.append(f"lstm.hidden_size {lstm.hidden_size} â  {hidden_size}")
                if lstm.num_layers != num_layers:
                    reasons.append(f"lstm.num_layers {lstm.num_layers} â  {num_layers}")

            if not (isinstance(fc, nn.Linear) and fc.in_features == hidden_size and fc.out_features == output_size):
                reasons.append("fc must be Linear(hidden_size â output_size)")

            # Forward shape on integer token IDs
            with torch.no_grad():
                X = torch.randint(0, vocab_size, (8, 50), dtype=torch.long)  # (batch, seq_len)
                logits = model(X)  # (batch, 1)
            if not (isinstance(logits, torch.Tensor) and logits.shape == (8, 1)):
                reasons.append(f"forward output shape {tuple(logits.shape)} â  (8, 1)")
        except Exception as e:
            reasons.append(f"forward failed: {e}")

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

    def test_loss_and_optimizer_ast(self):
        # AST-based check: BCEWithLogitsLoss and Adam must be declared
        try:
            src = _load_user_source()
        except Exception as e:
            _dynamic(self, False, "", f"Cannot read user_code: {e}")
            return

        assigns = _find_assign_calls(src, {"criterion", "optimizer"})
        reasons = []

        crit = assigns.get("criterion")
        opt  = assigns.get("optimizer")

        valid_crit = crit in {"nn.BCEWithLogitsLoss", "torch.nn.BCEWithLogitsLoss"}
        valid_opt  = opt in {"optim.Adam", "torch.optim.Adam"}

        if not valid_crit:
            reasons.append(f"criterion must be BCEWithLogitsLoss; found {crit!r}")
        if not valid_opt:
            reasons.append(f"optimizer must be Adam; found {opt!r}")

        _dynamic(self,
                 len(reasons) == 0,
                 "PASS: criterion & optimizer are declared (AST)",
                 "FAIL: " + "; ".join(reasons))


test_code.py

Padroneggia le reti neurali ricorrenti e le loro varianti avanzate come LSTM e GRU utilizzando PyTorch. Acquisisci esperienza pratica nell'elaborazione di dati sequenziali per applicazioni concrete. Applica questi potenti modelli per affrontare sfide reali nella previsione di serie temporali e in vari compiti di elaborazione del linguaggio naturale.

Tratta le limitazioni delle reti neurali tradizionali per i dati sequenziali e introduce i fondamenti delle Reti Neurali Ricorrenti. Spiega l'architettura delle RNN, le tipologie e l'implementazione passo dopo passo tramite esempi di base e una sfida di programmazione.

Esplora le comuni sfide di addestramento come la scomparsa e l'esplosione dei gradienti. Introduce varianti avanzate di RNN, tra cui LSTM e GRU, evidenziando i loro meccanismi interni e casi d'uso, con esempi pratici di implementazione per ciascuna.

Si concentra sull'elaborazione e la previsione di dati di serie temporali utilizzando modelli basati su RNN. Include caricamento dei dati, tecniche di preprocessamento, addestramento del modello e valutazione delle prestazioni, con enfasi sul confronto tra architetture LSTM e GRU.

Dimostra l'applicazione delle RNN ai compiti di classificazione del testo. Copre i concetti fondamentali di NLP, i metodi di codifica del testo, le fasi di preparazione dei dati e la costruzione di un modello basato su LSTM per la previsione del sentiment.

Sfida: Costruzione di una LSTM per l'Analisi del Sentiment

Soluzione

Awesome!

Sfida: Costruzione di una LSTM per l'Analisi del Sentiment

Soluzione