TPU (Tensor Processing Unit)

Una unidad de procesamiento tensorial (TPU) es un circuito integrado de aplicación específica (ASIC) que Google diseña para acelerar el entrenamiento y la inferencia de redes neuronales. Las TPU se basan en grandes unidades de multiplicación de matrices, porque esta operación concentra la mayor parte del trabajo del aprendizaje profundo. Google utiliza TPU en sus centros de datos desde 2015, entrena sus modelos Gemini con ellas y las alquila a otras empresas como Cloud TPU. La octava generación, anunciada en abril de 2026, se divide en dos chips: TPU 8t para entrenamiento y TPU 8i para inferencia.

Cómo funciona una TPU#

El núcleo de cada TPU es una unidad de multiplicación de matrices (MXU) dispuesta como una matriz sistólica: una cuadrícula de celdas de multiplicación y acumulación que transmiten datos directamente a sus vecinas. Los pesos se cargan una vez en las celdas, las entradas recorren la cuadrícula un paso por ciclo de reloj y las sumas parciales bajan por las columnas, de modo que cada valor obtenido de la memoria se reutiliza en muchas celdas. Leer la memoria consume mucho más tiempo y energía que hacer cálculos, y ahí reside la eficiencia del diseño. En Cloud TPU v2 y v3, cada MXU era una matriz de 128×128 que multiplicaba en bfloat16 y acumulaba en FP32. Una simulación breve muestra el flujo de datos en una cuadrícula de 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)}")

Imprime 96 multiply-adds in 12 cycles, equal to X @ W: True: las 16 celdas producen el producto matricial exacto, y cada peso se lee una vez de la memoria y se reutiliza para las seis filas de entrada. La TPU de primera generación ejecutaba este patrón en una cuadrícula de 256×256 celdas de 8 bits, con 65 536 operaciones de multiplicación y acumulación por ciclo y un máximo de 92 billones de operaciones por segundo; su ejecución sencilla y determinista se ajustaba al objetivo de Google de cumplir un objetivo de tiempo de respuesta del percentil 99 para la inferencia.

Las TPU ejecutan código compilado por XLA, que toma el grafo de cálculo completo de JAX, TensorFlow o PyTorch y lo asigna a las unidades matriciales. Los chips se conectan mediante interconexiones dedicadas en pods de miles de unidades; así se entrenan los mayores modelos fundacionales en muchas TPU a la vez.

TPU frente a GPU y CPU#

• CPU: Unos pocos núcleos potentes para ramificaciones y código de propósito general, que gestionan la carga y el preprocesamiento de datos en la mayoría de las canalizaciones de entrenamiento.
• GPU: Miles de núcleos programables y Tensor Cores para cálculos matriciales. Las GPU ejecutan prácticamente cualquier modelo y framework, y las ofrecen numerosos proveedores y servicios en la nube.
• TPU: Sacrifica esa flexibilidad a cambio de eficiencia en operaciones matriciales densas de gran tamaño. Funcionan mejor con cargas de trabajo que tienen formas de tensor estáticas, ya que un cambio de forma obliga a XLA a recompilar; las TPU no son adecuadas para operaciones personalizadas, ramificaciones intensivas ni aritmética de alta precisión.
• NPU: Nombre genérico de los aceleradores de redes neuronales presentes en teléfonos, portátiles y chips de borde; esta categoría incluye Edge TPU.

Edge TPU#

Edge TPU es una TPU pequeña, dedicada únicamente a la inferencia, presente en el acelerador USB Coral de Google, los módulos M.2 y PCIe y la placa Dev Board. Realiza 4 billones de operaciones por segundo con 2 vatios y solo ejecuta operaciones enteras de 8 bits, por lo que las redes deben convertirse por completo a INT8 mediante la cuantización del modelo y después compilarse con el compilador Edge TPU de Google, que sitúa las operaciones compatibles en el chip y deja el resto en la CPU anfitriona. Ultralytics YOLO automatiza ambos pasos con format="edgetpu", que activa la cuantización INT8 y ejecuta el compilador en una máquina Linux x86-64 para generar un modelo que funciona en placas como una Raspberry Pi con acelerador 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 plataforma Coral de Google se centra ahora en Coral NPU, un diseño de acelerador RISC-V de código abierto anunciado en octubre de 2025 para dispositivos ponibles, cuyo objetivo es alcanzar 512 000 millones de operaciones por segundo con unos pocos milivatios.