Skip to content

TensorFlow Hoja de referencia

Plataforma de machine learning de código abierto de extremo a extremo de Google.

01

Primeros pasos

Instalación y fundamentos

TensorFlow 2.x corre con ejecución ansiosa por defecto (las operaciones se ejecutan de inmediato, como Python normal). Usa tf.config.list_physical_devices('GPU') para verificar que las GPUs CUDA son visibles. Para soporte de GPU instala el extra [and-cuda] en Linux/Windows, o usa tensorflow-metal en Apple Silicon. TF 2.x fusionó a Keras como tf.keras — la API de alto nivel usada en la mayoría de flujos de trabajo.

tensorflow
# 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())   # True

Primeros tensores

tf.constant crea un tensor inmutable; tf.zeros / tf.ones / tf.random.* crean patrones comunes. Cada tensor tiene shape, dtype y rank. .numpy() regresa a NumPy — en GPU esto puede disparar una copia sincrónica. Prefiere dtypes explícitos (float32 es el de por defecto en ML) para evitar promociones silenciosas que rompen el rendimiento.

tensorflow
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]])

Ejecución ansiosa y gradientes

La ejecución ansiosa hace a TF depurable como Python normal — print, pdb y los tracebacks funcionan sin problemas. GradientTape registra las operaciones de forward sobre los tensores observados (tf.Variable se observa automáticamente) para que tape.gradient pueda computar derivadas. Es la fundación de los bucles de entrenamiento personalizados. Los tapes son de un solo uso por defecto; usa persistent=True para llamar a gradient varias veces.

tensorflow
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 y grafos

@tf.function convierte una función de Python en un grafo de TensorFlow portable y optimizable — mucho más rápido en GPU y requerido para distribución. La función se traza una vez por firma de entrada, así que evita los efectos secundarios de Python o el flujo de control de Python dependiente de datos dentro (usa tf.cond / tf.while_loop o la función se re-trazará). Las variables deben crearse una vez, fuera de la función, o reutilizar tf.Variable con el mismo nombre.

tensorflow
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.]))

Precisión mixta

La precisión mixta computa en float16 pero conserva copias maestras en float32, dando 2-3 veces de rendimiento y la mitad de memoria en GPUs con Tensor Cores (Volta+). La política 'mixed_float16' maneja el escalado de pérdida automáticamente para prevenir el subdesbordamiento. Fuerza la capa de salida a float32 por estabilidad numérica. Necesita capacidad de cómputo >= 7.0; en GPUs antiguas puede ser más lenta.

tensorflow
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())
02

Tensores

tf.constant

tf.constant crea un tensor inmutable — no puedes asignar a sus elementos. Para tensores entrenables usa tf.Variable. tf.random.normal/uniform aceptan un argumento seed por reproducibilidad; tf.random.set_seed(42) hace reproducible el programa entero. Usa tuplas de shape (no enteros) para la creación multidimensional y evitar sorpresas.

tensorflow
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  -> TypeError

tf.Variable

tf.Variable es un envoltorio de tensor mutable usado para los parámetros del modelo y el estado del optimizador. assign / assign_add / assign_sub lo actualizan en el sitio — la asignación ordinaria de Python (w = w + 1) crea un tensor nuevo y no muta. Las variables son observadas por GradientTape automáticamente, a diferencia de tf.constant que debes observar explícitamente con tape.watch(). Mantén las variables en el mismo dispositivo que las operaciones que las usan.

tensorflow
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)   # 2w

Operaciones de tensor

La mayoría de la matemática refleja a NumPy: tf.reduce_sum / reduce_mean / reduce_max corresponden a np.sum/mean/max. Usa axis= para reducir una dimensión concreta y keepdims=True para conservar el rango por broadcasting. tf.matmul y el operador @ hacen multiplicación de matrices (por lotes cuando las entradas son 3D+). reshape devuelve una vista cuando es posible; transpose siempre devuelve una copia en TF.

tensorflow
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)

Indexación y slicing

TF soporta slicing estilo NumPy en modo ansioso y dentro de tf.function. tf.boolean_mask extrae los elementos donde la máscara es True (aplanados). tf.gather selecciona a lo largo del eje 0 por defecto (como la indexación elegante). tf.where(cond, x, y) es el ternario vectorizado — cuando cond es True toma de x, si no de y. Para asignar usa tf.tensor_scatter_nd_update o un tf.Variable.

tensorflow
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))

Tensores ragged y dispersos

Los tensores ragged guardan secuencias de longitud variable sin relleno — perfectos para lotes de NLP de longitudes distintas. Los tensores dispersos guardan solo índices y valores no cero, ahorrando memoria para datos muy dispersos (recomendaciones, grafos). La mayoría de operaciones tienen variantes conscientes de lo disperso; convierte a denso solo cuando una operación lo exija. tf.RaggedTensor.to_tensor() rellena a un rectángulo para las búsquedas de embeddings.

tensorflow
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 y matemática

El broadcasting estira los tensores de dimensión menor para igualar a los mayores, elemento a elemento. clip_by_value es el clamp de TF. tf.maximum/minimum son elemento a elemento (distintos de tf.reduce_max/min que reducen una dimensión). cumsum/cumprod producen sumas/productos acumulados a lo largo de un eje — útil para métricas acumulativas y algoritmos de suma de prefijos en capas personalizadas.

tensorflow
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]
03

Modelos Keras

API Sequential

Sequential es el modelo Keras más simple — un pipeline lineal donde la salida de cada capa alimenta a la siguiente. input_shape excluye la dimensión de lote (usa None para lote variable). model.summary() imprime las formas de las capas y los conteos de parámetros. Si no pasas input_shape, el modelo se construye perezosamente en la primera llamada fit/forward — llama a build() explícitamente para inspeccionarlo antes.

tensorflow
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 batch

API funcional

La API funcional permite que las capas se ramifiquen, fusionen y salten — requerida para cualquier cosa no lineal (ResNets, multi-entrada/salida, redes siamesas). Define tensores Input, encadena capas llamándolas y luego pasa inputs/outputs a Model. El modelo resultante se comporta idénticamente a uno Sequential para fit/predict. Nombra inputs/outputs para un guardado limpio y firmas de servicio.

tensorflow
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)

Subclases de modelo

Heredar de tf.keras.Model da control total del forward (como PyTorch). Define las capas en __init__ e implementa call(inputs, training=). El flag training alterna el comportamiento de dropout y BatchNorm. La herencia es más flexible pero pierde algunos beneficios de la API funcional: más difícil de inspeccionar/graficar, sin inferencia automática de forma de entrada, y la serialización es más delicada. Prefiere la funcional para la mayoría de arquitecturas; hereda para modelos de investigación.

tensorflow
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()

Compilación del modelo

compile conecta el optimizador, la pérdida y las métricas antes de fit. Las cadenas ('adam', 'mse') son atajos de las clases correspondientes; pasa objetos para hiperparámetros personalizados. Para modelos multi-salida pasa diccionarios que mapeen nombres de salida a pérdidas. run_eagerly=True desactiva el trazado de tf.function para que puedas usar pdb y print — inestimable para depurar, pero lento.

tensorflow
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
)

Summary y plot del modelo

summary() imprime una tabla por capa con formas de salida y conteos de parámetros — la forma más rápida de detectar bugs de forma. plot_model guarda un grafo visual (requiere pydot y Graphviz). get_config devuelve un dict serializable para que la arquitectura pueda reconstruirse sin pesos — lo usan model.to_json() y el formato de guardado de Keras. Para modelos funcionales, la configuración captura por completo la arquitectura; para modelos con subclases debes implementar get_config tú mismo.

