TPU (Tensor Processing Unit)

Un'unità di elaborazione tensoriale (TPU) è un circuito integrato specifico per applicazione (ASIC) progettato da Google per accelerare l'addestramento e l'inferenza delle reti neurali. Una TPU è basata su grandi unità di moltiplicazione di matrici, perché la moltiplicazione di matrici costituisce la maggior parte del lavoro del deep learning. Google usa TPU nei propri data center dal 2015, addestra i modelli Gemini su queste unità e le noleggia ad altre aziende come Cloud TPU. L'ottava generazione, annunciata nell'aprile 2026, si divide in due chip: TPU 8t per l'addestramento e TPU 8i per l'inferenza.

Come funziona una TPU#

Il cuore di ogni TPU è un’unità di moltiplicazione di matrici (MXU) disposta come un array sistolico, una griglia di celle di moltiplicazione e accumulo che trasmettono i dati direttamente alle celle vicine. I pesi vengono caricati una volta nelle celle, gli input attraversano la griglia un passo per ciclo di clock e le somme parziali scorrono lungo le colonne, così ogni valore letto dalla memoria viene riutilizzato da molte celle. Accedere alla memoria richiede molto più tempo ed energia dell’esecuzione di calcoli: è qui che il design diventa efficiente. Nelle Cloud TPU v2 e v3, ogni MXU era un array 128×128 che eseguiva moltiplicazioni in bfloat16 e accumulava in FP32. Una breve simulazione mostra il flusso dei dati su una griglia 4×4:

import numpy as np

rng = np.random.default_rng(0)
W = rng.integers(-5, 5, (4, 4))  # weights, preloaded one per cell of a 4x4 grid
X = rng.integers(-5, 5, (6, 4))  # six input rows stream through the grid
Y = np.zeros((6, 4), dtype=int)

# Cell (k, j) holds W[k, j]. Input X[i, k] enters row k from the left and reaches
# cell (k, j) at cycle i + k + j, where it is multiplied by the stored weight and
# added to the partial sum for Y[i, j] passing down column j
cycles = 6 + 4 + 4 - 2
for t in range(cycles):
    for k in range(4):
        for j in range(4):
            i = t - k - j
            if 0 <= i < 6:
                Y[i, j] += X[i, k] * W[k, j]

print(f"{X.size * 4} multiply-adds in {cycles} cycles, equal to X @ W: {np.array_equal(Y, X @ W)}")

Stampa 96 multiply-adds in 12 cycles, equal to X @ W: True: le 16 celle producono il prodotto esatto delle matrici, mentre ogni peso viene letto una sola volta dalla memoria e riutilizzato per tutte e sei le righe di input. La TPU di prima generazione eseguiva questo schema su una griglia 256×256 di celle a 8 bit, con 65.536 operazioni di moltiplicazione e accumulo per ciclo e un picco di 92 trilioni di operazioni al secondo. La sua esecuzione semplice e deterministica era adatta all’obiettivo di Google di rispettare un obiettivo di tempo di risposta al 99° percentile per l’inferenza.

Le TPU eseguono codice compilato da XLA, che prende l’intero grafo di calcolo da JAX, TensorFlow o PyTorch e lo mappa sulle unità matriciali. I chip sono collegati tramite interconnessioni dedicate in pod composti da migliaia di unità: è così che i più grandi modelli di base vengono addestrati contemporaneamente su molte TPU.

TPU, GPU e CPU a confronto#

• CPU: pochi core potenti per il codice con diramazioni e di uso generale, che nella maggior parte delle pipeline di addestramento gestiscono il caricamento e la pre-elaborazione dei dati.
• GPU: migliaia di core programmabili e Tensor Core per i calcoli matriciali. Le GPU eseguono quasi ogni modello e framework e sono vendute da numerosi fornitori e servizi cloud.
• TPU: rinuncia a questa flessibilità per essere più efficiente nelle operazioni su matrici dense di grandi dimensioni. Le attività con forme tensoriali statiche ottengono i risultati migliori, perché una variazione di forma obbliga XLA a ricompilare; le TPU sono invece poco adatte alle operazioni personalizzate, alle diramazioni complesse e ai calcoli ad alta precisione.
• NPU: denominazione generica degli acceleratori per reti neurali presenti in telefoni, laptop e chip edge; questa categoria comprende Edge TPU.

Edge TPU#

Edge TPU è una piccola TPU dedicata esclusivamente all’inferenza, il chip presente nell’acceleratore USB Coral di Google, nei moduli M.2 e PCIe e nella Dev Board. Esegue 4 trilioni di operazioni al secondo con 2 watt e supporta solo operazioni intere a 8 bit, quindi le reti vengono convertite interamente in INT8 tramite la quantizzazione del modello e poi compilate con Edge TPU Compiler di Google, che assegna al chip le operazioni supportate e lascia le altre alla CPU host. Ultralytics YOLO automatizza entrambi i passaggi con format="edgetpu", che abilita la quantizzazione INT8 ed esegue il compilatore su una macchina Linux x86-64, generando un modello utilizzabile su schede come Raspberry Pi con un acceleratore USB Coral:

from ultralytics import YOLO

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

# Quantize to INT8 and compile for the Edge TPU (x86-64 Linux only)
path = model.export(format="edgetpu")
print(f"Edge TPU model: {path}")

La piattaforma Coral di Google ora si basa su Coral NPU, un design di acceleratore RISC-V open source annunciato a ottobre 2025 per i dispositivi indossabili, che punta a 512 miliardi di operazioni al secondo con pochi milliwatt.