Summary  
This chapter covers implementing complete forward propagation in a perceptron by defining a `forward()` method that iterates through each layer, passing each layer’s output as the next layer’s input to produce the final output.

General domain of usage  
Machine learning (neural network inference)

Olet jo toteuttanut eteenpäin syötön (forward propagation) yhdelle kerrokselle edellisessä luvussa. Nyt tavoitteena on toteuttaa **täydellinen eteenpäin syöttö**, syötteistä lähtien aina ulostuloihin asti.

Koko eteenpäin syötön toteuttamiseksi sinun tulee määritellä `forward()`-metodi `Perceptron`-luokkaan. Tämä metodi suorittaa eteenpäin syötön **kerros kerrallaan** kutsumalla jokaisen kerroksen omaa 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 saadaan 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

Neuroverkot ovat tehokkaita algoritmeja, jotka on inspiroitu ihmisaivojen rakenteesta ja joita käytetään ratkaisemaan monimutkaisia koneoppimisen ongelmia. Rakennat oman neuroverkkosi alusta alkaen ymmärtääksesi sen toimintaa. Tämän kurssin jälkeen osaat luoda neuroverkkoja luokittelu- ja regressio-ongelmien ratkaisemiseksi scikit-learn-kirjaston avulla.

Ensiksi käsittelemme, mitä neuroverkko on ja miten se toimii. Tarkastelemme myös sen sovellusalueita.

Seuraavaksi rakennamme oman neuroverkon ja tarkastelemme, kuinka tehokkaasti se oppii. Lisäksi käsittelemme valmista ratkaisua scikit-learn-kirjastosta.

Lopuksi annamme sinulle lisätietoa siitä, miten valita sopiva malli ja millaisia neuroverkkoja on olemassa. Kurssin suorittamiseksi osaamisesi testataan.

Eteenpäinlevitys

Ratkaisu