Python Pour l’IA

Pr. EL AZAMI
[Link]@[Link]
Chapitre 6: TensorFlow/Keras
Deep Learning

elazami © 2025-2026 2
Introduction: Définition DL
Définition du Deep Learning
• Le Deep Learning (ou apprentissage profond) est une branche du machine learning qui utilise des
réseaux de neurones artificiels comportant plusieurs couches pour apprendre
automatiquement des représentations complexes à partir de grandes quantités de données.
• Il permet d’extraire lui-même les caractéristiques pertinentes, sans nécessiter une ingénierie
manuelle des features,
• et atteint des performances très élevées dans des tâches comme:
• la vision par ordinateur,
• le traitement du langage naturel ou
• la reconnaissance vocale.

elazami © 2025-2026 3
Introduction: Éléments Fondamentaux du DL
1. Réseaux de neurones artificiels (ANN)
• Un réseau est composé de :
- Neurones (nœuds)
- Poids et biais
- Fonctions d’activation (ReLU, Sigmoid, Tanh, etc.)
• Chaque neurone calcule une combinaison linéaire, suivie d’une activation non linéaire.

elazami © 2025-2026 4
Introduction: Éléments Fondamentaux du DL
2. Architecture en couches profondes
Les modèles deep learning utilisent plusieurs couches :
- Couche d’entrée
- Couches cachées (souvent nombreuses)
- Couche de sortie
• Plus il y a de couches, plus le modèle peut apprendre des représentations abstraites et
complexes.

elazami © 2025-2026 5
Introduction: Éléments Fondamentaux du DL
3. Propagation avant (Forward Propagation)
• Les données traversent les couches du réseau pour produire une prédiction.
• Chaque couche transforme progressivement la représentation des données.

elazami © 2025-2026 6
Introduction: Éléments Fondamentaux du DL
4. Fonction de perte (Loss Function)
• Elle mesure l’erreur entre la prédiction et la réalité :
- MSE pour la régression
- Cross Entropy pour la classification
- etc.
• L’objectif est de minimiser cette erreur.

elazami © 2025-2026 7
 Introduction: Éléments Fondamentaux du DL
4. Fonction de perte (Loss Function)

elazami © 2025-2026 8
Introduction: Éléments Fondamentaux du DL
5. Rétropropagation et optimisation
• Le réseau ajuste ses paramètres grâce :
- à la rétropropagation du gradient
- à un optimiseur (SGD, Adam, RMSprop…)
• Ce processus met à jour les poids pour réduire progressivement la fonction de perte.

elazami © 2025-2026 9
Introduction: Éléments Fondamentaux du DL
6. Grand volume de données et GPU
• Le deep learning fonctionne généralement mieux lorsque :
- il y a beaucoup de données,
- ou la réalisation d’apprentissage via GPU/TPU pour accélérer les calculs
matriciels massifs.

elazami © 2025-2026 10
Introduction: Éléments Fondamentaux du DL
7. Spécialisation des architectures
Selon les tâches :
• CNN (Convolutional Neural Networks) → images
• RNN / LSTM / GRU → séquences, texte
• Transformers → NLP, Vision, multimodal
• Auto-encoders → réduction de dimension, génération
• GAN → génération d’images réalistes

elazami © 2025-2026 11
DL: TensorFlow
• TensorFlow est un framework open-source de Google conçu pour créer, entraîner et
déployer des modèles de deep learning.
• Il fonctionne en manipulant des tensors (tableaux multidimensionnels) et en utilisant
des graphes de calcul pour exécuter efficacement les opérations mathématiques sur
CPU, GPU ou TPU.

elazami © 2025-2026 12
TensorFlow: Éléments fondamentaux
1. Les Tensors : la base de TensorFlow
• Un tensor est simplement un tableau de données :
• scalaire : 0D
• vecteur : 1D
• matrice : 2D
• tenseur : nD
• TensorFlow manipule les données sous forme de tensors, ce qui permet de faire des
opérations parallélisées et optimisées.

elazami © 2025-2026 13
TensorFlow: Éléments fondamentaux
2. Le graphe de calcul
• TensorFlow fonctionne en créant un graphe computationnel :
• les nœuds = opérations mathématiques (matrices, convolutions, activations…)
• les arêtes = tensors qui circulent entre les nœuds
• Ce graphe est ensuite exécuté par le moteur TensorFlow (runtime), ce qui rend
l’entraînement rapide et optimisé, notamment sur GPU/TPU.

