NeuralMath

Fonctions d’activation

L’implémentation commence par les deux non-linéarités utilisées par le réseau. ReLU agit dans la couche cachée et la sigmoïde transforme le score final en une valeur comprise entre 0 et 1.

def relu(s):
    return np.maximum(0, s)

def relu_derivative(s):
    return (s > 0).astype(float)

def sigmoid(s):
    return 1 / (1 + np.exp(-s))

Construire un jeu de données synthétique étendu

Nous utilisons la masse et le diamètre comme deux caractéristiques physiques. Les données sont synthétiques, mais restent dans des plages plausibles pour l’exemple pédagogique. Une courbe de référence lisse sert uniquement à produire une géométrie non triviale ; elle n’est jamais fournie au réseau.

def base_boundary(m):
    return (
        6.68
        + 0.74 * np.exp(-((m - 155) / 20) ** 2)
        + 1.50 / (1 + np.exp(-(m - 202) / 5))
    )

X_train = np.vstack([apple_1, apple_2, orange_1, orange_2])
y_train = np.array([1.0] * 32 + [0.0] * 32)

Standardiser les entrées

La masse et le diamètre n’ont pas la même échelle numérique. La moyenne et l’écart-type sont calculés uniquement sur l’ensemble d’entraînement, puis réutilisés de manière cohérente.

mean = X_train.mean(axis=0)
std = X_train.std(axis=0)
Xn = (X_train - mean) / std

Initialiser un réseau 2–12–1

Le modèle possède deux entrées, douze neurones ReLU cachés et une sortie sigmoïde. Cela représente 49 paramètres entraînables, tout en gardant un réseau suffisamment petit pour être inspecté ligne par ligne.

rng = np.random.default_rng(42)
W1 = 0.1 * rng.standard_normal((12, 2))
b1 = np.zeros(12)
W2 = 0.1 * rng.standard_normal(12)
b2 = 0.0

Propagation avant

Une prédiction est une suite de transformations affines et de fonctions d’activation. Ces quatre lignes constituent le cœur calculatoire de l’inférence.

z1 = W1 @ x + b1
h = relu(z1)
z2 = W2 @ h + b2
y_hat = sigmoid(z2)

Rétropropagation

Les dérivées sont écrites explicitement. Aucune différentiation automatique n’est utilisée : la règle de la chaîne apparaît directement dans le code, ce qui constitue le point pédagogique central.

delta2 = (y_hat - target) * y_hat * (1 - y_hat)
dW2 = delta2 * h
db2 = delta2

delta1 = (delta2 * W2) * relu_derivative(z1)
dW1 = np.outer(delta1, x)
db1 = delta1

Descente de gradient stochastique

À chaque époque, les exemples sont mélangés et les paramètres sont mis à jour après chaque observation. La procédure réutilise les gradients ci-dessus afin de réduire la perte.

for epoch in range(n_epochs):
    for i in rng.permutation(len(Xn)):
        # forward pass and backpropagation
        W1 -= learning_rate * dW1
        b1 -= learning_rate * db1
        W2 -= learning_rate * dW2
        b2 -= learning_rate * db2

Résultat de l’entraînement

Avec la graine aléatoire et les hyperparamètres fixés ici, le petit réseau classe correctement les 64 exemples d’entraînement et les 8 exemples de test illustratifs selon les étiquettes définies pour l’expérience synthétique.

Final mean loss: 0.0001785644
Training accuracy: 1.0000
Illustrative test accuracy: 1.0000

Test outputs:
[121.0, 7.20] -> 0.999927 -> apple
[135.0, 7.45] -> 0.999900 -> apple
[152.0, 7.75] -> 0.999780 -> apple
[171.0, 7.32] -> 0.986972 -> apple
[121.0, 6.28] -> 0.000019 -> orange
[152.0, 6.86] -> 0.000009 -> orange
[189.0, 6.48] -> 0.000028 -> orange
[208.0, 7.55] -> 0.014957 -> orange

Tracer la frontière de décision apprise

Après l’entraînement, le réseau est évalué sur une grille dense. Le niveau y-hat = 0,5 devient la frontière de décision apprise et révèle la géométrie non linéaire construite par la couche cachée.

masses = np.linspace(116, 214, 500)
diameters = np.linspace(6.0, 8.85, 500)
M, D = np.meshgrid(masses, diameters)
grid = np.column_stack([M.ravel(), D.ravel()])
P = predict(grid, mean, std, W1, b1, W2, b2).reshape(M.shape)

ax.contour(M, D, P, levels=[0.5], linewidths=2.2)

Ressources complètes

Les scripts complets, notebooks et sorties reproductibles sont disponibles ci-dessous. Le code présenté dans toutes les langues conserve les mêmes identifiants canoniques en anglais afin d’éviter toute divergence entre traductions.

Python sourceGitHub repositoryGoogle ColabFigure (PDF)

Extensions futures

NeuralMath est conçu pour évoluer comme une suite d’exemples calculatoires. Les extensions prévues comprennent la dynamique de l’entraînement, la contribution des neurones cachés, la vérification des gradients, la classification multiclasse avec softmax, des réseaux plus profonds et de petites expériences interactives dans le navigateur.

À propos de l’auteur

Americo Cunha Jr est scientifique du calcul, chercheur au Laboratório Nacional de Computação Científica (LNCC) et professeur associé à l’Universidade do Estado do Rio de Janeiro (UERJ). Ses recherches se situent à l’interface de la dynamique non linéaire, de la modélisation mathématique et numérique, de la quantification des incertitudes, des problèmes inverses et de l’intelligence artificielle/apprentissage automatique scientifique. Il a reçu le prix ABMEC pour jeunes scientifiques en 2023 et participe à des collaborations scientifiques et éditoriales internationales.

americocunha.orgORCIDGoogle Scholar

Licence

Sauf indication contraire, le texte explicatif du site et ses figures originales sont mis à disposition sous licence Creative Commons Attribution 4.0 International (CC BY 4.0). Le PDF pédagogique peut être soumis à la licence de sa version publiée par la revue. Le code source est distribué séparément et devrait utiliser une licence logicielle dédiée.