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

Erlernen Sie die grundlegenden und fortgeschrittenen Konzepte, die für eine effiziente Arbeit mit PyTorch erforderlich sind. Erhalten Sie ein fundiertes Verständnis von Tensoren, einschließlich deren Erstellung, Operationen und Umformung. Erkunden Sie die Grundlagen von Gradienten, Backpropagation und linearer Regression, bevor Sie sich mit der Handhabung von Datensätzen beschäftigen. Beherrschen Sie die Fähigkeiten, die zum Erstellen, Trainieren und Bewerten neuronaler Netzwerke notwendig sind.

Erkunden der Grundlagen von PyTorch mit Schwerpunkt auf Tensors – der zentralen Datenstruktur für Berechnungen. Vermittlung von Tensor-Erstellung, zufälliger Initialisierung, mathematischen Operationen und Formmanipulation.

Erkunden zentraler Konzepte für das Trainieren von Modellen in PyTorch, einschließlich der Berechnung von Gradienten und der Durchführung mehrstufiger Backpropagation. Vertiefung der linearen Regression als grundlegendes Machine-Learning-Modell sowie Einführung in die effiziente Handhabung von Datensätzen.

Erfahren Sie, wie neuronale Netzwerke mit PyTorch erstellt, trainiert und bewertet werden. Sie lernen, wie ein einfaches Feedforward-Neuronales Netzwerk definiert, seine Parameter durch Training optimiert und seine Leistung bewertet wird.

Herausforderung: Klassifizierung von Blumen

Lösung

Awesome!

Herausforderung: Klassifizierung von Blumen

Lösung