Summary  
This chapter covers implementing complete forward propagation in a perceptron by defining a `forward()` method that iterates through each layer, passing each layer’s output as the next layer’s input to produce the final output.

General domain of usage  
Machine learning (neural network inference)

Hai già implementato la propagazione in avanti per un singolo strato nel capitolo precedente. Ora, l'obiettivo è implementare la **propagazione in avanti completa**, dagli input agli output.

Per implementare l'intero processo di propagazione in avanti, è necessario definire il metodo `forward()` nella classe `Perceptron`. Questo metodo esegue la propagazione in avanti **strato per strato** chiamando il metodo corrispondente per ciascuno strato:

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

    def forward(self, inputs):
        x = inputs
        for layer in ...:
            # Pass x layer by layer
            x = ...

        return ...
```

Gli input passano attraverso il primo strato nascosto, con **gli output di ciascuno strato che fungono da input per il successivo**, fino a raggiungere lo strato finale per produrre l'output finale.

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

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

        # Build perceptron as in the task
        cls.perceptron = cls.user_code.perceptron
        cls.inputs = [1, 0]

        # Compute user output
        cls.user_output = cls.perceptron.forward(cls.inputs)

        # Reference forward computation (deterministic)
        # Rebuild layers with same seed and logic from layers.py
        from layers import hidden_1, hidden_2, output_layer

        def forward_reference(inputs):
            x = inputs
            for layer in [hidden_1, hidden_2, output_layer]:
                x = layer.forward(x)
            return x

        cls.ref_output = forward_reference(cls.inputs)

    def test_output_type(self):
        _dynamic_test(
            self,
            isinstance(self.user_output, np.ndarray),
            "Output type is NumPy array",
            "Output type is incorrect (must be NumPy array)",
        )

    def test_output_shape(self):
        _dynamic_test(
            self,
            self.user_output.shape == (1, 1),
            "Output shape is correct (1, 1)",
            f"Output shape is incorrect: got {self.user_output.shape}",
        )

    def test_forward_result_value(self):
        _dynamic_test(
            self,
            np.allclose(self.user_output, self.ref_output, atol=1e-6),
            "Forward propagation output is correct",
            f"Forward propagation output is incorrect: got {self.user_output}, expected {self.ref_output}",
        )

    def test_output_range(self):
        val = float(self.user_output[0, 0])
        _dynamic_test(
            self,
            0 <= val <= 1,
            "Output is within (0, 1) as expected for sigmoid activation",
            f"Output value {val} is outside expected sigmoid range (0,1)",
        )

    def test_determinism(self):
        # Recompute again to ensure reproducibility
        np.random.seed(10)
        out2 = self.user_code.perceptron.forward(self.inputs)
        _dynamic_test(
            self,
            np.allclose(out2, self.user_output, atol=1e-6),
            "Forward pass is deterministic",
            "Forward pass produces inconsistent results between runs",
        )


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.

Propagazione in Avanti

Soluzione