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

Beherrschen Sie rekurrente neuronale Netze und deren fortgeschrittene Varianten wie LSTMs und GRUs mit PyTorch. Sammeln Sie praktische Erfahrungen in der Verarbeitung sequentieller Daten für praxisnahe Anwendungen. Setzen Sie diese leistungsstarken Modelle ein, um reale Herausforderungen in der Zeitreihenprognose und verschiedenen Aufgaben der natürlichen Sprachverarbeitung zu bewältigen.

Behandelt die Einschränkungen traditioneller neuronaler Netze bei sequenziellen Daten und führt in die Grundlagen von Rekurrenten Neuronalen Netzen ein. Erklärt die RNN-Architektur, Typen sowie die schrittweise Implementierung anhand grundlegender Beispiele und einer Programmieraufgabe.

Untersucht häufige Trainingsherausforderungen wie verschwindende und explodierende Gradienten. Stellt fortgeschrittene RNN-Varianten wie LSTM und GRU vor, hebt deren interne Mechanismen und Anwendungsfälle hervor und bietet praktische Implementierungsbeispiele für jede Variante.

Konzentriert sich auf die Verarbeitung und Prognose von Zeitreihendaten mithilfe von RNN-basierten Modellen. Beinhaltet das Laden von Daten, Vorverarbeitungstechniken, Modelltraining und Leistungsevaluierung, mit Schwerpunkt auf dem Vergleich von LSTM- und GRU-Architekturen.

Demonstriert die Anwendung von RNNs auf Aufgaben der Textklassifikation. Behandelt zentrale NLP-Konzepte, Methoden der Textkodierung, Schritte der Datenvorbereitung sowie den Aufbau eines LSTM-basierten Modells zur Sentimentvorhersage.

Herausforderung: Entwicklung eines LSTM für Sentiment-Analyse

Lösung

Awesome!

Herausforderung: Entwicklung eines LSTM für Sentiment-Analyse

Lösung

Awesome!