Machine & Deep Learning

Python TensorFlow Keras : les 9 étapes clés pour passer de zéro à opérationnel

Python TensorFlow Keras : l'essentiel en un article — vrai code, schémas et étapes concrètes, extraits d'un cours de 34 leçons.

REHOUMA Haythem

11 Jun 2026 • 12 min read

Tout le monde peut apprendre Python TensorFlow Keras — à condition de suivre les étapes dans le bon ordre. On a condensé un cours complet de 34 leçons en un parcours clair, avec les extraits de code les plus utiles.

tl;dr

Introduction et installation
Bases de TensorFlow
Keras Sequential API
Reseau dense MLP
Convolutional Neural Networks

~$ cat ./parcours.md # Python TensorFlow Keras — 10 chapitres

Introduction et installation

→ Qu'est-ce que le deep learning ?→ Installer TensorFlow 2.x+ 1 autres leçons

Bases de TensorFlow

→ Tenseurs et operations→ GradientTape et autodiff+ 1 autres leçons

Keras Sequential API

→ Sequential — empiler des couches→ Compiler — optimizer, loss, metrics+ 1 autres leçons

Réseau dense MLP

→ Architecture MLP (Multi-Layer Perceptron)→ Classification MNIST avec MLP+ 1 autres leçons

Convolutional Neural Networks

→ Convolutions et pooling→ CNN sur CIFAR-10+ 2 autres leçons

Réseaux récurrents et NLP

→ RNN, LSTM, GRU→ Embeddings pour le texte+ 2 autres leçons

Transfer learning

→ Pourquoi et quand utiliser le transfer learning→ Fine-tuning MobileNet+ 1 autres leçons

Tuning et optimisation

→ Optimizers SGD, Adam, RMSprop→ Learning rate scheduling+ 2 autres leçons

🏁

Projet final (+ 2 chapitres en chemin)

→ Tu repars avec un projet concret et démontrable

Pourquoi et quand utiliser le transfer learning

NOTEObjectif — Comprendre comment reutiliser des modeles pre-entraines sur ImageNet pour vos propres taches.

L'idee

Au lieu d'entrainer un modele from scratch (coute des jours et besoin de millions d'images), on prend un modele deja entraine sur ImageNet (1.4M images, 1000 classes) et on l'adapte.

Pourquoi ca marche ?

TIPResultat magique — Atteindre 95% accuracy sur 1000 images custom au lieu de 70% from scratch.

2 strategies principales

Strategie	Quand	Comment
Feature extraction	Petit dataset (<1000)	Geler la base, entrainer une tete
Fine-tuning	Dataset moyen (1k-10k)	Degeler les dernieres couches

Modeles pre-entraines populaires

Modele	Domaine	Taille
MobileNetV2 / V3	Images, mobile	3-5 MB
EfficientNet B0-B7	Images, top precision	20-200 MB
ResNet50 / 152	Images, classique	100-200 MB
VGG16 / 19	Images, vintage	500 MB+
BERT	NLP	400 MB
DistilBERT	NLP rapide	250 MB

Charger un modele pre-entraine

output

from tensorflow.keras.applications import MobileNetV2

base = MobileNetV2(
    input_shape=(224, 224, 3),
    include_top=False,    # enlever la tete ImageNet
    weights="imagenet"
)
base.trainable = False     # geler les poids

print(base.summary())

Construire le nouveau modele

output

from tensorflow.keras import models, layers

n_classes = 5   # vos classes

model = models.Sequential([
    layers.Input(shape=(224, 224, 3)),
    
    # Preprocessing specifique au modele
    tf.keras.applications.mobilenet_v2.preprocess_input,
    
    # Base gelee
    base,
    
    # Nouvelle tete
    layers.GlobalAveragePooling2D(),
    layers.Dropout(0.3),
    layers.Dense(n_classes, activation="softmax")
])

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

Pre-processing par modele

MobileNet	`preprocess_input` : [-1, 1]
ResNet	Moyenne ImageNet soustraite
EfficientNet	`preprocess_input` : [0, 255]

