Summary
This chapter explains how to implement a neural network layer by defining trainable weight and bias variables, performing matrix multiplication to compute weighted sums, adding bias, and applying an activation function to produce neuron outputs.

General domain of usage
Neural network models in machine learning

Perustason syötteestä ulostuloon etenevässä neuroverkossa neuronin kerroksen ulostulo lasketaan käyttämällä **syötteiden painotettua summaa**, joka kulkee **aktivointifunktion** läpi. Tämä voidaan esittää seuraavasti:

$$
y=\sigma(W \cdot x + b)
$$

Missä:
- $$y$$: neuronin ulostulo;
- $$W$$: matriisi, joka edustaa neuronin yhteyksiin liittyviä painoja;
- $$x$$: sarakematriisi (tai vektori), joka edustaa neuronin syötearvoja;
- $$b$$: skalaarinen arvo;
- $$\sigma$$: aktivointifunktio, kuten sigmoid, ReLU tai softmax.

Parhaan suorituskyvyn saavuttamiseksi kaikki laskutoimitukset suoritetaan **matriiseilla**. Toteutamme tämän tehtävän samalla tavalla.

import unittest
import tensorflow as tf
import numpy as np


# Dynamic test helper required by Codefinity
def _dynamic_test(test_case, condition, ok_msg, fail_msg):
    if condition:
        test_case._testMethodName = ok_msg
        test_case.assertTrue(True)
    else:
        test_case._testMethodName = fail_msg
        test_case.fail(fail_msg)


class TestUserCode(unittest.TestCase):

    # 1. Test transpose of W
    def test_weight_transpose(self):
        import user_code

        W_original = np.array([[0.5, 0.4, 0.7],
                               [0.1, 0.9, 0.5]], dtype=np.float64)
        expected = W_original.T

        cond = False
        try:
            W = user_code.W
            cond = isinstance(W, tf.Tensor) and np.allclose(W.numpy(), expected)
        except Exception:
            cond = False

        _dynamic_test(
            self,
            cond,
            "Weight matrix W is transposed correctly.",
            "Expected W to be transposed to shape (3,2)."
        )

    # 2. Test weighted sum = I @ W
    def test_weighted_sum(self):
        import user_code

        I = np.array([[0.5, 0.6, 0.1]], dtype=np.float64)
        W = np.array([[0.5, 0.4, 0.7],
                      [0.1, 0.9, 0.5]], dtype=np.float64).T

        expected = I @ W

        cond = False
        try:
            ws = user_code.weighted_sum.numpy()
            cond = ws.shape == (1, 2) and np.allclose(ws, expected)
        except Exception:
            cond = False

        _dynamic_test(
            self,
            cond,
            "Weighted sum is computed correctly.",
            "Expected weighted_sum = I @ W with correct shape (1,2)."
        )

    # 3. Test biased sum = weighted_sum + b
    def test_biased_sum(self):
        import user_code

        I = np.array([[0.5, 0.6, 0.1]], dtype=np.float64)
        W = np.array([[0.5, 0.4, 0.7],
                      [0.1, 0.9, 0.5]], dtype=np.float64).T
        weighted = I @ W
        expected = weighted + 0.1  # bias is scalar

        cond = False
        try:
            bs = user_code.biased_sum.numpy()
            cond = bs.shape == (1, 2) and np.allclose(bs, expected)
        except Exception:
            cond = False

        _dynamic_test(
            self,
            cond,
            "Biased sum is computed correctly by adding bias.",
            "Expected biased_sum = weighted_sum + bias with shape (1,2)."
        )

    # 4. Test sigmoid activation
    def test_neuron_output(self):
        import user_code

        I = np.array([[0.5, 0.6, 0.1]], dtype=np.float64)
        W = np.array([[0.5, 0.4, 0.7],
                      [0.1, 0.9, 0.5]], dtype=np.float64).T
        weighted = I @ W
        biased = weighted + 0.1
        expected = 1 / (1 + np.exp(-biased))

        cond = False
        try:
            out = user_code.neuron_output.numpy()
            cond = out.shape == (1, 2) and np.allclose(out, expected)
        except Exception:
            cond = False

        _dynamic_test(
            self,
            cond,
            "Sigmoid activation applied correctly.",
            "Expected neuron_output = sigmoid(biased_sum)."
        )

    # Verify tf.sigmoid is actually used in code
    def test_uses_sigmoid(self):
        cond = False
        try:
            with open("user_code.py", "r") as f:
                src = f.read()
            cond = "tf.sigmoid" in src
        except Exception:
            cond = False

        _dynamic_test(
            self,
            cond,
            "The code uses tf.sigmoid() as required.",
            "Expected to use tf.sigmoid() activation function."
        )


if __name__ == "__main__":
    unittest.main()


test_code.py

Hallitse neuroverkkojen rakentaminen, kouluttaminen ja arviointi TensorFlow'n ja Kerasin avulla. Tämä kurssi kattaa mallien luomisen, mukautetut koulutussilmukat sekä parhaat käytännöt tehokkaisiin syväoppimisen työnkulkuihin. Käytännön projektien ja todellisten esimerkkien kautta saat käytännön kokemusta alan standardityökaluista ja -tekniikoista, jotka ovat olennaisia edistyneessä syväoppimisen kehityksessä.

Neuroverkkokerroksen Luominen

Ratkaisu