tensorflow
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)

Preprocesamiento en el modelo

Poner el preprocesamiento dentro del modelo (Rescaling, capas Keras de aumentación) lo hace desplegable: el mismo SavedModel acepta imágenes crudas en inferencia, sin paso de preprocesamiento separado. Las capas de preprocesamiento de Keras corren en GPU y dentro de tf.function, así que son rápidas. Para aumentación solo de entrenamiento, fja training=True en fit para que las capas queden inactivas en inferencia. Rescaling(1./255) convierte imágenes uint8 [0,255] a float [0,1].

tensorflow
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 images
04

Capas

Capa Dense

Dense es la capa totalmente conectada: y = activation(xW + b). La forma del peso es (in_features, out_features) — la transpuesta de PyTorch. kernel_initializer usa Glorot/Xavier uniforme por defecto, bueno para tanh/sigmoid; usa 'he_normal' para la familia ReLU. Añade regularización L2 vía kernel_regularizer. GELU es la activación por defecto en los transformers.

tensorflow
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)

Capa Conv2D

TF/Keras usa NHWC (canales al final) por defecto, lo opuesto al NCHW de PyTorch. padding='same' rellena para que el tamaño espacial de salida = entrada / stride; 'valid' significa sin relleno. DepthwiseConv2D aplica un filtro por canal de entrada (usado en MobileNet). Conv2DTranspose submuestrea hacia arriba (usada en decodificadores de segmentación). La forma del kernel es (kH, kW, canales_entrada, filtros).

tensorflow
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')

Capas recurrentes (LSTM/GRU)

La forma de entrada para RNNs es (lote, pasos_de_tiempo, características). return_sequences=True es necesario al apilar RNNs o para modelos de secuencia-a-secuencia; False para secuencia-a-vector. Bidirectional duplica el tamaño de salida concatenando hacia adelante y hacia atrás. recurrent_dropout es cómodo pero lento (sin aceleración cuDNN) — prefiere dropout plano sobre las entradas.

tensorflow
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 * 2

Dropout y regularización

Dropout pone a cero unidades al azar durante el entrenamiento para prevenir la co-adaptación — se desactiva automáticamente en inferencia (training=False). SpatialDropout2D descarta mapas de características enteros, mejor para conv nets. L2 (weight decay) es el regularizador más común. LayerNormalization normaliza sobre el eje de características (por muestra), a diferencia de BatchNorm que normaliza sobre el eje de lote — preferida para transformers y RNNs.

tensorflow
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()

Normalización por lotes

BatchNormalization normaliza las activaciones por canal, conservando estadísticas EMA acumuladas para inferencia. axis=-1 normaliza el último eje (canales) para NHWC. Pon BN después de la conv y antes de la activación, y desactiva el sesgo de la conv (use_bias=False) ya que el beta de BN maneja el desplazamiento. momentum controla la velocidad con que las estadísticas acumuladas siguen a los datos — valores altos (0.99) son más estables. BN se comporta distinto en entrenamiento vs inferencia (flag training).

tensorflow
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))    # 2

Capa personalizada

Hereda de Layer para construir operaciones personalizadas. Define los pesos en build() (llamada una vez con la forma de entrada) en lugar de __init__ para que la capa se adapte al tamaño de entrada. Implementa get_config() para que la capa pueda serializarse y recargarse. add_weight registra el tensor con el rastreo de Keras (así aparece en weights, se guarda y se mueve al dispositivo). Para transformaciones sin estado, puedes saltarte build() y simplemente sobrescribir call().

tensorflow
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)))
05

Pérdidas

BinaryCrossentropy

BinaryCrossentropy es para tareas binarias o multi-etiqueta (cada clase independiente). Pasa from_logits=True si tu modelo genera logits crudos — es numéricamente más seguro que aplicar sigmoid + BCE por separado. pos_weight sobrepesifica los ejemplos positivos para manejar el desequilibrio. Para problemas multi-etiqueta con C clases, la forma del objetivo es (N, C) de 0/1 y las predicciones son (N, C) de probabilidades o logits.

tensorflow
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 espera objetivos one-hot; SparseCategoricalCrossentropy espera índices de clase enteros (más eficiente en memoria para muchas clases). Pasa siempre from_logits=True cuando el modelo no termina en softmax — usa el truco log-sum-exp por estabilidad numérica. Para suavizado de etiquetas usa CategoricalCrossentropy(label_smoothing=0.1), un potente regularizador de clasificación y NLP.

tensorflow
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 y pérdidas de regresión

MSE penaliza los errores grandes cuadráticamente (sensible a atípicos); MAE es lineal. Huber se comporta como MSE cerca de cero y MAE lejos — el valor por defecto de la regresión en detección de objetos. LogCosh es similar pero doblemente diferenciable en cualquier punto, útil cuando necesitas gradientes de segundo orden. Por defecto la reducción es la media sobre el lote en cada una; sobrescríbela con reduction=tf.keras.losses.Reduction.NONE para pérdidas por muestra.

tensorflow
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)

Pérdida personalizada

Una pérdida personalizada es cualquier callable que toma (y_true, y_pred) y devuelve un tensor escalar. Para serialización o hiperparámetros, hereda de tf.keras.losses.Loss e implementa call() + get_config(). Mantén cada operación diferenciable. FocalLoss reduce el peso de los ejemplos fáciles para centrarse en los difíciles — popular en detección de objetos. Usa Reduction.NONE en call() y deja que Keras reduzca al final si quieres que el enmascarado funcione.

tensorflow
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)

Pérdida desde logits

Computar softmax y luego la entropía cruzada por separado puede desbordarse con logits grandes (e^100). Pasar from_logits=True deja a TF fusionarlas con el truco log-sum-exp, que es numéricamente estable. Las APIs funcionales tf.nn.*_cross_entropy_with_logits hacen lo mismo. Asegúrate de que tu modelo NO termine en softmax/sigmoid al usar from_logits=True, de lo contrario aplicarías la activación dos veces.

tensorflow
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)

Pérdidas multi-salida

Para modelos multi-salida, pasa un dict que mapee nombres de salida a funciones de pérdida y un dict loss_weights para equilibrarlas. La pérdida total es la suma ponderada. Este es el patrón estándar del aprendizaje multitarea — cada cabeza recibe su propia pérdida y métrica. Pasa los objetivos de entrenamiento como un dict con las mismas claves en el momento del fit. Ajusta loss_weights para que ninguna tarea domine el gradiente.

tensorflow
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)
06

Optimizadores

Adam

Adam es el optimizador por defecto para la mayoría de tareas — tasas de aprendizaje adaptativas por parámetro, robusto ante la elección de hiperparámetros. beta_1/beta_2 controlan la decadencia EMA de los momentos primero y segundo. Pasa un objeto LearningRateSchedule en lugar de un float para decaer el LR a lo largo del entrenamiento. global_clipnorm reescala la totalidad de los gradientes si su norma combinada excede el umbral — importante para RNNs y transformers.

tensorflow
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 a menudo generaliza mejor que Adam en el entrenamiento CNN con lotes grandes, al coste de más ajuste de LR. momentum=0.9 es el estándar; Nesterov da una pequeña ventaja extra. weight_decay añade regularización L2 desacoplada (Keras 3) — las versiones antiguas usan kernel_regularizer en las capas. SGD necesita warmup y programación de LR para competir con Adam de fábrica.

tensorflow
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 y otros optimizadores

AdamW desacopla el weight decay de la actualización del gradiente, lo que importa a escala (transformers, CNNs grandes). RMSprop es el optimizador clásico de RNNs. Adagrad se adapta por parámetro pero puede estancarse temprano — bien para características dispersas. FTRL está diseñado para aprendizaje en línea a gran escala con características dispersas (predicción de clics). Para proyectos nuevos, empieza con AdamW.

