Per costruire un **percettrone multistrato (MLP)**, è utile definire una classe `Perceptron`. Questa memorizza una lista di oggetti `Layer` che costituiscono la rete:

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

L'MLP utilizzerà tre valori:

* `input_size`: numero di caratteristiche in ingresso;
* `hidden_size`: numero di neuroni in ciascun livello nascosto;
* `output_size`: numero di neuroni nel livello di uscita.

Quindi, il modello è composto da:

1. Un **livello di input**;
2. **Due livelli nascosti** (stesso numero di neuroni, ReLU);
3. Un **livello di output** (sigmoide).

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

Le reti neurali sono potenti algoritmi ispirati alla struttura del cervello umano, utilizzati per risolvere complessi problemi di machine learning. Costruirai una rete neurale da zero per comprenderne il funzionamento. Al termine di questo corso, sarai in grado di creare reti neurali per risolvere problemi di classificazione e regressione utilizzando la libreria scikit-learn.

Per prima cosa, discuteremo cosa sia una rete neurale e come funziona. Considereremo inoltre l'ambito delle sue applicazioni.

Successivamente, proveremo a costruire una nostra rete neurale e valuteremo quanto sia efficiente nell'apprendimento. Prenderemo inoltre in considerazione una soluzione già pronta dalla libreria scikit-learn.

Infine, forniremo alcune informazioni aggiuntive utili su come comprendere quale modello utilizzare e quali tipi di reti neurali esistono. Per completare il corso, verrà verificata la conoscenza acquisita.

Sfida: Creazione di un Percettrone

1. Inizializzazione dei parametri del layer (`init`)

2. Implementazione della propagazione in avanti (`forward`)

3. Definizione dei layer dell'MLP

Soluzione

Sfida: Creazione di un Percettrone

1. Inizializzazione dei parametri del layer (`init`)

2. Implementazione della propagazione in avanti (`forward`)

3. Definizione dei layer dell'MLP

Soluzione

Sfida: Creazione di un Percettrone

1. Inizializzazione dei parametri del layer (__init__)

2. Implementazione della propagazione in avanti (forward)

3. Definizione dei layer dell'MLP

Soluzione

Sfida: Creazione di un Percettrone

1. Inizializzazione dei parametri del layer (__init__)

2. Implementazione della propagazione in avanti (forward)

3. Definizione dei layer dell'MLP

Soluzione

1. Inizializzazione dei parametri del layer (`init`)

2. Implementazione della propagazione in avanti (`forward`)

1. Inizializzazione dei parametri del layer (`init`)

2. Implementazione della propagazione in avanti (`forward`)