Tutoriel : Entraîner un modèle IA simple avec Google Colab

Google Colab : votre GPU gratuit dans le cloud

Google Colab (colab.research.google.com) est un environnement de développement Python gratuit qui s’exécute dans votre navigateur. Son avantage majeur : il fournit un accès gratuit à des GPU (cartes graphiques) puissantes, essentielles pour entraîner des modèles d’intelligence artificielle. Pas besoin d’acheter un PC gamer à 1 500 000 FCFA — un simple navigateur Chrome sur votre téléphone suffit pour entraîner votre premier modèle IA.

Prise en main de Google Colab

1. Accédez à colab.research.google.com
2. Connectez-vous avec votre compte Google
3. "Nouveau notebook" → un environnement Python est prêt

Configuration du GPU gratuit :
→ Exécution → Modifier le type d'environnement d'exécution
→ Accélérateur matériel : GPU (T4)
→ Enregistrer

Vérifiez le GPU :
!nvidia-smi

# Sortie attendue :
# Tesla T4 | 15 Go VRAM | CUDA 12.x
# C'est une carte graphique qui vaut ~1 500$ — gratuite sur Colab !

Limites du plan gratuit :
- Sessions de 12h maximum (déconnexion automatique)
- GPU T4 (pas toujours disponible aux heures de pointe)
- 12.7 Go de RAM
- 78 Go de stockage temporaire
- Pas de garantie de disponibilité GPU

Plan Colab Pro (10$/mois) :
- GPU T4 garanti ou V100
- Sessions plus longues (24h)
- Plus de RAM (25+ Go)
- Priorité d'accès GPU

Plan Colab Pro+ (50$/mois) :
- GPU A100 (80 Go VRAM !)
- Sessions en arrière-plan
- 52 Go de RAM

Projet 1 : Classificateur d’images (chiens vs chats)

Notre premier projet consiste à entraîner un réseau de neurones qui distingue les photos de chiens et de chats. C’est le « Hello World » du machine learning visuel.

# Cellule 1 : Installer et importer les bibliothèques
import tensorflow as tf
from tensorflow import keras
from tensorflow.keras import layers
import matplotlib.pyplot as plt
import numpy as np

print(f"TensorFlow version : {tf.__version__}")
print(f"GPU disponible : {tf.config.list_physical_devices('GPU')}")

# Cellule 2 : Télécharger le dataset Cats vs Dogs
import tensorflow_datasets as tfds

# Le dataset contient 23 262 images de chiens et chats
(train_ds, val_ds), info = tfds.load(
    'cats_vs_dogs',
    split=['train[:80%]', 'train[80%:]'],
    as_supervised=True,
    with_info=True
)

print(f"Images d'entraînement : {tf.data.experimental.cardinality(train_ds).numpy()}")
print(f"Images de validation : {tf.data.experimental.cardinality(val_ds).numpy()}")

# Cellule 3 : Préparer les données
IMG_SIZE = 150

def preprocess(image, label):
    """Redimensionne et normalise les images"""
    image = tf.image.resize(image, (IMG_SIZE, IMG_SIZE))
    image = image / 255.0  # Normaliser entre 0 et 1
    return image, label

# Appliquer le prétraitement
train_ds = train_ds.map(preprocess).batch(32).prefetch(tf.data.AUTOTUNE)
val_ds = val_ds.map(preprocess).batch(32).prefetch(tf.data.AUTOTUNE)

# Visualiser quelques images
plt.figure(figsize=(12, 6))
for images, labels in train_ds.take(1):
    for i in range(8):
        plt.subplot(2, 4, i+1)
        plt.imshow(images[i])
        plt.title("Chat" if labels[i] == 0 else "Chien")
        plt.axis("off")
plt.tight_layout()
plt.show()