tensorflow
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)

Aplicar gradientes

En un bucle de entrenamiento personalizado computas los gradientes con GradientTape y luego llamas a opt.apply_gradients(zip(grads, vars)). Es el bloque de construcción de los bucles de entrenamiento personalizados (ver la sección de bucle de entrenamiento personalizado). clip_by_global_norm reescala los gradientes para que su norma L2 combinada quede bajo el umbral. Los gradientes None significan que la variable no afectó a la pérdida — común en parámetros sin usar y vale la pena registrarlos.

tensorflow
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)

Programaciones de tasa de aprendizaje

Los objetos LearningRateSchedule computan el LR como función del contador de pasos del optimizador. CosineDecay hace annealing suave hasta alpha*lr_inicial — un fuerte valor por defecto. CosineDecayRestarts implementa reinicios calientes estilo SGDR. Pasa la programación como learning_rate al construir el optimizador; Keras la llama automáticamente en cada paso. Para warmup, envuélvela con una programación personalizada o usa el callback WarmUp de tensorflow/addons.

tensorflow
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))

Recorte de gradientes y EMA

global_clipnorm (reescala la totalidad de los gradientes juntos) es la elección más común y es la que usan los transformers. clipvalue acorta duramente cada elemento. Para un recorte personalizado, modifica los grads entre tape.gradient y apply_gradients. La media móvil exponencial (EMA) de los pesos a menudo da una pequeña mejora de exactitud en inferencia — aplícala tras cada paso y usa los pesos promediados para la evaluación. TF Addons tiene un envoltorio de optimizador MovingAverage.

tensorflow
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)
07

Entrenamiento

compile y fit

fit es la API de entrenamiento de alto nivel: maneja el batcheo, el barajado, la validación, los callbacks y el progreso. Pasa o validation_data=(x, y) o validation_split=0.2 (apartado del entrenamiento). verbose=2 imprime una línea por época (bueno para logs); 1 muestra una barra de progreso. El objeto history devuelto guarda pérdida y métricas por época — grafícalo para detectar sobreajuste.

tensorflow
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'])

Validación y métricas

Las métricas son objetos con estado que se acumulan entre lotes y computan el valor final al final de la época — a diferencia de las pérdidas no afectan al entrenamiento. Pasa cadenas ('accuracy') u objetos Metric para métricas personalizadas. Hereda de tf.keras.metrics.Metric e implementa update_state/result/reset_state. reset_state (renombrado desde reset_states en TF 2.11+) se llama al inicio de cada época.

tensorflow
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()

Épocas, tamaño de lote y pasos

Al usar tf.data.Dataset, no pases batch_size — el dataset ya está agrupado en lotes. steps_per_epoch le dice a fit cuántos lotes constituyen una época cuando el dataset repite indefinidamente. validation_steps hace lo mismo para la validación. Usa initial_epoch para reanudar el entrenamiento desde un checkpoint — fit se saltará las primeras N épocas pero el estado del optimizador (programación de LR, momentum) continúa correctamente.

tensorflow
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)

Pesos de clase y de muestra

class_weight escala la pérdida por cada clase para contrarrestar el desequilibrio — equivalente al sobremuestreo sin el cómputo extra. sample_weight da control por ejemplo, útil para minería de ejemplos difíciles o enmascarar posiciones de relleno. Al usar un tf.data.Dataset, incluye sample_weight como el tercer elemento de la tupla para que el dataset genere (x, y, w). Usa sklearn.utils.class_weight para computar pesos equilibrados automáticamente.

tensorflow
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 y evaluate

predict devuelve un array de NumPy de predicciones para toda la entrada — usa batch_size para controlar la memoria. evaluate devuelve la pérdida más las métricas de compile. Para entradas muy grandes, itera lotes manualmente con predict_on_batch. Llamar al modelo directamente (model(x)) devuelve un tensor y respeta training=, mientras que predict siempre corre en modo inferencia y devuelve NumPy. Usa model(x, training=True) para aumentación en tiempo de prueba.

tensorflow
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 aug

Sobrescribir train_step

Sobrescribir train_step te permite personalizar lo que ocurre en cada lote de fit manteniendo el bucle de épocas, los callbacks y la distribución de fit. Es el puente entre el fit de alto nivel y un bucle totalmente personalizado — genial para GANs, aprendizaje contrastivo o cualquier objetivo no estándar. Usa self.compiled_loss y self.compiled_metrics para que la pérdida/métricas de compile() sigan funcionando. test_step sobrescribe el comportamiento de validación de la misma forma.

tensorflow
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)
08

Callbacks

EarlyStopping

EarlyStopping detiene el entrenamiento cuando la métrica monitoreada deja de mejorar, ahorrando tiempo y previniendo el sobreajuste. patience=N espera N épocas sin mejora antes de detenerse. restore_best_weights=True retrocede a la mejor época al final — sin él conservas los pesos finales (posiblemente peores). mode='min' para pérdidas, 'max' para exactitud. Fja siempre un máximo de épocas generoso y deja que el callback decida.

tensorflow
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 guarda el modelo durante el entrenamiento para poder recuperarte de caídas o elegir la mejor época. save_best_only=True conserva solo el mejor checkpoint (por la métrica monitor) — fja monitor a tu métrica de validación. save_weights_only=True es menor e independiente de la arquitectura pero necesitas la clase del modelo para recargarlo. Los placeholders de formato como {epoch:02d} incrustan el número de época en el nombre de archivo. save_freq='epoch' es el valor por defecto; un entero N guarda cada N lotes.

tensorflow
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 baja el LR cuando la métrica monitoreada se estanca — útil cuando no conoces la programación correcta de antemano. factor es el multiplicador (0.5 = reducir a la mitad), patience cuántas épocas esperar, min_lr el suelo. cooldown pausa el monitoreo justo tras una reducción para dejar que el nuevo LR se asiente. Combínalo con EarlyStopping: reduce el LR primero y luego detente si no hay más mejora. verbose=1 imprime cada reducción.

tensorflow
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 de TensorBoard

El callback de TensorBoard transmite métricas de entrenamiento, histogramas de pesos, el grafo del modelo y datos de perfilado a un directorio de logs durante fit. histogram_freq=1 registra las distribuciones de pesos por época — fjálo a 0 para ahorrar espacio. profile_batch=2 corre el TF Profiler sobre ese lote para identificar cuellos de botella (pipeline de entrada, latencia de ops). Lanza TensorBoard apuntando a log_dir para ver los gráficos. Usa subdirectorios distintos por experimento para comparar ejecuciones.

tensorflow
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=./logs

LearningRateScheduler

LearningRateScheduler toma una función de (época, lr) y aplica el nuevo LR al inicio de cada época — simple pero solo por época. Para programaciones por paso prefiere un objeto LearningRateSchedule pasado al optimizador (ver la sección de optimizadores) — se llama en cada lote y funciona dentro de tf.function. La forma de Callback está bien para programaciones gruesas. Para warmup+decadencia, un objeto de programación es más limpio.

tensorflow
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 personalizado

Los callbacks se enganchan al ciclo de vida del entrenamiento: on_epoch_begin/end, on_train_batch_begin/end, on_test_*, on_predict_*. Accede al modelo vía self.model y al optimizador vía self.model.optimizer. logs es un dict de las métricas actuales. Los callbacks personalizados son geniales para logging, manipulación de LR, terminación temprana (self.model.stop_training = True) o sincronizar con sistemas externos (W&B, MLflow). Mantenlos baratos — corren en cada lote.

