Skip to content

TensorFlow Aide-mémoire

Plateforme open-source d'apprentissage automatique de bout en bout de Google.

01

Premiers pas

Installation et bases

TensorFlow 2.x tourne en mode eager par défaut (les opérations s'exécutent immédiatement, comme du Python normal). Utilisez tf.config.list_physical_devices('GPU') pour vérifier que les GPU CUDA sont visibles. Pour le support GPU, installez l'extra [and-cuda] sur Linux/Windows, ou tensorflow-metal sur Apple Silicon. TF 2.x a fusionné Keras en tf.keras — l'API de haut niveau utilisée dans la plupart des workflows.

tensorflow
# install TensorFlow (CPU)
pip install tensorflow

# with GPU support on Linux/Windows (CUDA-enabled)
pip install tensorflow[and-cuda]

import tensorflow as tf

# check version and devices
print(tf.__version__)
print("GPU:", tf.config.list_physical_devices('GPU'))

# eager execution is on by default in TF2
print(tf.executing_eagerly())   # True

Premiers tenseurs

tf.constant crée un tenseur immuable ; tf.zeros / tf.ones / tf.random.* créent des patterns courants. Chaque tenseur a une shape, un dtype et un rang. .numpy() fait le pont vers NumPy — sur GPU cela peut déclencher une copie synchronisée. Préférez des dtypes explicites (float32 est le défaut du ML) pour éviter des promotions silencieuses qui cassent la performance.

tensorflow
import tensorflow as tf

# constants are immutable
x = tf.constant([[1, 2], [3, 4]])
y = tf.zeros((3, 3))
z = tf.random.normal((2, 3), mean=0.0, stddev=1.0)

print(x.shape, x.dtype)   # (2, 2) int32
print(tf.reduce_sum(x))   # tf.Tensor(10, shape=(), dtype=int32)

# numpy interop is zero-copy when possible
print(x.numpy())          # array([[1, 2], [3, 4]])

Exécution eager et gradients

L'exécution eager rend TF débogable comme du Python normal — print, pdb et tracebacks marchent tous. GradientTape enregistre les ops du forward sur les tenseurs surveillés (tf.Variable est surveillée automatiquement) pour que tape.gradient calcule les dérivées. C'est le socle des boucles d'entraînement custom. Les tapes sont à usage unique par défaut ; utilisez persistent=True pour appeler gradient plusieurs fois.

tensorflow
import tensorflow as tf

a = tf.constant(3.0)
b = tf.constant(4.0)
print(a * b + 1)   # tf.Tensor(13.0, ...)

# GradientTape records ops for automatic differentiation
with tf.GradientTape() as tape:
    tape.watch(a)
    y = a ** 2 + b    # y = a^2 + b, dy/da = 2a
grad = tape.gradient(y, a)
print(grad)   # tf.Tensor(6.0, ...)  (= 2*3)

tf.function et graphes

@tf.function convertit une fonction Python en un graphe TensorFlow portable et optimisable — bien plus rapide sur GPU et requis pour la distribution. La fonction se trace une fois par signature d'entrée, donc évitez les effets de bord Python ou le flux de contrôle Python dépendant des données à l'intérieur (utilisez tf.cond / tf.while_loop sinon la fonction re-tracera). Les Variables doivent se créer une fois, hors de la fonction, ou réutiliser tf.Variable du même nom.

tensorflow
import tensorflow as tf

@tf.function  # traces a graph; runs in graph mode after first call
def train_step(x, y):
    with tf.GradientTape() as tape:
        preds = x * w + b
        loss = tf.reduce_mean((preds - y) ** 2)
    grads = tape.gradient(loss, [w, b])
    optimizer.apply_gradients(zip(grads, [w, b]))
    return loss

w = tf.Variable(0.1)
b = tf.Variable(0.0)
optimizer = tf.keras.optimizers.SGD(0.01)

# first call builds the graph (slower); subsequent calls are fast
loss = train_step(tf.constant([1., 2.]), tf.constant([2., 4.]))

Précision mixte

La précision mixte calcule en float16 mais garde des copies maîtres float32, donnant 2 à 3x de débit et la moitié de la mémoire sur les GPU Tensor Core (Volta+). La politique 'mixed_float16' gère le loss scaling automatiquement pour prévenir l'underflow. Forcez la couche de sortie en float32 pour la stabilité numérique. Exige compute capability >= 7.0 ; sur de vieux GPU, elle peut être plus lente.

tensorflow
import tensorflow as tf

# enable mixed precision: compute in float16, store in float32
tf.keras.mixed_precision.set_global_policy('mixed_float16')

model = tf.keras.Sequential([
    tf.keras.layers.Dense(64, activation='relu', dtype='float32'),
    tf.keras.layers.Dense(10, activation='softmax', dtype='float32')
])

# loss scaling is automatic with mixed_float16 policy
print(tf.keras.mixed_precision.global_policy())
02

Tenseurs

tf.constant

tf.constant crée un tenseur immuable — impossible d'affecter aux éléments. Pour des tenseurs entraînables, utilisez tf.Variable. tf.random.normal/uniform acceptent un argument seed pour la reproductibilité ; tf.random.set_seed(42) rend tout le programme reproductible. Utilisez des tuples de shape (pas des ints) pour la création multi-dim afin d'éviter les surprises.

tensorflow
import tensorflow as tf

a = tf.constant([1, 2, 3])
b = tf.constant([[1.0, 2.0], [3.0, 4.0]], dtype=tf.float32)

zeros = tf.zeros((2, 3))
ones = tf.ones((3, 3))
eye = tf.eye(3)
full = tf.fill((2, 3), 7.0)

arange = tf.range(0, 10, 2)       # [0, 2, 4, 6, 8]
linspace = tf.linspace(0.0, 1.0, 5)

rand = tf.random.uniform((2, 3))
randn = tf.random.normal((2, 3))

# constants are immutable: a[0] = 5  -> TypeError

tf.Variable

tf.Variable est un wrapper de tenseur mutable utilisé pour les paramètres du modèle et l'état de l'optimiseur. assign / assign_add / assign_sub le mettent à jour en place — une affectation Python ordinaire (w = w + 1) crée un nouveau tenseur et ne mute pas. Les Variables sont surveillées par GradientTape automatiquement, contrairement à tf.constant qu'il faut tape.watch() explicitement. Gardez les Variables sur le même device que les ops qui les utilisent.

tensorflow
import tensorflow as tf

w = tf.Variable(0.1, dtype=tf.float32)
W = tf.Variable(tf.random.normal((3, 4)))
b = tf.Variable(tf.zeros((4,)))

# read value
print(w.numpy())        # 0.1

# update value
w.assign(0.5)
w.assign_add(0.1)       # w += 0.1
w.assign_sub(0.05)

# assign in place on a slice
W[0, 0].assign(99.0)

# watched by GradientTape automatically
with tf.GradientTape() as tape:
    y = w ** 2
grad = tape.gradient(y, w)   # 2w

Opérations sur tenseurs

La plupart des maths rappellent NumPy : tf.reduce_sum / reduce_mean / reduce_max correspondent à np.sum/mean/max. Utilisez axis= pour réduire une dimension précise et keepdims=True pour préserver le rang pour le broadcasting. tf.matmul et l'opérateur @ font la multiplication matricielle (batchée quand les entrées sont 3D+). reshape retourne une vue quand possible ; transpose retourne toujours une copie en TF.

tensorflow
import tensorflow as tf

a = tf.constant([[1.0, 2.0], [3.0, 4.0]])
b = tf.constant([[5.0, 6.0], [7.0, 8.0]])

a + b; a - b; a * b; a / b      # element-wise
c = tf.matmul(a, b)              # matrix multiply
c = a @ b                        # equivalent

tf.reduce_sum(a)                 # sum of all
tf.reduce_sum(a, axis=0)         # sum along axis 0
tf.reduce_mean(a, axis=1)        # mean along axis 1
tf.reduce_max(a, axis=1)
tf.reduce_sum(a, axis=1, keepdims=True)

x = tf.range(12)
y = tf.reshape(x, (3, 4))
t = tf.transpose(y)              # shape (4, 3)

Indexation et slicing

TF supporte le slicing façon NumPy en mode eager et dans tf.function. tf.boolean_mask extrait les éléments où le masque est True (aplati). tf.gather sélectionne le long de l'axe 0 par défaut (comme l'indexation fancy). tf.where(cond, x, y) est le ternaire vectorisé — quand cond est True prendre de x sinon de y. Pour l'affectation, utilisez tf.tensor_scatter_nd_update ou une tf.Variable.

tensorflow
import tensorflow as tf

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

x[0]              # first row
x[1, 2]           # element (1,2) -> 6
x[:, 1]           # second column
x[0:2]            # first two rows
x[:, ::2]         # every other column

# boolean mask
mask = x > 4
sel = tf.boolean_mask(x, mask)   # tensor([5, 6, 7, 8, 9])

# gather by indices
idx = tf.constant([0, 2])
rows = tf.gather(x, idx)         # rows 0 and 2

# where: select from two tensors
tf.where(x > 4, x, tf.zeros_like(x))

Tenseurs ragged et sparses

Les tenseurs ragged stockent des séquences de longueur variable sans padding — parfaits pour des batchs NLP de longueurs différentes. Les tenseurs sparses ne stockent que les indices et valeurs non nuls, économisant la mémoire pour des données très sparses (recommandation, graphes). La plupart des ops ont des variantes conscientes du sparse ; convertissez en dense seulement quand une op l'exige. tf.RaggedTensor.to_tensor() bourre vers un rectangle pour les lookups d'embedding.

tensorflow
import tensorflow as tf

# ragged: variable-length sequences
ragged = tf.ragged.constant([[1, 2, 3], [4], [5, 6]])
print(ragged.shape)           # (3, None)
ragged.to_tensor()            # pad to (3, 3)

# sparse: mostly-zero tensors
indices = [[0, 0], [1, 2], [2, 1]]
values = [1.0, 2.0, 3.0]
sparse = tf.sparse.SparseTensor(
    indices=indices, values=values, dense_shape=[3, 3])
dense = tf.sparse.to_dense(sparse)

sp_sum = tf.sparse.reduce_sum(sparse)
sp_matmul = tf.sparse.sparse_dense_matmul(sparse, tf.eye(3))

Broadcasting et maths

Le broadcasting étire les tenseurs de plus petites dimensions pour matcher les plus grandes, élément par élément. clip_by_value est le clamp de TF. tf.maximum/minimum sont élément par élément (différents de tf.reduce_max/min qui réduisent une dimension). cumsum/cumprod produisent des sommes/produits courants le long d'un axe — utiles pour les métriques cumulatives et les algorithmes de somme préfixée dans des couches custom.

tensorflow
import tensorflow as tf

# broadcasting follows NumPy rules
a = tf.constant([[1.0, 2.0, 3.0]])    # shape (1, 3)
b = tf.constant([[10.0], [20.0]])      # shape (2, 1)
c = a + b                              # shape (2, 3)

tf.abs(x); tf.sqrt(x); tf.exp(x); tf.log(x)
tf.square(x); tf.pow(x, 3)
tf.maximum(a, b); tf.minimum(a, b)
tf.clip_by_value(x, 0.0, 1.0)

tf.norm(x)                  # L2 norm
tf.norm(x, ord=1)           # L1 norm

tf.cumsum(tf.range(5))      # [0, 1, 3, 6, 10]
tf.cumprod(tf.range(1, 5))  # [1, 2, 6, 24]
03

Modèles Keras

API Sequential

Sequential est le modèle Keras le plus simple — un pipeline linéaire où la sortie de chaque couche alimente la suivante. input_shape exclut la dimension de batch (None pour un batch variable). model.summary() imprime les shapes des couches et les comptes de paramètres. Sans input_shape, le modèle se bâtie paresseusement au premier fit/forward — appelez build() explicitement pour l'inspecter plus tôt.

tensorflow
import tensorflow as tf

model = tf.keras.Sequential([
    tf.keras.layers.Dense(128, activation='relu', input_shape=(784,)),
    tf.keras.layers.Dropout(0.5),
    tf.keras.layers.Dense(64, activation='relu'),
    tf.keras.layers.Dense(10, activation='softmax'),
])

model.summary()

# build later with input_shape (or first call)
model = tf.keras.Sequential()
model.add(tf.keras.layers.Dense(128, activation='relu'))
model.add(tf.keras.layers.Dense(10))
model.build((None, 784))   # None = variable batch

API Functional

L'API Functional laisse les couches brancher, fusionner et sauter — requis pour tout ce qui n'est pas linéaire (ResNet, multi-entrées/sorties, siamese). Définissez des tenseurs Input, enchaînez les couches en les appelant, puis passez inputs/outputs à Model. Le modèle résultant se comporte identiquement à un Sequential pour fit/predict. Nommez entrées/sorties pour une sauvegarde propre et des signatures de serving.

tensorflow
import tensorflow as tf

inputs = tf.keras.Input(shape=(784,), name='img')
x = tf.keras.layers.Dense(128, activation='relu')(inputs)
x = tf.keras.layers.Dropout(0.5)(x)
x = tf.keras.layers.Dense(64, activation='relu')(x)
outputs = tf.keras.layers.Dense(10, activation='softmax')(x)

model = tf.keras.Model(inputs=inputs, outputs=outputs, name='mlp')

# multi-input / multi-output
img_in = tf.keras.Input(shape=(224, 224, 3))
meta_in = tf.keras.Input(shape=(10,))
x = tf.keras.layers.Conv2D(32, 3, activation='relu')(img_in)
x = tf.keras.layers.GlobalAveragePooling2D()(x)
x = tf.keras.layers.concatenate([x, meta_in])
out = tf.keras.layers.Dense(1, activation='sigmoid')(x)
model = tf.keras.Model([img_in, meta_in], out)

Sous-classage de modèle

Le sous-classage de tf.keras.Model donne le contrôle total du forward (comme PyTorch). Définissez les couches dans __init__, implémentez call(inputs, training=). Le flag training bascule le comportement de dropout et BatchNorm. Plus flexible mais perd des bénéfices de l'API Functional : plus dur à inspecter/tracer, pas d'inférence automatique de forme d'entrée, et la sérialisation est plus délicate. Préférez Functional pour la plupart des architectures ; sous-classez pour les modèles de recherche.

tensorflow
import tensorflow as tf

class MLP(tf.keras.Model):
    def __init__(self, hidden=128, num_classes=10):
        super().__init__()
        self.dense1 = tf.keras.layers.Dense(hidden, activation='relu')
        self.drop = tf.keras.layers.Dropout(0.5)
        self.dense2 = tf.keras.layers.Dense(hidden, activation='relu')
        self.out = tf.keras.layers.Dense(num_classes, activation='softmax')

    def call(self, inputs, training=False):
        x = self.dense1(inputs)
        x = self.drop(x, training=training)
        x = self.dense2(x)
        return self.out(x)

model = MLP(hidden=64)
model.build((None, 784))
model.summary()

Compilation du modèle

compile câble l'optimiseur, la perte et les métriques ensemble avant fit. Les chaînes ('adam', 'mse') sont des raccourcis vers les classes correspondantes ; passez des objets pour des hyperparamètres custom. Pour les modèles multi-sorties, passez des dicts mappant les noms de sortie aux pertes. run_eagerly=True désactive le tracing de tf.function pour pouvoir utiliser pdb et print — inestimable pour déboguer, mais lent.

tensorflow
model.compile(
    optimizer='adam',
    loss='sparse_categorical_crossentropy',
    metrics=['accuracy'],
    loss_weights={'cls': 1.0, 'box': 0.5},
)

# explicit objects (more control)
model.compile(
    optimizer=tf.keras.optimizers.Adam(learning_rate=1e-3),
    loss=tf.keras.losses.SparseCategoricalCrossentropy(),
    metrics=[tf.keras.metrics.SparseCategoricalAccuracy(name='acc')],
    run_eagerly=False,   # debug mode: run without graph
)

Résumé et tracé du modèle

summary() imprime une table par couche avec shapes de sortie et comptes de paramètres — le moyen le plus rapide de repérer les bugs de shape. plot_model sauvegarde un graphe visuel (exige pydot et Graphviz). get_config retourne un dict sérialisable pour reconstruire l'architecture sans les poids — utilisé par model.to_json() et le format de sauvegarde Keras. Pour les modèles Functional, la config capture toute l'architecture ; pour les sous-classés, il faut implémenter get_config soi-même.

tensorflow
model.summary()
print(model.layers)
print(model.inputs, model.outputs)

# plot architecture (needs pydot + graphviz)
tf.keras.utils.plot_model(
    model, to_file='model.png', show_shapes=True,
    show_layer_names=True, rankdir='TB',
)