elazami © 2025-2026 14
TensorFlow: Éléments fondamentaux
3. Création des modèles
TensorFlow propose deux approches principales :
• API Keras (haut niveau – la plus utilisée)
• Simple, intuitive
• Création de modèles en quelques lignes
• exemple : [Link], [Link]()
• TensorFlow Core (bas niveau)
• Contrôle total des opérations
• Permet de construire des modèles personnalisés
• Aujourd’hui, Keras est l’API standard pour le deep learning avec TensorFlow.

elazami © 2025-2026 15
TensorFlow: Éléments fondamentaux
4. Forward Pass (propagation avant)
• Quand une entrée traverse le modèle :
1. le tensor passe par chaque couche
2. chaque couche applique une opération : convolution, multiplication matricielle,
activation…
3. un tensor de sortie est produit
• TensorFlow exécute ces opérations de façon optimisée via le graphe.

elazami © 2025-2026 16
TensorFlow: Éléments fondamentaux
5. Calcul de la fonction de perte
• Après la prédiction, TensorFlow calcule l'erreur via une loss function (ex : cross-entropy).
• La perte est un scalaire représentant la qualité du modèle.

elazami © 2025-2026 17
TensorFlow: Éléments fondamentaux
6. Rétropropagation automatique (AutoDiff)
TensorFlow utilise Automatic Differentiation pour calculer automatiquement :
• les gradients de la perte
• par rapport aux poids du réseau
Il utilise pour cela :

with [Link]() as tape:

• Cela remplace le calcul manuel et rend

l’entraînement automatisé.

elazami © 2025-2026 18
TensorFlow: Éléments fondamentaux
7. Optimisation
• Les gradients sont envoyés à un optimiseur qui met à jour les poids du modèle pour
réduire la perte:
• Adam
• SGD
• RMSprop
• TensorFlow fait cela automatiquement lors de l’appel à :

[Link](...)

elazami © 2025-2026 19
TensorFlow: Éléments fondamentaux
8. Entraînement (Training Loop)
• En résumé, chaque epoch suit cette boucle :
1. Passage des données dans le modèle (forward pass)
2. Calcul de la perte
3. Gradient des poids via autodiff
4. Mise à jour des poids via l’optimiseur
5. Suivi des métriques (accuracy, loss, etc.)
• TensorFlow optimise tout cela en parallèle (batches, GPU…).

elazami © 2025-2026 20
TensorFlow: Éléments fondamentaux
9. Exécution accélérée (GPU / TPU)
TensorFlow sait optimiser automatiquement :
• la parallélisation des opérations
• l’utilisation de NVIDIA CUDA pour les GPUs
• l’accélération sur les TPUs de Google
L’utilisateur n’a qu’à écrire :

with [Link]('/GPU:0'): # ou TPU:0 ou CPU:0 ou GPU:1

• Mais même sans cela, TensorFlow choisit automatiquement le meilleur device.

elazami © 2025-2026 21
TensorFlow: Éléments fondamentaux
10. Sauvegarde et déploiement
TensorFlow permet facilement de :
• sauvegarder un modèle ([Link]())
• l’exporter en format TensorFlow SavedModel
• l'utiliser pour l’inference dans :
• TensorFlow Lite (mobile)
• [Link] (web)
• serveurs de production

elazami © 2025-2026 22
TensorFlow
En résumé:
TensorFlow fonctionne en :
• manipulant des tensors
• créant un graphe d’opérations
• exécutant ce graphe de manière optimisée
• automatisant la forward pass, la loss, la rétropropagation, et l’optimisation
• permettant un entraînement accéléré via GPU/TPU
• facilitant la création, l’entraînement et le déploiement de modèles via Keras

elazami © 2025-2026 23
Exemple: TensorFlow/Keras
Exemple simple en TensorFlow/Keras
• un petit modèle de classification sur le dataset MNIST (chiffres manuscrits).
• Objectif : Entraîner un réseau de neurones fully connected (dense) pour reconnaître des chiffres (0–9).
import tensorflow as tf # 3. Compiler le modèle
from [Link] import layers, models [Link](
optimizer='adam',
# 1. Charger le dataset MNIST loss='sparse_categorical_crossentropy',
(x_train, y_train), (x_test, y_test) = [Link].load_data() metrics=['accuracy']
)
# Normalisation des images (0-255 ➜ 0-1)
x_train = x_train / 255.0 # 4. Entraîner le modèle
x_test = x_test / 255.0 [Link](x_train, y_train, epochs=5, batch_size=32)

