TensorFlow

TensorFlow è un framework open source per l'apprendimento automatico (ML) rilasciato da Google nel novembre 2015 con licenza Apache 2.0, dopo essere stato sviluppato dal team Google Brain per la ricerca e i prodotti interni. I programmi per il deep learning e altre attività numeriche esprimono i calcoli come operazioni su tensori, array multidimensionali di numeri; TensorFlow li differenzia automaticamente, li compila in grafi ottimizzati e li esegue su CPU, GPU e TPU. Il suo ecosistema copre l'intero percorso MLOps, dall'addestramento alla distribuzione dei modelli: Keras per definire i modelli, TensorBoard per monitorare gli esperimenti, TensorFlow Serving per fornire i modelli in produzione, TensorFlow.js per i browser e LiteRT, in precedenza TensorFlow Lite, per telefoni e dispositivi embedded che eseguono IA edge. Con TensorFlow 2.21, nel marzo 2026, Google ha dichiarato che il lavoro futuro su TensorFlow si sarebbe concentrato su sicurezza e correzioni di bug, aggiornamenti delle dipendenze e contributi della community, indirizzando i nuovi progetti di IA generativa verso Keras 3, JAX o PyTorch.

Come funziona TensorFlow#

TensorFlow 1.x richiedeva agli utenti di costruire prima un grafo computazionale statico e poi eseguirlo in una sessione. TensorFlow 2.0, rilasciato nel 2019, ha impostato l'esecuzione eager come predefinita, in modo che le operazioni vengano eseguite immediatamente come nel normale codice Python, mantenendo i grafi come ottimizzazione: una funzione decorata con tf.function viene tracciata una volta per ogni firma di input in un grafo che TensorFlow può ottimizzare, compilare con il compilatore XLA e salvare in formato SavedModel per la distribuzione senza Python. tf.GradientTape registra le operazioni di un passaggio in avanti, così TensorFlow può calcolare i gradienti per la retropropagazione e la discesa del gradiente. Questo codice svolge entrambe le operazioni:

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()}")

Stampa Tracing una volta e poi loss 25.0, gradient [-30. -40.]: la seconda chiamata ha eseguito il grafo memorizzato nella cache senza eseguire il corpo Python, e il gradiente di (3w₁ + 4w₂)² in w = (1, -2) è 2 × (-5) × (3, 4). Per l'addestramento distribuito, le strategie tf.distribute replicano un modello su più GPU, sezioni TPU o macchine.

L'ecosistema TensorFlow#

• Keras: l'API di alto livello per definire livelli e modelli e addestrarli con fit. Da TensorFlow 2.16, installando TensorFlow si installa Keras 3, che funziona anche con JAX e PyTorch.
• TensorBoard: una dashboard per visualizzare le curve di perdita, le metriche, gli istogrammi e i grafi del modello durante l'addestramento. Legge anche i log scritti da altri framework e TensorFlow 2.21 non lo installa più come dipendenza.
• TensorFlow Serving: un sistema di serving che carica SavedModel e risponde alle richieste di predizione tramite gRPC o REST, con versionamento per sostituire i modelli a caldo.
• TFX: un framework di pipeline per l'apprendimento automatico in produzione che concatena convalida dei dati, addestramento, valutazione e pubblicazione di un modello approvato nel sistema di serving.
• TensorFlow.js: esegue e addestra modelli nel browser e in Node.js, così l'inferenza può avvenire sul dispositivo dell'utente senza inviare dati a un server.
• LiteRT: il runtime di Google per l'esecuzione direttamente su Android, iOS, Linux embedded e microcontrollori, rinominato da TensorFlow Lite nel settembre 2024. Esegue modelli .tflite convertiti da TensorFlow, PyTorch o JAX, con accelerazione su GPU e NPU mobili.

TensorFlow, PyTorch e JAX a confronto#

• PyTorch e TensorFlow a confronto: PyTorch ha adottato l'esecuzione eager fin dall'inizio, con torch.compile che aggiunge la compilazione dei grafi. È il framework predefinito per la maggior parte del nuovo codice di ricerca e dei modelli con pesi aperti, mentre il punto di forza di TensorFlow è il suo maturo stack di distribuzione per server, browser e dispositivi mobili.
• JAX: la libreria di Google in stile NumPy che offre trasformazioni componibili, grad per le derivate, jit per la compilazione XLA e vmap per la vettorizzazione. Google addestra i suoi modelli Gemini con JAX.
• Keras: un'API di alto livello, non un motore separato. Il codice Keras 3 funziona con TensorFlow, JAX o PyTorch, quindi la definizione di un modello non vincola un progetto a un solo framework.

Conversione dei modelli per i runtime TensorFlow#

I modelli addestrati con altri framework raggiungono gli strumenti di distribuzione di TensorFlow tramite convertitori: onnx2tf ricostruisce un grafo ONNX come SavedModel TensorFlow, jax2tf converte le funzioni JAX in funzioni TensorFlow e il convertitore LiteRT Torch di Google produce direttamente modelli LiteRT da PyTorch. I modelli Ultralytics YOLO sono scritti in PyTorch e la loro modalità di esportazione usa questi percorsi per YOLO26: format="saved_model" esporta ONNX e lo converte con onnx2tf in un SavedModel per TensorFlow Serving; format="edgetpu" compila un modello INT8 per le TPU Coral Edge, mentre format="litert" usa LiteRT Torch e non richiede quindi un'installazione di TensorFlow. Questo codice esegue l'esportazione in 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'esportazione crea una cartella yolo26n_saved_model, che tf.saved_model.load carica in Python e che Ultralytics YOLO può eseguire direttamente con YOLO("yolo26n_saved_model").