För att bygga en **multilagerperceptron (MLP)** är det användbart att definiera en `Perceptron`-klass. Den lagrar en lista av `Layer`-objekt som utgör nätverket:

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

MLP:n kommer att använda tre värden:

* `input_size`: antal indatafunktioner;
* `hidden_size`: antal neuroner i varje dolt lager;
* `output_size`: antal neuroner i utdata-lagret.

Modellen består alltså av:

1. Ett **indatalager**;
2. **Två dolda lager** (samma antal neuroner, ReLU);
3. Ett **utdatalager** (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

Neurala nätverk är kraftfulla algoritmer inspirerade av den mänskliga hjärnans struktur som används för att lösa komplexa maskininlärningsproblem. Du kommer att bygga ett eget neuralt nätverk från grunden för att förstå hur det fungerar. Efter denna kurs kommer du att kunna skapa neurala nätverk för att lösa klassificerings- och regressionsproblem med hjälp av scikit-learn-biblioteket.

Först kommer vi att diskutera vad ett neuralt nätverk är och hur det fungerar. Vi kommer även att behandla dess användningsområden.

Därefter kommer vi att försöka bygga vårt eget neuronnätverk och se hur effektivt det klarar av inlärning. Vi kommer även att titta på en färdig lösning från scikit-learn-biblioteket.

Slutligen kommer vi att ge dig ytterligare användbar information om hur du kan förstå vilken modell som ska användas och vilka typer av neurala nätverk som finns. För att slutföra kursen kommer dina förvärvade kunskaper att testas.

Utmaning: Skapa en Perceptron

1. Initiera lagerparametrar (`init`)

2. Implementera framåtriktad propagiering (`forward`)

3. Definiera MLP-lagren

Lösning

Utmaning: Skapa en Perceptron

1. Initiera lagerparametrar (__init__)

2. Implementera framåtriktad propagiering (forward)

3. Definiera MLP-lagren

Lösning

1. Initiera lagerparametrar (`init`)

2. Implementera framåtriktad propagiering (`forward`)