Premiers Modèles avec TensorFlow

Maintenant que nous avons les bases de TensorFlow (tenseurs, variables, opérations, graphe de calcul), nous allons construire notre premier modèle : une régression linéaire simple.

Pourquoi la Régression Linéaire ?

La régression linéaire est un modèle simple, mais fondamental en Machine Learning. Il permet de comprendre les concepts clés de l'entraînement d'un modèle :

• Fonction de coût : Comment mesurer l'erreur du modèle.
• Descente de gradient : Comment ajuster les paramètres du modèle pour minimiser l'erreur.
• Entraînement itératif : Comment répéter le processus d'ajustement jusqu'à obtenir un modèle performant.

Ce que Vous Allez Apprendre

• Comment définir un modèle de régression linéaire avec TensorFlow.
• Comment définir une fonction de coût (erreur quadratique moyenne).
• Comment utiliser l'optimiseur tf.keras.optimizers.SGD (descente de gradient stochastique) pour entraîner le modèle.
• Comment suivre l'évolution de la perte pendant l'entraînement.
• Comprendre le processus d'entrainement du modèle

info

L'objectif de cette partie est de vous montrer concrètement comment utiliser TensorFlow pour construire et entraîner un modèle, même simple. Cela vous donnera une base solide pour aborder des modèles plus complexes par la suite.

Implémentation d'une Régression Linéaire Simple

Nous allons implémenter une régression linéaire simple en utilisant uniquement les fonctionnalités de base de TensorFlow (pas Keras, que nous verrons plus tard).

Problème