tensorflow
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()])
09

Pipeline tf.data

tf.data.Dataset

tf.data.Dataset es la API de datos en streaming de TF — canaliza datos de disco/CPU a la GPU eficientemente. from_tensor_slices encadena tensores a lo largo del eje 0. La cadena canónica es shuffle -> batch -> prefetch: shuffle aleatoriza, batch agrupa, prefetch solapa la preparación del siguiente lote con el entrenamiento actual. Usa AUTOTUNE para dejar que TF elija automáticamente los tamaños de búfer de prefetch.

tensorflow
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)
    break

Map, filter y cache

map aplica una función a cada elemento — aumentación, normalización, tokenización. num_parallel_calls=AUTOTUNE paraleliza entre núcleos de CPU. cache() guarda el dataset en memoria (o archivo) para que las épocas siguientes se salten la fuente — una gran aceleración para datos de tamaño pequeño a medio, pero cachea ANTES de las operaciones aleatorias o repetirás las mismas aumentaciones cada época. El orden canónico es cache -> map(aumentar) -> shuffle -> batch -> prefetch.

tensorflow
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 y repeat

shuffle usa un búfer de tamaño N: lo llena, muestrea uno, lo rellena — así que un búfer >= al tamaño del dataset da un orden verdaderamente aleatorio. shuffle -> repeat -> batch vuelve a barajar cada época. Para entrenar con steps_per_epoch, usa repeat() para que el dataset nunca se agote. drop_remainder=True descarta el último lote corto — importante para BatchNorm y modelos de forma fija. La semilla hace reproducible el barajado entre iteraciones solo si reshuffle_each_iteration=True con la misma semilla.

tensorflow
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 y rendimiento

prefetch(AUTOTUNE) es la mayor victoria individual — deja que la CPU prepare el lote N+1 mientras la GPU entrena el lote N, así que ninguno espera. num_parallel_calls=AUTOTUNE en map paraleliza el preprocesamiento limitado por CPU. El orden óptimo del pipeline es: fuente -> cache -> shuffle -> map(aumentar) -> batch -> prefetch. Usa tf.data.experimental.AUTOTUNE (lo mismo que tf.data.AUTOTUNE) y deja que TF ajuste los tamaños de búfer. Perfila siempre antes de optimizar — el cuello de botella suele estar en otra parte.

tensorflow
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))

Leer archivos

TextLineDataset transmite líneas de archivos de texto (logs, filas CSV). make_csv_dataset parsea CSVs con inferencia automática de tipos de columna. image_dataset_from_directory es el equivalente Keras del ImageFolder de PyTorch — infiere las etiquetas de los nombres de subdirectorio y devuelve (lote_imagen, lote_etiqueta). Para más control sobre la carga de imágenes usa tf.io.read_file + tf.io.decode_image dentro de una función map. Agrupa siempre el dataset en lotes antes de pasarlo a fit.

tensorflow
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 es el formato binario de registros de TF — la forma más rápida de alimentar datasets grandes desde disco. Cada registro es un tf.train.Example serializado (un dict de características). La lectura es I/O secuencial, mucho más rápida que las lecturas aleatorias en almacenamiento en la nube (GCS/S3). Para imágenes, guarda los bytes crudos y decodifícalos en map(). Usa tf.data.TFRecordDataset con compression='GZIP' para archivos menores. La fragmentación (varios archivos .tfrecord-0000N-of-0000M) habilita la lectura paralela.

tensorflow
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)
10

Guardar y cargar

Formato SavedModel

SavedModel es el formato de grado de producción: agrupa la arquitectura, los pesos y un grafo trazado para que el modelo pueda cargarse en TF Serving, TFLite, TF.js o C++ sin el código Python original. Usa tf.keras.models.load_model para recargarlo en Python. Pasa un input_signature para definir la firma de servicio explícitamente — requerido para TF Serving. SavedModel es un directorio, no un único archivo.

tensorflow
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)

Formato Keras (.keras)

El formato .keras (por defecto en Keras 3) es un único archivo comprimido que contiene la configuración de la arquitectura, los pesos y el estado del optimizador — fácil de compartir y versionar. .h5 es el formato heredado HDF5, aún soportado pero no recomendado para proyectos nuevos. SavedModel (un directorio) es obligatorio para el despliegue (TFLite, TF Serving). Para capas personalizadas, .keras guarda la configuración para que la capa pueda reconstruirse — asegúrate de que get_config() sea correcto.

tensorflow
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/serving

Guardar y cargar solo pesos

save_weights guarda solo los tensores de parámetros — mucho menor que un modelo completo y desacoplado de la arquitectura. Debes reconstruir el modelo con la misma estructura antes de cargar. skip_mismatch=True (Keras 3) carga solo las capas coincidentes, útil para transferencia de aprendizaje. El formato de checkpoint (prefijo 'ckpt') crea archivos checkpoint/weights-of-ckpt-1.index — el formato nativo de checkpoint de TF usado internamente por los callbacks de fit.

tensorflow
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')

Gestor de checkpoints

Checkpoint + CheckpointManager te dan control total del guardado en bucles de entrenamiento personalizados — conserva los últimos N checkpoints, restaura el más reciente automáticamente y versiona por paso. expect_partial() silencia las advertencias sobre ranuras no restauradas (por ejemplo, el momentum del optimizador para variables nuevas). Los checkpoints guardan el grafo de objetos, no las definiciones de clases — aún necesitas el código del modelo para restaurar. CheckpointManager.max_to_keep=3 autoelimina los checkpoints antiguos.

tensorflow
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()

Cargar con objetos personalizados

Al cargar un modelo que usa capas, pérdidas o métricas personalizadas, Keras necesita saber cómo reconstruirlas. Pasa un dict custom_objects que mapee nombres a clases/funciones. Para un código más limpio, decora las clases con @register_keras_serializable para que se registren globalmente y no necesiten custom_objects. Asegúrate de que get_config devuelva cada argumento del constructor para que el objeto pueda reconstruirse exactamente — Keras llama a from_config(config) por debajo.

tensorflow
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):
    ...

Exportar para servir

TF Serving espera directorios versionados (serving/1/, serving/2/) para poder intercambiar modelos en caliente. La firma de servicio define los nombres y formas de los tensores de entrada/salida que usan los clientes. model.export() (Keras 3) lo envuelve automáticamente. Para preprocesamiento personalizado, envuelve el modelo en un tf.Module y define __call__ con un input_signature que incluya la entrada cruda (por ejemplo, imagen uint8) y devuelva la salida final. Nombra los tensores para que los clientes puedan dirigirse a ellos.

tensorflow
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']
11

CNN

Conv2D y pooling

El bloque CNN canónico en Keras: Conv2D -> BatchNormalization -> ReLU -> MaxPooling. padding='same' conserva el tamaño espacial para stride 1. GlobalAveragePooling2D colapsa las dimensiones espaciales a un vector — más eficiente en parámetros que Flatten + Dense y menos propenso al sobreajuste. Keras usa NHWC (canales al final) por defecto, así que la forma de Input es (H, W, C) sin dimensión de lote. Las convs con stride pueden reemplazar al pooling para un submuestreo aprendible.

tensorflow
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()

Construir una CNN

Una CNN estilo VGG con filtros doblados en cada etapa (32 -> 64 -> 128) y tamaño espacial reducido a la mitad vía MaxPooling. Dos convs por etapa (bloque VGG) extrae características más ricas que una. Rescaling dentro del modelo lo hace desplegable — las imágenes uint8 crudas entran directamente. GlobalAveragePooling + Dropout regulariza la cabeza. Compila con sparse_categorical_crossentropy porque las etiquetas son índices de clase enteros.

