CodeUtility
Faciliter la vie des développeurs !
Concepts d'IA en Python

Neurones et fonctions d'activation en Python

Un neurone artificiel est une toute petite fonction. Il multiplie chaque entrée par un poids, ajoute un biais et fait passer le résultat dans une fonction d'activation qui décide de l'intensité avec laquelle il « s'active ».

Le concept en termes simples

Un neurone artificiel est une toute petite fonction. Il multiplie chaque entrée par un poids, ajoute un biais et fait passer le résultat dans une fonction d'activation qui décide de l'intensité avec laquelle il « s'active ».

Construisez un neurone artificiel en Python pur : une somme pondérée des entrées plus un biais, passée par sigmoid ou ReLU.

Idées clés

  • Les poids indiquent l'importance de chaque entrée ; le biais décale le résultat vers le haut ou le bas.
  • Sans activation, empiler des neurones ne donnerait toujours qu'un modèle linéaire (une droite).
  • Sigmoid renvoie une valeur entre 0 et 1, ce qui convient aux probabilités.
  • ReLU est rapide et c'est le choix habituel pour les couches cachées des réseaux modernes.

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

Déplacez les curseurs pour changer les entrées, les poids et le biais. Regardez la somme pondérée z se déplacer sur les courbes sigmoid et ReLU.

Code d’exemple

Exécuter le code →
main.py
import math

# A neuron multiplies each input by a weight, adds them up and adds a bias.
def dot(a, b):
    return sum(x * y for x, y in zip(a, b))

def sigmoid(z):
    return 1 / (1 + math.exp(-z))   # squashes any number into (0, 1)

def relu(z):
    return max(0.0, z)              # keeps positives, turns negatives into 0

inputs = [0.5, -1.0, 2.0]
weights = [0.8, 0.2, -0.5]
bias = 0.1

z = dot(inputs, weights) + bias      # weighted sum
print("weighted sum z =", round(z, 3))
print("sigmoid(z) =", round(sigmoid(z), 3))
print("relu(z) =", relu(z))

# The activation decides how strongly the neuron "fires".
for value in [-2, 0, 2]:
    print(f"z={value:>2}  sigmoid={sigmoid(value):.3f}  relu={relu(value)}")

Résultat attendu

weighted sum z = -0.7
sigmoid(z) = 0.332
relu(z) = 0.0
z=-2  sigmoid=0.119  relu=0.0
z= 0  sigmoid=0.500  relu=0.0
z= 2  sigmoid=0.881  relu=2

Fonctionnement

dot() calcule la somme pondérée z. Sigmoid comprime z entre 0 et 1, tandis que ReLU garde les valeurs positives et transforme les négatives en 0. La boucle montre comment chaque activation réagit à une entrée négative, nulle et positive.

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.

  1. Modifiez les entrées ou les poids et prédisez la sortie avant d'exécuter.
  2. Affichez les valeurs intermédiaires pour suivre chaque étape du calcul.
  3. 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