# Cellule 4 : Construire le modèle CNN
model = keras.Sequential([
    # Couche de convolution 1 : détecte les bords et textures
    layers.Conv2D(32, (3, 3), activation='relu', input_shape=(IMG_SIZE, IMG_SIZE, 3)),
    layers.MaxPooling2D((2, 2)),
    
    # Couche de convolution 2 : détecte les formes simples
    layers.Conv2D(64, (3, 3), activation='relu'),
    layers.MaxPooling2D((2, 2)),
    
    # Couche de convolution 3 : détecte les formes complexes
    layers.Conv2D(128, (3, 3), activation='relu'),
    layers.MaxPooling2D((2, 2)),
    
    # Couche de convolution 4 : détecte les objets
    layers.Conv2D(128, (3, 3), activation='relu'),
    layers.MaxPooling2D((2, 2)),
    
    # Aplatir et classifier
    layers.Flatten(),
    layers.Dropout(0.5),               # Régularisation (éviter le surapprentissage)
    layers.Dense(512, activation='relu'),
    layers.Dense(1, activation='sigmoid')  # 1 sortie : 0=chat, 1=chien
])

model.summary()
# Total params: ~3.5 millions
# Trainable params: ~3.5 millions

# Cellule 5 : Compiler et entraîner
model.compile(
    optimizer='adam',
    loss='binary_crossentropy',    # Perte pour classification binaire
    metrics=['accuracy']
)

# Entraîner pendant 10 époques (~5-10 min sur GPU T4)
print("Début de l'entraînement...")
history = model.fit(
    train_ds,
    epochs=10,
    validation_data=val_ds,
    verbose=1
)

# Sortie typique :
# Epoch 1/10 — accuracy: 0.65 — val_accuracy: 0.72
# Epoch 2/10 — accuracy: 0.76 — val_accuracy: 0.78
# ...
# Epoch 10/10 — accuracy: 0.89 — val_accuracy: 0.85

# Cellule 6 : Visualiser les résultats d'entraînement
fig, (ax1, ax2) = plt.subplots(1, 2, figsize=(14, 5))

# Courbe de précision
ax1.plot(history.history['accuracy'], label='Entraînement', linewidth=2)
ax1.plot(history.history['val_accuracy'], label='Validation', linewidth=2)
ax1.set_title('Précision du modèle')
ax1.set_xlabel('Époque')
ax1.set_ylabel('Précision')
ax1.legend()
ax1.grid(True, alpha=0.3)

# Courbe de perte
ax2.plot(history.history['loss'], label='Entraînement', linewidth=2)
ax2.plot(history.history['val_loss'], label='Validation', linewidth=2)
ax2.set_title('Perte du modèle')
ax2.set_xlabel('Époque')
ax2.set_ylabel('Perte')
ax2.legend()
ax2.grid(True, alpha=0.3)

plt.tight_layout()
plt.show()

# Si la courbe de validation plafonne ou remonte → surapprentissage
# Solution : ajouter plus de dropout, augmenter les données, 
# ou utiliser le transfer learning (voir ci-dessous)

# Cellule 7 : Tester sur une nouvelle image
from google.colab import files
import PIL

# Option 1 : Upload une image depuis votre ordinateur
uploaded = files.upload()  # Cliquez pour uploader

# Option 2 : Télécharger une image depuis Internet
!wget -O test_image.jpg "https://example.com/photo-chat.jpg"

# Prédire
from tensorflow.keras.preprocessing import image

img = image.load_img("test_image.jpg", target_size=(IMG_SIZE, IMG_SIZE))
img_array = image.img_to_array(img) / 255.0
img_array = np.expand_dims(img_array, axis=0)

prediction = model.predict(img_array)[0][0]
label = "Chien 🐕" if prediction > 0.5 else "Chat 🐱"
confidence = prediction if prediction > 0.5 else 1 - prediction

plt.imshow(image.load_img("test_image.jpg"))
plt.title(f"Prédiction : {label} ({confidence:.1%})")
plt.axis("off")
plt.show()

Projet 2 : Transfer Learning (précision 95%+)