# Aplatir les images 28x28 → 784 # 5. Évaluer sur le test set

x_train = x_train.reshape(-1, 28*28) loss, accuracy = [Link](x_test, y_test)
x_test = x_test.reshape(-1, 28*28) print(f"Test accuracy : {accuracy:.4f}")

# 2. Construire le modèle # 6. Faire une prédiction

model = [Link]([ pred = [Link](x_test[:1])
[Link](128, activation='relu', input_shape=(784,)), print("Classe prédite :", [Link]())
[Link](64, activation='relu'),
[Link](10, activation='softmax') # 10 classes
])

elazami © 2025-2026 24
Sample images from MNIST test dataset

elazami © 2025-2026 25
elazami © 2025-2026 26
 Exemple: TensorFlow/Keras
Explication des étapes:
# Importation
import tensorflow as tf
from [Link] import layers, models

On importe TensorFlow et ses sous-modules Keras.

• layers permet de créer les différentes couches du réseau.
• models permet de construire et assembler le modèle neuronal.

# 1. Chargement des données

(x_train, y_train), (x_test, y_test) = [Link].load_data()

• On charge le dataset MNIST, un jeu d’images 28×28 de chiffres manuscrits.

• Keras fournit directement ce dataset très utilisé pour les exemples, pour éviter de télécharger
des données manuellement.
• [Link] fournit directement les images 28×28 en niveaux de gris.

elazami © 2025-2026 27
Exemple: TensorFlow/Keras
Prétraitement
• normalisation pour stabiliser l'entraînement
• reshape pour transformer l’image en vecteur
# Normalisation des images (0-255 ➜ 0-1)
x_train = x_train / 255.0
x_test = x_test / 255.0
• Les images ont des valeurs de pixels entre 0 et 255.
• Diviser par 255 ramène les valeurs entre 0 et 1, ce qui stabilise et accélère l’entraînement
(meilleure convergence du gradient).
# Aplatir les images 28x28 → 784
x_train = x_train.reshape(-1, 28*28) #-1 représente le nombre automatique d’images.
x_test = x_test.reshape(-1, 28*28) # On transforme chaque image en vector de 784 valeurs.

• Les images sont des matrices 28×28.

• Les couches Dense de Keras attendent un vecteur (1 dimension).
• On transforme donc 28×28 → 784 pour pouvoir les donner au réseau fully connected.
elazami © 2025-2026 28
 Exemple: TensorFlow/Keras
Architecture du modèle
• 2 couches denses cachées (128 et 64 neurones)
• activation ReLU
• softmax final → probabilités des 10 classes
# 2. Construire le modèle
model = [Link]([
[Link](128, activation='relu', input_shape=(784,)),
[Link](64, activation='relu'),
[Link](10, activation='softmax')
])

[Link]([...]) [Link](64, activation='relu')

On utilise l’API Sequential car le modèle est linéaire : •Deuxième couche cachée, plus petite que la première.
une couche → une autre → une autre. •Pourquoi ? Réduction progressive de la dimension →
C’est la façon la plus simple de construire un réseau feedforward. aide à la généralisation et réduit le surapprentissage.
[Link](128, activation='relu', input_shape=(784,)) [Link](10, activation='softmax')
•Dense(128) : première couche avec 128 neurones •10 neurones → une sortie par classe (0 à 9).
•Pourquoi ? C’est une taille courante pour débuter, offrant une •softmax transforme la sortie en probabilités qui
bonne capacité d’apprentissage. somment à 1.
•activation='relu' : ReLU est l’activation la plus utilisée pour éviter •Pourquoi ? indispensable pour un problème de
le problème du gradient qui disparaît. classification multiclasse.
•input_shape=(784,) : on spécifie la forme des données en entrée
(obligatoire pour la première couche).
elazami © 2025-2026 29
Exemple: TensorFlow/Keras
# 3. Compiler le modèle
[Link](
optimizer='adam',
loss='sparse_categorical_crossentropy',
metrics=['accuracy']
)
optimizer='adam'
Adam est l’un des meilleurs optimiseurs par défaut :
• rapide,
• robuste,
• adapté aux données bruitées.