WARNINGToujours appliquer le preprocessing du modele original. Sans cela, performances mauvaises.

Quand utiliser le transfer learning

OUI

NON

Resume

NOTEA retenir

Transfer learning = reutilise un modele pre-entraine
Feature extraction si peu de data
Fine-tuning si dataset moyen
Toujours appliquer le preprocessing du modele
tf.keras.applications = modeles prets

Prochaine etape : Partie 2 — Fine-tuning MobileNet

Qu'est-ce que le deep learning ?

NOTEObjectif — Comprendre ce qui distingue le deep learning du ML classique, et quand l'utiliser.

Definition

Le deep learning est une sous-branche du machine learning utilisant des reseaux de neurones profonds (plusieurs couches cachees) pour apprendre des representations hierarchiques des donnees.

ML classique vs Deep Learning

Aspect	ML classique	Deep Learning
Donnees	Centaines a milliers	Milliers a millions
Features	Manuelles (engineering)	Apprises automatiquement
Hardware	CPU suffit	GPU/TPU recommande
Temps entrainement	Secondes a minutes	Heures a jours
Interpretabilite	Bonne	Faible (black box)
Cas d'usage	Tabulaire	Images, audio, texte

Un neurone artificiel

output

# Sortie = activation(somme(poids * entrees) + biais)
y = activation(w1*x1 + w2*x2 + ... + w_n*x_n + b)

Plusieurs neurones en parallele = couche. Plusieurs couches = reseau profond.

Anatomie d'un reseau dense

output

Input (28x28=784)
   |
   v
Couche cachee 1 (128 neurones, ReLU)
   |
   v
Couche cachee 2 (64 neurones, ReLU)
   |
   v
Couche de sortie (10 neurones, Softmax)
   |
   v
Probabilites des 10 classes

Architectures principales

MLP (Dense)

Tabulaire, classification simple. Base du DL.

CNN (Convolutional)

Images. Detecte motifs locaux via convolutions.

RNN / LSTM / GRU

Sequences : texte, audio, series temporelles.

Transformers

NLP moderne (BERT, GPT). Attention mechanism.

Quand utiliser le DL ?

TIPBons cas

Images, audio, video, texte
Beaucoup de donnees (10k+ exemples)
Performance maximale recherchee
Patterns complexes non lineaires

WARNINGMauvais cas

Donnees tabulaires < 10k lignes (preferez GBM)
Interpretabilite critique
Pas de GPU disponible
Probleme simple lineairement separable

TensorFlow vs PyTorch

TensorFlow / Keras	Production-ready, deploiement facile, mobile (TFLite)
PyTorch	Recherche, plus pythonic, dominant en NLP
JAX	Performances brutes, Google interne

Resume

NOTEA retenir

DL = reseaux profonds qui apprennent les features eux-memes
Excellent pour images, audio, texte
Necessite GPU et beaucoup de donnees
4 families : MLP, CNN, RNN, Transformer
TensorFlow + Keras = production-ready

API FastAPI + deploiement Docker

Projet final • FastAPI • Docker • production

NOTEObjectif — Servir le modele de detection masques via une API FastAPI, packager dans un conteneur Docker, et tester en production.

Structure du projet

output

mask-api/
  â“œâ”€â”€ app/
  â”‚   â“œâ”€â”€ main.py          # FastAPI
  â”‚   â“œâ”€â”€ mask_final.keras # modele
  â”‚   â””â”€â”€ __init__.py
  â“œâ”€â”€ requirements.txt
  â“œâ”€â”€ Dockerfile
  â””â”€â”€ README.md

requirements.txt

output

fastapi==0.109.0
uvicorn[standard]==0.27.0
tensorflow==2.16.1
pillow==10.2.0
python-multipart==0.0.6

app/main.py

output

from fastapi import FastAPI, UploadFile, File, HTTPException
from fastapi.responses import JSONResponse
import tensorflow as tf
import numpy as np
from PIL import Image
import io

app = FastAPI(title="Face Mask Detection", version="1.0")
model = tf.keras.models.load_model("app/mask_final.keras")
LABELS = ["with_mask", "without_mask"]

