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 TestNeuron(unittest.TestCase):

    @classmethod
    def setUpClass(cls):
        # Import user solution
        cls.user_code = importlib.import_module("user_code")

        # Fix random seed for reproducibility
        np.random.seed(10)

        # Prepare input data
        cls.inputs = np.array([0.5, 0.2, -0.8])

        # Create neuron with same deterministic random generator
        cls.user_neuron = cls.user_code.Neuron(3)

        # Compute expected result using user’s weights and bias
        cls.ref_input_sum = np.dot(cls.inputs, cls.user_neuron.weights) + cls.user_neuron.bias
        cls.ref_output = 1 / (1 + np.exp(-cls.ref_input_sum))

        # Run activation
        cls.user_output = cls.user_neuron.activate(cls.inputs)

    def test_weights_shape(self):
        _dynamic_test(
            self,
            self.user_neuron.weights.shape == (3,),
            "Weights shape is correct",
            "Weights shape is incorrect"
        )

    def test_bias_is_scalar(self):
        _dynamic_test(
            self,
            np.isscalar(self.user_neuron.bias),
            "Bias is a scalar",
            "Bias is not a scalar"
        )

    def test_random_initialization_range(self):
        w_in_range = np.all((self.user_neuron.weights >= -1) & (self.user_neuron.weights < 1))
        b_in_range = -1 <= self.user_neuron.bias < 1
        _dynamic_test(
            self,
            w_in_range and b_in_range,
            "Weights and bias are within [-1, 1)",
            "Weights or bias are outside the expected range"
        )

    def test_forward_computation(self):
        _dynamic_test(
            self,
            np.allclose(self.user_output, self.ref_output, atol=1e-6),
            "Forward computation is correct",
            "Forward computation is incorrect"
        )

    def test_output_type(self):
        _dynamic_test(
            self,
            isinstance(self.user_output, (float, np.floating, np.ndarray)),
            "Output type is numeric",
            "Output type is not numeric"
        )

    def test_sigmoid_activation(self):
        _dynamic_test(
            self,
            0 < float(self.user_output) < 1,
            "Sigmoid activation applied correctly",
            "Output not in (0, 1); sigmoid may not be applied"
        )


if __name__ == "__main__":
    unittest.main(argv=["first-arg-is-ignored"], exit=False)

test_code.py

Les réseaux de neurones sont des algorithmes puissants, inspirés par la structure du cerveau humain, utilisés pour résoudre des problèmes complexes d'apprentissage automatique. Vous construirez votre propre réseau de neurones à partir de zéro afin de comprendre son fonctionnement. Après ce cours, vous serez en mesure de créer des réseaux de neurones pour résoudre des problèmes de classification et de régression en utilisant la bibliothèque scikit-learn.

Tout d'abord, nous aborderons ce qu'est un réseau de neurones et son fonctionnement. Nous examinerons également l'étendue de ses applications.

Ensuite, nous allons essayer de construire notre propre réseau de neurones et observer son efficacité lors de l'apprentissage. Nous examinerons également une solution prête à l'emploi de la bibliothèque scikit-learn.

Enfin, nous vous fournirons des informations supplémentaires utiles pour comprendre quel modèle utiliser et quels types de réseaux de neurones existent. Pour valider le cours, vos connaissances acquises seront évaluées.

Défi : Création d’un Neurone

Solution

Awesome!

Défi : Création d’un Neurone

Solution