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

Master Recurrent neural networks and their advanced variants like LSTMs and GRUs using PyTorch. Gain hands-on experience processing sequential data for practical applications. Apply these powerful models to tackle real-world challenges in time series forecasting and various Natural language processing tasks.

Covers the limitations of traditional neural networks for sequential data and introduces the fundamentals of Recurrent Neural Networks. Explains RNN architecture, types, and step-by-step implementation through basic examples and a coding challenge.

Explores common training challenges such as vanishing and exploding gradients. Introduces advanced RNN variants including LSTM and GRU, highlighting their internal mechanisms and use cases, with practical implementation examples for each.

Focuses on processing and forecasting time series data using RNN-based models. Includes data loading, preprocessing techniques, model training, and performance evaluation, with emphasis on comparing LSTM and GRU architectures.

Demonstrates the application of RNNs to text classification tasks. Covers core NLP concepts, text encoding methods, data preparation steps, and construction of an LSTM-based model for sentiment prediction.

Challenge: Building an LSTM for Sentiment Analysis

解答