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

Olet jo toteuttanut eteenpäinlevityksen yhdelle kerrokselle edellisessä luvussa. Nyt tavoitteena on toteuttaa **täydellinen eteenpäinlevitys**, syötteistä ulostuloihin.

Koko eteenpäinlevitysprosessin toteuttamiseksi sinun tulee määritellä `forward()`-metodi `Perceptron`-luokkaan. Tämä metodi suorittaa eteenpäinlevityksen **kerros kerrallaan** kutsumalla jokaiselle kerrokselle tarkoitettua metodia:

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

Syötteet kulkevat ensimmäisen piilokerroksen läpi, ja **jokaisen kerroksen ulostulo toimii seuraavan kerroksen syötteenä**, kunnes saavutetaan viimeinen kerros ja tuotetaan lopullinen ulostulo.

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

Keskittyy neuroverkkojen matemaattisiin perusteisiin ja ydintoimintoihin. Sisältää perceptronien, aktivointifunktioiden, eteen- ja taaksepäin etenemisen, häviön laskennan sekä gradienttilaskun toteutuksen alusta alkaen Pythonilla ja NumPyllä ilman korkean tason kirjastoja. Tarjoaa käytännönläheistä kokemusta ja syvällistä ymmärrystä neuroverkkojen toiminnasta matalimmalla tasolla.

Eteenpäinlevitys

Ratkaisu