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.
# 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()) # TruePremiers 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.
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.
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.
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.
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())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.
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 -> TypeErrortf.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.
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) # 2wOpé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.
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.
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.
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.
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]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.
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 batchAPI 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.
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.
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.
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.
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].
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 imagesCouches
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.
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).
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.
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 * 2Dropout 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.
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).
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)) # 2Couche 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().
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)))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.
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.
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.
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.
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.
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.
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)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.
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.
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.
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.
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.
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.
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)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.
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.
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.
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.
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.
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 augSurcharger 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.
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)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.
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.
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.
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.
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=./logsLearningRateScheduler
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.
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.
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()])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.
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)
breakMap, 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.
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.
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.
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.
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.
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)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.
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.
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/servingSauver 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.
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.
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.
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.
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']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.
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.
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.
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.
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.
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.
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}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.
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.
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.
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.
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.
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.
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])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.
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.
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.
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.
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.
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.
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 xTensorBoard
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`.
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.
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.
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.
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.
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 recommendationsEntraî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.
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.
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).
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.
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.
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">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.
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.
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.
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.
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.
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)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.
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.
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.
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).
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.
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},
)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.
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.
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.
# 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.
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).
# 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 opsOptimisation 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.
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 stepBoucle 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.
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.
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.
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.
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_lossAccumulation 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.
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)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.
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.
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 modelsOptimisation 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.
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.
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.
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 onesAutoGraph 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).
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 retracingSnippets TensorFlow associés
Copy-paste ready code for common tasks.
Tensor Basics
Create and operate on TensorFlow tensors.
Keras Model
Build models with Sequential and the functional API.
Layers
Use core layers and build a custom one.
Compile and Train
Compile, fit, and evaluate a Keras model.
Custom Training Loop
Step through batches with GradientTape.
Callbacks
Monitor and control training with callbacks.
Save and Load
Persist models in SavedModel and Keras formats.
Data Pipeline
Build efficient input pipelines with tf.data.
Was this helpful?