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

Sie haben die Vorwärtsausbreitung für eine einzelne Schicht bereits im vorherigen Kapitel implementiert. Nun besteht das Ziel darin, die **vollständige Vorwärtsausbreitung** von den Eingaben bis zu den Ausgaben zu implementieren.

Um den gesamten Vorwärtsausbreitungsprozess zu implementieren, muss die Methode `forward()` in der Klasse `Perceptron` definiert werden. Diese Methode führt die Vorwärtsausbreitung **Schicht für Schicht** durch, indem sie die jeweilige Methode für jede Schicht aufruft:

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

Die Eingaben durchlaufen die erste versteckte Schicht, wobei **die Ausgaben jeder Schicht als Eingaben für die nächste dienen**, bis die letzte Schicht erreicht wird und die endgültige Ausgabe erzeugt wird.

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

Konzentriert sich auf die mathematischen Grundlagen und Kernmechanismen von neuronalen Netzen. Vermittelt die Implementierung von Perzeptronen, Aktivierungsfunktionen, Vorwärts- und Rückwärtspropagation, Verlustberechnung und Gradientenabstieg von Grund auf mit Python und NumPy, ohne Verwendung von High-Level-Frameworks. Bietet praxisnahe Erfahrung und ein tiefes Verständnis für die Funktionsweise neuronaler Netze auf niedrigster Ebene.

Vorwärtspropagation

Lösung