print(f"{model.count_params():,} params")

config = model.get_config()
new_model = tf.keras.Model.from_config(config)

Prétraitement dans le modèle

Mettre le prétraitement dans le modèle (Rescaling, couches d'augmentation Keras) le rend déployable : le même SavedModel accepte des images brutes à l'inférence, sans étape de prétraitement séparée. Les couches de prétraitement Keras tournent sur GPU et dans tf.function, donc rapides. Pour une augmentation réservée à l'entraînement, réglez training=True dans fit pour que les couches soient inactives à l'inférence. Rescaling(1./255) convertit les images uint8 [0,255] en float [0,1].

tensorflow
import tensorflow as tf

# preprocessing as part of the model (deployable)
model = tf.keras.Sequential([
    tf.keras.layers.Input(shape=(224, 224, 3)),
    tf.keras.layers.Rescaling(1./255),
    tf.keras.layers.RandomFlip('horizontal'),
    tf.keras.layers.RandomRotation(0.1),
    tf.keras.layers.Conv2D(32, 3, activation='relu'),
    # ...
])
# the model now includes preprocessing, so inference needs raw images
04

Couches

Couche Dense

Dense est la couche entièrement connectée : y = activation(xW + b). La forme du poids est (in_features, out_features) — la transposée de PyTorch. kernel_initializer passe par défaut à Glorot/Xavier uniform, bien pour tanh/sigmoid ; utilisez 'he_normal' pour la famille ReLU. Ajoutez la régularisation L2 via kernel_regularizer. GELU est l'activation par défaut des transformers.

tensorflow
import tensorflow as tf

dense = tf.keras.layers.Dense(
    units=64, activation='relu', use_bias=True,
    kernel_initializer='glorot_uniform',
    bias_initializer='zeros',
    kernel_regularizer=tf.keras.regularizers.l2(1e-4),
)

x = tf.random.normal((4, 128))
y = dense(x)                     # shape (4, 64)

print(dense.kernel.shape)        # (128, 64)
print(dense.bias.shape)          # (64,)

dense = tf.keras.layers.Dense(64, activation=tf.nn.gelu)

Couche Conv2D

TF/Keras utilise NHWC (channels-last) par défaut, l'inverse du NCHW de PyTorch. padding='same' bourre pour que la taille spatiale de sortie = taille d'entrée / stride ; 'valid' signifie pas de bourrage. DepthwiseConv2D applique un filtre par canal d'entrée (utilisé dans MobileNet). Conv2DTranspose sur-échantillonne (utilisée dans les décodeurs de segmentation). La forme du noyau est (kH, kW, in_channels, filtres).

tensorflow
import tensorflow as tf

conv = tf.keras.layers.Conv2D(
    filters=32, kernel_size=3, strides=(1, 1),
    padding='same', activation='relu', use_bias=True,
)

x = tf.random.normal((4, 28, 28, 3))   # NHWC
out = conv(x)
print(out.shape)                        # (4, 28, 28, 32) with padding='same'

dw = tf.keras.layers.DepthwiseConv2D(3, padding='same', activation='relu')
up = tf.keras.layers.Conv2DTranspose(32, 3, strides=2, padding='same')

Couches récurrentes (LSTM/GRU)

La forme d'entrée des RNN est (batch, timesteps, features). return_sequences=True est nécessaire pour empiler des RNN ou pour du seq2seq ; False pour du sequence-to-vector. Bidirectional double la taille de sortie en concaténant avant et arrière. recurrent_dropout est pratique mais lent (pas d'accélération cuDNN) — préférez un dropout simple sur les entrées.

tensorflow
import tensorflow as tf

lstm = tf.keras.layers.LSTM(units=128, return_sequences=False)
x = tf.random.normal((4, 10, 64))   # (batch, time, features)
out = lstm(x)                       # (4, 128)

# stacked LSTM needs return_sequences=True
model = tf.keras.Sequential([
    tf.keras.layers.LSTM(128, return_sequences=True, input_shape=(10, 64)),
    tf.keras.layers.LSTM(64),
    tf.keras.layers.Dense(10),
])

gru = tf.keras.layers.GRU(128)
bi = tf.keras.layers.Bidirectional(tf.keras.layers.LSTM(64))
out = bi(x)   # shape (4, 128) — 64 * 2

Dropout et régularisation

Dropout met des unités à zéro aléatoirement pendant l'entraînement pour prévenir la co-adaptation — automatiquement désactivé à l'inférence (training=False). SpatialDropout2D jette des cartes de caractéristiques entières, mieux pour les nets conv. L2 (weight decay) est le régularisateur le plus courant. LayerNormalization normalise sur l'axe des caractéristiques (par échantillon), contrairement à BatchNorm qui normalise sur l'axe du batch — préféré pour transformers et RNN.

tensorflow
import tensorflow as tf

drop = tf.keras.layers.Dropout(0.5)
x = tf.random.normal((4, 10))
y = drop(x, training=True)   # training=True activates dropout

tf.keras.layers.SpatialDropout2D(0.5)   # drop entire feature maps
tf.keras.layers.GaussianDropout(0.5)
tf.keras.layers.AlphaDropout(0.5)

# weight regularization
tf.keras.layers.Dense(64,
    kernel_regularizer=tf.keras.regularizers.l2(1e-4),
    activity_regularizer=tf.keras.regularizers.l1(1e-5))

norm = tf.keras.layers.LayerNormalization()

Normalisation par batch

BatchNormalization normalise les activations par canal, en gardant des stats EMA courantes pour l'inférence. axis=-1 normalise le dernier axe (canaux) pour NHWC. Placez BN après la conv et avant l'activation, et désactivez le biais de la conv (use_bias=False) puisque le beta de BN gère le décalage. momentum contrôle la vitesse à laquelle les stats courantes suivent les données — des valeurs hautes (0.99) sont plus stables. BN se comporte différemment en train et en inférence (flag training).

tensorflow
import tensorflow as tf

bn = tf.keras.layers.BatchNormalization(
    axis=-1, momentum=0.99, epsilon=1e-3,
)

model = tf.keras.Sequential([
    tf.keras.layers.Conv2D(32, 3, padding='same', use_bias=False),
    tf.keras.layers.BatchNormalization(),
    tf.keras.layers.ReLU(),
])

print(len(bn.weights))         # 4
print(len(bn.trainable_weights))    # 2

Couche personnalisée

