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 implementeret fremadrettet propagiering for et enkelt lag i det forrige kapitel. Nu er målet at implementere **fuldstændig fremadrettet propagiering**, fra input til output.

For at implementere hele processen med fremadrettet propagiering skal du definere metoden `forward()` i klassen `Perceptron`. Denne metode udfører fremadrettet propagiering **lag for lag** ved at kalde den respektive metode 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 ...
```

Input passerer gennem det første skjulte lag, hvor **hvert lags output fungerer som input til det næste**, indtil det sidste lag nås for at producere det endelige output.

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

Neurale netværk er kraftfulde algoritmer inspireret af den menneskelige hjernes struktur, som anvendes til at løse komplekse maskinlæringsproblemer. Du vil konstruere dit eget neurale netværk fra bunden for at forstå dets funktion. Efter dette kursus vil du kunne oprette neurale netværk til løsning af klassifikations- og regressionsopgaver ved hjælp af scikit-learn-biblioteket.

Først vil vi diskutere, hvad et neuralt netværk er, og hvordan det fungerer. Vi vil også overveje anvendelsesområdet.

Herefter vil vi forsøge at opbygge vores eget neurale netværk og undersøge, hvor effektivt det håndterer læring. Vi vil også se på en færdig løsning fra scikit-learn-biblioteket.

Afslutningsvis vil vi give dig yderligere nyttig information om, hvordan du kan forstå, hvilken model der skal anvendes, samt hvilke typer neurale netværk der findes. For at afslutte kurset vil din tilegnede viden blive testet.

Fremadrettet Propagering

Løsning

Awesome!

Fremadrettet Propagering

Løsning