For å bygge en **multilags perseptron (MLP)**, er det hensiktsmessig å definere en `Perceptron`-klasse. Den lagrer en liste med `Layer`-objekter som utgjør nettverket:

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

MLP-en vil bruke tre verdier:

* `input_size`: antall input-funksjoner;
* `hidden_size`: antall nevroner i hvert skjult lag;
* `output_size`: antall nevroner i utgangslaget.

Modellen består dermed av:

1. Et **input-lag**;
2. **To skjulte lag** (samme antall nevroner, ReLU);
3. Et **utgangslag** (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

Nevrale nettverk er kraftige algoritmer inspirert av strukturen til den menneskelige hjernen, og brukes til å løse komplekse maskinlæringsproblemer. Du vil bygge ditt eget nevrale nettverk fra bunnen av for å forstå hvordan det fungerer. Etter dette kurset vil du kunne lage nevrale nettverk for å løse klassifikasjons- og regresjonsproblemer ved hjelp av scikit-learn-biblioteket.

Først skal vi diskutere hva et nevralt nettverk er og hvordan det fungerer. Vi vil også vurdere anvendelsesområdet.

Deretter skal vi forsøke å bygge vårt eget nevrale nettverk og se hvor effektivt det håndterer læring. Vi vil også vurdere en ferdig løsning fra scikit-learn-biblioteket.

Til slutt vil vi gi deg tilleggsinformasjon om hvordan du kan forstå hvilken modell som bør brukes og hvilke typer nevrale nettverk som finnes. For å fullføre kurset vil du bli testet på den tilegnede kunnskapen din.

Utfordring: Lage en Perseptron

1. Initialiser lagparametere (`init`)

2. Implementer fremoverpropagering (`forward`)

3. Definer MLP-lagene

Løsning

Awesome!

Utfordring: Lage en Perseptron

1. Initialiser lagparametere (`init`)

2. Implementer fremoverpropagering (`forward`)

3. Definer MLP-lagene

Løsning

Utfordring: Lage en Perseptron

1. Initialiser lagparametere (__init__)

2. Implementer fremoverpropagering (forward)

3. Definer MLP-lagene

Løsning

Awesome!

Utfordring: Lage en Perseptron

1. Initialiser lagparametere (__init__)

2. Implementer fremoverpropagering (forward)

3. Definer MLP-lagene

Løsning

1. Initialiser lagparametere (`init`)

2. Implementer fremoverpropagering (`forward`)

1. Initialiser lagparametere (`init`)

2. Implementer fremoverpropagering (`forward`)