Sous-classez Layer pour bâtir des ops custom. Définissez les poids dans build() (appelé une fois avec la forme d'entrée) plutôt que __init__ pour que la couche s'adapte à la taille d'entrée. Implémentez get_config() pour que la couche se sérialise et se recharge. add_weight enregistre le tenseur auprès du suivi de Keras (il apparaît donc dans weights, est sauvegardé et déplacé vers le device). Pour des transforms sans état, on peut sauter build() et seulement surcharger call().

tensorflow
import tensorflow as tf

class Linear(tf.keras.layers.Layer):
    def __init__(self, units=32, **kwargs):
        super().__init__(**kwargs)
        self.units = units

    def build(self, input_shape):
        self.w = self.add_weight(
            shape=(input_shape[-1], self.units),
            initializer='glorot_uniform', trainable=True, name='w')
        self.b = self.add_weight(
            shape=(self.units,), initializer='zeros', trainable=True, name='b')

    def call(self, inputs):
        return tf.matmul(inputs, self.w) + self.b

    def get_config(self):
        config = super().get_config()
        config.update({'units': self.units})
        return config

layer = Linear(64)
out = layer(tf.random.normal((4, 10)))
05

Pertes

BinaryCrossentropy

BinaryCrossentropy sert aux tâches binaires ou multi-labels (chaque classe indépendante). Passez from_logits=True si votre modèle sort des logits bruts — numériquement plus sûr que d'appliquer sigmoid + BCE séparément. pos_weight surpondère les exemples positifs pour gérer le déséquilibre. Pour du multi-label à C classes, la cible a une shape (N, C) de 0/1 et les prédictions (N, C) de probabilités ou logits.

tensorflow
import tensorflow as tf

bce = tf.keras.losses.BinaryCrossentropy(from_logits=False)
y_true = tf.constant([[1.0], [0.0], [1.0], [0.0]])
y_pred = tf.constant([[0.9], [0.1], [0.8], [0.2]])
loss = bce(y_true, y_pred)

# from_logits=True is more numerically stable
bce_logits = tf.keras.losses.BinaryCrossentropy(from_logits=True)
logits = tf.constant([[2.0], [-2.0], [1.5], [-1.5]])
loss = bce_logits(y_true, logits)

bce = tf.keras.losses.BinaryCrossentropy(
    from_logits=True, pos_weight=tf.constant([5.0]))

CategoricalCrossentropy

CategoricalCrossentropy attend des cibles one-hot ; SparseCategoricalCrossentropy des indices de classe entiers (plus économe pour beaucoup de classes). Passez toujours from_logits=True quand le modèle ne finit pas en softmax — il utilise l'astuce log-sum-exp pour la stabilité numérique. Pour le lissage de labels, utilisez CategoricalCrossentropy(label_smoothing=0.1), un fort régularisateur de classification et NLP.

tensorflow
import tensorflow as tf

# one-hot labels
cce = tf.keras.losses.CategoricalCrossentropy(from_logits=False)
y_true = tf.constant([[0, 1, 0], [1, 0, 0]], dtype=tf.float32)
y_pred = tf.constant([[0.1, 0.8, 0.1], [0.7, 0.2, 0.1]])
loss = cce(y_true, y_pred)

# integer labels -> use sparse version
scce = tf.keras.losses.SparseCategoricalCrossentropy(from_logits=True)
y_true_int = tf.constant([1, 0])
logits = tf.constant([[1.0, 3.0, 0.5], [2.5, 0.2, 0.1]])
loss = scce(y_true_int, logits)

MSE et pertes de régression

MSE pénalise les grandes erreurs quadratiquement (sensible aux aberrantes) ; MAE est linéaire. Huber se comporte comme MSE près de zéro et MAE loin — le défaut de la régression de détection d'objets. LogCosh est similaire mais deux fois dérivable partout, utile quand on a besoin de gradients de second ordre. La réduction passe par défaut à la moyenne sur le batch ; surchargez avec reduction=tf.keras.losses.Reduction.NONE pour des pertes par échantillon.

tensorflow
import tensorflow as tf

mse = tf.keras.losses.MeanSquaredError()
y_true = tf.constant([3.0, -0.5, 2.0, 7.0])
y_pred = tf.constant([2.5, 0.0, 2.0, 8.0])
loss = mse(y_true, y_pred)

mae = tf.keras.losses.MeanAbsoluteError()
loss = mae(y_true, y_pred)

huber = tf.keras.losses.Huber(delta=1.0)
loss = huber(y_true, y_pred)

logcosh = tf.keras.losses.LogCosh()
loss = logcosh(y_true, y_pred)

Perte personnalisée

Une perte custom est n'importe quel appelable prenant (y_true, y_pred) et retournant un tenseur scalaire. Pour la sérialisation ou des hyperparamètres, sous-classez tf.keras.losses.Loss et implémentez call() + get_config(). Gardez chaque op différentiable. FocalLoss baisse le poids des exemples faciles pour se concentrer sur les durs — populaire en détection d'objets. Utilisez Reduction.NONE dans call() et laissez Keras réduire à la fin si vous voulez que le masquage marche.

tensorflow
import tensorflow as tf

def weighted_mse(y_true, y_pred):
    weights = tf.cast(y_true != 0, tf.float32)
    return tf.reduce_sum(weights * tf.square(y_true - y_pred)) / tf.reduce_sum(weights)

class FocalLoss(tf.keras.losses.Loss):
    def __init__(self, alpha=0.25, gamma=2.0, **kwargs):
        super().__init__(**kwargs)
        self.alpha = alpha
        self.gamma = gamma

    def call(self, y_true, y_pred):
        bce = tf.keras.losses.binary_crossentropy(y_true, y_pred)
        p = y_pred
        pt = p * y_true + (1 - p) * (1 - y_true)
        return self.alpha * tf.pow(1 - pt, self.gamma) * bce

    def get_config(self):
        config = super().get_config()
        config.update({'alpha': self.alpha, 'gamma': self.gamma})
        return config

loss = FocalLoss(alpha=0.25, gamma=2.0)

Perte depuis les logits

Calculer softmax puis cross-entropie séparément peut déborder pour de grands logits (e^100). Passer from_logits=True laisse TF les fusionner avec l'astuce log-sum-exp, numériquement stable. Les API fonctionnelles tf.nn.*_cross_entropy_with_logits font pareil. Assurez-vous que votre modèle ne finit PAS en softmax/sigmoid quand vous utilisez from_logits=True, sinon vous appliquez l'activation deux fois.

tensorflow
import tensorflow as tf

# why logits? numerical stability
logits = tf.constant([[100.0, 0.0, 0.0]])

# BAD: softmax first then CCE (can overflow)
probs = tf.nn.softmax(logits)
loss_bad = tf.keras.losses.CategoricalCrossentropy()(
    tf.constant([[1.0, 0.0, 0.0]]), probs)

# GOOD: from_logits=True uses log-sum-exp internally
loss_good = tf.keras.losses.CategoricalCrossentropy(from_logits=True)(
    tf.constant([[1.0, 0.0, 0.0]]), logits)

loss = tf.nn.sigmoid_cross_entropy_with_logits(labels=y, logits=z)
loss = tf.nn.softmax_cross_entropy_with_logits(labels=y, logits=z)

Pertes multi-sorties

Pour les modèles multi-sorties, passez un dict mappant les noms de sortie aux fonctions de perte et un dict loss_weights pour les équilibrer. La perte totale est la somme pondérée. C'est le pattern standard du multi-tâches — chaque tête a sa perte et métrique. Passez les cibles d'entraînement comme un dict avec les mêmes clés au fit. Réglez loss_weights pour qu'aucune tâche ne domine le gradient.

tensorflow
import tensorflow as tf

model.compile(
    optimizer='adam',
    loss={
        'priority': tf.keras.losses.BinaryCrossentropy(from_logits=True),
        'department': tf.keras.losses.SparseCategoricalCrossentropy(from_logits=True),
    },
    loss_weights={'priority': 1.0, 'department': 0.5},
    metrics={'priority': ['accuracy'], 'department': ['accuracy']},
)

inputs = tf.keras.Input(shape=(64,))
x = tf.keras.layers.Dense(64, activation='relu')(inputs)
out_a = tf.keras.layers.Dense(1, name='priority')(x)
out_b = tf.keras.layers.Dense(10, name='department')(x)
model = tf.keras.Model(inputs, [out_a, out_b])

model.fit(x_train, {'priority': y_pri, 'department': y_dep}, epochs=5)
06

Optimiseurs

Adam

Adam est l'optimiseur par défaut de la plupart des tâches — taux d'apprentissage adaptatifs par paramètre, robuste au choix d'hyperparamètres. beta_1/beta_2 contrôlent la décroissance EMA des premier et second moments. Passez un objet LearningRateSchedule plutôt qu'un flottant pour décroître le LR pendant l'entraînement. global_clipnorm remet à l'échelle tous les gradients si leur norme combinée dépasse le seuil — important pour RNN et transformers.

tensorflow
import tensorflow as tf

opt = tf.keras.optimizers.Adam(learning_rate=1e-3)

opt = tf.keras.optimizers.Adam(
    learning_rate=1e-3, beta_1=0.9, beta_2=0.999,
    epsilon=1e-7, amsgrad=False,
)

# schedule as learning_rate
lr_schedule = tf.keras.optimizers.schedules.CosineDecay(
    initial_learning_rate=1e-3, decay_steps=10000)
opt = tf.keras.optimizers.Adam(learning_rate=lr_schedule)

# gradient clipping
opt = tf.keras.optimizers.Adam(learning_rate=1e-3, global_clipnorm=1.0)

SGD

SGD + momentum généralise souvent mieux qu'Adam sur l'entraînement CNN à grands batchs, au prix de plus de réglage de LR. momentum=0.9 standard ; Nesterov donne un petit plus. weight_decay ajoute une régularisation L2 découplée (Keras 3) — les vieilles versions utilisent kernel_regularizer sur les couches. SGD a besoin de warmup et de planification de LR pour rivaliser avec Adam d'emblée.

tensorflow
import tensorflow as tf

opt = tf.keras.optimizers.SGD(learning_rate=0.01)
opt = tf.keras.optimizers.SGD(learning_rate=0.01, momentum=0.9)
opt = tf.keras.optimizers.SGD(
    learning_rate=0.01, momentum=0.9, nesterov=True)

# with weight decay (Keras 2.13+ / 3.x)
opt = tf.keras.optimizers.SGD(
    learning_rate=0.01, momentum=0.9, weight_decay=1e-4)

# clip gradients by value
opt = tf.keras.optimizers.SGD(
    learning_rate=0.01, momentum=0.9, clipvalue=0.5)

AdamW et autres optimiseurs

AdamW découple la weight decay de la mise à jour du gradient, ce qui compte à l'échelle (transformers, grands CNN). RMSprop est l'optimiseur RNN classique. Adagrad s'adapte par paramètre mais peut caler tôt — bien pour des caractéristiques sparses. FTRL est conçu pour l'apprentissage en ligne à grande échelle avec caractéristiques sparses (prédiction de clic). Pour les nouveaux projets, commencez par AdamW.

tensorflow
import tensorflow as tf

opt = tf.keras.optimizers.AdamW(
    learning_rate=3e-4, weight_decay=0.01,
    beta_1=0.9, beta_2=0.999)

opt = tf.keras.optimizers.RMSprop(learning_rate=1e-3, rho=0.9)
opt = tf.keras.optimizers.Adagrad(learning_rate=1e-2)
opt = tf.keras.optimizers.Adadelta(learning_rate=1.0)
opt = tf.keras.optimizers.Nadam(learning_rate=1e-3)
opt = tf.keras.optimizers.Ftrl(learning_rate=0.1)

Appliquer les gradients

Dans une boucle d'entraînement custom, calculez les gradients avec GradientTape, puis appelez opt.apply_gradients(zip(grads, vars)). C'est la brique des boucles d'entraînement custom (voir section boucle custom). clip_by_global_norm remet à l'échelle les gradients pour que leur norme L2 combinée reste sous le seuil. Des gradients None signifient que la variable n'a pas affecté la perte — courant pour des paramètres inutilisés, à logger.

tensorflow
import tensorflow as tf

opt = tf.keras.optimizers.Adam(1e-3)
vars = [w, b]

with tf.GradientTape() as tape:
    preds = model(x)
    loss = loss_fn(y, preds)
grads = tape.gradient(loss, vars)

grads, _ = tf.clip_by_global_norm(grads, 1.0)
opt.apply_gradients(zip(grads, vars))

for v, g in zip(vars, grads):
    print(v.name, g is not None, g.numpy().norm() if g is not None else None)

Plannings de taux d'apprentissage

Les objets LearningRateSchedule calculent le LR en fonction du compteur de pas de l'optimiseur. CosineDecay anneale en douceur vers alpha*lr_initial — un fort défaut. CosineDecayRestarts implémente les redémarrages chauds style SGDR. Passez le planning comme learning_rate à la construction de l'optimiseur ; Keras l'appelle automatiquement à chaque pas. Pour le warmup, enveloppez dans un planning custom ou utilisez le callback WarmUp de tensorflow/addons.

tensorflow
import tensorflow as tf

sched = tf.keras.optimizers.schedules.PiecewiseConstantDecay(
    boundaries=[500, 1500], values=[1e-3, 1e-4, 1e-5])

sched = tf.keras.optimizers.schedules.ExponentialDecay(
    initial_learning_rate=1e-3, decay_steps=1000, decay_rate=0.96,
    staircase=True)

sched = tf.keras.optimizers.schedules.CosineDecay(
    initial_learning_rate=1e-3, decay_steps=10000, alpha=0.0)

opt = tf.keras.optimizers.Adam(learning_rate=sched)
print(opt.learning_rate(opt.iterations))

Clipping de gradient et EMA

global_clipnorm (remet à l'échelle tous les gradients ensemble) est le choix le plus courant et celui des transformers. clipvalue borne durement chaque élément. Pour un clipping custom, modifiez les grads entre tape.gradient et apply_gradients. La moyenne mobile exponentielle (EMA) des poids donne souvent un petit gain d'exactitude à l'inférence — appliquez-la après chaque pas et utilisez les poids moyennés pour l'évaluation. TF Addons a un wrapper d'optimiseur MovingAverage.

tensorflow
import tensorflow as tf

opt = tf.keras.optimizers.Adam(1e-3, global_clipnorm=1.0)
opt = tf.keras.optimizers.Adam(1e-3, clipvalue=0.5)
opt = tf.keras.optimizers.Adam(1e-3, clipnorm=1.0)

# manual clipping (more control)
grads = tape.gradient(loss, vars)
grads = [tf.clip_by_norm(g, 1.0) if g is not None else g for g in grads]
grads, _ = tf.clip_by_global_norm(grads, 1.0)
opt.apply_gradients(zip(grads, vars))

# exponential moving average of weights (improves generalization)
ema = tf.train.ExponentialMovingAverage(decay=0.999)
07

Entraînement

compile et fit

fit est l'API d'entraînement de haut niveau : batching, mélange, validation, callbacks et progression. Passez validation_data=(x, y) ou validation_split=0.2 (retenu de l'entraînement). verbose=2 imprime une ligne par époque (bien pour les logs) ; 1 montre une barre de progression. L'objet history retourné stocke perte et métriques par époque — tracez-le pour repérer le surapprentissage.

tensorflow
import tensorflow as tf

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

history = model.fit(
    x_train, y_train, batch_size=32, epochs=10,
    validation_data=(x_val, y_val),
    validation_split=0.2, shuffle=True, verbose=2,
)

print(history.history['loss'])

Validation et métriques

Les métriques sont des objets avec état qui accumulent entre batchs et calculent la valeur finale en fin d'époque — contrairement aux pertes, elles n'affectent pas l'entraînement. Passez des chaînes ('accuracy') ou des objets Metric pour des métriques custom. Sous-classez tf.keras.metrics.Metric et implémentez update_state/result/reset_state. reset_state (renommé depuis reset_states en TF 2.11+) s'appelle au début de chaque époque.

tensorflow
model.compile(
    optimizer='adam', loss='sparse_categorical_crossentropy',
    metrics=[
        'accuracy',
        tf.keras.metrics.SparseTopKCategoricalAccuracy(k=5, name='top5_acc'),
        tf.keras.metrics.Precision(name='precision'),
        tf.keras.metrics.Recall(name='recall'),
    ],
)

class F1Score(tf.keras.metrics.Metric):
    def __init__(self, **kwargs):
        super().__init__(**kwargs)
        self.precision = tf.keras.metrics.Precision()
        self.recall = tf.keras.metrics.Recall()
    def update_state(self, y_true, y_pred, sample_weight=None):
        self.precision.update_state(y_true, y_pred, sample_weight)
        self.recall.update_state(y_true, y_pred, sample_weight)
    def result(self):
        p, r = self.precision.result(), self.recall.result()
        return 2 * p * r / (p + r + 1e-8)
    def reset_state(self):
        self.precision.reset_state(); self.recall.reset_state()

Époques, taille de batch et pas

Avec tf.data.Dataset, ne passez pas batch_size — le dataset est déjà batché. steps_per_epoch dit à fit combien de batchs constituent une époque quand le dataset se répète indéfiniment. validation_steps pareil pour la validation. Utilisez initial_epoch pour reprendre l'entraînement depuis un checkpoint — fit saute les N premières époques mais l'état de l'optimiseur (planning de LR, momentum) continue correctement.

tensorflow
model.fit(x_train, y_train, batch_size=32, epochs=10)

# with tf.data.Dataset
model.fit(train_dataset, epochs=10, validation_data=val_dataset)

# Dataset of unknown size: use steps_per_epoch
model.fit(
    train_dataset, epochs=10, steps_per_epoch=500,
    validation_data=val_dataset, validation_steps=50,
)

# initial epoch (resume training)
model.fit(train_dataset, initial_epoch=5, epochs=10)

Poids de classe et d'échantillon

class_weight met à l'échelle la perte par classe pour contrer le déséquilibre — équivalent au sur-échantillonnage sans le calcul supplémentaire. sample_weight donne un contrôle par exemple, utile pour l'extraction d'exemples durs ou le masquage des positions bourrées. Avec tf.data.Dataset, incluez sample_weight comme troisième élément du tuple pour que le dataset produise (x, y, w). Utilisez sklearn.utils.class_weight pour calculer automatiquement des poids équilibrés.

tensorflow
class_weight = {0: 1.0, 1: 5.0, 2: 1.0}   # class 1 is rare
model.fit(x_train, y_train, class_weight=class_weight, epochs=10)

sample_weight = np.where(y_train == 1, 5.0, 1.0)
model.fit(x_train, y_train, sample_weight=sample_weight, epochs=10)

# with Dataset: yield (x, y, sample_weight) tuples
ds = tf.data.Dataset.from_tensor_slices((x, y, w))
model.fit(ds, epochs=10)

from sklearn.utils import class_weight
cw = class_weight.compute_class_weight('balanced', classes=np.unique(y), y=y)
class_weight = dict(enumerate(cw))

Predict et evaluate

predict retourne un tableau NumPy de prédictions pour toute l'entrée — utilisez batch_size pour contrôler la mémoire. evaluate retourne la perte plus les métriques de compile. Pour de très grandes entrées, itérez les batchs manuellement avec predict_on_batch. Appeler le modèle directement (model(x)) retourne un tenseur et respecte training=, tandis que predict tourne toujours en mode inférence et retourne du NumPy. Utilisez model(x, training=True) pour l'augmentation au temps de test.

tensorflow
preds = model.predict(x_test, batch_size=64)
print(preds.shape)   # (N, num_classes)

pred = model.predict(x_test[:1])

loss, acc = model.evaluate(x_test, y_test, batch_size=64, verbose=2)
test_loss, test_acc, test_prec = model.evaluate(test_dataset)

for batch in test_dataset:
    preds = model.predict_on_batch(batch[0])

preds = model(x_test, training=True)   # callable form, test-time aug

Surcharger train_step

Surcharger train_step permet de personnaliser ce qui se passe dans chaque batch de fit tout en gardant la boucle d'époques, les callbacks et la distribution de fit. C'est le pont entre le fit de haut niveau et une boucle pleinement custom — génial pour les GAN, l'apprentissage contrastif ou tout objectif non standard. Utilisez self.compiled_loss et self.compiled_metrics pour que la perte/métriques de compile() continuent de marcher. test_step surcharge la validation pareil.

tensorflow
import tensorflow as tf

class CustomModel(tf.keras.Model):
    def train_step(self, data):
        x, y = data
        with tf.GradientTape() as tape:
            y_pred = self(x, training=True)
            loss = self.compiled_loss(y, y_pred, regularization_losses=self.losses)
        grads = tape.gradient(loss, self.trainable_variables)
        self.optimizer.apply_gradients(zip(grads, self.trainable_variables))
        self.compiled_metrics.update_state(y, y_pred)
        return {m.name: m.result() for m in self.metrics}

    def test_step(self, data):
        x, y = data
        y_pred = self(x, training=False)
        self.compiled_loss(y, y_pred)
        self.compiled_metrics.update_state(y, y_pred)
        return {m.name: m.result() for m in self.metrics}

model = CustomModel(inputs, outputs)
model.compile(optimizer='adam', loss='...', metrics=['accuracy'])
model.fit(dataset, epochs=10)
08

Callbacks

EarlyStopping

EarlyStopping arrête l'entraînement quand la métrique surveillée cesse de progresser, économisant du temps et prévenant le surapprentissage. patience=N attend N époques sans amélioration avant d'arrêter. restore_best_weights=True revient à la meilleure époque à la fin — sans lui on garde les poids finaux (possiblement moins bons). mode='min' pour les pertes, 'max' pour l'exactitude. Réglez toujours un grand nombre max d'époques et laissez le callback décider.

tensorflow
import tensorflow as tf

early = tf.keras.callbacks.EarlyStopping(
    monitor='val_loss', min_delta=0.001, patience=5,
    mode='auto', restore_best_weights=True, verbose=1,
)

model.fit(train_ds, validation_data=val_ds, epochs=100, callbacks=[early])

ModelCheckpoint

ModelCheckpoint sauvegarde le modèle pendant l'entraînement pour récupérer des crashs ou choisir la meilleure époque. save_best_only=True ne garde que le meilleur checkpoint (selon la métrique monitor) — réglez monitor sur votre métrique de val. save_weights_only=True est plus petit et agnostique d'architecture mais il faut la classe du modèle pour recharger. Les placeholders de format comme {epoch:02d} embarquent le numéro d'époque dans le nom de fichier. save_freq='epoch' est le défaut ; un entier N sauvegarde tous les N batchs.

tensorflow
import tensorflow as tf

ckpt = tf.keras.callbacks.ModelCheckpoint(
    filepath='checkpoints/epoch-{epoch:02d}-val-{val_loss:.3f}.keras',
    monitor='val_loss', save_best_only=True, save_weights_only=False,
    mode='min', save_freq='epoch', verbose=1,
)

ckpt = tf.keras.callbacks.ModelCheckpoint(
    'weights.{epoch:02d}.h5', save_weights_only=True, save_freq='epoch',
)

model.fit(train_ds, validation_data=val_ds, epochs=50, callbacks=[ckpt])

ReduceLROnPlateau

ReduceLROnPlateau baisse le LR quand la métrique surveillée stagne — utile quand on ignore le bon planning à l'avance. factor est le multiplicateur (0.5 = moitié), patience le nombre d'époques à attendre, min_lr le plancher. cooldown suspend la surveillance juste après une réduction pour laisser le nouveau LR s'installer. Combinez à EarlyStopping : réduire le LR d'abord, puis arrêter sans amélioration supplémentaire. verbose=1 imprime chaque réduction.

tensorflow
import tensorflow as tf

reduce = tf.keras.callbacks.ReduceLROnPlateau(
    monitor='val_loss', factor=0.5, patience=3, min_lr=1e-7,
    mode='min', min_delta=1e-4, cooldown=0, verbose=1,
)

model.fit(train_ds, validation_data=val_ds, epochs=100, callbacks=[reduce])

Callback TensorBoard

Le callback TensorBoard streame métriques d'entraînement, histogrammes de poids, graphe du modèle et données de profilage vers log_dir pendant fit. histogram_freq=1 logge les distributions de poids par époque — réglez à 0 pour économiser l'espace. profile_batch=2 lance le TF Profiler sur le batch 2 pour identifier les goulots (pipeline d'entrée, latence des ops). Lancez TensorBoard pointant vers log_dir pour voir les graphiques. Utilisez des sous-répertoires distincts par expérience pour comparer les runs.

tensorflow
import tensorflow as tf

tb = tf.keras.callbacks.TensorBoard(
    log_dir='./logs/fit', histogram_freq=1, write_graph=True,
    write_images=False, update_freq='epoch',
    profile_batch=2, embeddings_freq=0,
)

model.fit(train_ds, validation_data=val_ds, epochs=10, callbacks=[tb])
# launch: tensorboard --logdir=./logs

LearningRateScheduler

LearningRateScheduler prend une fonction de (epoch, lr) et applique le nouveau LR au début de chaque époque — simple mais seulement par époque. Pour des plannings par pas, préférez un objet LearningRateSchedule passé à l'optimiseur (voir section optimiseurs) — appelé à chaque batch et marche dans tf.function. La forme Callback convient aux plannings grossiers. Pour warmup+décroissance, un objet schedule est plus propre.

tensorflow
import tensorflow as tf

def schedule(epoch, lr):
    if epoch < 10:
        return lr
    return lr * tf.math.exp(-0.1).numpy()

scheduler = tf.keras.callbacks.LearningRateScheduler(schedule, verbose=1)

class StepScheduler(tf.keras.callbacks.Callback):
    def on_train_batch_begin(self, batch, logs=None):
        step = self.model.optimizer.iterations.numpy()
        new_lr = 1e-3 * (0.5 ** (step // 1000))
        self.model.optimizer.learning_rate.assign(new_lr)

scheduler = tf.keras.callbacks.LearningRateScheduler(
    lambda epoch: 1e-3 * 0.9 ** epoch)

Callback personnalisé

Les callbacks s'accrochent au cycle de vie de l'entraînement : on_epoch_begin/end, on_train_batch_begin/end, on_test_*, on_predict_*. Accédez au modèle via self.model et à l'optimiseur via self.model.optimizer. logs est un dict des métriques courantes. Les callbacks custom sont parfaits pour le logging, la manipulation du LR, l'arrêt anticipé (self.model.stop_training = True) ou la sync avec des systèmes externes (W&B, MLflow). Gardez-les légers — ils tournent à chaque batch.

tensorflow
import tensorflow as tf

class DebugCallback(tf.keras.callbacks.Callback):
    def on_epoch_end(self, epoch, logs=None):
        lr = self.model.optimizer.learning_rate
        if hasattr(lr, 'numpy'):
            lr = lr.numpy()
        print(f"Epoch {epoch}: lr={lr}, logs={logs}")

    def on_train_batch_end(self, batch, logs=None):
        if batch % 100 == 0:
            print(f"  batch {batch}: loss={logs.get('loss'):.4f}")

    def on_train_end(self, logs=None):
        print("Training finished!")

model.fit(train_ds, epochs=5, callbacks=[DebugCallback()])
09

Pipeline tf.data

tf.data.Dataset

tf.data.Dataset est l'API de données en streaming de TF — elle pipeline les données du disque/CPU vers le GPU efficacement. from_tensor_slices zippe les tenseurs le long de l'axe 0. La chaîne canonique est shuffle -> batch -> prefetch : shuffle randomise, batch groupe, prefetch chevauche la préparation du batch suivant avec l'entraînement courant. Utilisez AUTOTUNE pour laisser TF choisir automatiquement les tailles de buffers de prefetch.

tensorflow
import tensorflow as tf

ds = tf.data.Dataset.from_tensor_slices((x_train, y_train))

def gen():
    for i in range(len(x_train)):
        yield x_train[i], y_train[i]
ds = tf.data.Dataset.from_generator(gen, output_signature=(
    tf.TensorSpec(shape=(28, 28), dtype=tf.float32),
    tf.TensorSpec(shape=(), dtype=tf.int32),
))

ds = ds.shuffle(10000).batch(32).prefetch(tf.data.AUTOTUNE)

for x, y in ds:
    print(x.shape, y.shape)
    break

Map, filter et cache

map applique une fonction à chaque élément — augmentation, normalisation, tokenisation. num_parallel_calls=AUTOTUNE parallélise sur les cœurs CPU. cache() stocke le dataset en mémoire (ou fichier) pour que les époques suivantes sautent la source — gros gain pour les données petites à moyennes, mais cachez AVANT les ops aléatoires sinon vous répéterez les mêmes augmentations à chaque époque. L'ordre canonique est cache -> map(augmenter) -> shuffle -> batch -> prefetch.

tensorflow
import tensorflow as tf

def augment(image, label):
    image = tf.image.random_flip_left_right(image)
    image = tf.image.random_brightness(image, 0.2)
    return image, label

ds = tf.data.Dataset.from_tensor_slices((images, labels))
ds = ds.map(augment, num_parallel_calls=tf.data.AUTOTUNE)
ds = ds.map(lambda x, y: (tf.cast(x, tf.float32) / 255.0, y))
ds = ds.filter(lambda x, y: y < 10)

ds = ds.cache()                    # in memory
ds = ds.cache('/tmp/data.cache')   # to file

ds = ds.cache().shuffle(1000).batch(32).prefetch(tf.data.AUTOTUNE)

Batch, shuffle et repeat

shuffle utilise un buffer de taille N : il le remplit, échantillonne un élément, le reremplace — donc un buffer >= taille du dataset donne un ordre vraiment aléatoire. shuffle -> repeat -> batch remélange à chaque époque. Pour l'entraînement avec steps_per_epoch, utilisez repeat() pour que le dataset ne s'épuise jamais. drop_remainder=True jette le dernier batch court — important pour BatchNorm et les modèles à formes fixes. La graine ne rend le mélange reproductible entre itérations que si reshuffle_each_iteration=True avec la même graine.

tensorflow
import tensorflow as tf

ds = tf.data.Dataset.from_tensor_slices((x, y))
ds = ds.batch(32, drop_remainder=False)
ds = ds.shuffle(buffer_size=10000, seed=42, reshuffle_each_iteration=True)
ds = ds.repeat()         # infinite
ds = ds.repeat(5)        # 5 epochs

# recommended order: shuffle -> repeat -> batch
ds = ds.shuffle(10000).repeat().batch(32)

Prefetch et performance

prefetch(AUTOTUNE) est le plus grand gain — il laisse le CPU préparer le batch N+1 pendant que le GPU s'entraîne sur le batch N, donc ni l'un ni l'autre n'attend. num_parallel_calls=AUTOTUNE sur map parallélise le prétraitement borné au CPU. L'ordre optimal du pipeline est : source -> cache -> shuffle -> map(augmenter) -> batch -> prefetch. Utilisez tf.data.experimental.AUTOTUNE (identique à tf.data.AUTOTUNE) et laissez TF régler les tailles de buffers. Profilez toujours avant d'optimiser — le goulot est souvent ailleurs.

tensorflow
import tensorflow as tf

ds = ds.prefetch(tf.data.AUTOTUNE)
ds = ds.map(parse_fn, num_parallel_calls=tf.data.AUTOTUNE)

# full recommended pipeline
ds = (tf.data.Dataset.from_tensor_slices((x, y))
      .cache()
      .shuffle(10000)
      .map(augment, num_parallel_calls=tf.data.AUTOTUNE)
      .batch(32)
      .prefetch(tf.data.AUTOTUNE))

Lire des fichiers

TextLineDataset streame des lignes depuis des fichiers texte (logs, lignes CSV). make_csv_dataset parse des CSV avec inférence automatique des types de colonnes. image_dataset_from_directory est l'équivalent Keras de l'ImageFolder de PyTorch — il infère les labels des noms de sous-répertoires et retourne (batch_images, batch_labels). Pour plus de contrôle du chargement d'images, utilisez tf.io.read_file + tf.io.decode_image dans une fonction map. Batchez toujours le dataset avant de le passer à fit.

tensorflow
import tensorflow as tf

ds = tf.data.TextLineDataset(['file1.txt', 'file2.txt'])

ds = tf.data.experimental.make_csv_dataset(
    'data.csv', batch_size=32, label_name='label',
    num_epochs=1, shuffle_buffer_size=1000,
)

ds = tf.keras.utils.image_dataset_from_directory(
    'data/train', image_size=(224, 224), batch_size=32,
    shuffle=True, seed=42, validation_split=0.2, subset='training',
)

TFRecord

TFRecord est le format d'enregistrement binaire de TF — le moyen le plus rapide d'alimenter de grands datasets depuis le disque. Chaque enregistrement est un tf.train.Example sérialisé (un dict de features). La lecture est un I/O séquentiel, bien plus rapide que les lectures aléatoires sur stockage cloud (GCS/S3). Pour les images, stockez les octets bruts et décodez dans map(). Utilisez tf.data.TFRecordDataset avec compression='GZIP' pour des fichiers plus petits. Le sharding (plusieurs fichiers .tfrecord-0000N-of-0000M) permet la lecture parallèle.

tensorflow
import tensorflow as tf

def serialize(x, y):
    feature = {
        'x': tf.train.Feature(float_list=tf.train.FloatList(value=x.flatten())),
        'y': tf.train.Feature(int64_list=tf.train.Int64List(value=[y])),
    }
    return tf.train.Example(features=tf.train.Features(feature=feature)).SerializeToString()

with tf.io.TFRecordWriter('data.tfrecord') as w:
    for x, y in dataset:
        w.write(serialize(x, y))

def parse(serialized):
    feature = {'x': tf.io.FixedLenFeature([784], tf.float32),
               'y': tf.io.FixedLenFeature([], tf.int64)}
    parsed = tf.io.parse_single_example(serialized, feature)
    return parsed['x'], parsed['y']

ds = tf.data.TFRecordDataset('data.tfrecord').map(parse).batch(32)
10

Sauvegarde et chargement

Format SavedModel

SavedModel est le format de qualité production : il regroupe architecture, poids et graphe tracé pour que le modèle se charge dans TF Serving, TFLite, TF.js ou C++ sans le code Python d'origine. Utilisez tf.keras.models.load_model pour recharger en Python. Passez un input_signature pour définir explicitement la signature de serving — requis pour TF Serving. SavedModel est un répertoire, pas un seul fichier.

tensorflow
import tensorflow as tf

model.save('saved_model')   # SavedModel directory
loaded = tf.keras.models.load_model('saved_model')
loaded.evaluate(x_test, y_test)

# export for serving (explicit signature)
@tf.function(input_signature=[tf.TensorSpec([None, 784], tf.float32)])
def serve(x):
    return {'outputs': model(x)}

tf.saved_model.save(model, 'serving_model', signatures=serve)

Format Keras (.keras)

Le format .keras (défaut Keras 3) est un unique fichier zippé contenant la config d'architecture, les poids et l'état de l'optimiseur — facile à partager et versionner. .h5 est le vieux format HDF5, encore supporté mais déconseillé pour les nouveaux projets. SavedModel (un répertoire) est requis pour le déploiement (TFLite, TF Serving). Pour les couches custom, .keras sauve la config pour que la couche se reconstruise — assurez-vous que get_config() est correct.

tensorflow
import tensorflow as tf

model.save('model.keras')   # Keras 3 default
loaded = tf.keras.models.load_model('model.keras')

# legacy HDF5 format
model.save('model.h5')
loaded = tf.keras.models.load_model('model.h5')

# .keras  — Keras 3 default, supports custom layers via config
# .h5     — legacy, weights + architecture but limited custom layer support
# SavedModel — directory, best for deployment/serving

Sauver et charger seulement les poids

save_weights ne stocke que les tenseurs de paramètres — bien plus petit qu'un modèle complet et découplé de l'architecture. Il faut reconstruire le modèle avec la même structure avant le chargement. skip_mismatch=True (Keras 3) ne charge que les couches correspondantes, utile pour le transfer learning. Le format checkpoint (préfixe 'ckpt') crée checkpoint/weights-of-ckpt-1.index — le format de checkpoint natif de TF utilisé en interne par les callbacks de fit.

tensorflow
import tensorflow as tf

model.save_weights('weights.keras')

model = build_model()   # must match the saved architecture
model.load_weights('weights.keras')

model.save_weights('weights.h5')
model.load_weights('weights.h5')

# load weights from one model into another (partial)
model.load_weights('weights.keras', skip_mismatch=True, by_name=True)

model.save_weights('ckpt')
model.load_weights('ckpt')

Checkpoint Manager

Checkpoint + CheckpointManager donnent le contrôle total de la sauvegarde dans les boucles d'entraînement custom — garder les N derniers checkpoints, restaurer le dernier automatiquement, versionner par pas. expect_partial() silencie les avertissements sur les slots non restaurés (ex. momentum de l'optimiseur pour de nouvelles variables). Les checkpoints stockent le graphe d'objets, pas les définitions de classes — il faut encore le code du modèle pour restaurer. CheckpointManager.max_to_keep=3 supprime automatiquement les vieux checkpoints.

tensorflow
import tensorflow as tf

ckpt = tf.train.Checkpoint(model=model, optimizer=optimizer, step=optimizer.iterations)
manager = tf.train.CheckpointManager(
    ckpt, directory='./ckpts', max_to_keep=3,
    checkpoint_name='step-{step}',
)

manager.save()
ckpt.restore(manager.latest_checkpoint).expect_partial()

# in a custom loop: save every N steps
if step % 1000 == 0:
    manager.save()

Charger avec objets custom

En chargeant un modèle utilisant des couches, pertes ou métriques custom, Keras doit savoir les reconstruire. Passez un dict custom_objects mappant les noms aux classes/fonctions. Pour un code plus propre, décorez les classes avec @register_keras_serializable pour qu'elles s'enregistrent globalement sans custom_objects. Assurez-vous que get_config retourne tous les arguments du constructeur pour que l'objet se reconstruise exactement — Keras appelle from_config(config) sous le capot.

tensorflow
import tensorflow as tf

class MyLayer(tf.keras.layers.Layer):
    ...

custom_objects = {'MyLayer': MyLayer, 'focal_loss': FocalLoss}

loaded = tf.keras.models.load_model(
    'model.keras', custom_objects=custom_objects,
)

# or register globally
@tf.keras.utils.register_keras_serializable(package='my_pkg')
class MyLayer(tf.keras.layers.Layer):
    ...

Exporter pour le serving

TF Serving attend des répertoires versionnés (serving/1/, serving/2/) pour pouvoir échanger les modèles à chaud. La signature de serving définit les noms et shapes de tenseurs d'entrée/sortie que les clients utilisent. model.export() (Keras 3) l'automatise. Pour un prétraitement custom, enveloppez le modèle dans un tf.Module et définissez __call__ avec un input_signature incluant l'entrée brute (ex. image uint8) et retournant la sortie finale. Nommez les tenseurs pour que les clients puissent les adresser.

tensorflow
import tensorflow as tf

# Keras 3 export API (recommended)
model.export('serving/1')

class ServingModule(tf.Module):
    def __init__(self, model):
        self.model = model
    @tf.function(input_signature=[tf.TensorSpec([None, 784], tf.float32, name='inputs')])
    def __call__(self, x):
        return {'outputs': self.model(x)}

module = ServingModule(model)
tf.saved_model.save(module, 'serving/1',
                    signatures={'serving_default': module.__call__})

loaded = tf.saved_model.load('serving/1')
print(list(loaded.signatures.keys()))   # ['serving_default']
11

CNN

Conv2D et pooling

Le bloc CNN canonique en Keras : Conv2D -> BatchNormalization -> ReLU -> MaxPooling. padding='same' garde la taille spatiale pour un stride de 1. GlobalAveragePooling2D effondre les dims spatiales en un vecteur — plus économe en paramètres que Flatten + Dense et moins sujet au surapprentissage. Keras utilise NHWC (channels-last) par défaut, donc la forme d'Input est (H, W, C) sans dimension de batch. Les convs à pas peuvent remplacer le pooling pour un sous-échantillonnage apprenable.

tensorflow
import tensorflow as tf

model = tf.keras.Sequential([
    tf.keras.layers.Input(shape=(28, 28, 1)),
    tf.keras.layers.Conv2D(32, 3, padding='same', activation='relu'),
    tf.keras.layers.BatchNormalization(),
    tf.keras.layers.MaxPooling2D(),                # 28 -> 14
    tf.keras.layers.Conv2D(64, 3, padding='same', activation='relu'),
    tf.keras.layers.BatchNormalization(),
    tf.keras.layers.MaxPooling2D(),                # 14 -> 7
    tf.keras.layers.Conv2D(128, 3, padding='same', activation='relu'),
    tf.keras.layers.GlobalAveragePooling2D(),      # (7,7,128) -> (128,)
    tf.keras.layers.Dense(10, activation='softmax'),
])
model.summary()

Bâtir un CNN

Un CNN style VGG avec filtres doublés à chaque étage (32 -> 64 -> 128) et taille spatiale divisée par deux via MaxPooling. Deux convs par étage (bloc VGG) extraient des caractéristiques plus riches qu'une. Le Rescaling dans le modèle le rend déployable — les images uint8 brutes entrent directement. GlobalAveragePooling + Dropout régularise la tête. Compilez avec sparse_categorical_crossentropy car les labels sont des indices de classe entiers.

tensorflow
import tensorflow as tf

inputs = tf.keras.Input(shape=(32, 32, 3))
x = tf.keras.layers.Rescaling(1./255)(inputs)

for filters in [32, 64, 128]:
    x = tf.keras.layers.Conv2D(filters, 3, padding='same', activation='relu')(x)
    x = tf.keras.layers.BatchNormalization()(x)
    x = tf.keras.layers.Conv2D(filters, 3, padding='same', activation='relu')(x)
    x = tf.keras.layers.MaxPooling2D()(x)
    x = tf.keras.layers.Dropout(0.25)(x)

x = tf.keras.layers.GlobalAveragePooling2D()(x)
x = tf.keras.layers.Dense(256, activation='relu')(x)
x = tf.keras.layers.Dropout(0.5)(x)
outputs = tf.keras.layers.Dense(10, activation='softmax')(x)
model = tf.keras.Model(inputs, outputs)

Feature maps et visualisation

Créez un Model avec la même entrée mais plusieurs sorties (les activations des couches conv) pour inspecter ce que chaque couche apprend. Les premières couches détectent contours/couleurs, les profondes textures/parties. Inestimable pour déboguer — des feature maps mortes (tout à zéro) signalent des ReLU cassés ou des soucis de taux d'apprentissage. Pour le Grad-CAM (cartes d'activation de classe), utilisez tf-keras-vis ou implémentez des activations de classe pondérées par gradient pour voir quelles régions ont motivé une prédiction.

tensorflow
import tensorflow as tf
import matplotlib.pyplot as plt

feature_model = tf.keras.Model(
    inputs=model.inputs,
    outputs=[layer.output for layer in model.layers if 'conv2d' in layer.name],
)

img = x_test[0:1]
features = feature_model.predict(img)
print([f.shape for f in features])

fig, axes = plt.subplots(4, 8, figsize=(12, 6))
for i, ax in enumerate(axes.flat):
    if i < features[0].shape[-1]:
        ax.imshow(features[0][0, :, :, i], cmap='viridis')
    ax.axis('off')

Backbones CNN préentraînés

keras.applications expose ResNet, EfficientNet, MobileNet, ViT et plus avec poids ImageNet. include_top=False retire la tête à 1000 classes pour attacher la vôtre. preprocess_input applique la normalisation exacte attendue par le backbone — appelez-la dans le modèle pour le déploiement. Gelez le backbone (trainable=False) et réglez training=False à l'appel pour que BatchNorm utilise les stats d'inférence — critique pour le transfer learning sur petits jeux de données.

tensorflow
import tensorflow as tf

backbone = tf.keras.applications.ResNet50(
    include_top=False, weights='imagenet',
    input_shape=(224, 224, 3), pooling='avg',
)
backbone.trainable = False

inputs = tf.keras.Input(shape=(224, 224, 3))
x = tf.keras.applications.resnet50.preprocess_input(inputs)
x = backbone(x, training=False)
x = tf.keras.layers.Dense(256, activation='relu')(x)
x = tf.keras.layers.Dropout(0.5)(x)
outputs = tf.keras.layers.Dense(10, activation='softmax')(x)
model = tf.keras.Model(inputs, outputs)

Connexions résiduelles

Les connexions résiduelles (skip) ajoutent l'entrée à la sortie d'un bloc, laissant les gradients couler directement vers les couches antérieures — c'est ce qui permet d'entraîner des réseaux très profonds (ResNet). Le raccourci doit correspondre aux canaux et à la taille spatiale de la sortie ; utilisez une conv 1x1 avec stride pour ajuster quand ils diffèrent. Add() fusionne les deux chemins. Utilisez l'API functional (pas Sequential) pour toute architecture à skip connections. ResNet-50 empile beaucoup de tels blocs.

tensorflow
import tensorflow as tf

def residual_block(x, filters, stride=1):
    shortcut = x
    x = tf.keras.layers.Conv2D(filters, 3, strides=stride, padding='same', use_bias=False)(x)
    x = tf.keras.layers.BatchNormalization()(x)
    x = tf.keras.layers.ReLU()(x)
    x = tf.keras.layers.Conv2D(filters, 3, padding='same', use_bias=False)(x)
    x = tf.keras.layers.BatchNormalization()(x)
    if stride != 1 or shortcut.shape[-1] != filters:
        shortcut = tf.keras.layers.Conv2D(filters, 1, strides=stride, use_bias=False)(shortcut)
        shortcut = tf.keras.layers.BatchNormalization()(shortcut)
    x = tf.keras.layers.Add()([x, shortcut])
    return tf.keras.layers.ReLU()(x)

inputs = tf.keras.Input(shape=(32, 32, 3))
x = residual_block(inputs, 64)
x = residual_block(x, 128, stride=2)
model = tf.keras.Model(inputs, x)

Tête de détection

Les têtes de détection prédisent des boîtes par ancre ou par pixel plus des probabilités de classe. L'API functional facilite les modèles multi-sorties : retournez un dict de tenseurs nommés. Pour de vrais projets, utilisez l'API TensorFlow Object Detection ou KerasCV (détection, segmentation) — ils gèrent le matching d'ancres, le NMS et l'évaluation. Écrire un détecteur complet from scratch est un exercice avancé : gérez soigneusement l'encodage des boîtes, la perte IoU et la focal loss.

tensorflow
import tensorflow as tf

# YOLO-style detection head: conv to (grid * grid * (5 + num_classes))
def detection_head(x, num_classes, num_anchors=3):
    out = tf.keras.layers.Conv2D(
        num_anchors * (5 + num_classes), 1, activation='linear')(x)
    return out

# anchor-free alternative: predict (cx, cy, w, h, obj, class_logits)
def center_net_head(features, num_classes):
    cls = tf.keras.layers.Conv2D(num_classes, 1, activation='sigmoid', name='cls')(features)
    wh = tf.keras.layers.Conv2D(2, 1, name='wh')(features)
    offset = tf.keras.layers.Conv2D(2, 1, name='offset')(features)
    return {'cls': cls, 'wh': wh, 'offset': offset}
12

RNN et LSTM

Couches LSTM et GRU

La forme d'entrée de LSTM/GRU est (batch, timesteps, features). return_sequences=False retourne la dernière sortie (pour la classification) ; True toute la séquence (pour empiler ou seq2seq). Bidirectional concatène les sorties avant et arrière, doublant la taille des caractéristiques. stateful=True porte l'état caché entre batchs — utile pour de très longues séquences découpées en morceaux, mais exige un batch_size fixe et des réinitialisations d'état manuelles entre époques.

tensorflow
import tensorflow as tf

lstm = tf.keras.layers.LSTM(128, return_sequences=False)
x = tf.random.normal((4, 10, 64))
out = lstm(x)                       # (4, 128)

gru = tf.keras.layers.GRU(128)
out = gru(x)                        # (4, 128)

lstm = tf.keras.layers.LSTM(128, return_sequences=True)
out = lstm(x)                       # (4, 10, 128)

bi = tf.keras.layers.Bidirectional(tf.keras.layers.LSTM(64))
out = bi(x)                         # (4, 128) — 64*2

lstm = tf.keras.layers.LSTM(64, stateful=True)

RNN empilés

Empilez les RNN en réglant return_sequences=True sur tous les LSTM/GRU sauf le dernier. mask_zero=True dans la couche Embedding génère un masque respecté par les RNN — ils sautent les positions bourrées, donc on peut batcher des séquences de longueur variable sans affecter l'état caché. Le dropout entre couches RNN régularise ; recurrent_dropout dans un RNN est plus lent (pas de cuDNN) — préférez le dropout d'entrée. Pour la classification de texte, ce biLSTM est un solide baseline.

tensorflow
import tensorflow as tf

model = tf.keras.Sequential([
    tf.keras.layers.Embedding(10000, 128, input_length=100, mask_zero=True),
    tf.keras.layers.LSTM(128, return_sequences=True),
    tf.keras.layers.Dropout(0.3),
    tf.keras.layers.LSTM(64),
    tf.keras.layers.Dense(64, activation='relu'),
    tf.keras.layers.Dense(10, activation='softmax'),
])

model.compile(optimizer='adam', loss='sparse_categorical_crossentropy')

Classification de texte avec RNN

Un classifieur de texte standard : Embedding -> biLSTM -> biLSTM -> Dense -> sigmoid. mask_zero=True est critique — sans lui le LSTM traite les tokens de padding, biaisant l'état caché. Bidirectional double le pouvoir de représentation en lisant la séquence dans les deux sens. Pour la classification binaire, utilisez sigmoid + binary_crossentropy. Pour les longues séquences (>500 tokens), les transformers surpassent les LSTM mais exigent plus de données et de calcul.

tensorflow
import tensorflow as tf

model = tf.keras.Sequential([
    tf.keras.layers.Input(shape=(200,)),
    tf.keras.layers.Embedding(10000, 128, mask_zero=True),
    tf.keras.layers.Bidirectional(tf.keras.layers.LSTM(64, return_sequences=True)),
    tf.keras.layers.Bidirectional(tf.keras.layers.LSTM(32)),
    tf.keras.layers.Dense(64, activation='relu'),
    tf.keras.layers.Dropout(0.5),
    tf.keras.layers.Dense(1, activation='sigmoid'),
])

model.compile(optimizer=tf.keras.optimizers.Adam(1e-3),
              loss='binary_crossentropy', metrics=['accuracy'])
model.fit(train_ds, validation_data=val_ds, epochs=5)

Seq2Seq encodeur-décodeur

LSTM encodeur-décodeur pour du seq2seq (traduction, résumé). L'état caché final de l'encodeur initialise le décodeur, qui génère la séquence cible token par token. Entraînez avec teacher forcing : alimentez la séquence cible décalée comme entrée du décodeur. Pour l'inférence, écrivez une boucle séparée qui alimente chaque token prédit comme entrée suivante. L'attention (Bahdanau/Luong) améliore drastiquement le seq2seq et est l'ancêtre conceptuel des transformers.

tensorflow
import tensorflow as tf

encoder_input = tf.keras.Input(shape=(None,), name='enc_in')
enc_emb = tf.keras.layers.Embedding(vocab_src, 128)(encoder_input)
encoder = tf.keras.layers.LSTM(256, return_state=True)
enc_out, state_h, state_c = encoder(enc_emb)

decoder_input = tf.keras.Input(shape=(None,), name='dec_in')
dec_emb = tf.keras.layers.Embedding(vocab_tgt, 128)(decoder_input)
decoder_lstm = tf.keras.layers.LSTM(256, return_sequences=True, return_state=True)
dec_out, _, _ = decoder_lstm(dec_emb, initial_state=[state_h, state_c])
decoder_dense = tf.keras.layers.Dense(vocab_tgt, activation='softmax')
outputs = decoder_dense(dec_out)

model = tf.keras.Model([encoder_input, decoder_input], outputs)
model.compile(optimizer='adam', loss='sparse_categorical_crossentropy')

Prévision de séries temporelles

Pour les séries temporelles, bâtissez des paires (entrée, cible) fenêtrées : la dernière valeur de chaque fenêtre est la cible, le reste des entrées. window(shift=1) crée des fenêtres chevauchantes ; drop_remainder garde la même taille. Le LSTM apprend les patterns temporels ; un Dense(1) final prédit la valeur suivante. Pour la prévision multi-pas, prédisez un vecteur d'horizon ou utilisez une architecture seq2seq. Standardisez toujours la série avec les seules statistiques d'entraînement.

tensorflow
import tensorflow as tf

def make_dataset(series, window=20, batch=32):
    ds = tf.data.Dataset.from_tensor_slices(series)
    ds = ds.window(window + 1, shift=1, drop_remainder=True)
    ds = ds.flat_map(lambda w: w.batch(window + 1))
    ds = ds.map(lambda w: (w[:-1][..., tf.newaxis], w[-1:]))
    return ds.shuffle(1000).batch(batch).prefetch(tf.data.AUTOTUNE)

model = tf.keras.Sequential([
    tf.keras.layers.Input(shape=(20, 1)),
    tf.keras.layers.LSTM(32, return_sequences=False),
    tf.keras.layers.Dense(1),
])
model.compile(optimizer='adam', loss='mse')
model.fit(make_dataset(train_series), epochs=10)

Mécanisme d'attention

L'attention laisse le décodeur se concentrer sur les états pertinents de l'encodeur au lieu de s'appuyer sur un unique vecteur fixe — une amélioration majeure pour les longues séquences. Bahdanau (additive) et Luong (multiplicative) sont les deux variantes classiques. Keras fournit tf.keras.layers.AdditiveAttention et Attention comme couches prêtes à l'emploi. L'attention est le pont conceptuel vers les transformers : la self-attention multi-têtes n'est que de l'attention appliquée à la même séquence.

tensorflow
import tensorflow as tf

class BahdanauAttention(tf.keras.layers.Layer):
    def __init__(self, units):
        super().__init__()
        self.W1 = tf.keras.layers.Dense(units)
        self.W2 = tf.keras.layers.Dense(units)
        self.V = tf.keras.layers.Dense(1)
    def call(self, query, values):
        q = tf.expand_dims(query, 1)
        scores = self.V(tf.nn.tanh(self.W1(values) + self.W2(q)))
        attn = tf.nn.softmax(scores, axis=1)
        context = tf.reduce_sum(attn * values, axis=1)
        return context, attn

attn = tf.keras.layers.AdditiveAttention()
context = attn([query, value])
13

Transformer

MultiHeadAttention

MultiHeadAttention est la couche transformer cœur — elle projette q/k/v en plusieurs têtes, prête attention en parallèle et recombine. Pour la self-attention, passez le même tenseur comme query, key et value. attention_mask peut être un masque causal (triangulaire inférieur) pour le décodage ou un masque de padding (True = ignorer). return_attention_scores=True retourne la matrice d'attention pour la visualisation. La dim de sortie égale la dim d'entrée pour que les blocs s'empilent.

tensorflow
import tensorflow as tf

mha = tf.keras.layers.MultiHeadAttention(
    num_heads=8, key_dim=64, dropout=0.1, use_bias=True)

x = tf.random.normal((4, 10, 512))
out, attn_weights = mha(query=x, value=x, key=x,
                        return_attention_scores=True)
print(out.shape)          # (4, 10, 512)
print(attn_weights.shape) # (4, 8, 10, 10)

# causal mask (decoder self-attention)
mask = tf.linalg.band_part(tf.ones((10, 10)), -1, 0)
out = mha(query=x, value=x, key=x, attention_mask=mask)

# key padding mask (ignore pad positions)
padding = tf.cast(tokens == 0, tf.bool)[:, tf.newaxis, tf.newaxis, :]
out = mha(query=x, value=x, key=x, attention_mask=padding)

Bloc d'encodeur Transformer

Un bloc d'encodeur transformer est : self-attention multi-têtes + add & norm + feed-forward (MLP) + add & norm. Pre-LN (norme avant la sous-couche) est plus stable pour un entraînement from scratch ; post-LN exige du warmup. La FFN est un MLP à 2 couches avec GELU, expandant vers 'ff' unités cachées puis revenant à 'dim'. Empilez N de ces blocs pour un encodeur complet. epsilon=1e-6 dans LayerNorm évite la division par zéro pour les faibles variances.

tensorflow
import tensorflow as tf

class TransformerBlock(tf.keras.layers.Layer):
    def __init__(self, dim=512, heads=8, ff=2048, dropout=0.1, **kwargs):
        super().__init__(**kwargs)
        self.att = tf.keras.layers.MultiHeadAttention(num_heads=heads, key_dim=dim // heads)
        self.ffn = tf.keras.Sequential([
            tf.keras.layers.Dense(ff, activation='gelu'),
            tf.keras.layers.Dense(dim),
        ])
        self.norm1 = tf.keras.layers.LayerNormalization(epsilon=1e-6)
        self.norm2 = tf.keras.layers.LayerNormalization(epsilon=1e-6)
        self.drop1 = tf.keras.layers.Dropout(dropout)
        self.drop2 = tf.keras.layers.Dropout(dropout)

    def call(self, x, training=False, mask=None):
        attn = self.att(x, x, x, attention_mask=mask)
        x = self.norm1(x + self.drop1(attn, training=training))
        ffn = self.ffn(x)
        return self.norm2(x + self.drop2(ffn, training=training))

Encodage positionnel

Les transformers sont invariants à la permutation — ils ont besoin d'information positionnelle pour connaître l'ordre des tokens. Les encodages sinusoïdaux ajoutent un motif fixe basé sur position et dimension ; ils généralisent à des séquences plus longues que vues à l'entraînement. Ajoutez l'encodage positionnel à la sortie de l'embedding. Alternativement, utilisez des embeddings de position appris (une couche Embedding indexée par position) ou des encodages de position relative (utilisés dans les transformers modernes comme T5). Pour les images (ViT), ajoutez un embedding de position apprenable par patch.

tensorflow
import tensorflow as tf
import numpy as np

class PositionalEncoding(tf.keras.layers.Layer):
    def __init__(self, max_len=5000, dim=512, **kwargs):
        super().__init__(**kwargs)
        pos = np.arange(max_len)[:, np.newaxis]
        i = np.arange(dim)[np.newaxis, :]
        angle = pos / np.power(10000, (2 * (i // 2)) / np.float32(dim))
        angle[:, 0::2] = np.sin(angle[:, 0::2])
        angle[:, 1::2] = np.cos(angle[:, 1::2])
        self.pos = tf.constant(angle[np.newaxis, ...], dtype=tf.float32)

    def call(self, x):
        return x + self.pos[:, :tf.shape(x)[1], :]

model = tf.keras.Sequential([
    tf.keras.layers.Embedding(10000, 512),
    PositionalEncoding(max_len=200, dim=512),
    tf.keras.layers.Dropout(0.1),
])

Transformer de classification de texte

Un classifieur de texte transformer from scratch : embedding + encodage positionnel + N blocs d'encodeur + pool moyenne globale + tête Dense. GlobalAveragePooling1D effondre la dimension de séquence (utilisez un token CLS pour une agrégation apprenable). mask_zero=True propage un masque respecté par MultiHeadAttention — transmettez-le manuellement si besoin. Pour du vrai NLP, utilisez un transformer préentraîné (BERT, T5) de HuggingFace — l'entraînement from scratch exige des données énormes.

tensorflow
import tensorflow as tf

class TransformerEncoder(tf.keras.layers.Layer):
    def __init__(self, dim, heads, ff, num_layers, dropout=0.1, **kwargs):
        super().__init__(**kwargs)
        self.blocks = [TransformerBlock(dim, heads, ff, dropout)
                       for _ in range(num_layers)]
    def call(self, x, training=False, mask=None):
        for block in self.blocks:
            x = block(x, training=training, mask=mask)
        return x

inputs = tf.keras.Input(shape=(200,))
x = tf.keras.layers.Embedding(10000, 128, mask_zero=True)(inputs)
x = PositionalEncoding(200, 128)(x)
x = TransformerEncoder(128, 4, 512, 4)(x)
x = tf.keras.layers.GlobalAveragePooling1D()(x)
x = tf.keras.layers.Dropout(0.3)(x)
outputs = tf.keras.layers.Dense(1, activation='sigmoid')(x)
model = tf.keras.Model(inputs, outputs)

Vision Transformer (ViT)

Un Vision Transformer patchifie l'image avec une Conv2d à pas (kernel=stride=patch_size), traite les patchs comme tokens, prépose un token CLS, ajoute des embeddings positionnels, et exécute des blocs d'encodeur transformer. L'état caché final du token CLS est la représentation globale de l'image pour la classification. Pour un usage réel, chargez un ViT préentraîné depuis keras.applications ou HuggingFace — ils exigent un préentraînement ImageNet-21k pour bien marcher. Patch 16 et dim 768 sont les défauts de ViT-Base.

tensorflow
import tensorflow as tf

class ViTPatchEmbed(tf.keras.layers.Layer):
    def __init__(self, patch_size=16, dim=768, **kwargs):
        super().__init__(**kwargs)
        self.proj = tf.keras.layers.Conv2D(dim, patch_size, strides=patch_size)
    def call(self, x):
        x = self.proj(x)
        shape = tf.shape(x)
        x = tf.reshape(x, [shape[0], -1, x.shape[-1]])
        return x

inputs = tf.keras.Input(shape=(224, 224, 3))
x = ViTPatchEmbed(16, 768)(inputs)
x = x + tf.Variable(tf.random.normal((1, 196, 768)))
cls = tf.Variable(tf.random.normal((1, 1, 768)))
x = tf.keras.layers.Concatenate(axis=1)([cls, x])
for _ in range(6):
    x = TransformerBlock(768, 12, 3072, 0.1)(x)
x = tf.keras.layers.Lambda(lambda t: t[:, 0])(x)
outputs = tf.keras.layers.Dense(10, activation='softmax')(x)
model = tf.keras.Model(inputs, outputs)

Décodeur Transformer

Un bloc de décodeur a trois sous-couches : self-attention masquée (masque causal pour que la position t ne voie pas le futur), cross-attention (query du décodeur, key/value de la sortie de l'encodeur) et une FFN. Chaque sous-couche porte un résidu + LayerNorm. La cross-attention est ce qui permet au décodeur de « regarder en arrière » la séquence source. Pour les modèles décodeur-seuls (GPT), retirez la sous-couche de cross-attention. Empilez N blocs pour un décodeur complet. L'inférence exige une boucle autorégressive réalimentant les tokens prédits.

tensorflow
import tensorflow as tf

class DecoderBlock(tf.keras.layers.Layer):
    def __init__(self, dim, heads, ff, dropout=0.1, **kwargs):
        super().__init__(**kwargs)
        self.self_att = tf.keras.layers.MultiHeadAttention(heads, dim // heads)
        self.cross_att = tf.keras.layers.MultiHeadAttention(heads, dim // heads)
        self.ffn = tf.keras.Sequential([
            tf.keras.layers.Dense(ff, activation='gelu'),
            tf.keras.layers.Dense(dim),
        ])
        self.norm1 = self.norm2 = self.norm3 = tf.keras.layers.LayerNormalization(epsilon=1e-6)
        self.drop = tf.keras.layers.Dropout(dropout)

    def call(self, x, enc_out, training=False, causal_mask=None, padding_mask=None):
        attn = self.self_att(x, x, x, attention_mask=causal_mask)
        x = self.norm1(x + self.drop(attn, training=training))
        cross = self.cross_att(query=x, value=enc_out, key=enc_out, attention_mask=padding_mask)
        x = self.norm2(x + self.drop(cross, training=training))
        x = self.norm3(x + self.drop(self.ffn(x), training=training))
        return x
14

TensorBoard

Mise en place et callback

Le callback TensorBoard streame métriques, graphes et données de profilage vers log_dir pendant fit. histogram_freq=1 logge les distributions de poids par époque — réglez à 0 pour économiser l'espace. profile_batch=2 lance le TF Profiler sur ce batch pour identifier les goulots (pipeline d'entrée, latence des ops, mémoire). Utilisez des sous-répertoires distincts par expérience (logs/exp1, logs/exp2) pour que TensorBoard les superpose — parfait pour les balayages d'hyperparamètres. Lancez avec `tensorboard --logdir=logs`.

tensorflow
import tensorflow as tf

tb = tf.keras.callbacks.TensorBoard(
    log_dir='logs/experiment_1', histogram_freq=1,
    write_graph=True, profile_batch=2,
)

model.fit(train_ds, validation_data=val_ds, epochs=10, callbacks=[tb])

# launch tensorboard
# tensorboard --logdir=logs

import datetime
log_dir = 'logs/fit/' + datetime.datetime.now().strftime('%Y%m%d-%H%M%S')

Scalaires custom (Summary Writer)

tf.summary.create_file_writer donne une prise bas niveau pour logger des scalaires custom dans les boucles d'entraînement custom. Utilisez writer.as_default() et tf.summary.scalar(nom, valeur, step=pas) pour écrire. Step doit être un entier (généralement le compteur d'itérations de l'optimiseur). Flushez périodiquement pour que les événements atteignent le disque. Utilisez des namespaces (train/loss, val/loss) pour organiser les graphiques dans l'UI TensorBoard. Loggez le LR, les normes de gradients et toute métrique custom qui vous importe.

tensorflow
import tensorflow as tf

writer = tf.summary.create_file_writer('logs/custom')

with writer.as_default():
    tf.summary.scalar('train/loss', loss, step=step)
    tf.summary.scalar('train/lr', lr, step=step)
    tf.summary.scalar('val/accuracy', acc, step=step)
    tf.summary.text('config', 'lr=1e-3, batch=32', step=0)
    writer.flush()

# in a custom training loop
for step, (x, y) in enumerate(train_ds):
    # ... train step ...
    if step % 100 == 0:
        with writer.as_default():
            tf.summary.scalar('loss', loss, step=step)

Images et histogrammes

tf.summary.image logge des images pour le QA visuel — passez une shape (B, H, W, C) avec B jusqu'à max_outputs. Les histogrammes montrent les distributions de poids et gradients dans le temps ; des pics soudains trahissent l'instabilité. Loggez quelques échantillons de validation par époque pour voir la progression qualitative, pas seulement les métriques scalaires. L'audio sert aux modèles de parole. Tous les summaries prennent un argument step devenant l'axe x dans TensorBoard. Gardez le logging bon marché en échantillonnant tous les N pas.

tensorflow
import tensorflow as tf

writer = tf.summary.create_file_writer('logs/viz')

with writer.as_default():
    tf.summary.image('sample', img[None, ...], step=step)
    tf.summary.image('batch', images[:8], step=step, max_outputs=8)
    for var in model.trainable_variables:
        tf.summary.histogram('weights/' + var.name, var, step=step)
    tf.summary.audio('waveform', audio[None, ...], sample_rate=16000, step=step)
    writer.flush()

Réglage d'hyperparamètres

Le plugin HParams organise les balayages d'hyperparamètres dans TensorBoard — une vue table permet de filtrer les runs et trouver la meilleure config. Définissez des objets HParam avec plages/valeurs discrètes, loggez une config une fois avec hp.hparams_config, puis pour chaque run loggez hp.hparams(hparams) plus la métrique finale. Pour des balayages sérieux, utilisez KerasTuner (RandomSearch, Hyperband, BayesianOptimization) qui automatise la recherche et s'intègre à TensorBoard.

tensorflow
import tensorflow as tf
# from tensorboard.plugins.hparams import api as hp
# (run: pip install tensorboard-plugin-hparams)

HP_LR = hp.HParam('lr', hp.RealInterval(1e-4, 1e-2))
HP_DROPOUT = hp.HParam('dropout', hp.Discrete([0.1, 0.3, 0.5]))
METRIC_ACC = 'accuracy'

with tf.summary.create_file_writer('logs/hparam_tuning').as_default():
    hp.hparams_config(hparams=[HP_LR, HP_DROPOUT], metrics=[hp.Metric(METRIC_ACC)])

for lr in [1e-3, 5e-3]:
    for dropout in [0.1, 0.3]:
        hparams = {HP_LR: lr, HP_DROPOUT: dropout}
        run_name = f"lr-{lr}-drop-{dropout}"
        with tf.summary.create_file_writer('logs/hparam_tuning/' + run_name).as_default():
            hp.hparams(hparams)
            acc = train(hparams)
            tf.summary.scalar(METRIC_ACC, acc, step=1)

Profiler la performance

Le TF Profiler montre où va le temps : par op, par device et dans le pipeline d'entrée. profile_batch='10,20' profile les batchs 10-20 (sautez les premiers pour que le warmup soit fait). La page Overview donne des recommandations actionnables (ex. « le pipeline d'entrée est le goulot »). Le Memory Viewer montre la mémoire pic et quels tenseurs dominent. Le Trace Viewer est une timeline style Chrome pour l'analyse profonde. Profilez toujours sur le matériel cible — les goulots diffèrent entre CPU et GPU.

tensorflow
import tensorflow as tf

# profile via callback
tb = tf.keras.callbacks.TensorBoard(
    log_dir='logs/profile', profile_batch='10,20',
)

# or use the Profiler API directly
tf.profiler.experimental.start('logs/profile')
# ... run a few batches ...
tf.profiler.experimental.stop()

# in TensorBoard, open the Profile tab to see:
# - op-level time breakdown
# - input pipeline analysis (tf.data bottleneck)
# - memory viewer
# - overview page with recommendations
15

Entraînement GPU / TPU

Détection GPU et mémoire

Par défaut TF saisit toute la mémoire GPU au démarrage, bloquant les autres processus. set_memory_growth(True) n'alloue que le nécessaire — essentiel pour partager un GPU. set_logical_device_configuration limite la mémoire ou scinde un GPU en plusieurs devices logiques (utile pour tester du code multi-GPU sur un GPU). tf.device('/GPU:1') place les ops sur un device précis. Les ops CPU tournent sur '/CPU:0'. Un placement de device discordant cause des copies implicites qui nuisent à la performance.

tensorflow
import tensorflow as tf

gpus = tf.config.list_physical_devices('GPU')
print('GPUs:', gpus)

# set memory growth (don't grab all GPU memory at start)
for gpu in gpus:
    tf.config.experimental.set_memory_growth(gpu, True)

# or limit GPU memory explicitly
tf.config.set_logical_device_configuration(
    gpus[0],
    [tf.config.LogicalDeviceConfiguration(memory_limit=4096)],
)

with tf.device('/GPU:1'):
    x = tf.random.normal((1000, 1000))
    y = tf.matmul(x, x)

Stratégie de distribution

Les stratégies de distribution abstraient la topologie des devices. MirroredStrategy est pour le multi-GPU mono-machine (miroir des variables entre GPU, all-reduce des gradients) — le chemin multi-GPU le plus simple. MultiWorkerMirroredStrategy s'étend à plusieurs machines. TPUStrategy tourne sur les TPU Google (Colab/Cloud). Créez toujours le modèle dans strategy.scope() pour que les variables se miroitent correctement. Le même code fit/predict marche entre stratégies.

tensorflow
import tensorflow as tf

strategy = tf.distribute.OneDeviceStrategy(device='/gpu:0')
strategy = tf.distribute.MirroredStrategy()
print('num replicas:', strategy.num_replicas_in_sync)

# TPU
resolver = tf.distribute.cluster_resolver.TPUClusterResolver()
tf.config.experimental_connect_to_cluster(resolver)
tf.tpu.experimental.initialize_tpu_system(resolver)
strategy = tf.distribute.TPUStrategy(resolver)

with strategy.scope():
    model = build_model()
    model.compile(optimizer='adam', loss='...', metrics=['accuracy'])

model.fit(train_ds, epochs=10)

Entraînement multi-GPU

MirroredStrategy miroite les variables du modèle sur chaque GPU et découpe chaque batch entre réplicas — le batch effectif est global_batch (ex. 64 par GPU * 4 GPU = 256). Passez le batch global au dataset ; TF distribue les morceaux automatiquement. fit() gère l'all-reduce des gradients sous le capot. Pour les boucles d'entraînement custom, utilisez strategy.experimental_distribute_dataset et strategy.run(train_step).

tensorflow
import tensorflow as tf

strategy = tf.distribute.MirroredStrategy()
print(f'using {strategy.num_replicas_in_sync} GPUs')

global_batch = 64 * strategy.num_replicas_in_sync
train_ds = make_dataset().batch(global_batch)

with strategy.scope():
    model = build_model()
    model.compile(optimizer='adam', loss='sparse_categorical_crossentropy',
                  metrics=['accuracy'])

model.fit(train_ds, epochs=10, validation_data=val_ds)

Entraînement TPU (Colab)

Les TPU sont disponibles dans Google Colab (changer le type de runtime -> TPU) et Google Cloud. Initialisez le système TPU une fois, puis enveloppez la création du modèle dans strategy.scope(). Les TPU sont les plus rapides avec de grands batchs (1024+) et des formes fixes — utilisez drop_remainder=True au batching. Les TPU ne peuvent pas lire les fichiers locaux directement ; chargez les données en mémoire ou streamez depuis GCS via tf.data. La précision mixte (bfloat16) donne un gros gain sur TPU sans loss scaling.

tensorflow
import tensorflow as tf

try:
    resolver = tf.distribute.cluster_resolver.TPUClusterResolver()
    tf.config.experimental_connect_to_cluster(resolver)
    tf.tpu.experimental.initialize_tpu_system(resolver)
    strategy = tf.distribute.TPUStrategy(resolver)
    print('TPUs:', strategy.num_replicas_in_sync)
except ValueError:
    print('No TPU found')
    strategy = tf.distribute.get_strategy()

with strategy.scope():
    model = tf.keras.Sequential([
        tf.keras.layers.Dense(128, activation='relu', input_shape=(784,)),
        tf.keras.layers.Dense(10, activation='softmax'),
    ])
    model.compile(optimizer='adam', loss='sparse_categorical_crossentropy')

model.fit(x_train, y_train, batch_size=1024, epochs=5)

Précision mixte

La précision mixte calcule en float16 mais garde des copies maîtres float32, donnant 2 à 3x de débit sur les GPU Tensor Core (Volta+) et la moitié de la mémoire. 'mixed_float16' exige du loss scaling (Keras le gère automatiquement via LossScaleOptimizer). 'mixed_bfloat16' a la même plage que float32 donc pas de scaling requis, mais seuls les GPU Ampere+ et les TPU le supportent. Forcez la couche finale en float32 pour la stabilité numérique (softmax/logits). La précision mixte est le plus facile des gains de performance uniques.

tensorflow
import tensorflow as tf

tf.keras.mixed_precision.set_global_policy('mixed_float16')
# or bfloat16 on Ampere+ / TPU (no loss scaling needed)
tf.keras.mixed_precision.set_global_policy('mixed_bfloat16')

model = tf.keras.Sequential([
    tf.keras.layers.Dense(512, activation='relu', input_shape=(784,)),
    tf.keras.layers.Dense(10, dtype='float32'),
])

model.compile(optimizer='adam', loss='sparse_categorical_crossentropy')
print(model.layers[0].dtype_policy)   # <Policy "mixed_float16">
16

Augmentation de données

Couches de prétraitement Keras

Les couches de prétraitement Keras (RandomFlip, RandomRotation, etc.) tournent sur GPU et dans tf.function — bien plus rapides que l'augmentation PIL/numpy. Les mettre dans le modèle signifie qu'elles se désactivent automatiquement à l'inférence (training=False). Alternativement, appliquez-les dans un map tf.data pour plus de contrôle. Ces couches sont sans état et compilent JIT, donc ne ralentissent pas l'inférence. Pour un prétraitement avec état (ex. scalers ajustés), utilisez l'API Adapt.

tensorflow
import tensorflow as tf

augment = tf.keras.Sequential([
    tf.keras.layers.RandomFlip('horizontal'),
    tf.keras.layers.RandomRotation(0.1),
    tf.keras.layers.RandomZoom(0.1),
    tf.keras.layers.RandomContrast(0.2),
    tf.keras.layers.RandomTranslation(0.1, 0.1),
])

# put augmentation INSIDE the model (training-only, inactive at inference)
model = tf.keras.Sequential([
    tf.keras.layers.Input(shape=(224, 224, 3)),
    tf.keras.layers.Rescaling(1./255),
    augment,
    tf.keras.layers.Conv2D(32, 3, activation='relu'),
])

# or apply via dataset.map
ds = ds.map(lambda x, y: (augment(x, training=True), y))

ImageDataGenerator (legacy)

ImageDataGenerator est l'API d'augmentation legacy — elle marche mais tourne sur CPU et est plus lente que les couches de prétraitement Keras. Réservez-la au besoin de son itération par répertoires ou au code legacy. Pour les nouveaux projets, préférez keras.utils.image_dataset_from_directory + couches de prétraitement Keras (RandomFlip etc.) — accélérées GPU et intégrées à tf.data. flow_from_directory infère les labels de classe des noms de sous-répertoires comme ImageFolder.

tensorflow
from tensorflow.keras.preprocessing.image import ImageDataGenerator

train_datagen = ImageDataGenerator(
    rescale=1./255, rotation_range=20,
    width_shift_range=0.2, height_shift_range=0.2,
    shear_range=0.2, zoom_range=0.2,
    horizontal_flip=True, fill_mode='nearest',
    validation_split=0.2,
)

train_gen = train_datagen.flow_from_directory(
    'data/train', target_size=(224, 224), batch_size=32,
    class_mode='binary', subset='training',
)

model.fit(train_gen, epochs=10)

Ops d'augmentation d'images

Les ops tf.image.* donnent un contrôle fin pour l'augmentation custom. random_brightness/contrast/saturation/hue changent la couleur sans la géométrie. Cutout et Mixup sont des augmentations avancées améliorant la régularisation ; implémentez-les avec des ops tf.image + tf.tensor_scatter_nd_update. Appliquez l'augmentation dans un map tf.data avec num_parallel_calls=AUTOTUNE pour qu'elle tourne sur les workers CPU et ne bloque jamais le GPU. Clippez toujours vers les plages de pixels valides après le jitter de couleurs.

tensorflow
import tensorflow as tf

def augment(image, label):
    image = tf.image.random_flip_left_right(image)
    image = tf.image.random_brightness(image, max_delta=0.2)
    image = tf.image.random_contrast(image, lower=0.8, upper=1.2)
    image = tf.image.random_saturation(image, lower=0.8, upper=1.2)
    image = tf.image.random_hue(image, max_delta=0.1)
    image = tf.clip_by_value(image, 0.0, 1.0)
    return image, label

ds = ds.map(augment, num_parallel_calls=tf.data.AUTOTUNE)

Mixup et CutMix

Mixup mélange linéairement deux images et leurs labels, créant des exemples virtuels entre classes — une forte régularisation qui réduit le surapprentissage et améliore la calibration. CutMix colle un patch rectangulaire d'une image sur une autre, préservant mieux la structure locale que Mixup. Les deux exigent que la perte accepte des labels doux (mélangés) — utilisez categorical_crossentropy, pas sparse. Appliquez par batch après le batching. Combinez à l'augmentation géométrique standard pour les meilleurs résultats.

tensorflow
import tensorflow as tf

def mixup(images, labels, alpha=0.2):
    lam = tf.random.beta([], alpha, alpha)
    batch_size = tf.shape(images)[0]
    idx = tf.random.shuffle(tf.range(batch_size))
    mixed_images = lam * images + (1 - lam) * tf.gather(images, idx)
    mixed_labels = lam * labels + (1 - lam) * tf.gather(labels, idx)
    return mixed_images, mixed_labels

ds = ds.batch(32).map(mixup, num_parallel_calls=tf.data.AUTOTUNE)

Augmentation texte et tabulaire

Pour le texte, les augmentations simples au niveau mot (échange de synonymes, suppression/échange aléatoires) sont bon marché et efficaces ; pour du NLP sérieux, utilisez la back-translation ou des modèles comme EDA/AugBERT. Pour le tabulaire, mixup mélange les lignes ; le bruit gaussien sur les caractéristiques numériques régularise. Appliquez l'augmentation seulement aux données d'entraînement, jamais à la validation/test. Gardez des augmentations préservant les labels (ou mélangeant les labels comme mixup) — corrompre les labels nuit plus qu'il n'aide.

tensorflow
import tensorflow as tf
import random

def text_augment(text):
    words = text.split()
    if random.random() < 0.2:
        words = [w for w in words if random.random() > 0.2]
    if len(words) > 1 and random.random() < 0.2:
        i, j = random.sample(range(len(words)), 2)
        words[i], words[j] = words[j], words[i]
    return ' '.join(words)

def tabular_mixup(x, y, alpha=0.2):
    lam = tf.random.beta([], alpha, alpha)
    idx = tf.random.shuffle(tf.range(tf.shape(x)[0]))
    return lam * x + (1 - lam) * tf.gather(x, idx), lam * y + (1 - lam) * tf.gather(y, idx)

def add_noise(x, std=0.01):
    return x + tf.random.normal(tf.shape(x), stddev=std)
17

Transfer learning

Modèles préentraînés

keras.applications expose ResNet, EfficientNet, MobileNet, ViT et plus avec poids ImageNet. include_top=False retire la tête à 1000 classes pour attacher la vôtre. preprocess_input applique la normalisation exacte attendue par le backbone — appelez-la dans le modèle pour le déploiement. Gelez le backbone (trainable=False) et appelez base(x, training=False) pour que BatchNorm utilise les stats d'inférence — critique pour les petits jeux où les statistiques de BN seraient autrement bruitées.

tensorflow
import tensorflow as tf

base = tf.keras.applications.ResNet50(
    include_top=False, weights='imagenet',
    input_shape=(224, 224, 3), pooling='avg',
)
base.trainable = False

inputs = tf.keras.Input(shape=(224, 224, 3))
x = tf.keras.applications.resnet50.preprocess_input(inputs)
x = base(x, training=False)
x = tf.keras.layers.Dense(256, activation='relu')(x)
x = tf.keras.layers.Dropout(0.5)(x)
outputs = tf.keras.layers.Dense(num_classes, activation='softmax')(x)
model = tf.keras.Model(inputs, outputs)

Extraction de caractéristiques

L'extraction de caractéristiques gèle tout le backbone et n'entraîne qu'une nouvelle tête — le baseline de transfer learning le plus rapide. Le backbone étant fixe, on peut précalculer les caractéristiques une fois (base.predict(train_ds)) et entraîner un petit classifieur dessus, économisant énormément de calcul. Réglez training=False à l'appel du backbone pour que BatchNorm utilise ses stats courantes — sinon les petits batchs les corrompent. Bien pour les petits jeux (centaines d'images) où le fine-tuning surapprendrait.

tensorflow
import tensorflow as tf

base = tf.keras.applications.MobileNetV2(
    include_top=False, weights='imagenet', pooling='avg')
base.trainable = False

model = tf.keras.Sequential([
    tf.keras.layers.Input(shape=(224, 224, 3)),
    tf.keras.applications.mobilenet_v2.preprocess_input,
    base,
    tf.keras.layers.Dropout(0.3),
    tf.keras.layers.Dense(num_classes, activation='softmax'),
])

model.compile(optimizer=tf.keras.optimizers.Adam(1e-3),
              loss='sparse_categorical_crossentropy', metrics=['accuracy'])
model.fit(train_ds, validation_data=val_ds, epochs=5)

Fine-tuning

Le fine-tuning dégèle certaines couches du backbone et les entraîne avec un petit LR pour que les caractéristiques préentraînées s'adaptent à votre tâche. Faites d'abord de l'extraction de caractéristiques (tête seule) quelques époques, PUIS dégeler — sinon les grands gradients de la tête aléatoire saccagent les caractéristiques préentraînées. Utilisez un LR bien plus petit (1e-5 vs 1e-3 pour la tête). Dégeler du haut vers le bas (les couches tardives sont plus spécifiques à la tâche ; les précoces générales). Gardez les couches BatchNorm gelées pour préserver leurs stats courantes.

tensorflow
import tensorflow as tf

base = tf.keras.applications.ResNet50(include_top=False, weights='imagenet', pooling='avg')
base.trainable = True

# freeze everything except the last few blocks
for layer in base.layers[:-20]:
    layer.trainable = False

model.compile(
    optimizer=tf.keras.optimizers.Adam(1e-5),   # 10x smaller than head
    loss='sparse_categorical_crossentropy', metrics=['accuracy'],
)
model.fit(train_ds, validation_data=val_ds, epochs=5)

Geler et dégeler

Réglez layer.trainable=False pour geler. Après changement de trainable, vous DEVEZ recompiler le modèle pour que l'optimiseur prenne le nouvel ensemble entraînable. Gardez les couches BatchNorm gelées pendant le fine-tuning — leurs stats courantes sont précieuses et les petits batchs de fine-tuning les corrompraient. Inspectez trainable_weights vs weights pour confirmer ce qui se mettra à jour. Loggez le compte de paramètres entraînables pour ne pas geler ou dégeler tout accidentellement (un bug silencieux courant).

tensorflow
import tensorflow as tf

base = tf.keras.applications.EfficientNetB0(
    include_top=False, weights='imagenet', pooling='avg')

base.trainable = False
for layer in base.layers:
    layer.trainable = 'block7' in layer.name

# freeze BatchNorm specifically (recommended during fine-tuning)
for layer in base.layers:
    if isinstance(layer, tf.keras.layers.BatchNormalization):
        layer.trainable = False

n_train = sum(tf.keras.backend.count_params(w) for w in model.trainable_weights)
n_total = sum(tf.keras.backend.count_params(w) for w in model.weights)
print(f"trainable: {n_train:,} / {n_total:,}")

Transfer multi-tâches

Le multi-tâches partage un backbone entre tâches liées, régularisant la représentation et économisant du calcul. Chaque tête est une petite branche des caractéristiques partagées. Passez les pertes par sortie et loss_weights dans compile pour équilibrer les gradients des tâches (réglez les poids pour qu'aucune tâche ne domine). Au fit, passez les cibles comme un dict matchant les noms de sortie. Le transfer multi-tâches est puissant quand une tâche a beaucoup de données et une autre peu — le backbone partagé profite aux deux.

tensorflow
import tensorflow as tf

base = tf.keras.applications.ResNet50(include_top=False, weights='imagenet')
base.trainable = False

inputs = tf.keras.Input(shape=(224, 224, 3))
x = tf.keras.applications.resnet50.preprocess_input(inputs)
features = base(x, training=False)
features = tf.keras.layers.GlobalAveragePooling2D()(features)

cls_out = tf.keras.layers.Dense(num_classes, activation='softmax', name='cls')(features)
box_out = tf.keras.layers.Dense(4, name='box')(features)
attr_out = tf.keras.layers.Dense(num_attr, activation='sigmoid', name='attr')(features)

model = tf.keras.Model(inputs, [cls_out, box_out, attr_out])
model.compile(
    optimizer='adam',
    loss={'cls': 'sparse_categorical_crossentropy', 'box': 'mse',
          'attr': 'binary_crossentropy'},
    loss_weights={'cls': 1.0, 'box': 5.0, 'attr': 0.5},
)
18

Déploiement de modèles

Convertisseur TFLite

TFLite convertit les modèles TF en format flatbuffer pour mobile, embarqué et edge. Optimize.DEFAULT applique la quantification post-entraînement automatiquement ; la quantification int8 complète exige un jeu de données représentatif pour calibrer les plages d'activations et produit un modèle tournant sur Edge TPU / microcontrôleurs. float16 garde la compatibilité GPU et est plus sûr si l'int8 nuit à l'exactitude. Le convertisseur infère les formes d'entrée du modèle ; pour des formes dynamiques, fixez-les avec des fonctions concrètes.

tensorflow
import tensorflow as tf

converter = tf.lite.TFLiteConverter.from_keras_model(model)
tflite_model = converter.convert()

with open('model.tflite', 'wb') as f:
    f.write(tflite_model)

# with quantization (8-bit, ~4x smaller, faster on CPU)
converter.optimizations = [tf.lite.Optimize.DEFAULT]
# float16 quantization (GPU-friendly, 2x smaller)
converter.target_spec.supported_types = [tf.float16]
# full integer quantization (needs representative dataset)
converter.representative_dataset = rep_data
converter.target_spec.supported_ops = [tf.lite.OpsSet.TFLITE_BUILTINS_INT8]
converter.inference_input_type = tf.int8
tflite_quant = converter.convert()

Interpréteur TFLite

L'interpréteur TFLite exécute les modèles .tflite sur CPU, GPU, Edge TPU ou microcontrôleurs. allocate_tensors prépare la mémoire selon la forme d'entrée fixe — redimensionnez avec resize_tensor_input pour les formes dynamiques. set_tensor / invoke / get_tensor est la boucle d'inférence. Pour l'inférence batchée, le modèle doit être converti avec une taille de batch fixe ou utiliser resize_tensor_input. TFLite a des bindings Python, C++, Java, Swift et JavaScript — le même fichier .tflite tourne partout.

tensorflow
import tensorflow as tf
import numpy as np

interpreter = tf.lite.Interpreter(model_path='model.tflite')
interpreter.allocate_tensors()

input_details = interpreter.get_input_details()
output_details = interpreter.get_output_details()
print(input_details)
# [{'name': 'input', 'shape': (1, 224, 224, 3), 'dtype': tf.float32, ...}]

input_data = np.expand_dims(img, axis=0).astype(np.float32)
interpreter.set_tensor(input_details[0]['index'], input_data)
interpreter.invoke()
output = interpreter.get_tensor(output_details[0]['index'])
print(output.shape, output.argmax())

TF Serving

TF Serving héberge des SavedModels derrière une API gRPC/REST avec versioning, batching et support GPU. La structure de répertoires serving/1/, serving/2/ permet les échanges de modèles à chaud. L'image Docker est le déploiement local le plus simple ; en production, utilisez Vertex AI, SageMaker ou KServe. TF Serving batche automatiquement les requêtes pour maximiser l'usage GPU. L'API REST utilise {instances: [...]} pour les entrées et retourne {predictions: [...]} ; pour des entrées/sorties nommées, utilisez le paramètre signature_name.

tensorflow
# save model in SavedModel format with versioning
# model.export('serving/1')  # Keras 3
tf.saved_model.save(model, 'serving/1')

# run TF Serving via Docker
# docker run -p 8501:8501 --name tfserving \
#   -v $(pwd)/serving:/models/my_model \
#   -e MODEL_NAME=my_model \
#   tensorflow/serving

# query via REST
import json, requests
data = json.dumps({'instances': x_test[:3].tolist()})
resp = requests.post(
    'http://localhost:8501/v1/models/my_model:predict',
    data=data, headers={'content-type': 'application/json'})
print(resp.json()['predictions'])

Entraînement conscient de la quantification

L'entraînement conscient de la quantification (QAT) insère des ops de fausse quantification pendant l'entraînement pour que le modèle s'adapte au bruit d'arrondi qu'il verra à l'inférence int8 — récupérant en général la plupart de l'exactitude perdue par la quantification post-entraînement. Utilisez tfmot (tensorflow-model-optimization) pour envelopper un modèle entraîné, fine-tuner quelques époques, puis convertir en TFLite. Le QAT est essentiel quand la quantification int8 post-entraînement fait tomber l'exactitude sous votre seuil (ex. EfficientNet, détecteurs d'objets). Le modèle TFLite résultant tourne sur Edge TPU.

tensorflow
import tensorflow as tf
# (requires: pip install tensorflow-model-optimization)
import tensorflow_model_optimization as tfmot

model = tf.keras.applications.MobileNetV2(weights='imagenet')
annot_model = tfmot.quantization.keras.quantize_model(model)
annot_model.compile(optimizer='adam', loss='sparse_categorical_crossentropy')
annot_model.fit(train_ds, epochs=3)

converter = tf.lite.TFLiteConverter.from_keras_model(annot_model)
converter.optimizations = [tf.lite.Optimize.DEFAULT]
tflite_qat = converter.convert()

TF.js et déploiement edge

TF.js exécute des modèles dans le navigateur ou Node.js. Le convertisseur transforme SavedModel/.keras/.h5 en model.json + répertoire de poids binaires. Les layers models supportent l'API Keras (fit, predict, même entraînement à la volée) ; les graph models sont plus compatibles mais moins flexibles. L'inférence navigateur utilise WebGL/WASM ; Node.js peut utiliser CUDA. TF.js est génial pour le ML côté client (pas d'aller-retour serveur, confidentialité, hors ligne). Pour le mobile, préférez TFLite (plus petit, plus rapide, accélération matérielle).

tensorflow
# convert to TF.js format
# pip install tensorflowjs
# tensorflowjs_converter --input_format=keras model.keras tfjs_model/

# in JavaScript:
# import * as tf from '@tensorflow/tfjs';
# const model = await tf.loadLayersModel('tfjs_model/model.json');
# const out = model.predict(tf.tensor4d(img, [1, 224, 224, 3]));

# OR convert SavedModel -> TF.js
# tensorflowjs_converter \
#   --input_format=tf_saved_model \
#   --output_format=tfjs_graph_model \
#   saved_model/ tfjs_model/

# TF.js layers model: full Keras-like API in the browser
# TF.js graph model: lower-level, supports more ops

Optimisation de l'inférence

Pour un déploiement à basse latence, empilez les optimisations : élagage (mettre à zéro les petits poids, compresser), distillation de connaissances (entraîner un petit étudiant à matcher les logits d'un grand enseignant), quantification (int8/float16) et compilation XLA (fusionner les ops). Chaque étape a des compromis — benchmark toujours sur le matériel cible. La distillation préserve généralement le mieux l'exactitude ; élagage+quantification donnent les plus grandes réductions de taille. XLA (jit_compile=True) fusionne les ops pour un gain gratuit de 1,2 à 2x sur GPU/TPU.

tensorflow
import tensorflow as tf

# knowledge distillation: train a small student to mimic a large teacher
def distill_loss(teacher_logits, student_logits, temperature=3.0):
    soft_targets = tf.nn.softmax(teacher_logits / temperature)
    soft_probs = tf.nn.log_softmax(student_logits / temperature)
    return tf.reduce_mean(
        tf.keras.losses.categorical_crossentropy(soft_targets, soft_probs, from_logits=True))

# XLA compilation (faster inference)
@tf.function(jit_compile=True)
def predict(x):
    return model(x)

# stack optimizations: prune + quantize + distill + XLA
# always benchmark latency and accuracy before/after each step
19

Boucle d'entraînement custom

Boucle custom de base

Une boucle custom donne le contrôle total : manipulation de gradients, plusieurs modèles, objectifs custom. Le pattern est GradientTape -> perte -> grads -> apply_gradients, enveloppé dans @tf.function pour la vitesse. N'oubliez pas model.losses — ce sont les pertes de régularisation ajoutées par kernel_regularizer et doivent s'ajouter à la perte principale. Suivez les métriques avec des objets Metric avec état et reset_state() à chaque époque. Plus verbeux que fit mais débloque tout.

tensorflow
import tensorflow as tf

optimizer = tf.keras.optimizers.Adam(1e-3)
loss_fn = tf.keras.losses.SparseCategoricalCrossentropy(from_logits=True)

train_loss = tf.keras.metrics.Mean(name='train_loss')
train_acc = tf.keras.metrics.SparseCategoricalAccuracy(name='train_acc')

@tf.function
def train_step(x, y):
    with tf.GradientTape() as tape:
        logits = model(x, training=True)
        loss = loss_fn(y, logits)
        loss += sum(model.losses)
    grads = tape.gradient(loss, model.trainable_variables)
    optimizer.apply_gradients(zip(grads, model.trainable_variables))
    train_loss.update_state(loss)
    train_acc.update_state(y, logits)
    return loss

for epoch in range(epochs):
    for x, y in train_ds:
        train_step(x, y)
    print(f"epoch {epoch}: loss={train_loss.result():.4f} acc={train_acc.result():.4f}")
    train_loss.reset_state(); train_acc.reset_state()

Validation dans la boucle custom

La validation reflète l'entraînement mais avec training=False (donc dropout désactivé et BatchNorm utilisant ses stats courantes) et sans gradient tape ni optimiseur. Utilisez des objets Metric séparés pour la val pour que train et val ne se mélangent pas. Enveloppez test_step dans @tf.function pour la vitesse. Réinitialisez toutes les métriques après logging de chaque époque. Pour sauvegarder le meilleur modèle, comparez val_acc.result() à un meilleur courant et appelez model.save() à l'amélioration.

tensorflow
import tensorflow as tf

val_loss = tf.keras.metrics.Mean(name='val_loss')
val_acc = tf.keras.metrics.SparseCategoricalAccuracy(name='val_acc')

@tf.function
def test_step(x, y):
    logits = model(x, training=False)
    loss = loss_fn(y, logits)
    val_loss.update_state(loss)
    val_acc.update_state(y, logits)

for epoch in range(epochs):
    for x, y in train_ds:
        train_step(x, y)
    for x, y in val_ds:
        test_step(x, y)
    print(f"epoch {epoch}: val_loss={val_loss.result():.4f} val_acc={val_acc.result():.4f}")
    train_loss.reset_state(); train_acc.reset_state()
    val_loss.reset_state(); val_acc.reset_state()

Boucle custom distribuée

Une boucle custom distribuée utilise strategy.run pour exécuter le pas par réplica sur chaque GPU et strategy.reduce pour agréger la perte. Divisez la perte par réplica par num_replicas_in_sync pour que le gradient sommé corresponde au gradient du batch global (sinon le LR effectif est multiplié par le nombre de GPU). Appliquez les gradients normalement — la stratégie gère l'all-reduce sous le capot. Le même pattern marche pour MultiWorkerMirroredStrategy et TPUStrategy.

tensorflow
import tensorflow as tf

strategy = tf.distribute.MirroredStrategy()

with strategy.scope():
    model = build_model()
    optimizer = tf.keras.optimizers.Adam(1e-3)
    loss_fn = tf.keras.losses.SparseCategoricalCrossentropy(from_logits=True)

train_ds_dist = strategy.experimental_distribute_dataset(train_ds)

@tf.function
def distributed_train_step(x, y):
    def step_fn(x, y):
        with tf.GradientTape() as tape:
            logits = model(x, training=True)
            loss = loss_fn(y, logits)
            loss += sum(model.losses)
            loss /= strategy.num_replicas_in_sync
        grads = tape.gradient(loss, model.trainable_variables)
        optimizer.apply_gradients(zip(grads, model.trainable_variables))
        return loss
    per_replica_loss = strategy.run(step_fn, args=(x, y))
    return strategy.reduce(tf.distribute.ReduceOp.SUM, per_replica_loss, axis=None)

for epoch in range(epochs):
    for x, y in train_ds_dist:
        distributed_train_step(x, y)

Boucle d'entraînement GAN

Les GAN entraînent deux modèles de façon adversariale : le générateur tente de tromper le discriminateur, le discriminateur tente de détecter les faux. Utilisez deux GradientTapes (une par modèle) et deux optimiseurs. beta_1=0.5 (plus bas que le défaut) stabilise l'entraînement GAN. Entraînez discriminateur et générateur à chaque pas (ou alternez les ratios). Les GAN sont notoirement instables — surveillez d_loss et g_loss, utilisez la normalisation spectrale et considérez le Wasserstein GAN avec pénalité de gradient en cas de mode collapse.

tensorflow
import tensorflow as tf

generator = build_generator()
discriminator = build_discriminator()
g_opt = tf.keras.optimizers.Adam(1e-4, beta_1=0.5)
d_opt = tf.keras.optimizers.Adam(1e-4, beta_1=0.5)
bce = tf.keras.losses.BinaryCrossentropy(from_logits=True)

@tf.function
def train_gan_step(real_images):
    batch = tf.shape(real_images)[0]
    noise = tf.random.normal((batch, 100))
    with tf.GradientTape() as g_tape, tf.GradientTape() as d_tape:
        fake = generator(noise, training=True)
        real_logits = discriminator(real_images, training=True)
        fake_logits = discriminator(fake, training=True)
        d_loss = bce(tf.ones_like(real_logits), real_logits) + \
                 bce(tf.zeros_like(fake_logits), fake_logits)
        g_loss = bce(tf.ones_like(fake_logits), fake_logits)
    g_grads = g_tape.gradient(g_loss, generator.trainable_variables)
    d_grads = d_tape.gradient(d_loss, discriminator.trainable_variables)
    g_opt.apply_gradients(zip(g_grads, generator.trainable_variables))
    d_opt.apply_gradients(zip(d_grads, discriminator.trainable_variables))
    return g_loss, d_loss

Accumulation de gradients

La vraie accumulation de gradients en TF est délicate car GradientTape ne supporte pas facilement la sommation des gradients entre appels — il faut accumuler dans des tf.Variables manuellement. La simple approximation ci-dessus met à l'échelle la perte et applique les gradients à chaque pas, effet similaire pour SGD mais pas identique pour Adam (l'optimiseur voit des gradients plus petits et bruités). Pour une accumulation exacte, accumulez les gradients dans des Variables persistantes et appliquez tous les N pas. Surtout utile quand la mémoire GPU limite la taille de batch.

tensorflow
import tensorflow as tf

accum_steps = 4
optimizer = tf.keras.optimizers.Adam(1e-3)

@tf.function
def accumulated_train_step(x, y):
    with tf.GradientTape() as tape:
        logits = model(x, training=True)
        loss = loss_fn(y, logits) / accum_steps
    grads = tape.gradient(loss, model.trainable_variables)
    optimizer.apply_gradients(zip(grads, model.trainable_variables))
    return loss

# simple accumulation via averaging
for batch_idx, (x, y) in enumerate(train_ds):
    accumulated_train_step(x, y)
    # equivalent effective batch = accum_steps * batch_size
    # (Adam moments are updated every step, so this is an approximation)
20

Optimisation des performances

tf.function

@tf.function trace une fonction Python en graphe statique — plus rapide sur GPU et requis pour la distribution. Le premier appel par signature d'entrée trace (lent) ; les suivants réutilisent le graphe. Évitez le flux de contrôle Python dépendant des VALEURS de tenseurs (if tensor > 0: ...) dans tf.function — il force un re-tracing. Utilisez tf.cond / tf.while_loop ou du flux Python dépendant seulement des shapes/littéraux Python. input_signature épingle les shapes pour prévenir entièrement le re-tracing. reduce_retracing=True élargit le cache.

tensorflow
import tensorflow as tf

@tf.function
def train_step(x, y):
    with tf.GradientTape() as tape:
        preds = model(x, training=True)
        loss = loss_fn(y, preds)
    grads = tape.gradient(loss, model.trainable_variables)
    optimizer.apply_gradients(zip(grads, model.trainable_variables))
    return loss

# first call traces the graph (slow), subsequent calls reuse it (fast)
train_step(x_batch, y_batch)

# experimental_relax_shapes allows retracing only when needed
@tf.function(reduce_retracing=True)
def fn(x): return model(x)

# input_signature pins the signature so no retracing
@tf.function(input_signature=[tf.TensorSpec([None, 784], tf.float32)])
def predict(x): return model(x)

Compilation XLA

XLA (Accelerated Linear Algebra) compile des sous-graphes en noyaux fusionnés, réduisant l'overhead de lancement et permettant des optimisations entre ops. jit_compile=True sur une tf.function déclenche XLA pour cette fonction. Le plus efficace pour les modèles gourmands en calcul (transformers, attention) et moins utile pour ceux bornés par l'I/O. XLA exige des formes statiques dans la région compilée — des formes variables causent des recompilations. En cas de soucis de formes, bourrez vers des formes fixes. Benchmark toujours : XLA peut parfois être plus lent pour les petits modèles.

tensorflow
import tensorflow as tf

# JIT-compile a function with XLA (fuses ops for speed)
@tf.function(jit_compile=True)
def train_step(x, y):
    with tf.GradientTape() as tape:
        loss = loss_fn(y, model(x, training=True))
    grads = tape.gradient(loss, model.trainable_variables)
    optimizer.apply_gradients(zip(grads, model.trainable_variables))
    return loss

# enable XLA globally
tf.config.optimizer.set_jit(True)

# XLA fuses element-wise ops, reduces kernel launches,
# and can give 1.5-3x speedup on GPU/TPU
# especially effective for transformer / attention heavy models

Optimisation du pipeline d'entrée

Le goulot de l'entraînement GPU est généralement le pipeline d'entrée, pas le modèle. Le pipeline canonique met en cache après chargement, mélange, mappe l'augmentation en parallèle, batche et prefetch. interleave lit plusieurs fichiers TFRecord en parallèle pour les charges bornées au disque. drop_remainder=True évite un dernier batch à forme variable forçant un re-tracing du graphe. Utilisez l'Input Pipeline Analyzer du TF Profiler pour trouver votre goulot précis. AUTOTUNE laisse TF choisir parallélisme et tailles de prefetch automatiquement.

tensorflow
import tensorflow as tf

# the canonical high-performance pipeline
ds = (tf.data.Dataset.from_tensor_slices((x, y))
      .cache()                                      # cache after loading
      .shuffle(10000)
      .map(augment, num_parallel_calls=tf.data.AUTOTUNE)
      .batch(32, drop_remainder=True)
      .prefetch(tf.data.AUTOTUNE))

# parallel file reading for TFRecord
files = tf.data.Dataset.list_files('data-*.tfrecord')
ds = files.interleave(
    tf.data.TFRecordDataset,
    cycle_length=4, num_parallel_calls=tf.data.AUTOTUNE)

# options for autotuning
options = tf.data.Options()
options.autotune.enabled = True
ds = ds.with_options(options)

Précision mixte et TF32

La précision mixte (float16/bfloat16) donne 2 à 3x de débit sur les GPU Tensor Core. TF32 est encore plus simple — un format à mantisse 19 bits utilisé de façon transparente pour le matmul sur Ampere+ (A100, H100), donnant ~3x d'accélération avec perte de précision minimale et AUCUN changement de code ni loss scaling. Activez les deux pour la vitesse maximale. TF32 est actif par défaut en CUDA 11+ mais TF expose le flag pour un contrôle explicite. Pour une reproductibilité fp32 stricte (calcul scientifique), désactivez TF32.

tensorflow
import tensorflow as tf

# mixed precision (float16 compute, float32 master)
tf.keras.mixed_precision.set_global_policy('mixed_float16')

# enable TF32 on Ampere+ (big matmul speedup, slight precision loss)
tf.config.experimental.enable_tensor_float_32_execution(True)

# TF32 uses 19-bit mantissa for matmul on A100/H100
# it's transparent — no code changes, no loss scaling
# gives ~3x matmul speedup with minimal accuracy impact

# check policy
print(tf.keras.mixed_precision.global_policy())
print('TF32:', tf.config.experimental.tensor_float_32_execution_enabled())

Optimisation de graphe

Grappler est l'optimiseur de graphe de TF qui tourne automatiquement avant l'exécution : pliage de constantes, optimisation de disposition (NCHW vs NHWC pour cuDNN), fusion d'ops (remapping), élimination de code mort et plus. Tout est actif par défaut — on ne les touche que pour désactiver des optimisations précises lors du débogage. debug_stripper retire Assert/CheckNumerics pour la vitesse de production. L'optimiseur de disposition choisit automatiquement NCHW pour les convs cuDNN sur GPU même si votre modèle spécifie NHWC.

tensorflow
import tensorflow as tf

# enable grappler (default graph optimizer)
tf.config.optimizer.set_jit(True)       # XLA
tf.config.optimizer.set_experimental_options({
    'disable_model_pruning': False,
    'disable_meta_optimizer': False,
    'layout_optimizer': True,           # optimize data layout (NCHW vs NHWC)
    'constant_folding': True,           # fold constants at build time
    'shape_optimization': True,
    'remapping': True,                  # fuse compatible ops
    'arithmetic_optimization': True,
    'loop_optimization': True,
    'dependency_optimization': True,
    'function_optimization': True,
    'debug_stripper': True,             # remove Assert/CheckNumerics
})

# all on by default — only set explicitly to disable specific ones

AutoGraph et flux de contrôle

AutoGraph convertit les if/for/while Python dans tf.function en ops de graphe TF (tf.cond / tf.while_loop) pour qu'ils tournent efficacement sur GPU. Les boucles sur un tf.data.Dataset avec un 'for' Python conviennent — elles itèrent au moment du tracing. Évitez les if/for dépendant des VALEURS de tenseurs (pas des shapes) — cela force un re-tracing à chaque changement de valeur. Pour un flux de contrôle à l'exécution sur des valeurs de tenseurs, utilisez explicitement tf.cond et tf.while_loop ou laissez AutoGraph gérer (il le fera, mais la conversion peut être subtile).

tensorflow
import tensorflow as tf

# AutoGraph converts Python if/for/while into tf.cond / tf.while_loop
@tf.function
def fn(x):
    if x > 0:          # AutoGraph converts this
        return x * 2
    else:
        return x

@tf.function
def sum_loop(n):
    total = tf.constant(0)
    for i in tf.range(n):    # AutoGraph converts to tf.while_loop
        total += i
    return total

# Python-side (compile-time) loop vs TF-side (runtime) loop
@tf.function
def train_epoch(dataset):
    for x, y in dataset:   # Python iteration over dataset (fine)
        train_step(x, y)

# avoid data-dependent Python control flow
# if x.shape[0] > 10: ...  # OK (static shape)
# if tf.reduce_sum(x) > 0: ...  # forces retracing

Was this helpful?

Learning path

Learn from scratch

Learn this language from the ground up with structured lessons.