loss='sparse_categorical_crossentropy'
Cette fonction de perte est adaptée lorsque :
• on a plusieurs classes
• les labels sont des entiers (0,1,2,…), pas des vecteurs one-hot.

metrics=['accuracy']
• On veut suivre la précision pendant l’entraînement.
• Pourquoi ? C’est la métrique la plus intuitive pour la classification.
elazami © 2025-2026 30
 Exemple: TensorFlow/Keras
# 4. Entraîner le modèle

[Link](x_train, y_train, epochs=5, batch_size=32)

[Link]()
C’est la fonction qui lance tout le processus d’entraînement :
• propagation avant (forward pass)
• calcul de la perte (loss function)
• rétropropagation automatique
• mise à jour des poids
epochs=5 : On passe 5 fois sur toutes les données.
Pourquoi 5 ? C’est suffisant pour MNIST, dataset simple.
batch_size=32 : On entraîne le réseau par mini-lots de 32 images.
Pourquoi ? c’est un compromis standard entre vitesse et stabilité du gradient.
MNIST contien 70 000 images (60 000 pour l’entrainement et 10 000 de test)

elazami © 2025-2026 31
Exemple: TensorFlow/Keras
# 5. Évaluer sur le test set

loss, accuracy = [Link](x_test, y_test)

print(f"Test accuracy : {accuracy:.4f}")

[Link]() teste le modèle sur des données jamais vues (jeu de test).
• On obtient la perte et la précision.
• Cela permet de mesurer la capacité de généralisation du modèle.

elazami © 2025-2026 32
Exemple: TensorFlow/Keras
# 6. Faire une prédiction

pred = [Link](x_test[:1])
print("Classe prédite :", [Link]())

predict()
Permet d’utiliser le modèle entraîné pour faire une prédiction.
x_test[:1]
On prend une seule image du test (la première).
argmax()
Le softmax renvoie un vecteur de probabilités → on prend la classe avec la plus grande probabilité.

elazami © 2025-2026 33
Exercice: TensorFlow
Exercice : Classification d’images de vêtements avec un réseau de neurones (Fashion-MNIST)
• Construire, entraîner et évaluer un modèle de Deep Learning (réseau de neurones fully-connected)
pour classer des images 28×28 de vêtements dans 10 catégories (T-shirt, sneakers, pull, etc.).

• On vous donne le dataset Fashion-MNIST, composé de 70 000 images en niveaux de gris de vêtements,
déjà disponible dans Keras.
Vous devez :
1. Charger les données via TensorFlow/Keras.
2. Normaliser les images.
3. Construire un réseau de neurones feedforward avec les couches suivantes :
Flatten
Dense 128 neurones, activation ReLU
Dense 10 neurones, activation softmax
4. Compiler le modèle avec :
Optimizer : Adam
Loss : sparse_categorical_crossentropy
Metrics : accuracy
5. Entraîner le modèle (epochs = 10).
6. Évaluer le modèle sur les données de test.
7. Effectuer une prédiction sur une image du test.

elazami © 2025-2026 34
 Exercice: Solution
import tensorflow as tf # 5. Entraînement
from [Link] import layers, models history = [Link](X_train, y_train, epochs=10,
validation_split=0.1)
# 1. Charger les données
(X_train, y_train), (X_test, y_test) = [Link].fashion_mnist.load_data() # 6. Évaluation
test_loss, test_acc = [Link](X_test, y_test)
# 2. Normalisation : convertir les pixels de [0,255] -> [0,1] print("Accuracy sur test :", test_acc)
X_train = X_train / 255.0
X_test = X_test / 255.0 # 7. Prédiction d'une image
import numpy as np
# 3. Construire le modèle index = 0
model = [Link]([ image = X_test[index].reshape(1, 28, 28)
[Link](input_shape=(28, 28)), # transformer image 2D en vecteur prediction = [Link](image)
[Link](128, activation='relu'),
[Link](10, activation='softmax') # 10 classes print("Classe prédite :", [Link](prediction))
]) print("Classe réelle :", y_test[index])

# 4. Compiler le modèle
[Link](
optimizer='adam',
loss='sparse_categorical_crossentropy',
metrics=['accuracy']
)

elazami © 2025-2026 35