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 grundlæggende feed-forward neuralt netværk beregnes outputtet fra en neuron i et lag ved hjælp af **den vægtede sum af dens input**, som føres gennem en **aktiveringsfunktion**. Dette kan repræsenteres som:

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

Hvor:
- $$y$$: output fra neuronen;
- $$W$$: en matrix, der repræsenterer vægtene forbundet til neuronen;
- $$x$$: en kolonnematrix (eller vektor), der repræsenterer inputværdierne til neuronen;
- $$b$$: en skalær værdi;
- $$\sigma$$: en aktiveringsfunktion, såsom sigmoid, ReLU eller softmax-funktion.

For at opnå den bedste ydeevne udføres alle beregninger ved hjælp af **matricer**. Vi vil håndtere denne opgave på samme måde.

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

Bliv fortrolig med opbygning, træning og evaluering af neurale netværk ved hjælp af TensorFlow og Keras. Dette kursus dækker modeloprettelse, brugerdefinerede træningssløjfer og bedste praksis for effektive deep learning-arbejdsgange. Gennem praktiske projekter og virkelighedsnære scenarier opnås erfaring med branchestandardværktøjer og -teknikker, der er essentielle for avanceret deep learning-udvikling.

Oprettelse af et Neuralt Netværkslag

Løsning