@app.get("/")
def root():
    return {"service": "face-mask-detection", "version": "1.0"}

@app.get("/health")
def health():
    return {"status": "ok", "model_loaded": True}

@app.post("/predict")
async def predict(file: UploadFile = File(...)):
    if file.content_type not in ["image/jpeg", "image/png"]:
        raise HTTPException(400, "Only JPEG/PNG allowed")
    
    contents = await file.read()
    img = Image.open(io.BytesIO(contents)).convert("RGB").resize((224, 224))
    arr = np.expand_dims(np.array(img), axis=0).astype("float32")
    
    proba = float(model.predict(arr, verbose=0)[0][0])
    label = LABELS[int(proba > 0.5)]
    confidence = proba if proba > 0.5 else 1 - proba
    
    return {
        "prediction": label,
        "confidence": round(confidence, 4),
        "with_mask_proba": round(1 - proba, 4),
        "without_mask_proba": round(proba, 4)
    }

Tester en local

output

uvicorn app.main:app --host 0.0.0.0 --port 8000 --reload

# Documentation auto sur http://localhost:8000/docs

# Test curl
curl -X POST "http://localhost:8000/predict" \
     -F "file=@test.jpg"

Dockerfile

output

FROM python:3.11-slim

WORKDIR /app

COPY requirements.txt .
RUN pip install --no-cache-dir -r requirements.txt

COPY app/ ./app/

EXPOSE 8000

HEALTHCHECK --interval=30s --timeout=10s \
    CMD curl -f http://localhost:8000/health || exit 1

CMD ["uvicorn", "app.main:app", "--host", "0.0.0.0", "--port", "8000"]

Build et run

output

docker build -t mask-detection:1.0 .
docker run -d -p 8000:8000 --name mask-api mask-detection:1.0

# Verifier
docker logs mask-api
curl http://localhost:8000/health

va-plus-loin

Cet article couvre les extraits les plus utiles — le cours complet Python TensorFlow Keras (10 chapitres, 34 leçons, exercices corrigés et projet final) t'emmène jusqu'au bout.

./acceder-au-cours-complet cours gratuit : Maîtriser Claude Code

FAQ

Combien de temps pour apprendre Python TensorFlow Keras ?

Avec une progression structurée (10 chapitres, 34 leçons courtes et pratiques), on atteint un niveau opérationnel en quelques semaines à raison de 30 à 60 minutes par jour. L'important est de pratiquer chaque notion immédiatement.

Faut-il des prérequis ?

Des bases en informatique suffisent. Si tu sais utiliser un terminal et lire du code simple, tu es prêt.

Par où commencer concrètement ?

Reproduis les commandes de cet article, puis suis le cours complet Python TensorFlow Keras : il enchaîne les 34 leçons dans l'ordre, avec exercices et projet final.

./a-lire-aussi

→ Lance-toi en Machine Learning Débutants : ton premier pas concret aujourd'hui → Machine Learning Simplifié en pratique : le code et les commandes qui comptent vraiment → Apprentissage Automatique Python : les 9 étapes clés pour passer de zéro à opérationnel

📬 Tu veux recevoir ce type de guide chaque semaine ? Abonne-toi gratuitement — code réel, zéro blabla.

Pourquoi et quand utiliser le transfer learning

L'idee

Pourquoi ca marche ?

2 strategies principales

Modeles pre-entraines populaires

Charger un modele pre-entraine

Construire le nouveau modele

Pre-processing par modele

Quand utiliser le transfer learning

OUI

NON

Resume

Qu'est-ce que le deep learning ?

Definition

ML classique vs Deep Learning

Un neurone artificiel

Anatomie d'un reseau dense

Architectures principales

MLP (Dense)

CNN (Convolutional)

RNN / LSTM / GRU

Transformers

Quand utiliser le DL ?

TensorFlow vs PyTorch

Resume

API FastAPI + deploiement Docker

Structure du projet

requirements.txt

app/main.py

Tester en local

Dockerfile

Build et run

FAQ

Stay up to date