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

Dans un réseau de neurones à propagation avant de base, la sortie d’un neurone dans une couche est calculée à l’aide de la **somme pondérée de ses entrées**, passée à travers une **fonction d’activation**. Cela peut être représenté comme suit :

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

Où :
- $$y$$ : sortie du neurone ;
- $$W$$ : matrice représentant les poids associés aux connexions du neurone ;
- $$x$$ : matrice colonne (ou vecteur) représentant les valeurs d’entrée du neurone ;
- $$b$$ : valeur scalaire ;
- $$\sigma$$ : fonction d’activation, telle que la fonction sigmoïde, ReLU ou softmax.

Pour obtenir les meilleures performances, tous les calculs sont effectués à l’aide de **matrices**. Nous aborderons cette tâche de la même manière.

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

Maîtrise de la construction, de l'entraînement et de l'évaluation des réseaux neuronaux avec TensorFlow et Keras. Ce cours couvre la création de modèles, les boucles d'entraînement personnalisées et les meilleures pratiques pour des workflows de deep learning efficaces. À travers des projets pratiques et des scénarios réels, vous acquerrez une expérience concrète avec des outils et techniques standards de l'industrie, essentiels pour l'ingénierie avancée du deep learning.

Création d'une Couche de Réseau de Neurones

Solution