tensorflow
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)

Mapas de características y visualización

Crea un Model con la misma entrada pero múltiples salidas (las activaciones de las capas conv) para inspeccionar qué aprende cada capa. Las capas tempranas detectan bordes/colores, las profundas texturas/partes. Es inestimable para depurar — los mapas de características muertos (puro cero) indican ReLUs rotas o problemas de tasa de aprendizaje. Para Grad-CAM (mapas de activación de clase), usa tf-keras-vis o implementa activaciones de clase ponderadas por gradiente para ver qué regiones impulsaron una predicción.

tensorflow
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 preentrenados

keras.applications expone ResNet, EfficientNet, MobileNet, ViT y más con pesos de ImageNet. include_top=False quita la cabeza de 1000 clases para que puedas adjuntar la tuya. preprocess_input aplica la normalización exacta con la que se entrenó el backbone — llámalo dentro del modelo para el despliegue. Congela el backbone (trainable=False) y fja training=False en la llamada para que BatchNorm use estadísticas de inferencia — crítico para la transferencia de aprendizaje con datasets pequeños.

tensorflow
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)

Conexiones residuales

Las conexiones residuales (de salto) añaden la entrada a la salida de un bloque, dejando que los gradientes fluyan directamente a capas anteriores — esto es lo que habilita entrenar redes muy profundas (ResNet). El atajo debe coincidir con los canales y el tamaño espacial de la salida; usa una conv 1x1 con stride para ajustar cuando difieran. Add() fusiona los dos caminos. Usa la API funcional (no Sequential) para cualquier arquitectura con conexiones de salto. ResNet-50 apila muchos de estos bloques.

tensorflow
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)

Cabeza de detección

Las cabezas de detección predicen cajas por ancla o por píxel más probabilidades de clase. La API funcional hace fáciles los modelos multi-salida: devuelve un dict de tensores con nombre. Para proyectos reales, usa la TensorFlow Object Detection API o KerasCV (detección, segmentación) — manejan el emparejamiento de anclas, el NMS y la evaluación. Escribir un detector completo desde cero es un ejercicio avanzado: maneja con cuidado la codificación de cajas, la pérdida IoU y la focal loss.

tensorflow
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}
12

RNN y LSTM

Capas LSTM y GRU

La forma de entrada de LSTM/GRU es (lote, pasos_de_tiempo, características). return_sequences=False devuelve la última salida (para clasificación); True devuelve la secuencia completa (para apilar o seq2seq). Bidirectional concatena las salidas hacia adelante y hacia atrás, duplicando el tamaño de características. stateful=True transporta el estado oculto entre lotes — útil para secuencias muy largas divididas en fragmentos, pero exige batch_size fijo y reinicios de estado manuales entre épocas.

tensorflow
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)

RNNs apiladas

Apila RNNs fijando return_sequences=True en todas salvo la última LSTM/GRU. mask_zero=True en la capa Embedding genera una máscara que las RNNs respetan — se saltan las posiciones de relleno, así que puedes agrupar secuencias de longitud variable sin afectar al estado oculto. El dropout entre capas de RNN regulariza; recurrent_dropout dentro de una RNN es más lento (sin cuDNN) — prefiere el dropout de entrada. Para clasificación de texto este biLSTM es una sólida línea base.

tensorflow
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')

Clasificación de texto con RNN

Un clasificador de texto estándar: Embedding -> biLSTM -> biLSTM -> Dense -> sigmoid. mask_zero=True es crítico — sin él, la LSTM procesa los tokens de relleno, sesgando el estado oculto. Bidirectional duplica el poder representacional leyendo la secuencia en ambos sentidos. Para clasificación binaria usa sigmoid + binary_crossentropy. Para secuencias largas (>500 tokens), los transformers superan a los LSTMs pero necesitan más datos y cómputo.

tensorflow
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)

Encoder-decoder Seq2Seq

LSTM encoder-decoder para seq2seq (traducción, resumición). El estado oculto final del encoder inicializa al decoder, que genera la secuencia objetivo token a token. Entrena con teacher forcing: alimenta la secuencia objetivo desplazada como entrada del decoder. Para inferencia, escribe un bucle aparte que alimente cada token predicho de vuelta como siguiente entrada. La atención (Bahdanau/Luong) mejora dramáticamente el seq2seq y es el ancestro conceptual de los transformers.

tensorflow
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')

Pronóstico de series temporales

Para series temporales, construye pares (entrada, objetivo) por ventana: el último valor de cada ventana es el objetivo, el resto son entradas. window(shift=1) crea ventanas solapadas; drop_remainder las mantiene del mismo tamaño. La LSTM aprende patrones temporales; una Dense(1) final predice el siguiente valor. Para pronóstico multi-paso, predice un vector de horizonte o usa una arquitectura seq2seq. Estandariza siempre la serie usando solo estadísticas de entrenamiento.

tensorflow
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)

Mecanismo de atención

La atención deja que el decoder se centre en los estados relevantes del encoder en lugar de depender de un único vector fijo — una mejora importante para secuencias largas. Bahdanau (aditiva) y Luong (multiplicativa) son las dos variantes clásicas. Keras aporta tf.keras.layers.AdditiveAttention y Attention como capas listas para usar. La atención es el puente conceptual hacia los transformers: la autoatención multi-cabeza es simplemente atención aplicada a la misma secuencia.

tensorflow
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])
13

Transformer

MultiHeadAttention

MultiHeadAttention es la capa transformer central — proyecta q/k/v en múltiples cabezas, atiende en paralelo y recombina. Para autoatención pasa el mismo tensor como query, key y value. attention_mask puede ser una máscara causal (triangular inferior) para decodificar o una máscara de padding (True = ignorar). return_attention_scores=True devuelve la matriz de atención para visualizar. La dim de salida iguala a la de entrada para que los bloques puedan apilarse.

tensorflow
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)

Bloque encoder de transformer

Un bloque encoder de transformer es: autoatención multi-cabeza + add & norm + feed-forward (MLP) + add & norm. Pre-LN (norma antes de la subcapa) es más estable para entrenar desde cero; post-LN necesita warmup. La FFN es un MLP de 2 capas con GELU, expandiéndose a 'ff' unidades ocultas y de vuelta a 'dim'. Apila N de estos para un encoder completo. epsilon=1e-6 en LayerNorm evita la división por cero ante varianzas pequeñas.

tensorflow
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))

Codificación posicional

Los transformers son invariantes a la permutación — necesitan información posicional para conocer el orden de los tokens. Las codificaciones sinusoidales añaden un patrón fijo basado en posición y dimensión; generalizan a secuencias más largas que las vistas en el entrenamiento. Añade la codificación posicional a la salida del embedding. Alternativamente usa embeddings de posición aprendidos (una capa Embedding indexada por posición) o codificaciones de posición relativa (usadas en transformers modernos como T5). Para imágenes (ViT), añade un embedding de posición aprendible por parche.

tensorflow
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 clasificación de texto

Un clasificador de texto transformer desde cero: embedding + codificación posicional + N bloques encoder + pool de promedio global + cabeza Dense. GlobalAveragePooling1D colapsa la dimensión de secuencia (usa un token CLS para una agregación aprendible). mask_zero=True propaga una máscara que MultiHeadAttention respeta — pásala manualmente si hace falta. Para NLP real, usa un transformer preentrenado (BERT, T5) de HuggingFace — entrenar desde cero exige muchísimos datos.

