🧠 TensorFlow – La Plateforme de Machine Learning

TensorFlow (TF) et PyTorch sont les deux leaders du Deep Learning. Le point fort historique de TF est son orientation **Production**.

L'installation se fait via pip (un environnement virtuel Python venv est fortement recommandé).

# 1. (Optionnel) Créer un environnement virtuel
python -m venv tf_env
source tf_env/bin/activate

# 2. Installer TensorFlow
pip install tensorflow

# 3. Vérifier
python -c "import tensorflow as tf; print(tf.__version__)"

# (Après installation CUDA/cuDNN)
pip install tensorflow

# Vérifier si le GPU est détecté
python -c "import tensorflow as tf; print(tf.config.list_physical_devices('GPU'))"
# (Doit lister votre carte GPU)

Le **Tensor** est l'unité de donnée centrale de TensorFlow (comme un ndarray en NumPy). C'est un tableau multi-dimensionnel.

Un tensor est défini par son **rang** (nombre de dimensions) et sa **forme** (shape).

import tensorflow as tf

# Rang 0 (Scalaire)
# Shape: []
tensor_0d = tf.constant(4)
print(tensor_0d)

# Rang 1 (Vecteur)
# Shape: [3]
tensor_1d = tf.constant([1, 2, 3])
print(tensor_1d)

# Rang 2 (Matrice)
# Shape: [2, 3]
tensor_2d = tf.constant([[1, 2, 3], [4, 5, 6]])
print(tensor_2d)

# Rang 3 (Ex: Image RGB)
# Shape: [Hauteur, Largeur, Canaux]
tensor_3d = tf.constant([ [[1],[2]], [[3],[4]] ]) # Shape [2, 2, 1]

# Rang 4 (Ex: Batch d'images)
# Shape: [Batch, Hauteur, Largeur, Canaux]
tensor_4d = tf.zeros([32, 28, 28, 3]) # (Batch de 32 images 28x28 RGB)

TensorFlow distingue deux types de tensors :

c = tf.constant([1.0, 2.0])

# c[0] = 5.0 # Erreur ! (Tensor non-assignable)
# c.assign(5.0) # Erreur !

v = tf.Variable([1.0, 2.0])

# Modifier la valeur
v.assign([5.0, 6.0])

v[0].assign(10.0) # OK

print(v)
# 

Vous pouvez utiliser les opérateurs Python (+, *, @) ou les fonctions tf.* (ex: tf.add) pour manipuler les tensors.

a = tf.constant([[1, 2], [3, 4]])
b = tf.constant([[5, 6], [7, 8]])

# 1. Addition (Element-wise)
c1 = a + b 
c2 = tf.add(a, b)

# 2. Multiplication (Element-wise)
d = a * b

# 3. Multiplication de Matrices (Dot product)
e1 = a @ b
e2 = tf.matmul(a, b)

# 4. Broadcasting
# (Similaire à NumPy. Le scalaire '2' est
# "étiré" pour s'adapter à la matrice 'a')
f = a * 2 
# [[2, 4], [6, 8]]

L'entraînement d'un réseau de neurones repose sur le calcul des **gradients** (la "pente" de la fonction de coût) pour mettre à jour les poids (via la "backpropagation").

TensorFlow utilise tf.GradientTape (Différenciation Automatique - AutoDiff) pour "enregistrer" les opérations et calculer les gradients.

Exemple (Calculer $d(x^2)/dx$ à $x=3$)

x = tf.Variable(3.0)

# 1. Ouvrir une "bande d'enregistrement"
with tf.GradientTape() as tape:
    # 2. Définir la fonction (y = x^2)
    y = x * x

# 3. Calculer le gradient de 'y' par rapport à 'x'
# (dy/dx = 2*x = 2*3 = 6)
dy_dx = tape.gradient(y, x)

print(dy_dx) # tf.Tensor(6.0, ...)

C'est le mécanisme utilisé par model.fit() pour calculer le gradient de la loss par rapport aux model.trainable_variables.

Keras était une bibliothèque indépendante, appréciée pour sa simplicité. Google l'a adoptée comme l'API haut niveau **officielle** de TensorFlow 2.x.

tf.keras masque la complexité (Tensors, GradientTape, Graphes) et permet de construire des modèles en assemblant des "briques" (Layers).

La structure Keras

1. Définir un Modèle : Une collection de Couches (Layers).
2. Compiler le Modèle : Définir la fonction de Perte (loss), l'Optimiseur (optimizer) et les Métriques (metrics).
3. Entraîner le Modèle : Appeler .fit() sur les données.
4. Évaluer / Prédire : Appeler .evaluate() ou .predict().

Les Layers sont les briques de Keras. Chaque couche contient des poids (tf.Variable) et une logique de calcul (ex: tf.matmul).

Couches Courantes (dans tf.keras.layers)

C'est le type de modèle le plus simple : une pile linéaire de couches. Parfait pour la plupart des CNN ou RNN simples.

