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.
# 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()) # TruePrimeros 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.
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.
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.
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.
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())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.
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 -> TypeErrortf.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.
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) # 2wOperaciones 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.
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.
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.
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.
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]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.
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 batchAPI 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.
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.
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.
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.
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].
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 imagesCapas
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.
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).
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.
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 * 2Dropout 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.
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).
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)) # 2Capa 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().
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)))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.
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.
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.
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.
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.
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.
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)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.
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.
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.
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.
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.
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.
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)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.
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.
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.
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.
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.
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 augSobrescribir 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.
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)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.
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.
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.
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.
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=./logsLearningRateScheduler
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.
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.
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()])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.
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)
breakMap, 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.
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.
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.
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.
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.
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)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.
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.
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/servingGuardar 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.
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.
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.
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.
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']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.
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.
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.
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.
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.
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.
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}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.
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.
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.
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.
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.
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.
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])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.
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.
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.
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.
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.
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.
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 xTensorBoard
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`.
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.
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.
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.
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.
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 recommendationsEntrenamiento 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.
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.
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).
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.
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.
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">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.
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.
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.
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.
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.
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)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.
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.
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.
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).
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.
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},
)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.
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.
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.
# 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.
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).
# 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 opsOptimizació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.
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 stepBucle 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.
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.
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.
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.
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_lossAcumulació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.
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)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é.
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.
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 modelsOptimizació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.
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.
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.
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 onesAutoGraph 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).
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 retracingFragmentos de TensorFlow relacionados
Copy-paste ready code for common tasks.
Tensor Basics
Create and operate on TensorFlow tensors.
Keras Model
Build models with Sequential and the functional API.
Layers
Use core layers and build a custom one.
Compile and Train
Compile, fit, and evaluate a Keras model.
Custom Training Loop
Step through batches with GradientTape.
Callbacks
Monitor and control training with callbacks.
Save and Load
Persist models in SavedModel and Keras formats.
Data Pipeline
Build efficient input pipelines with tf.data.
Was this helpful?