Supposons que nous ayons des données représentant la relation entre une variable d'entrée (x) et une variable de sortie (y). Par exemple, x pourrait être la surface d'une maison (en mètres carrés) et y son prix (en milliers d'euros).

Nous voulons trouver une relation linéaire entre x et y, de la forme :

$y = w \cdot x + b$

Où :

• $w$ est le poids (ou coefficient) associé à la variable d'entrée.
• $b$ est le biais (ou ordonnée à l'origine).

Notre objectif est de trouver les valeurs de $w$ et $b$ qui minimisent l'erreur entre les prédictions du modèle ($\hat{y} = w \cdot x + b$) et les vraies valeurs de $y$.

Étapes de l'Implémentation

1. Définition des données d'entrée et de sortie : Nous allons créer des données synthétiques pour cet exemple.
2. Définition des variables du modèle : Les poids (w) et le biais (b) seront stockés dans des variables TensorFlow.
3. Définition du modèle : Une fonction qui calcule la prédiction ($\hat{y}$) à partir de l'entrée ($x$) et des paramètres ($w$ et $b$).
4. Définition de la fonction de coût : Nous utiliserons l'erreur quadratique moyenne (MSE) comme fonction de coût.
5. Définition de l'optimiseur : Nous utiliserons la descente de gradient stochastique (SGD) pour minimiser la fonction de coût.
6. Entraînement du modèle : Nous effectuerons plusieurs itérations de la descente de gradient, en mettant à jour les variables w et b à chaque étape.
7. Visualisation de l'entrainement.
8. Utilisation du modèle.

Code Complet

import tensorflow as tf
import numpy as np
import matplotlib.pyplot as plt

# 1. Données d'entrée et de sortie (synthétiques)
x_train = np.array([1.0, 2.0, 3.0, 4.0, 5.0, 6.0], dtype=np.float32)
y_train = np.array([2.0, 3.0, 4.0, 5.0, 6.0, 7.0], dtype=np.float32)  # Relation linéaire simple : y = x + 1

# 2. Variables du modèle (initialisées aléatoirement)
w = tf.Variable(tf.random.normal(()))
b = tf.Variable(tf.random.normal(()))

# 3. Modèle (prédiction)
def linear_regression(x):
    return w * x + b

# 4. Fonction de coût (erreur quadratique moyenne)
def mean_squared_error(y_pred, y_true):
    return tf.reduce_mean(tf.square(y_pred - y_true))

# 5. Optimiseur (descente de gradient stochastique)
optimizer = tf.keras.optimizers.SGD(learning_rate=0.01)

# 6. Entraînement du modèle
def train_step(x, y):
    with tf.GradientTape() as tape:
        y_pred = linear_regression(x)
        loss = mean_squared_error(y_pred, y)

    # Calcul des gradients
    gradients = tape.gradient(loss, [w, b])

    # Mise à jour des variables (descente de gradient)
    optimizer.apply_gradients(zip(gradients, [w, b]))

    return loss

# Nombre d'époques (itérations)
epochs = 300

list_loss = []
# Boucle d'entraînement
for epoch in range(epochs):
    loss = train_step(x_train, y_train)
    list_loss.append(loss)
    if epoch % 50 == 0:
      print(f"Epoch {epoch}, Loss: {loss.numpy()}, w: {w.numpy()}, b: {b.numpy()}")

Epoch 0, Loss: 13.77857494354248, w: 1.7453012466430664, b: 0.5799626708030701
Epoch 50, Loss: 0.042684704065322876, w: 1.109609842300415, b: 0.5307387113571167
Epoch 100, Loss: 0.029613487422466278, w: 1.0912973880767822, b: 0.6091380715370178
Epoch 150, Loss: 0.020545033738017082, w: 1.0760443210601807, b: 0.6744391918182373
Epoch 200, Loss: 0.014253546483814716, w: 1.0633395910263062, b: 0.7288309335708618
Epoch 250, Loss: 0.009888711385428905, w: 1.0527573823928833, b: 0.7741353511810303

#7. Visualisation de l'entrainement
plt.plot(list_loss)
plt.xlabel("Epoch")
plt.ylabel("Loss")
plt.title("Courbe de perte")
plt.show()

#8. Utilisation du modèle
x_test = np.array([7.0, 8.0, 9.0], np.float32)
y_pred = linear_regression(x_test)
print(f"Prédictions : {y_pred.numpy()}")

Prédictions : [ 8.119911  9.164015 10.208119]

plt.plot(x_train, y_train, 'ro', label='Données originales')
plt.plot(x_train, [float(w * x + b) for x in x_train], label='Droite de régression')
plt.xlabel('x')
plt.ylabel('y')
plt.title('Régression Linéaire')
plt.legend()
plt.show()

Explications Détaillées

• Données d'entrée et de sortie : Nous créons des données simples où la relation entre x et y est linéaire (y = x + 1).
• Variables du modèle : w et b sont initialisées avec des valeurs aléatoires.
• Modèle : La fonction linear_regression(x) calcule $w \cdot x + b$.
• Fonction de coût : La fonction mean_squared_error(y_pred, y_true) calcule l'erreur quadratique moyenne entre les prédictions et les vraies valeurs.
• Optimiseur : Nous utilisons tf.keras.optimizers.SGD (une implémentation de la descente de gradient stochastique fournie par Keras, mais utilisable ici car Keras est intégré à TensorFlow).
• train_step(x, y) : Cette fonction effectue une étape d'entraînement :
  • tf.GradientTape() : Enregistre les opérations effectuées sur les variables pour pouvoir calculer les gradients automatiquement.
  • tape.gradient(loss, [w, b]) : Calcule les gradients de la perte par rapport à w et b.
  • optimizer.apply_gradients(...) : Applique les gradients pour mettre à jour les variables.
• Boucle d'entraînement : On répète l'étape d'entraînement plusieurs fois (ici, 300 époques). À chaque époque, on affiche la perte, la valeur de w et la valeur de b.
• Visualisation de l'entrainement: On affiche la courbe de perte
• Utilisation du modèle: On effectue une prédiction et on affiche la droite de régression.

Ce code implémente une régression linéaire complète avec TensorFlow, en utilisant les concepts que nous avons vus précédemment (tenseurs, variables, opérations, graphe de calcul, descente de gradient).

info

Ce code est un peu plus complexe que ce que nous avons vu jusqu'à présent, mais il est important de le comprendre étape par étape. C'est la base de l'entraînement de presque tous les modèles de Machine Learning.

Intuition (Rappel)

Imaginez que vous êtes sur une colline (la fonction de perte) et que vous voulez descendre dans la vallée (le minimum de la perte).

• Gradient : Indique la direction de la pente la plus raide vers le haut.
• Descente de gradient : Vous faites un petit pas dans la direction opposée à la pente la plus raide.
• Taux d'apprentissage : Détermine la taille de votre pas.
• Itérations : Vous répétez ce processus jusqu'à ce que vous atteigniez le fond de la vallée (ou que vous soyez suffisamment proche).

Visualisation

La courbe de perte, que nous avons tracée dans l'exemple précédent, montre comment la perte diminue au fil des itérations. C'est une visualisation directe du processus d'entraînement. Si tout se passe bien, la perte doit diminuer rapidement au début, puis se stabiliser.

Importance de la Visualisation de la Perte

La courbe de perte est un outil de diagnostic essentiel pour l'entraînement des modèles de Machine Learning. Elle permet de :

• Vérifier que l'entraînement se déroule correctement : La perte doit diminuer au fil des itérations.
• Détecter les problèmes :
  • Si la perte ne diminue pas, cela peut indiquer un problème (taux d'apprentissage trop faible, modèle trop simple, problème avec les données, etc.).
  • Si la perte oscille beaucoup, cela peut indiquer un taux d'apprentissage trop élevé.
  • Si la perte diminue sur les données d'entraînement mais augmente sur des données de validation (que nous n'avons pas utilisées ici, mais que nous verrons plus tard), cela indique un surapprentissage.
• Choisir le nombre d'époques : La courbe de perte permet de déterminer quand arrêter l'entraînement (lorsque la perte ne diminue plus significativement).
• Comparer les modèles: On peut comparer les modèles et/ou les hyperparamètres.

Interprétation de la Courbe de Perte

Dans l'exemple de la régression linéaire, nous devrions observer une courbe de perte qui :

1. Diminue rapidement au début : Le modèle apprend vite à partir des données.
2. Se stabilise ensuite : Le modèle a convergé (il ne s'améliore plus beaucoup).

Si la courbe ne se stabilise pas, cela peut signifier qu'il faut :

• Continuer l'entraînement (augmenter le nombre d'époques).
• Ajuster le taux d'apprentissage (le diminuer s'il y a des oscillations, l'augmenter s'il est trop lent).

Explications code matplotlib

import matplotlib.pyplot as plt

plt.plot(list_loss)
plt.xlabel("Epoch")
plt.ylabel("Loss")
plt.title("Courbe de perte")
plt.show()

Ce code utilise matplotlib pour tracer la courbe de perte :

• plt.plot(list_loss) : Trace la courbe à partir de la liste loss_values (qui contient les valeurs de la perte à chaque époque).
• plt.xlabel("Epoch") : Ajoute un label à l'axe horizontal (nombre d'époques).
• plt.ylabel("Loss") : Ajoute un label à l'axe vertical (perte).
• plt.title("Courbe de perte") : Ajoute un titre au graphique.
• plt.show() : Affiche le graphique.

info

La visualisation de la perte est une étape cruciale de l'entraînement d'un modèle. Elle permet de suivre les progrès, de détecter les problèmes et de s'assurer que le modèle converge correctement.