tensorflow
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 trocea la imagen con un Conv2d con stride (kernel=stride=patch_size), trata los parches como tokens, antepone un token CLS, añade embeddings posicionales y corre bloques encoder de transformer. El estado oculto final del token CLS es la representación global de la imagen para clasificar. Para uso real, carga un ViT preentrenado de keras.applications o HuggingFace — necesitan preentrenamiento en ImageNet-21k para funcionar bien. Patch size 16 y dim 768 son los valores por defecto de ViT-Base.

tensorflow
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)

Decoder de transformer

Un bloque decoder tiene tres subcapas: autoatención enmascarada (máscara causal para que la posición t no vea el futuro), atención cruzada (query del decoder, key/value de la salida del encoder) y una FFN. Cada subcapa lleva residual + LayerNorm. La atención cruzada es lo que deja al decoder 'mirar atrás' a la secuencia fuente. Para modelos solo-decodificador (GPT), elimina la subcapa de atención cruzada. Apila N bloques para un decoder completo. La inferencia necesita un bucle autoregresivo que alimente los tokens predichos de vuelta.

tensorflow
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 x
14

TensorBoard

Configuración y callback

El callback de TensorBoard transmite métricas, grafos y datos de perfilado a log_dir durante fit. histogram_freq=1 registra las distribuciones de pesos por época — fjálo a 0 para ahorrar espacio. profile_batch=2 corre el TF Profiler sobre ese lote para identificar cuellos de botella (pipeline de entrada, latencia de ops, memoria). Usa subdirectorios distintos por experimento (logs/exp1, logs/exp2) para que TensorBoard los superponga — perfecto para barridos de hiperparámetros. Lánzalo con `tensorboard --logdir=logs`.

tensorflow
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')

Escalares personalizados (summary writer)

tf.summary.create_file_writer te da un manejador de bajo nivel para registrar escalares personalizados en bucles de entrenamiento personalizados. Usa writer.as_default() y tf.summary.scalar(nombre, valor, step=paso) para escribir. El paso debe ser un entero (normalmente el contador de iteraciones del optimizador). Vacía periódicamente para que los eventos lleguen a disco. Usa espacios de nombres (train/loss, val/loss) para organizar los gráficos en la UI de TensorBoard. Registra el LR, las normas de gradiente y cualquier métrica personalizada que te importe.

tensorflow
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)

Imágenes e histogramas

tf.summary.image registra imágenes para QA visual — pasa forma (B, H, W, C) con B hasta max_outputs. Los histogramas muestran las distribuciones de pesos y gradientes a lo largo del tiempo; los picos súbitos insinúan inestabilidad. Registra unas pocas muestras de validación por época para ver el progreso cualitativo, no solo métricas escalares. El audio es útil para modelos de habla. Cada summary toma un argumento step que se vuelve el eje x en TensorBoard. Mantén el logging barato muestreando cada N pasos.

tensorflow
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()

Ajuste de hiperparámetros

El plugin HParams organiza los barridos de hiperparámetros en TensorBoard — una vista de tabla te deja filtrar ejecuciones y hallar la mejor configuración. Define objetos HParam con rangos/valores discretos, registra una configuración una vez con hp.hparams_config y luego para cada ejecución registra hp.hparams(hparams) más la métrica final. Para barridos serios usa KerasTuner (RandomSearch, Hyperband, BayesianOptimization) que automatiza la búsqueda y se integra con TensorBoard.

tensorflow
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)

Perfilar rendimiento

El TF Profiler muestra dónde se gasta el tiempo: por operación, por dispositivo y en el pipeline de entrada. profile_batch='10,20' perfila los lotes 10-20 (sáltate los primeros para que el warmup termine). La página Overview da recomendaciones accionables (por ejemplo, 'el pipeline de entrada es el cuello de botella'). El Memory Viewer muestra la memoria pico y qué tensores dominan. El Trace Viewer es una línea de tiempo estilo Chrome para profundizar. Perfila siempre en el hardware objetivo — los cuellos de botella difieren entre CPU y GPU.

tensorflow
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 recommendations
15

Entrenamiento GPU / TPU

Detección y memoria de GPU

Por defecto TF toma toda la memoria de la GPU al arrancar, bloqueando a otros procesos. set_memory_growth(True) asigna solo lo necesario — esencial para compartir una GPU. set_logical_device_configuration limita la memoria o divide una GPU en varios dispositivos lógicos (útil para probar código multi-GPU en una sola GPU). tf.device('/GPU:1') coloca las ops en un dispositivo concreto. Las ops de CPU corren en '/CPU:0'. La colocación de dispositivos mal emparejada causa copias implícitas que perjudican el rendimiento.

tensorflow
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)

Estrategia de distribución

Las estrategias de distribución abstraen la topología de dispositivos. MirroredStrategy es para multi-GPU en una máquina (espeja las variables entre GPUs, all-reduce de gradientes) — el camino multi-GPU más fácil. MultiWorkerMirroredStrategy se extiende a varias máquinas. TPUStrategy corre en TPUs de Google (Colab/Nube). Crea siempre el modelo dentro de strategy.scope() para que las variables se espejen correctamente. El mismo código fit/predict funciona en todas las estrategias.

tensorflow
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)

Entrenamiento multi-GPU

MirroredStrategy espeja las variables del modelo en cada GPU y divide cada lote entre réplicas — el tamaño de lote efectivo es el global (por ejemplo, 64 por GPU * 4 GPUs = 256). Pasa el lote global al dataset; TF distribuye los fragmentos automáticamente. fit() maneja el all-reduce de gradientes por debajo. Para bucles de entrenamiento personalizados, usa strategy.experimental_distribute_dataset y strategy.run(train_step).

tensorflow
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)

Entrenamiento en TPU (Colab)

Las TPUs están disponibles en Google Colab (cambiar tipo de runtime -> TPU) y en Google Cloud. Inicializa el sistema TPU una vez y luego envuelve la creación del modelo en strategy.scope(). Las TPUs son más rápidas con tamaños de lote grandes (1024+) y formas fijas — usa drop_remainder=True al agrupar. Las TPUs no pueden leer archivos locales directamente; carga los datos en memoria o transmítelos desde GCS vía tf.data. La precisión mixta (bfloat16) da una gran aceleración en TPU y no necesita escalado de pérdida.

tensorflow
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)

Precisión mixta

La precisión mixta computa en float16 pero conserva copias maestras en float32, dando 2-3 veces de rendimiento en GPUs con Tensor Cores (Volta+) y la mitad de memoria. 'mixed_float16' necesita escalado de pérdida (Keras lo maneja automáticamente vía LossScaleOptimizer). 'mixed_bfloat16' tiene el mismo rango que float32 así que no se necesita escalado, pero solo las GPUs Ampere+ y las TPUs lo soportan. Fuerza la capa final a float32 por estabilidad numérica (softmax/logits). La precisión mixta es la victoria de rendimiento individual más fácil.

tensorflow
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">
16

Aumentación de datos

Capas de preprocesamiento Keras

Las capas de preprocesamiento de Keras (RandomFlip, RandomRotation, etc.) corren en GPU y dentro de tf.function — mucho más rápido que la aumentación con PIL/numpy. Ponerlas dentro del modelo significa que se desactivan en inferencia automáticamente (training=False). Alternativamente, aplícalas en un map de tf.data para más control. Estas capas no tienen estado y compilan por JIT, así que no ralentizan la inferencia. Para preprocesamiento con estado (por ejemplo, escaladores ajustados) usa la API Adapt.

tensorflow
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 (herencia)

