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

Gå från hög-nivå bibliotek till flexibiliteten i PyTorch. Bemästra byggstenarna i djupinlärning genom att arbeta med tensorer, den centrala datastrukturen i PyTorch. Utforska automatisk differentiering med gradienter, implementera backpropagation och bygg kompletta neurala nätverk från grunden. Lär dig hantera verkliga datamängder och administrera hela träningscykeln – från viktinitialisering till modelevaluering.

Utmaning: Klassificering av Blommor

Lösning