Intelligence Artificielle

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

16 دقائق للقراءة

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ètrès)
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-modèle-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 terminé, 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.

Quel premier projet pour apprendre en pratique ?

Le piège classique pour qui débute en machine learning est de vouloir entraîner GPT depuis zéro. Cette approche dépasse de plusieurs ordres de grandeur ce qu’un GPU T4 peut faire en une session Colab. Trois familles de projets sont à la fois pédagogiquement riches et techniquement réalisables sur l’offre gratuite.

Le premier est la classification d’images sur un dataset standard comme CIFAR-10 ou un dataset personnel (50 à 500 images par classe). Un réseau de neurones convolutionnel modeste (ResNet-18 pré-entraîné, fine-tuné sur vos classes) atteint des taux d’exactitude supérieurs à 90 % en moins de 10 minutes d’entraînement, et illustre concrètement les notions de batch size, learning rate, et data augmentation. Le second est la classification de texte avec un modèle BERT pré-entraîné (DistilBERT ou CamemBERT pour le français), fine-tuné sur quelques milliers d’exemples. Le troisième, plus avancé, est le fine-tuning d’un petit LLM avec la technique LoRA (Low-Rank Adaptation) : un Mistral-7B ou un Llama-3-8B peut être spécialisé sur un domaine en quelques heures sur un T4 grâce à la quantisation 4-bit fournie par la bibliothèque bitsandbytes et le framework PEFT de Hugging Face.

L’écosystème indispensable autour de Colab

Colab seul est un environnement minimal. Quatre outils complémentaires structurent un projet réel.

Hugging Face est devenu le standard de facto pour la communauté ML. Le hub propose plus de 750 000 modèles pré-entraînés en 2026 (compteur public sur huggingface.co), tous téléchargeables en deux lignes via la bibliothèque transformers. Les datasets publics couvrent la plupart des cas d’usage (classification, NER, traduction, résumé, dialogue). L’authentification se fait avec un token personnel à coller dans un secret Colab.

Google Drive sert de stockage persistant. Les sessions Colab sont éphémères — l’instance disparaît typiquement après 12 heures d’inactivité. Monter Drive avec drive.mount('/content/drive') permet de sauvegarder les modèles, les checkpoints et les datasets entre sessions sans tout retélécharger.

Weights & Biases (wandb.ai) ou TensorBoard fournissent l’observabilité du training : courbes de perte, métriques d’évaluation, hyperparamètres versionnés. C’est ce qui transforme un script de notebook en projet reproductible. La version gratuite de W&B est largement suffisante pour un usage individuel.

Git/GitHub stocke le notebook (.ipynb) avec les commits, permet la collaboration et le versionnage. Colab s’intègre nativement : Fichier → Enregistrer une copie dans GitHub.

Limites du plan gratuit et quand passer à payant

Le plan gratuit Colab impose plusieurs contraintes documentées sur la page tarifs officielle. La session est limitée à environ 12 heures continues, avec une durée d’inactivité maximale de 90 minutes avant déconnexion. La RAM est plafonnée à 12 Go, la VRAM GPU à 15 Go (T4), et le quota GPU est partagé : durant les heures de pointe, l’accès GPU peut être refusé et l’utilisateur basculer en CPU only, ce qui rend l’entraînement impraticable.

Pour un usage régulier, trois paliers commerciaux existent. Colab Pro (~10 USD par mois en 2026) garantit l’accès GPU prioritaire et étend la durée de session à 24 heures. Colab Pro+ (~50 USD par mois) ajoute l’exécution en arrière-plan (le notebook continue à tourner même fenêtre fermée) et des GPU plus puissants (L4 ou A100 selon la disponibilité). Au-delà, Colab Enterprise via Google Cloud s’adresse aux équipes et facture à l’usage.

