Zum Aufbau eines **Multilayer-Perzeptrons (MLP)** ist es hilfreich, eine `Perceptron`-Klasse zu definieren. Diese speichert eine Liste von `Layer`-Objekten, die das Netzwerk bilden:

```python
class Perceptron:
    def __init__(self, layers):
        self.layers = layers
```

Das MLP verwendet drei Werte:

* `input_size`: Anzahl der Eingabemerkmale;
* `hidden_size`: Anzahl der Neuronen in jeder versteckten Schicht;
* `output_size`: Anzahl der Neuronen in der Ausgabeschicht.

Das Modell besteht somit aus:

1. Einer **Eingabeschicht**;
2. **Zwei versteckten Schichten** (gleiche Neuronenzahl, ReLU);
3. Einer **Ausgabeschicht** (Sigmoid).

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 TestPerceptron(unittest.TestCase):

    @classmethod
    def setUpClass(cls):
        cls.user_code = importlib.import_module("user_code")
        np.random.seed(10)

        cls.input_size = 2
        cls.hidden_size = 3
        cls.output_size = 1

        cls.perceptron = cls.user_code.perceptron
        cls.layers = cls.perceptron.layers

    def test_layers_structure(self):
        _dynamic_test(
            self,
            len(self.layers) == 3,
            "Three layers are defined",
            "Incorrect number of layers defined",
        )

    def test_weights_shapes(self):
        shapes = [layer.weights.shape for layer in self.layers]
        expected = [
            (self.hidden_size, self.input_size),
            (self.hidden_size, self.hidden_size),
            (self.output_size, self.hidden_size),
        ]
        _dynamic_test(
            self,
            shapes == expected,
            "Weights shapes are correct",
            f"Weights shapes are incorrect: got {shapes}, expected {expected}",
        )

    def test_biases_shapes(self):
        shapes = [layer.biases.shape for layer in self.layers]
        expected = [
            (self.hidden_size, 1),
            (self.hidden_size, 1),
            (self.output_size, 1),
        ]
        _dynamic_test(
            self,
            shapes == expected,
            "Bias shapes are correct",
            "Bias shapes are incorrect",
        )

    def test_weights_range(self):
        all_in_range = all(
            np.all((layer.weights >= -1) & (layer.weights < 1)) for layer in self.layers
        )
        _dynamic_test(
            self,
            all_in_range,
            "All weights are within [-1, 1)",
            "Weights are outside expected range",
        )

    def test_biases_range(self):
        all_in_range = all(
            np.all((layer.biases >= -1) & (layer.biases < 1)) for layer in self.layers
        )
        _dynamic_test(
            self,
            all_in_range,
            "All biases are within [-1, 1)",
            "Biases are outside expected range",
        )

    def test_third_neuron_weights_second_hidden_layer(self):
        w_user = np.round(self.layers[1].weights[2], 2)
        np.random.seed(10)
        _ = np.random.uniform(-1, 1, (self.hidden_size, self.input_size))
        _ = np.random.uniform(-1, 1, (self.hidden_size, 1))
        ref_w = np.random.uniform(-1, 1, (self.hidden_size, self.hidden_size))
        np.round(ref_w[2], 2)
        _dynamic_test(
            self,
            np.allclose(w_user, np.round(ref_w[2], 2), atol=1e-6),
            "Weights of 3rd neuron in 2nd hidden layer are correct",
            "Weights of 3rd neuron in 2nd hidden layer are incorrect",
        )

    def test_output_layer_weights(self):
        w_user = np.round(self.layers[2].weights[0], 2)
        np.random.seed(10)
        # Hidden layer 1: weights + biases
        np.random.uniform(-1, 1, (self.hidden_size, self.input_size))
        np.random.uniform(-1, 1, (self.hidden_size, 1))
        # Hidden layer 2: weights + biases
        np.random.uniform(-1, 1, (self.hidden_size, self.hidden_size))
        np.random.uniform(-1, 1, (self.hidden_size, 1))
        # Output layer weights
        ref_w = np.random.uniform(-1, 1, (self.output_size, self.hidden_size))
        _dynamic_test(
            self,
            np.allclose(w_user, np.round(ref_w[0], 2), atol=1e-6),
            "Weights of output neuron are correct",
            "Weights of output neuron are incorrect",
        )


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


test_code.py

Neuronale Netze sind leistungsfähige Algorithmen, die von der Struktur des menschlichen Gehirns inspiriert sind und zur Lösung komplexer Machine-Learning-Probleme eingesetzt werden. Sie werden Ihr eigenes neuronales Netz von Grund auf erstellen, um dessen Funktionsweise zu verstehen. Nach diesem Kurs sind Sie in der Lage, neuronale Netze zur Lösung von Klassifikations- und Regressionsproblemen mit der scikit-learn-Bibliothek zu erstellen.

Zunächst besprechen wir, was ein neuronales Netzwerk ist und wie es funktioniert. Außerdem betrachten wir den Anwendungsbereich.

Als Nächstes werden wir versuchen, ein eigenes neuronales Netzwerk zu erstellen und beobachten, wie effizient es das Lernen bewältigt. Außerdem betrachten wir eine fertige Lösung aus der scikit-learn-Bibliothek.

Abschließend erhalten Sie zusätzliche nützliche Informationen darüber, wie Sie das passende Modell auswählen und welche Arten von neuronalen Netzen existieren. Zum Abschluss des Kurses wird Ihr erworbenes Wissen überprüft.

Herausforderung: Erstellung eines Perzeptrons

1. Initialisierung der Schichtparameter (`init`)

2. Implementierung der Vorwärtspropagation (`forward`)

3. Definition der MLP-Schichten

Lösung

Herausforderung: Erstellung eines Perzeptrons

1. Initialisierung der Schichtparameter (__init__)

2. Implementierung der Vorwärtspropagation (forward)

3. Definition der MLP-Schichten

Lösung

1. Initialisierung der Schichtparameter (`init`)

2. Implementierung der Vorwärtspropagation (`forward`)