Voor het bouwen van een **multilayer perceptron (MLP)** is het handig om een `Perceptron`-klasse te definiëren. Deze slaat een lijst van `Layer`-objecten op die het netwerk vormen:

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

De MLP gebruikt drie waarden:

* `input_size`: aantal invoerkenmerken;
* `hidden_size`: aantal neuronen in elke verborgen laag;
* `output_size`: aantal neuronen in de uitvoerlaag.

Het model bestaat dus uit:

1. Een **invoerlaag**;
2. **Twee verborgen lagen** (zelfde aantal neuronen, ReLU);
3. Een **uitvoerlaag** (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

Neurale netwerken zijn krachtige algoritmen geïnspireerd op de structuur van het menselijk brein en worden gebruikt om complexe machine learning-problemen op te lossen. Je bouwt je eigen neuraal netwerk vanaf nul om te begrijpen hoe het werkt. Na deze cursus ben je in staat om neurale netwerken te creëren voor het oplossen van classificatie- en regressieproblemen met behulp van de scikit-learn-bibliotheek.

Eerst bespreken we wat een neuraal netwerk is en hoe het werkt. Daarnaast behandelen we het toepassingsgebied ervan.

Vervolgens zullen we proberen ons eigen neuraal netwerk te bouwen en bekijken hoe efficiënt het leert. We zullen ook een kant-en-klare oplossing uit de scikit-learn-bibliotheek behandelen.

Tot slot geven we aanvullende nuttige informatie over hoe u kunt bepalen welk model u moet gebruiken en welke typen neurale netwerken er zijn. Ter afronding van de cursus wordt uw opgedane kennis getoetst.

Uitdaging: Een Perceptron Maken

1. Initialiseren van laagparameters (`init`)

2. Implementeren van forward propagatie (`forward`)

3. Definieer de MLP-lagen

Oplossing

Awesome!

Uitdaging: Een Perceptron Maken

1. Initialiseren van laagparameters (`init`)

2. Implementeren van forward propagatie (`forward`)

3. Definieer de MLP-lagen

Oplossing

Uitdaging: Een Perceptron Maken

1. Initialiseren van laagparameters (__init__)

2. Implementeren van forward propagatie (forward)

3. Definieer de MLP-lagen

Oplossing

Awesome!

Uitdaging: Een Perceptron Maken

1. Initialiseren van laagparameters (__init__)

2. Implementeren van forward propagatie (forward)

3. Definieer de MLP-lagen

Oplossing

1. Initialiseren van laagparameters (`init`)

2. Implementeren van forward propagatie (`forward`)

1. Initialiseren van laagparameters (`init`)

2. Implementeren van forward propagatie (`forward`)