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

I et grunnleggende fremovermatet nevralt nettverk beregnes utdataene til et nevron i et lag ved hjelp av **vektet sum av inngangene**, som deretter sendes gjennom en **aktiveringsfunksjon**. Dette kan representeres som:

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

Hvor:
- $$y$$: utdata fra nevronet;
- $$W$$: en matrise som representerer vektene tilkoblet nevronet;
- $$x$$: en kolonnematrise (eller vektor) som representerer inngangsverdiene til nevronet;
- $$b$$: en skalarverdi;
- $$\sigma$$: en aktiveringsfunksjon, som sigmoid, ReLU eller softmax-funksjonen.

For å oppnå best mulig ytelse utføres alle beregninger ved hjelp av **matriser**. Vi vil håndtere denne oppgaven på samme måte.

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

Bli ekspert på å bygge, trene og evaluere nevrale nettverk ved hjelp av TensorFlow og Keras. Dette kurset dekker modellopprettelse, egendefinerte treningssløyfer og beste praksis for effektive arbeidsflyter innen dyp læring. Gjennom praktiske prosjekter og virkelighetsnære scenarioer får du praktisk erfaring med bransjestandard verktøy og teknikker som er essensielle for avansert ingeniørarbeid innen dyp læring.

Opprettelse av et Nevralt Nettverkslag

Løsning