Summary  
This chapter covers implementing a `forward()` method that iterates through each layer in a Perceptron class, passing the output of one layer as the input to the next to compute the final result.

General domain of usage  
Neural network inference in machine learning

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

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

Inndataene går gjennom det første skjulte laget, hvor **hvert lags utdata fungerer som inndata for 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

Fokuserer på de matematiske grunnprinsippene og kjernemekanismene i nevrale nettverk. Lær hvordan man implementerer perseptroner, aktiveringsfunksjoner, fremover- og bakoverpropagering, tapsberegning og gradientnedstigning fra bunnen av ved bruk av Python og NumPy, uten å benytte høynivå-rammeverk. Oppnå praktisk, hands-on erfaring og dyp intuisjon for hvordan nevrale nettverk fungerer på det laveste nivået.

Fremoverpropagasjon

Løsning