Comparaison rapide avec les alternatives sérieuses pour ML individuel en 2026. Kaggle Notebooks offre 30 heures hebdomadaires de GPU P100 ou T4 gratuit, idéal pour qui participe aux compétitions du même nom. Lightning AI Studios propose 22 GPU-heures gratuites mensuelles sur du matériel récent. Paperspace Gradient et RunPod facturent à la minute (à partir de 0,30 USD/h pour un T4) sans engagement, ce qui convient pour les sessions ponctuelles d’entraînement long. Vast.ai permet de louer du GPU consommateur (RTX 3090, 4090) à des tarifs concurrentiels, avec moins de garantie de disponibilité.

Bonnes pratiques pour ne pas perdre son travail

La majorité des frustrations Colab vient de la perte de données quand la session expire. Cinq pratiques règlent le problème.

Toujours monter Drive en début de notebook et configurer un répertoire de travail dédié (/content/drive/MyDrive/mlproject/). Tous les datasets, modèles et logs y vont. Sauvegarder un checkpoint après chaque epoch avec torch.save(model.state_dict(), 'checkpoint.pt') ou l’équivalent Keras. Loguer les hyperparamètres et résultats dans W&B ou un simple results.json incrémental. Utiliser des seeds déterministes (torch.manual_seed(42), numpy.random.seed(42)) pour rendre les expériences reproductibles. Pinner les versions des bibliothèques dans une cellule !pip install -r requirements.txt au lieu de laisser pip prendre la dernière version automatiquement — un upgrade de transformers peut casser un script écrit 6 mois plus tôt.

Risques et limites éthiques

Entraîner un modèle d’IA implique trois précautions souvent négligées par les débutants. La licence des données est le premier point : un dataset téléchargé depuis Kaggle ou Hugging Face est gouverné par une licence (souvent Creative Commons, parfois research-only) qui restreint les usages commerciaux. Vérifier la licence avant tout déploiement en production. Les biais du modèle reproduisent les biais des données : un classifieur entraîné sur des photos majoritairement européennes performe mal sur d’autres populations. Au minimum, mesurer les performances par sous-groupe avant déploiement. La protection des données personnelles s’applique dès qu’on utilise des emails, des messages ou des photos identifiables — supprimer les informations directement identifiantes, et documenter le traitement conformément aux exigences locales.

FAQ

Combien de temps pour entraîner un modèle de classification d’images sur Colab ?
Un ResNet-18 fine-tuné sur un dataset de 5 000 images réparties en 10 classes converge en 5 à 10 minutes sur un T4. Un CNN entraîné from scratch sur CIFAR-10 prend 20 à 40 minutes. Un BERT fine-tuné pour classification de texte sur 10 000 exemples prend 15 à 30 minutes.

Peut-on entraîner un modèle d’image generation (Stable Diffusion) sur Colab gratuit ?
Inférence oui (génération d’images depuis un modèle existant), entraînement complet non. Le fine-tuning LoRA ou DreamBooth d’un Stable Diffusion sur 10 à 30 images personnelles est faisable en 30 à 60 minutes sur un T4. L’entraînement complet d’un modèle de diffusion depuis zéro demande des dizaines de GPU-heures et n’est pas réaliste sur Colab gratuit.

Mes données sont-elles privées sur Colab ?
Le contenu des notebooks est privé par défaut (visible uniquement par votre compte Google et les personnes invitées). Les datasets uploadés sur l’instance Colab y restent le temps de la session. En revanche, les modèles publics téléchargés depuis Hugging Face transitent sans chiffrement de bout en bout — pour des données sensibles, préférer un environnement maîtrisé (Paperspace privé, RunPod, ou GPU on-premise).

Que faire quand Colab ne donne plus de GPU ?
Patienter quelques heures (le quota est attribué dynamiquement), basculer sur Kaggle Notebooks pour la session courante, ou souscrire Colab Pro qui garantit l’accès prioritaire. Pour un projet régulier, planifier les sessions tôt le matin ou tard le soir améliore notablement la disponibilité GPU.

Références et ressources

#entraînement #google colab #modèle
Service ITSkillsCenter

Application mobile Android et iOS

Création d'application mobile Android et iOS. À partir de 350 000 FCFA.

Démarrer mon projet
Publicité