Exemple (Classification d'images MNIST)

from tensorflow.keras import Sequential
from tensorflow.keras.layers import Flatten, Dense, Conv2D, MaxPooling2D

# 1. Définir le Modèle
model = Sequential([
    # (Input shape: 28x28 pixels, 1 canal (gris))
    Conv2D(32, (3, 3), activation='relu', input_shape=(28, 28, 1)),
    MaxPooling2D((2, 2)),
    
    Conv2D(64, (3, 3), activation='relu'),
    MaxPooling2D((2, 2)),
    
    Flatten(),
    
    Dense(64, activation='relu'),
    # (Couche de sortie: 10 classes, softmax pour probas)
    Dense(10, activation='softmax')
])

# 2. Visualiser
model.summary()

Pour les modèles complexes (ex: connexions résiduelles "ResNet", multi-input, multi-output), l'API Fonctionnelle est nécessaire. On définit les flux de tensors (Input -> Layer -> Output).

Exemple (Modèle simple, 2 inputs)

from tensorflow.keras.layers import Input, Dense, concatenate
from tensorflow.keras.models import Model

# 1. Définir les Entrées
input_A = Input(shape=(32,), name="Input_A")
input_B = Input(shape=(64,), name="Input_B")

# 2. "Appeler" les couches sur les tensors
x = Dense(16, activation='relu')(input_A)
y = Dense(32, activation='relu')(input_B)

# 3. Concaténer les branches
combined = concatenate([x, y])

# 4. Sortie
output = Dense(1, activation='sigmoid', name="Output")(combined)

# 5. Créer le Modèle
model = Model(inputs=[input_A, input_B], outputs=output)

model.summary()

Une fois le modèle défini, il faut le "compiler" (configurer l'entraînement) puis l'"entraîner" (fit).

1. model.compile()

Configure l'apprentissage :

• optimizer : L'algorithme de descente de gradient (ex: 'adam', 'sgd').
• loss : La fonction de coût (erreur) à minimiser (ex: 'binary_crossentropy', 'mse').
• metrics : Les métriques à surveiller (ex: ['accuracy']).

2. model.fit()

Lance la boucle d'entraînement (backpropagation).

# (x_train, y_train sont des Tensors/Numpy arrays)

# 1. Compilation
model.compile(
    optimizer='adam',
    loss='sparse_categorical_crossentropy', # (Pour classes entières 0-9)
    metrics=['accuracy']
)

# 2. Entraînement
# (5 "epochs" = 5 passages sur tout le dataset)
# (Batch size = 32 échantillons par mise à jour)
history = model.fit(
    x_train,
    y_train,
    epochs=5,
    batch_size=32,
    validation_split=0.2 # (Garde 20% pour la validation)
)

# 3. Évaluation
model.evaluate(x_test, y_test)

# 4. Prédiction
predictions = model.predict(x_new)

Pour les datasets volumineux, charger tout en mémoire (ex: x_train) n'est pas possible. tf.data est l'API (ETL) pour créer des pipelines de données performants (streaming depuis le disque, pré-traitement...).

model.fit() accepte directement un objet tf.data.Dataset.

Exemple (Pipeline simple)

# (Supposons que 'fichiers_images' est une liste de chemins)

# 1. Créer le Dataset (ex: à partir des noms de fichiers)
dataset = tf.data.Dataset.from_tensor_slices(fichiers_images)

# 2. Fonction de chargement et pré-traitement
def load_and_preprocess(path):
    image = tf.io.read_file(path)
    image = tf.image.decode_jpeg(image)
    image = tf.image.resize(image, [128, 128])
    image = image / 255.0 # Normaliser
    return image

# 3. Appliquer les transformations
# (map: applique la fonction, num_parallel_calls: parallélise)
dataset = dataset.map(load_and_preprocess, num_parallel_calls=tf.data.AUTOTUNE)

# 4. Configurer le pipeline (Performance)
dataset = dataset.shuffle(buffer_size=1000) # Mélanger
dataset = dataset.batch(32) # Créer des lots
dataset = dataset.prefetch(buffer_size=tf.data.AUTOTUNE) # Pré-charger

# 5. Entraîner (TF gère le streaming depuis le disque)
model.fit(dataset, epochs=10)

Il est crucial de sauvegarder l'architecture ET les poids (weights) du modèle après l'entraînement.

# 1. Sauvegarder
model.save("mon_modele_dossier")
# (Crée un dossier 'mon_modele_dossier'
# contenant 'saved_model.pb', 'assets', 'variables')

# 2. Charger
from tensorflow.keras.models import load_model
new_model = load_model("mon_modele_dossier")

# 1. Sauvegarder (en spécifiant .h5)
model.save("mon_modele.h5")

# 2. Charger
from tensorflow.keras.models import load_model
new_model = load_model("mon_modele.h5")

La force de TensorFlow réside dans son écosystème de déploiement "end-to-end".

TensorFlow est massivement utilisé en production par les plus grandes entreprises technologiques pour des tâches critiques.

Ressources pour apprendre et travailler avec TensorFlow.