Réseaux de neurones 🧠

Un réseau de neurones, c'est comme un cerveau simplifié : des milliers de petits "neurones" artificiels connectés entre eux qui apprennent à reconnaître des patterns.

1. Inspiré du cerveau humain 🧠

pseudo ' Un neurone artificiel = une petite usine de calcul : ' 1. Il reçoit des ENTRÉES (x₁, x₂, x₃...) ' 2. Chaque entrée a un POIDS (importance) ' 3. Il fait la somme : (x₁ × poids₁ + x₂ × poids₂ + ...) + biais ' 4. Il applique une FONCTION D'ACTIVATION ' 5. Il produit une SORTIE

' Exemple : décider si on sort au cinéma 🎬 ' x₁ = j'ai de l'argent ? (1=oui, 0=non) → poids = 0.8 ' x₂ = il fait beau ? (1=oui, 0=non) → poids = 0.5 ' x₃ = j'ai fini mes devoirs ? (1=oui, 0=non) → poids = 0.9 ' ' Si somme > 1.5 → SORTIE = 1 (je sors !) 🎉 ' Sinon → SORTIE = 0 (je reste) 😴 ``'

import numpy as np

def sigmoide(x):
    return 1 / (1 + np.exp(-x))

class Neurone:
    def __init__(self, n_entrees):
        self.poids = np.random.randn(n_entrees) * 0.01
        self.biais = 0

    def forward(self, entrees):
        z = np.dot(entrees, self.poids) + self.biais
        return sigmoide(z)
``'

---

## 3. Perceptron multicouche (MLP) 🏗️

python
import numpy as np

class ReseauNeurones:
    def __init__(self, couches):
        """couches = [784, 128, 64, 10]"""
        self.couches = couches
        self.poids = []
        self.biais = []

        for i in range(len(couches) - 1):
            w = np.random.randn(couches[i], couches[i + 1]) * 0.01
            b = np.zeros((1, couches[i + 1]))
            self.poids.append(w)
            self.biais.append(b)

    def relu(self, x):
        return np.maximum(0, x)

    def forward(self, X):
        for w, b in zip(self.poids[:-1], self.biais[:-1]):
            X = self.relu(np.dot(X, w) + b)
        # Dernière couche : softmax
        z = np.dot(X, self.poids[-1]) + self.biais[-1]
        exp_z = np.exp(z - np.max(z, axis=1, keepdims=True))
        return exp_z / np.sum(exp_z, axis=1, keepdims=True)
``'

---

## 4. Fonctions d'activation 🔌

```pseudo
' La fonction d'activation décide si le neurone "s'allume" ou pas

' ReLU (la plus utilisée) :
' Si entrée > 0 → sortie = entrée
' Si entrée ≤ 0 → sortie = 0
' → Simple et efficace !

' Sigmoïde :
' Transforme n'importe quelle valeur en probabilité (entre 0 et 1)
' → Utile pour les décisions binaires (oui/non)

' Softmax (pour la sortie) :
' Transforme les sorties en probabilités qui additionnent à 1
' → "Le chiffre est 7 avec 95% de chance"
``'

| Fonction | Formule | Utilisation |
|----------|---------|-------------|
| **ReLU** | `max(0, x)` | Couches cachées (la plus courante) |
| **Sigmoïde** | `1/(1+e⁻ˣ)` | Classification binaire |
| **Tanh** | `tanh(x)` | Valeurs entre -1 et 1 |
| **Softmax** | `eˣ/∑eˣ` | Sortie multi-classes |

---

## 5. Entraînement : la rétropropagation 🔄

```pseudo
' Comment le réseau apprend-il ?
' Il fait une prédiction, regarde l'erreur, et ajuste ses poids

' 1. FORWARD (aller) : le réseau prédit quelque chose
' 2. CALCUL DE L'ERREUR : à quel point c'est faux ?
' 3. BACKWARD (retour) : on propage l'erreur en arrière
' 4. AJUSTEMENT : on modifie les poids pour faire mieux
' 5. On répète des MILLIERS de fois !
``'

```python
# Pseudo-code de la rétropropagation
def entrainer(X, y, taux_apprentissage):
    # Forward
    predictions = reseau.forward(X)
    erreur = cout(predictions, y)  # Ex: cross-entropy

    # Backward (calcul des gradients)
    gradient = derivee_cout(predictions, y)
    for couche in reversed(reseau.couches):
        gradient = couche.backward(gradient, taux_apprentissage)

    # Les poids sont mis à jour
    # w = w - taux * gradient
``'

---

## 6. Exemple avec TensorFlow/Keras 🔥

```python
from tensorflow.keras.models import Sequential
from tensorflow.keras.layers import Dense

model = Sequential([
    Dense(128, activation="relu", input_shape=(784,)),
    Dense(64, activation="relu"),
    Dense(10, activation="softmax"),
])

model.compile(
    optimizer="adam",
    loss="sparse_categorical_crossentropy",
    metrics=["accuracy"],
)

# Entraînement
model.fit(X_train, y_train, epochs=10, batch_size=32)

# Évaluation
test_loss, test_acc = model.evaluate(X_test, y_test)
print(f"Précision test : {test_acc:.3f}")
``'

---

## Exercices pour toi 🎯

1. **Neurone simple** : implémente un neurone qui décide si un film est bien selon 3 critères (note, durée, genre) avec des poids que tu choisis
2. **Réseau profond** : crée un réseau avec Keras pour reconnaître des chiffres manuscrits (dataset MNIST)
3. **Expérience** : compare un réseau avec 1 couche cachée vs 3 couches cachées — lequel est le plus précis ? Le plus long à entraîner ?