Zur Bewertung des zuvor erstellten Perzeptrons wird ein Datensatz mit **zwei Eingabemerkmalen** und **zwei unterschiedlichen Klassen** (`0` und `1`) verwendet:

Dieser Datensatz ist **ausgeglichen**, mit 500 Stichproben aus Klasse `1` und 500 Stichproben aus Klasse `0`. Daher ist **Genauigkeit** in diesem Fall ein ausreichendes Evaluationsmaß, das mit der Funktion `accuracy_score()` berechnet werden kann:

```python
accuracy_score(y_true, y_pred)
```

`y_true` steht für die tatsächlichen Labels, während `y_pred` die vorhergesagten Labels repräsentiert.

Der Datensatz ist in `perceptron.py` als zwei **NumPy-Arrays** gespeichert: `X` (Eingabemerkmale) und `y` (zugehörige Labels), sodass sie einfach importiert werden können. Diese Datei enthält außerdem `model`, die Instanz der zuvor erstellten `Perceptron`-Klasse.

import unittest
import importlib
import numpy as np


def _dynamic_test(test_case, condition, success_msg, failure_msg):
    if condition:
        test_case._testMethodName = success_msg
        test_case.assertTrue(True, success_msg)
    else:
        test_case._testMethodName = failure_msg
        test_case.fail(failure_msg)


class TestPerceptronEvaluation(unittest.TestCase):

    @classmethod
    def setUpClass(cls):
        cls.user_code = importlib.import_module("user_code")

        from sklearn.model_selection import train_test_split
        from sklearn.metrics import accuracy_score
        from perceptron import X, y, model

        cls.train_test_split = train_test_split
        cls.accuracy_score = accuracy_score
        cls.X = X
        cls.y = y
        cls.model = model

        cls.X_train, cls.X_test, cls.y_train, cls.y_test = cls.train_test_split(
            cls.X, cls.y, test_size=0.2, random_state=10
        )

    def test_split_ratio_and_shapes(self):
        user_vars = [v for v in dir(self.user_code) if v.startswith("X_") or v.startswith("y_")]
        has_train = any("train" in v for v in user_vars)
        has_test = any("test" in v for v in user_vars)
        _dynamic_test(
            self,
            has_train and has_test,
            "Dataset correctly split into train and test sets",
            "Train-test split variables not found (X_train/X_test/y_train/y_test)",
        )

        if hasattr(self.user_code, "X_train") and hasattr(self.user_code, "X_test"):
            n_train = len(self.user_code.X_train)
            n_test = len(self.user_code.X_test)
            total = n_train + n_test
            ratio = round(n_test / total, 1)
            _dynamic_test(
                self,
                abs(ratio - 0.2) < 0.05,
                "Test set ratio is approximately 20%",
                f"Test set ratio incorrect: {ratio*100:.1f}%",
            )

    def test_model_trained(self):
        # Save initial weights (copy)
        initial_weights = [layer.weights.copy() for layer in self.model.layers]

        # Fit model on a few iterations
        self.user_code.model.fit(self.X_train, self.y_train, epochs=1, learning_rate=0.05)

        # Compare with previous weights
        updated_weights = [layer.weights for layer in self.model.layers]
        changed = any(not np.allclose(w0, w1, atol=1e-12) for w0, w1 in zip(initial_weights, updated_weights))

        _dynamic_test(
            self,
            changed,
            "Model weights updated successfully during training",
            "Model weights did not update after training",
        )

    def test_predictions_type_and_shape(self):
        preds = getattr(self.user_code, "predictions", None)
        _dynamic_test(
            self,
            preds is not None and isinstance(preds, np.ndarray),
            "Predictions stored in a NumPy array",
            "Predictions variable missing or not a NumPy array",
        )

        if preds is not None:
            _dynamic_test(
                self,
                preds.ndim == 1 or preds.shape[1] == 1,
                "Predictions have correct shape",
                f"Predictions shape incorrect: {preds.shape}",
            )

    def test_accuracy_computation(self):
        from sklearn.metrics import accuracy_score
        preds_ref = np.array([self.user_code.model.forward(x)[0] for x in self.X_test])
        acc_ref = accuracy_score(self.y_test, np.round(preds_ref))
        _dynamic_test(
            self,
            0.5 <= acc_ref <= 1.0,
            "Accuracy computed successfully",
            f"Accuracy value unreasonable: {acc_ref}",
        )


if __name__ == "__main__":
    unittest.main(argv=["first-arg-is-ignored"], exit=False)


test_code.py

Konzentriert sich auf die mathematischen Grundlagen und Kernmechanismen von neuronalen Netzen. Vermittelt die Implementierung von Perzeptronen, Aktivierungsfunktionen, Vorwärts- und Rückwärtspropagation, Verlustberechnung und Gradientenabstieg von Grund auf mit Python und NumPy, ohne Verwendung von High-Level-Frameworks. Bietet praxisnahe Erfahrung und ein tiefes Verständnis für die Funktionsweise neuronaler Netze auf niedrigster Ebene.

Herausforderung: Bewertung des Perzeptrons

Lösung