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

Konzentriert sich auf die mathematischen Grundlagen und Kernmechanismen von neuronalen Netzen. Vermittelt die Implementierung von Perzeptronen, Aktivierungsfunktionen, Vorwärts- und Rückwärtspropagation, Verlustberechnung und Gradientenabstieg von Grund auf mit Python und NumPy, ohne Verwendung von High-Level-Frameworks. Bietet praxisnahe Erfahrung und ein tiefes Verständnis für die Funktionsweise neuronaler Netze auf niedrigster Ebene.

Herausforderung: Erstellung Eines Neurons

Lösung