ImageDataGenerator es la API de aumentación heredada — funciona pero corre en CPU y es más lenta que las capas de preprocesamiento de Keras. Úsalo solo cuando necesites su comodidad de iterar directorios o código heredado. Para proyectos nuevos prefiere keras.utils.image_dataset_from_directory + capas de preprocesamiento Keras (RandomFlip etc.) — están aceleradas por GPU y se integran con tf.data. flow_from_directory infiere las etiquetas de clase de los nombres de subdirectorio como ImageFolder.

tensorflow
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)

Operaciones de aumentación de imagen

Las ops tf.image.* dan control fino para la aumentación personalizada. random_brightness/contrast/saturation/hue cambian el color sin tocar la geometría. Cutout y Mixup son aumentaciones avanzadas que mejoran la regularización; implementalas con ops de tf.image + tf.tensor_scatter_nd_update. Aplica la aumentación en un map de tf.data con num_parallel_calls=AUTOTUNE para que corra en los workers de CPU y nunca bloquee a la GPU. Recorta siempre de vuelta a los rangos de píxel válidos tras el jitter de color.

tensorflow
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 y CutMix

Mixup mezcla linealmente dos imágenes y sus etiquetas, creando ejemplos virtuales entre clases — una regularización fuerte que reduce el sobreajuste y mejora la calibración. CutMix pega un parche rectangular de una imagen sobre otra, preservando mejor la estructura local que Mixup. Ambas exigen que la pérdida acepte etiquetas suaves (mezcladas) — usa categorical_crossentropy, no sparse. Aplícalas por lote después del batcheo. Combínalas con la aumentación geométrica estándar para los mejores resultados.

tensorflow
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)

Aumentación de texto y tabular

Para texto, las aumentaciones simples a nivel de palabra (intercambio de sinónimos, borrado/intercambio aleatorio) son baratas y efectivas; para NLP serio usa retro-traducción o modelos como EDA/AugBERT. Para datos tabulares, mixup mezcla filas; el ruido gaussiano sobre características numéricas regulariza. Aplica la aumentación solo a los datos de entrenamiento, nunca a validación/prueba. Mantén las aumentaciones que preservan etiquetas (o las mezclan como mixup) — corromper etiquetas perjudica más de lo que ayuda.

tensorflow
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)
17

Transferencia de aprendizaje

Modelos preentrenados

keras.applications expone ResNet, EfficientNet, MobileNet, ViT y más con pesos de ImageNet. include_top=False quita la cabeza de 1000 clases para que puedas adjuntar la tuya. preprocess_input aplica la normalización exacta que espera el backbone — llámalo dentro del modelo para el despliegue. Congela el backbone (trainable=False) y llama a base(x, training=False) para que BatchNorm use estadísticas de inferencia — crítico para datasets pequeños donde las estadísticas de BN serían ruidosas.

tensorflow
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)

Extracción de características

La extracción de características congela el backbone completo y entrena solo una cabeza nueva — la línea base de transferencia más rápida. Como el backbone está fijo, puedes precomputar las características una vez (base.predict(train_ds)) y entrenar un clasificador diminuto sobre ellas, ahorrando enorme cómputo. Fija training=False al llamar al backbone para que BatchNorm use estadísticas acumuladas — de lo contrario lotes pequeños las corrompen. Bueno para datasets pequeños (cientos de imágenes) donde el fine-tuning sobreajustaría.

tensorflow
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

El fine-tuning descongelta algunas capas del backbone y las entrena con un LR pequeño para que las características preentrenadas se adapten a tu tarea. Haz siempre primero extracción de características (solo cabeza) por unas épocas y LUEGO descongela — de lo contrario los grandes gradientes de la cabeza aleatoria destrozan las características preentrenadas. Usa un LR mucho menor (1e-5 frente a 1e-3 para la cabeza). Descongela de arriba abajo (las capas posteriores son más específicas de la tarea; las anteriores generales). Mantén las capas BatchNorm congeladas para preservar sus estadísticas acumuladas.

tensorflow
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)

Congelar y descongelar

Fija layer.trainable=False para congelarla. Tras cambiar trainable, DEBES recompilar el modelo para que el optimizador recoja el nuevo conjunto entrenable. Mantén las capas BatchNorm congeladas durante el fine-tuning — sus estadísticas acumuladas son preciosas y los lotes finos de fine-tuning las corromperían. Inspecciona trainable_weights frente a weights para confirmar qué se actualizará. Registra el conteo de parámetros entrenables para no congelar o descongelar accidentalmente el modelo entero (un bug silencioso común).

tensorflow
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:,}")

Transferencia multitarea

El aprendizaje multitarea comparte un backbone entre tareas relacionadas, regularizando la representación y ahorrando cómputo. Cada cabeza es una pequeña rama desde las características compartidas. Pasa pérdidas por salida y loss_weights en compile para equilibrar los gradientes de las tareas (ajusta los pesos para que ninguna tarea domine). En el momento del fit, pasa los objetivos como un dict que coincida con los nombres de salida. La transferencia multitarea es potente cuando tienes una tarea con muchos datos y otra con pocos — el backbone compartido beneficia a ambas.

tensorflow
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},
)
18

Despliegue del modelo

Conversor TFLite

TFLite convierte los modelos de TF a un formato flatbuffer para móviles, embebidos y dispositivos de borde. Optimize.DEFAULT aplica la cuantización post-entrenamiento automáticamente; la cuantización int8 completa necesita un dataset representativo para calibrar los rangos de activación y produce un modelo que corre en Edge TPU / microcontroladores. float16 conserva la compatibilidad con GPU y es más seguro si int8 daña la exactitud. El conversor infiere las formas de entrada del modelo; para formas dinámicas, fíjalas con concrete functions.

tensorflow
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()

Intérprete TFLite

El intérprete TFLite corre modelos .tflite en CPU, GPU, Edge TPU o microcontroladores. allocate_tensors prepara la memoria según la forma de entrada fija — redimensiona con resize_tensor_input para formas dinámicas. set_tensor / invoke / get_tensor es el bucle de inferencia. Para inferencia por lotes, el modelo debe convertirse con un tamaño de lote fijo o usar resize_tensor_input. TFLite tiene enlaces para Python, C++, Java, Swift y JavaScript — el mismo archivo .tflite corre en todas partes.

tensorflow
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 hospeda SavedModels detrás de una API gRPC/REST con versionado, batcheo y soporte de GPU. La estructura de directorios serving/1/, serving/2/ habilita los intercambios calientes de modelos. La imagen de Docker es el despliegue local más fácil; para producción usa Vertex AI, SageMaker o KServe. TF Serving agrupa automáticamente las peticiones para maximizar la utilización de la GPU. La API REST usa {instances: [...]} para las entradas y devuelve {predictions: [...]}; para entradas/salidas con nombre usa el parámetro signature_name.

tensorflow
# 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'])

Entrenamiento consciente de cuantización

El entrenamiento consciente de cuantización (QAT) inserta ops de falsa cuantización durante el entrenamiento para que el modelo se adapte al ruido de redondeo que verá en la inferencia int8 — normalmente recupera la mayor parte de la exactitud perdida por la cuantización post-entrenamiento. Usa tfmot (tensorflow-model-optimization) para envolver un modelo entrenado, hacer fine-tuning por unas épocas y luego convertir a TFLite. QAT es esencial cuando la cuantización int8 post-entrenamiento baja la exactitud por debajo de tu umbral (por ejemplo, EfficientNet, detectores de objetos). El modelo TFLite resultante corre en Edge TPU.

tensorflow
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 y despliegue en borde

