Summary  
This chapter covers implementing complete forward propagation in a multi-layer perceptron by iteratively passing inputs through each layer’s forward method to produce the final outputs.

General domain of usage  
Machine learning model inference

Du har allerede implementert fremoverpropagering for et enkelt lag i forrige kapittel. Nå er målet å implementere **fullstendig fremoverpropagering**, fra input til output.

For å implementere hele prosessen med fremoverpropagering, må du definere `forward()`-metoden i `Perceptron`-klassen. Denne metoden utfører fremoverpropagering **lag for lag** ved å kalle den respektive metoden for hvert lag:

```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 ...
```

Inputene går gjennom det første skjulte laget, hvor **hvert lags output fungerer som input til det neste**, helt til det siste laget produserer sluttresultatet.

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

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.

Fremoverpropagasjon

Løsning

Awesome!

Fremoverpropagasjon

Løsning