import unittest
import torch
import torch.nn as nn
import torch.optim as optim
import importlib
import io
import sys
import pandas as pd
from sklearn.model_selection import train_test_split


def _dynamic(test, cond, success, fail):
    if cond:
        test._testMethodName = success
        test.assertTrue(True)
    else:
        test._testMethodName = fail
        test.fail(fail)


class TestUserNN(unittest.TestCase):

    @classmethod
    def setUpClass(cls):
        cls.df = pd.read_csv(
            "https://content-media-cdn.codefinity.com/courses/1dd2b0f6-6ec0-40e6-a570-ed0ac2209666/section_2/iris.csv"
        )
        cls.X = cls.df.drop(columns=["species"]).values
        cls.y = cls.df["species"].values

        cls.X_train_ref, cls.X_test_ref, cls.y_train_ref, cls.y_test_ref = train_test_split(
            cls.X, cls.y, test_size=0.2, random_state=42
        )

    # -------- train_test_split --------
    def test_train_test_split(self):
        import user_code
        cond = (
            (user_code.X_train.tolist() == self.X_train_ref.tolist())
            and (user_code.X_test.tolist() == self.X_test_ref.tolist())
            and (user_code.y_train.tolist() == self.y_train_ref.tolist())
            and (user_code.y_test.tolist() == self.y_test_ref.tolist())
        )
        _dynamic(
            self,
            cond,
            "Data successfully split with test_size=0.2 and random_state=42.",
            "Incorrect data split. Use train_test_split(..., test_size=0.2, random_state=42)."
        )

    # -------- tensor conversion --------
    def test_tensor_shapes_and_types(self):
        import user_code

        cond = (
            isinstance(user_code.X_train_tensor, torch.Tensor)
            and user_code.X_train_tensor.dtype == torch.float32
            and isinstance(user_code.X_test_tensor, torch.Tensor)
            and user_code.X_test_tensor.dtype == torch.float32
            and isinstance(user_code.y_train_tensor, torch.Tensor)
            and user_code.y_train_tensor.dtype == torch.long
            and isinstance(user_code.y_test_tensor, torch.Tensor)
            and user_code.y_test_tensor.dtype == torch.long
        )

        _dynamic(
            self,
            cond,
            "All tensors are correctly created with appropriate dtypes.",
            "Tensor types are incorrect. X_tensors must be float32, y_tensors must be long."
        )

    # -------- model class --------
    def test_model_defined(self):
        import user_code
        cond = hasattr(user_code, "IrisModel")
        _dynamic(
            self,
            cond,
            "IrisModel class is defined.",
            "IrisModel class is missing."
        )

    def test_model_structure(self):
        import user_code
        model = user_code.model
        cond = (
            isinstance(model.fc1, nn.Linear)
            and isinstance(model.fc2, nn.Linear)
            and model.fc1.in_features == self.X.shape[1]
            and model.fc1.out_features == 16
            and model.fc2.in_features == 16
            and model.fc2.out_features == len(self.df["species"].unique())
        )
        _dynamic(
            self,
            cond,
            "Model architecture is correct (fc1 -> ReLU -> fc2).",
            "Model layers are incorrect. Ensure fc1, fc2, and hidden_size=16 are used."
        )

    # -------- loss and optimizer --------
    def test_loss_and_optimizer(self):
        import user_code
        cond = (
            isinstance(user_code.criterion, nn.CrossEntropyLoss)
            and isinstance(user_code.optimizer, optim.Adam)
            and user_code.optimizer.param_groups[0]["lr"] == 0.01
        )
        _dynamic(
            self,
            cond,
            "Loss and optimizer correctly configured.",
            "Loss must be CrossEntropyLoss and optimizer must be Adam(lr=0.01)."
        )

    # -------- training loop --------
    def test_training_outputs(self):
        import user_code
        cond = hasattr(user_code, "y_pred") and hasattr(user_code, "loss")
        _dynamic(
            self,
            cond,
            "Training performed successfully (forward pass and loss computed).",
            "Missing training steps. Ensure predictions and loss are computed."
        )

    # -------- evaluation mode --------
    def test_eval_mode(self):
        import user_code
        cond = not user_code.model.training
        _dynamic(
            self,
            cond,
            "Model evaluation mode enabled.",
            "model.eval() must be called after training."
        )

    # -------- no_grad block --------
    def test_no_grad(self):
        import user_code
        cond = hasattr(user_code, "y_test_pred")
        _dynamic(
            self,
            cond,
            "Predictions on test data computed under no_grad().",
            "Missing inference. Ensure predictions are computed inside torch.no_grad()."
        )

    # -------- class label predictions --------
    def test_label_prediction(self):
        import user_code

        preds = user_code.y_test_pred
        labels = user_code.y_test_pred_labels

        cond = isinstance(labels, torch.Tensor) and labels.ndim == 1 and len(labels) == preds.shape[0]

        _dynamic(
            self,
            cond,
            "Predicted class labels computed correctly using argmax.",
            "Class label prediction incorrect. Use torch.argmax(y_test_pred, dim=1)."
        )

    # -------- printed output --------
    def test_print_output(self):
        import user_code

        buf = io.StringIO()
        sys.stdout = buf

        importlib.reload(user_code)
        sys.stdout = sys.__stdout__

        cond = len(buf.getvalue().strip()) > 0

        _dynamic(
            self,
            cond,
            "Training logs and test accuracy printed successfully.",
            "No output detected. Ensure you print loss during training and final accuracy."
        )


if __name__ == "__main__":
    unittest.main()


test_code.py

Der Übergang von High-Level-Bibliotheken zur Flexibilität von PyTorch. Beherrschung der Bausteine des Deep Learning durch die Arbeit mit Tensors, der zentralen Datenstruktur von PyTorch. Untersuchung der automatischen Differenzierung mit Gradienten, Implementierung der Backpropagation und Aufbau vollständiger neuronaler Netze von Grund auf. Umgang mit realen Datensätzen und Verwaltung des gesamten Trainingszyklus – von der Gewichtsinitalisierung bis zur Modellevaluierung.

Herausforderung: Klassifizierung von Blumen

Lösung