TensorFlow

TensorFlow est un framework open source d’apprentissage automatique (ML) publié par Google en novembre 2015 sous licence Apache 2.0, après avoir été développé par l’équipe Google Brain pour ses recherches et produits internes. Les programmes d’apprentissage profond et d’autres tâches numériques expriment les calculs sous forme d’opérations sur des tenseurs, des tableaux multidimensionnels de nombres. TensorFlow les différencie automatiquement, les compile en graphes optimisés et les exécute sur des CPU, des GPU et des TPU. Son écosystème couvre tout le parcours MLOps, de l’entraînement au déploiement de modèles : Keras pour définir les modèles, TensorBoard pour suivre les expériences, TensorFlow Serving pour le service des modèles en production, TensorFlow.js pour les navigateurs et LiteRT, anciennement TensorFlow Lite, pour les téléphones et les appareils embarqués exécutant de l’IA en périphérie. Avec TensorFlow 2.21, en mars 2026, Google a indiqué que les travaux futurs sur TensorFlow se concentreraient sur la sécurité et les corrections de bogues, les mises à jour des dépendances et les contributions de la communauté, et a orienté les nouveaux projets d’IA générative vers Keras 3, JAX ou PyTorch.

Fonctionnement de TensorFlow#

Avec TensorFlow 1.x, il fallait d’abord construire un graphe de calcul statique, puis l’exécuter dans une session. TensorFlow 2.0, publié en 2019, a fait de l’exécution immédiate le comportement par défaut : les opérations s’exécutent alors instantanément, comme du code Python ordinaire, tandis que les graphes sont conservés pour l’optimisation. Une fonction décorée avec tf.function est retracée pour chaque signature d’entrée en un graphe que TensorFlow peut optimiser, compiler avec le compilateur XLA et enregistrer au format SavedModel pour le déploiement sans Python. tf.GradientTape enregistre les opérations d’une passe avant afin que TensorFlow puisse calculer les gradients pour la rétropropagation et la descente de gradient. Ce code effectue ces deux opérations :

import tensorflow as tf

w = tf.Variable([[1.0], [-2.0]])
x = tf.constant([[3.0, 4.0]])


@tf.function  # trace the Python function into a TensorFlow graph on the first call
def loss_fn(x):
    print("Tracing")  # Python code runs only while tracing, not on every call
    return tf.reduce_sum((x @ w) ** 2)


# Record operations on a tape to compute the gradient of the loss with respect to w
with tf.GradientTape() as tape:
    loss = loss_fn(x)
gradient = tape.gradient(loss, w)

loss_fn(x)  # same input shape and dtype: reuses the traced graph without printing
print(f"loss {loss.numpy()}, gradient {gradient.numpy().ravel()}")

Il affiche Tracing une fois, puis loss 25.0, gradient [-30. -40.] : le deuxième appel a exécuté le graphe mis en cache sans exécuter le corps Python, et le gradient de (3w₁ + 4w₂)² en w = (1, -2) vaut 2 × (-5) × (3, 4). Pour l’entraînement distribué, les stratégies tf.distribute répliquent un modèle sur plusieurs GPU, tranches de TPU ou machines.

L’écosystème TensorFlow#

• Keras : L’API de haut niveau qui permet de définir des couches et des modèles, puis de les entraîner avec fit. Depuis TensorFlow 2.16, l’installation de TensorFlow installe Keras 3, qui fonctionne également avec JAX et PyTorch.
• TensorBoard : Tableau de bord des courbes de perte, des métriques, des histogrammes et des graphes de modèles pendant l’entraînement. Il lit aussi les journaux écrits par d’autres frameworks, notamment les exécutions d’entraînement Ultralytics YOLO, et TensorFlow 2.21 ne l’installe plus comme dépendance.
• TensorFlow Serving : Un système de service qui charge les SavedModels et répond aux requêtes de prédiction via gRPC ou REST, avec gestion des versions pour remplacer les modèles à chaud.
• TFX : Un framework de pipelines pour l’apprentissage automatique en production, qui enchaîne la validation des données, l’entraînement, l’évaluation et le déploiement d’un modèle approuvé dans le système de service.
• TensorFlow.js : Exécute et entraîne des modèles dans le navigateur et dans Node.js, ce qui permet de réaliser l’inférence sur l’appareil de l’utilisateur sans envoyer de données à un serveur.
• LiteRT : L’environnement d’exécution sur appareil de Google pour Android, iOS, Linux embarqué et les microcontrôleurs, renommé après TensorFlow Lite en septembre 2024. Il exécute des modèles .tflite convertis depuis TensorFlow, PyTorch ou JAX, avec accélération sur les GPU et les NPU mobiles.

TensorFlow, PyTorch et JAX : comparaison#

• PyTorch et TensorFlow : PyTorch privilégie l’exécution immédiate depuis ses débuts, et torch.compile y ajoute la compilation de graphes. C’est le framework par défaut pour la plupart des nouveaux codes de recherche et des modèles à poids ouverts, tandis que TensorFlow se distingue par sa pile de déploiement éprouvée pour les serveurs, les navigateurs et les appareils mobiles.
• JAX : La bibliothèque de Google, inspirée de NumPy, propose des transformations composables, grad pour les dérivées, jit pour la compilation XLA et vmap pour la vectorisation. Google entraîne ses modèles Gemini avec JAX.
• Keras : Une API de haut niveau plutôt qu’un moteur distinct. Le code Keras 3 fonctionne avec TensorFlow, JAX ou PyTorch ; la définition d’un modèle ne lie donc pas un projet à un seul framework.

Convertir des modèles pour les environnements d’exécution TensorFlow#

Les modèles entraînés avec d’autres frameworks sont compatibles avec les outils de déploiement de TensorFlow grâce à des convertisseurs : onnx2tf reconstruit un graphe ONNX sous forme de SavedModel TensorFlow, jax2tf transforme des fonctions JAX en fonctions TensorFlow, et le convertisseur LiteRT Torch de Google produit directement des modèles LiteRT à partir de PyTorch. Les modèles Ultralytics YOLO sont écrits en PyTorch, et leur mode d’exportation emprunte ces voies pour YOLO26 : format="saved_model" exporte vers ONNX et convertit le modèle avec onnx2tf en SavedModel pour TensorFlow Serving ; format="edgetpu" compile un modèle INT8 pour les TPU Coral Edge ; et format="litert" utilise LiteRT Torch, sans nécessiter l’installation de TensorFlow. Ce code exécute l’exportation SavedModel :

from ultralytics import YOLO

# Load the smallest YOLO26 detection model
model = YOLO("yolo26n.pt")

# Convert through ONNX to a TensorFlow SavedModel directory
path = model.export(format="saved_model")
print(f"SavedModel: {path}")

L’exportation crée un dossier yolo26n_saved_model, que tf.saved_model.load charge en Python et qu’Ultralytics YOLO peut exécuter lui-même avec YOLO("yolo26n_saved_model").