Propagation avant et fonctions de perte en Python

Le concept en termes simples

Un réseau de neurones est formé de couches de neurones. Lors de la propagation avant, l'entrée traverse chaque couche pour produire une prédiction, et une fonction de perte mesure l'écart entre cette prédiction et la bonne réponse.

Faites passer des entrées couche par couche dans un petit réseau de neurones, puis mesurez l'erreur avec l'erreur quadratique et l'entropie croisée.

Idées clés

Une couche dense relie chaque entrée à chaque neurone de la couche.
La sortie d'une couche est l'entrée de la suivante.
La perte est un seul nombre, et plus elle est basse, meilleures sont les prédictions.
Utilisez l'erreur quadratique pour des nombres et l'entropie croisée pour des probabilités et des classes.

Quand l’utiliser ?

Comprendre ce qui se passe à l'intérieur des réseaux de neurones et des bibliothèques d'IA.
Apprendre l'idée avant de l'implémenter dans les défis correspondants.
Se préparer aux cours d'apprentissage automatique, aux entretiens et aux projets.

À vous de jouer

Changez les entrées et la cible. Suivez les valeurs à travers la couche cachée et voyez comment les deux pertes réagissent à la prédiction.

Code d’exemple

Exécuter le code →

main.py

import math

def dense(inputs, weights, biases, activation):
    # Each row of weights belongs to one neuron in the layer.
    return [activation(sum(x * w for x, w in zip(inputs, row)) + b) for row, b in zip(weights, biases)]

relu = lambda z: max(0.0, z)
sigmoid = lambda z: 1 / (1 + math.exp(-z))

x = [1.0, 2.0]
hidden = dense(x, [[0.5, -0.2], [0.3, 0.8]], [0.0, -0.5], relu)
output = dense(hidden, [[1.0, -1.0]], [0.2], sigmoid)
print("hidden layer:", [round(h, 3) for h in hidden])
print("prediction:", round(output[0], 3))

# A loss function measures how wrong the prediction is.
target = 1.0
mse = (output[0] - target) ** 2
bce = -(target * math.log(output[0]) + (1 - target) * math.log(1 - output[0]))
print("squared error:", round(mse, 3))
print("cross-entropy:", round(bce, 3))

Résultat attendu

hidden layer: [0.1, 1.4]
prediction: 0.25
squared error: 0.563
cross-entropy: 1.387

Fonctionnement

dense() calcule une couche, où chaque ligne de poids est un neurone. La couche cachée utilise ReLU et la couche de sortie sigmoid pour donner une probabilité. L'erreur quadratique et l'entropie croisée mesurent toutes deux l'écart entre la prédiction 0.25 et la cible 1.0 ; l'entraînement cherche à les réduire.

Modifiez les valeurs et exécutez le programme avec le compilateur Python en ligne CodeUtility, sans installation locale.

Exercices pratiques

Modifiez les entrées et testez les cas limites avant d’utiliser des données plus volumineuses.

Modifiez les entrées ou les poids et prédisez la sortie avant d'exécuter.
Affichez les valeurs intermédiaires pour suivre chaque étape du calcul.
Résolvez les défis liés ci-dessous pour implémenter l'idée vous-même.

Exécuter dans l’IDE Python →

S'entraîner avec un défi

Utilisez le contenu de cette leçon pour résoudre un vrai problème. Chaque défi s'exécute dans le navigateur, avec des tests instantanés et une revue par l'IA.

Tous les défis