TF.js corre modelos en el navegador o en Node.js. El conversor transforma SavedModel/.keras/.h5 en un model.json más un directorio de pesos binarios. Los modelos de capas soportan la API de Keras (fit, predict, incluso entrenamiento al vuelo); los de grafo son más compatibles pero menos flexibles. La inferencia en el navegador usa WebGL/WASM; Node.js puede usar CUDA. TF.js es genial para ML del lado del cliente (sin viaje al servidor, privacidad, offline). Para móvil, prefiere TFLite (menor, más rápido, aceleración por hardware).

tensorflow
# 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 ops

Optimización de inferencia

Para un despliegue de baja latencia, apila optimizaciones: pruning (poner a cero pesos pequeños, comprimir), destilación de conocimiento (entrenar a un estudiante pequeño que iguale los logits de un profesor grande), cuantización (int8/float16) y compilación XLA (fusionar ops). Cada paso tiene contrapartidas — haz siempre benchmark en el hardware objetivo. La destilación suele preservar mejor la exactitud; pruning+cuantización dan las mayores reducciones de tamaño. XLA (jit_compile=True) fusiona ops para una aceleración gratis de 1.2-2 veces en GPU/TPU.

tensorflow
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 step
19

Bucle de entrenamiento personalizado

Bucle personalizado básico

Un bucle personalizado te da control total: manipulación de gradientes, múltiples modelos, objetivos personalizados. El patrón es GradientTape -> pérdida -> grads -> apply_gradients, envuelto en @tf.function por velocidad. No olvides model.losses — son las pérdidas de regularización añadidas por kernel_regularizer y deberían sumarse a la pérdida principal. Sigue las métricas con objetos Metric con estado y reset_state() en cada época. Es más verboso que fit pero desbloquea cualquier cosa.

tensorflow
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()

Validación en el bucle personalizado

La validación refleja al entrenamiento pero con training=False (así el dropout está apagado y BatchNorm usa estadísticas acumuladas) y sin tape de gradiente ni optimizador. Usa objetos Metric separados para val para que train y val no se mezclen. Envuelve test_step en @tf.function por velocidad. Reinicia todas las métricas tras registrar cada época. Para guardar el mejor modelo, compara val_acc.result() con el mejor acumulado y llama a model.save() cuando mejore.

tensorflow
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()

Bucle personalizado distribuido

Un bucle personalizado distribuido usa strategy.run para correr el paso por réplica en cada GPU y strategy.reduce para agregar la pérdida. Divide la pérdida por réplica entre num_replicas_in_sync para que el gradiente sumado coincida con el del lote global (de lo contrario el LR efectivo se escala por el número de GPUs). Aplica los gradientes normalmente — la estrategia maneja el all-reduce por debajo. El mismo patrón funciona para MultiWorkerMirroredStrategy y TPUStrategy.

tensorflow
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)

Bucle de entrenamiento GAN

Las GANs entrenan dos modelos en adversario: el generador intenta engañar al discriminador, el discriminador intenta detectar falsificaciones. Usa dos GradientTapes (uno por modelo) y dos optimizadores. beta_1=0.5 (menor que el por defecto) estabiliza el entrenamiento GAN. Entrena al discriminador y al generador en cada paso (o alterna proporciones). Las GANs son notoriamente inestables — monitorea d_loss y g_loss, usa normalización espectral y considera la Wasserstein GAN con penalización de gradiente si ocurre colapso de modos.

tensorflow
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_loss

Acumulación de gradientes

La acumulación de gradientes verdadera en TF es delicada porque GradientTape no soporta sumar grads entre llamadas fácilmente — tendrías que acumular grads en tf.Variables manualmente. La aproximación simple de arriba escala la pérdida y aplica gradientes en cada paso, lo que da un efecto similar para SGD pero no es idéntico para Adam (el optimizador ve gradientes menores y más ruidosos). Para acumulación exacta, acumula gradientes en variables persistentes y aplica cada N pasos. Es principalmente útil cuando la memoria de la GPU limita el tamaño del lote.

tensorflow
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)
20

Optimización de rendimiento

tf.function

@tf.function traza una función de Python en un grafo estático — más rápido en GPU y requerido para distribución. La primera llamada por firma de entrada traza (lenta); las siguientes reutilizan el grafo. Evita el flujo de control de Python que dependa de los VALORES de los tensores (if tensor > 0: ...) dentro de tf.function — fuerza re-trazado. Usa tf.cond / tf.while_loop o flujo de control de Python que dependa solo de formas/literales de Python. input_signature fija las formas para prevenir el re-trazado por completo. reduce_retracing=True amplía la caché.

tensorflow
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)

Compilación XLA

XLA (Accelerated Linear Algebra) compila subgrafos en kernels fusionados, reduciendo la sobrecarga de lanzamiento y habilitando optimizaciones entre operaciones. jit_compile=True sobre un tf.function dispara XLA para esa función. Es más efectiva para modelos intensivos en cómputo (transformers, atención) y menos útil para los limitados por I/O. XLA exige formas estáticas dentro de una región compilada — las formas variables causan recompilación. Si te topas con problemas de forma, rellena a formas fijas. Haz siempre benchmark: XLA puede ocasionalmente ser más lenta para modelos pequeños.

tensorflow
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 models

Optimización del pipeline de entrada

El cuello de botella del entrenamiento en GPU suele ser el pipeline de entrada, no el modelo. El pipeline canónico cachea tras cargar, baraja, mapea la aumentación en paralelo, agrupa en lotes y hace prefetch. interleave lee múltiples archivos TFRecord en paralelo para cargas limitadas por disco. drop_remainder=True evita un último lote de forma variable que fuerza re-trazado del grafo. Usa el Input Pipeline Analyzer del TF Profiler para hallar tu cuello de botella concreto. AUTOTUNE deja que TF elija automáticamente el paralelismo y los tamaños de prefetch.

tensorflow
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)

Precisión mixta y TF32

La precisión mixta (float16/bfloat16) da 2-3 veces de rendimiento en GPUs con Tensor Cores. TF32 es aún más fácil — es un formato de mantisa de 19 bits usado transparentemente para matmul en Ampere+ (A100, H100), dando ~3 veces de aceleración con pérdida mínima de exactitud y SIN cambios de código ni escalado de pérdida. Habilita ambos para máxima velocidad. TF32 está activado por defecto en CUDA 11+ pero TF expone el flag para control explícito. Para reproducibilidad estricta fp32 (computación científica), desactiva TF32.

tensorflow
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())

Optimización del grafo

Grappler es el optimizador de grafos de TF que corre automáticamente antes de ejecutar: plegado de constantes, optimización de layout (NCHW vs NHWC para cuDNN), fusión de ops (remapping), eliminación de código muerto y más. Cada una está activada por defecto — solo necesitas tocarlo para deshabilitar optimizaciones concretas al depurar. debug_stripper elimina Assert/CheckNumerics por velocidad de producción. El optimizador de layout elige automáticamente NCHW para las convs cuDNN en GPU incluso si tu modelo especifica NHWC.

tensorflow
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 ones

AutoGraph y flujo de control

AutoGraph convierte los if/for/while de Python dentro de tf.function en ops de grafo de TF (tf.cond / tf.while_loop) para que corran eficientemente en GPU. Los bucles sobre un tf.data.Dataset con 'for' de Python están bien — iteran en el momento del trazado. Evita if/for que dependa de los VALORES de los tensores (no de las formas) — eso fuerza re-trazado cada vez que el valor cambia. Para flujo de control en runtime sobre valores de tensores, usa tf.cond y tf.while_loop explícitamente o deja que AutoGraph lo maneje (lo hará, pero la conversión puede ser sutil).

tensorflow
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 retracing

Was this helpful?

Learning path

Learn from scratch

Learn this language from the ground up with structured lessons.