Notre modèle précédent atteint ~85% de précision. Pour faire mieux sans collecter plus de données, on utilise le transfer learning : prendre un modèle déjà entraîné sur des millions d’images (MobileNetV2) et l’adapter à notre tâche spécifique.

# Transfer Learning avec MobileNetV2

# Charger le modèle pré-entraîné (sans la dernière couche)
base_model = keras.applications.MobileNetV2(
    input_shape=(IMG_SIZE, IMG_SIZE, 3),
    include_top=False,            # Enlever la dernière couche de classification
    weights='imagenet'            # Poids pré-entraînés sur 14M d'images
)

# Geler les couches pré-entraînées (ne pas les modifier)
base_model.trainable = False

# Ajouter nos propres couches de classification
model_transfer = keras.Sequential([
    base_model,
    layers.GlobalAveragePooling2D(),
    layers.Dropout(0.3),
    layers.Dense(256, activation='relu'),
    layers.Dropout(0.3),
    layers.Dense(1, activation='sigmoid')
])

model_transfer.compile(
    optimizer=keras.optimizers.Adam(learning_rate=0.001),
    loss='binary_crossentropy',
    metrics=['accuracy']
)

model_transfer.summary()
# Total params: ~2.3 millions
# Trainable params: ~330 000 (seulement nos couches ajoutées !)
# Non-trainable params: ~2.2 millions (couches MobileNetV2 gelées)

# Entraîner (beaucoup plus rapide car on entraîne peu de paramètres)
history_transfer = model_transfer.fit(
    train_ds,
    epochs=5,          # 5 époques suffisent avec le transfer learning
    validation_data=val_ds
)

# Résultat typique :
# Epoch 1/5 — accuracy: 0.94 — val_accuracy: 0.96
# Epoch 5/5 — accuracy: 0.97 — val_accuracy: 0.96
# → 96% de précision en validation (vs 85% avant) !

Projet 3 : Analyse de sentiments sur des avis clients

# Classificateur de sentiments pour avis clients en français

!pip install transformers datasets torch

from transformers import pipeline, AutoTokenizer, AutoModelForSequenceClassification
import torch

# Charger un modèle pré-entraîné pour le français
sentiment_pipeline = pipeline(
    "sentiment-analysis",
    model="nlptown/bert-base-multilingual-uncased-sentiment",
    device=0  # Utiliser le GPU
)

# Tester sur des avis clients (contexte sénégalais)
avis = [
    "Le service est excellent, livraison rapide à Dakar !",
    "Très mauvaise qualité, le produit ne fonctionne pas du tout",
    "Correct pour le prix, mais l'emballage était abîmé",
    "Je recommande fortement cette boutique, personnel très aimable",
    "Arnaque totale, ne commandez jamais chez eux !",
    "La livraison a pris 5 jours au lieu de 2, mais le produit est bien",
    "Meilleur rapport qualité-prix à Dakar, merci !",
]

print("=== ANALYSE DE SENTIMENTS — AVIS CLIENTS ===
")
for texte in avis:
    result = sentiment_pipeline(texte)[0]
    stars = int(result['label'][0])  # Extraire le nombre d'étoiles
    sentiment = "😊 Positif" if stars >= 4 else "😐 Neutre" if stars == 3 else "😠 Négatif"
    print(f"{sentiment} ({stars}★) | {texte}")
    print(f"   Confiance : {result['score']:.1%}
")

# Sortie :
# 😊 Positif (5★) | Le service est excellent, livraison rapide à Dakar !
#    Confiance : 87.3%
# 😠 Négatif (1★) | Très mauvaise qualité, le produit ne fonctionne pas
#    Confiance : 92.1%
# 😐 Neutre (3★) | Correct pour le prix, mais l'emballage était abîmé
#    Confiance : 65.4%
# ...

# Entraîner votre propre modèle de sentiment (spécifique à votre domaine)

from datasets import Dataset
from transformers import Trainer, TrainingArguments

# Vos données d'entraînement (avis collectés manuellement)
data = {
    "text": [
        "Livraison ultra rapide, je suis fan !",
        "Le téléphone est arrivé cassé, honteux",
        "RAS, conforme à la description",
        "Meilleur prix du marché, je reviens c'est sûr",
        "Service client inexistant, impossible de les joindre",
        "Bon produit, livraison un peu lente mais acceptable",
        # ... ajoutez 50-100 exemples pour de bons résultats
    ],
    "label": [2, 0, 1, 2, 0, 1]  # 0=négatif, 1=neutre, 2=positif
}

dataset = Dataset.from_dict(data)
dataset = dataset.train_test_split(test_size=0.2)

# Tokeniser
tokenizer = AutoTokenizer.from_pretrained("camembert-base")

def tokenize(examples):
    return tokenizer(examples["text"], padding="max_length", truncation=True, max_length=128)

tokenized_ds = dataset.map(tokenize, batched=True)

# Charger CamemBERT (modèle français)
model = AutoModelForSequenceClassification.from_pretrained(
    "camembert-base", 
    num_labels=3
)

# Configurer l'entraînement
training_args = TrainingArguments(
    output_dir="./sentiment_model",
    num_train_epochs=5,
    per_device_train_batch_size=8,
    evaluation_strategy="epoch",
    save_strategy="epoch",
    learning_rate=2e-5,
    weight_decay=0.01,
    fp16=True,  # Entraînement en précision mixte (plus rapide)
)

trainer = Trainer(
    model=model,
    args=training_args,
    train_dataset=tokenized_ds["train"],
    eval_dataset=tokenized_ds["test"],
    tokenizer=tokenizer,
)

# Lancer l'entraînement (~2-5 min sur GPU T4)
trainer.train()

# Sauvegarder le modèle
trainer.save_model("./mon_modele_sentiment")
print("Modèle sauvegardé !")

Sauvegarder et réutiliser votre modèle

# Sauvegarder sur Google Drive (persistant)
from google.colab import drive
drive.mount('/content/drive')

# Sauvegarder le modèle Keras
model_transfer.save('/content/drive/MyDrive/modeles_ia/cats_dogs_v1.keras')
print("Modèle sauvegardé sur Google Drive !")

# Charger le modèle plus tard
model_charge = keras.models.load_model(
    '/content/drive/MyDrive/modeles_ia/cats_dogs_v1.keras'
)

# Sauvegarder le modèle Hugging Face
trainer.save_model('/content/drive/MyDrive/modeles_ia/sentiment_fr')

# Publier sur Hugging Face Hub (optionnel, rend votre modèle public)
!pip install huggingface_hub
from huggingface_hub import login
login(token="hf_votre_token")  # Créez un token sur huggingface.co

trainer.push_to_hub("mon-modele-sentiment-senegal")
# Votre modèle est maintenant disponible sur huggingface.co !

Conseils pour bien utiliser Google Colab

Sauvegardez régulièrement sur Google Drive. Les fichiers sur Colab sont temporaires — quand la session se termine, tout est effacé. Montez votre Google Drive dès le début de chaque session et sauvegardez vos modèles et données dessus.

Utilisez le GPU uniquement pour l’entraînement. Le GPU gratuit est limité. Ne le gaspillez pas pour du code qui n’en a pas besoin (préparation de données, visualisations). Basculez en CPU pour ces tâches et repassez en GPU pour l’entraînement.

Optimisez la mémoire. Si vous avez des erreurs « Out of Memory », réduisez la taille du batch (batch_size=16 au lieu de 32), utilisez la précision mixte (fp16=True) ou choisissez un modèle plus petit.

Commencez petit, itérez. Entraînez d’abord sur un petit sous-ensemble de données pendant 2-3 époques pour vérifier que tout fonctionne. Une fois validé, lancez l’entraînement complet. Cela évite de perdre 2 heures de GPU à cause d’une erreur dans le code.