Formación corporativa en TensorFlow

Construir pipelines de datos eficientes es tan importante como el diseño del modelo. tf.data es la API de TensorFlow para crear y gestionar flujos de datos de alto rendimiento que alimentan el entrenamiento con mínima latencia.

¿Por qué importa el pipeline de datos?

En proyectos de deep learning reales, la lectura y preprocesado de datos puede convertirse en el cuello de botella del entrenamiento: si la GPU espera datos, se desperdicia potencia de cómputo. tf.data resuelve esto con operaciones asíncronas, caché en memoria y prefetch automático.

Fuentes de datos soportadas

• Imágenes: tf.keras.utils.image_dataset_from_directory detecta clases por subdirectorio.
• CSV y texto: tf.data.experimental.CsvDataset y TextLineDataset para datos tabulares y NLP.
• TFRecord: formato binario eficiente para grandes datasets que no caben en memoria.
• NumPy y tensores: tf.data.Dataset.from_tensor_slices para datos ya cargados en RAM.

Transformaciones clave

TensorFlow ofrece varias formas de construir redes neuronales, pero Keras se ha convertido en la API estándar y recomendada para el desarrollo de estos modelos debido a su simplicidad y flexibilidad. Keras está integrado directamente en TensorFlow desde la versión 2.0, proporcionando una interfaz de alto nivel que facilita la creación, entrenamiento y evaluación de modelos de aprendizaje profundo.

Keras sigue una filosofía de diseño centrada en la experiencia del desarrollador, siendo intuitivo, modular y extensible. Esto permite construir redes neuronales complejas con pocas líneas de código, manteniendo al mismo tiempo la potencia y flexibilidad de TensorFlow como motor de cómputo subyacente.

La estructura fundamental de cualquier red neuronal en Keras se compone de capas que procesan tensores de entrada y producen tensores de salida. Estas capas encapsulan tanto los parámetros entrenables (pesos y sesgos) como las operaciones que transforman los datos.

import tensorflow as tf
from tensorflow import keras
from tensorflow.keras import layers

## Verificamos la versión de Keras que estamos utilizando
print(f"Versión de TensorFlow: {tf.__version__}")
print(f"Versión de Keras: {keras.__version__}")

En Keras existen dos formas principales de construir modelos: la API Secuencial y la API Funcional. La primera es más sencilla y adecuada para redes con una sola entrada y una sola salida, donde las capas se conectan secuencialmente. La segunda ofrece mayor flexibilidad para crear arquitecturas complejas con múltiples entradas, salidas o conexiones no lineales.

Veamos primero cómo construir un modelo secuencial básico:

## Modelo secuencial para clasificación de imágenes
modelo = keras.Sequential([
    layers.Conv2D(32, (3, 3), activation='relu', input_shape=(28, 28, 1)),
    layers.MaxPooling2D((2, 2)),
    layers.Conv2D(64, (3, 3), activation='relu'),
    layers.MaxPooling2D((2, 2)),
    layers.Flatten(),
    layers.Dense(128, activation='relu'),
    layers.Dropout(0.5),
    layers.Dense(10, activation='softmax')
])

Este ejemplo ilustra una arquitectura convolucional típica para clasificación de imágenes, donde las capas convolutivas extraen características, las capas de pooling reducen la dimensionalidad, y las capas densas realizan la clasificación final.

Para modelos con estructuras más complejas, la API Funcional proporciona mayor flexibilidad:

## Modelo funcional con múltiples entradas
entrada_texto = keras.Input(shape=(100,))
entrada_imagen = keras.Input(shape=(28, 28, 3))

## Procesar texto
x1 = layers.Embedding(20000, 128)(entrada_texto)
x1 = layers.LSTM(32)(x1)

## Procesar imagen
x2 = layers.Conv2D(32, (3, 3))(entrada_imagen)
x2 = layers.MaxPooling2D((2, 2))(x2)
x2 = layers.Flatten()(x2)

## Combinar ambas entradas
combinado = layers.concatenate([x1, x2])
salida = layers.Dense(1, activation='sigmoid')(combinado)

## Crear el modelo especificando entradas y salidas
modelo = keras.Model(inputs=[entrada_texto, entrada_imagen], outputs=salida)

Las capas son los bloques fundamentales de cualquier red neuronal en Keras. TensorFlow ofrece una amplia variedad de capas predefinidas:

• Capas básicas: Dense (completamente conectada), Dropout, Activation
• Capas convolucionales: Conv1D, Conv2D, Conv3D, SeparableConv2D
• Capas de pooling: MaxPooling2D, AveragePooling2D, GlobalMaxPooling2D
• Capas recurrentes: SimpleRNN, LSTM, GRU, Bidirectional
• Capas de normalización: BatchNormalization, LayerNormalization
• Capas de regularización: Dropout, ActivityRegularization, SpatialDropout
• Capas de atención: Attention, MultiHeadAttention
• Capas para procesamiento de secuencias: Embedding, TimeDistributed
• Capas para operaciones de fusión: Add, Concatenate, Multiply, Average

La compilación del modelo es un paso crucial antes de iniciar el entrenamiento. Aquí definimos el optimizador, la función de pérdida y las métricas que evaluarán el rendimiento:

modelo.compile(
    optimizer=keras.optimizers.Adam(learning_rate=0.001),
    loss=keras.losses.SparseCategoricalCrossentropy(),
    metrics=['accuracy']
)

TensorFlow ofrece varios optimizadores como SGD, Adam, RMSprop o Adagrad, cada uno con sus propias características y casos de uso recomendados. Igualmente, podemos elegir entre diversas funciones de pérdida según el tipo de problema, como BinaryCrossentropy para clasificación binaria, MeanSquaredError para regresión o KLDivergence para distribuciones probabilísticas.

Una vez compilado el modelo, podemos entrenarlo con el método fit():

## Supongamos que x_train e y_train son nuestros datos de entrenamiento
history = modelo.fit(
    x_train, y_train,
    epochs=10,
    batch_size=64,
    validation_split=0.2,
    callbacks=[
        keras.callbacks.EarlyStopping(patience=3, restore_best_weights=True),
        keras.callbacks.ModelCheckpoint('mejor_modelo.keras', save_best_only=True),
        keras.callbacks.TensorBoard(log_dir='./logs')
    ]
)

Los callbacks son funciones que se ejecutan en determinados momentos durante el entrenamiento y permiten automatizar tareas como detener el entrenamiento cuando no hay mejora (EarlyStopping), guardar el mejor modelo (ModelCheckpoint) o registrar métricas para su visualización posterior (TensorBoard).

El objeto history devuelto por fit() contiene información valiosa sobre el proceso de entrenamiento:

import matplotlib.pyplot as plt

## Visualizar la evolución del entrenamiento
plt.figure(figsize=(12, 4))

plt.subplot(1, 2, 1)
plt.plot(history.history['loss'], label='Pérdida entrenamiento')
plt.plot(history.history['val_loss'], label='Pérdida validación')
plt.title('Evolución de la pérdida')
plt.legend()

plt.subplot(1, 2, 2)
plt.plot(history.history['accuracy'], label='Precisión entrenamiento')
plt.plot(history.history['val_accuracy'], label='Precisión validación')
plt.title('Evolución de la precisión')
plt.legend()

plt.tight_layout()
plt.show()

Una vez entrenado, podemos evaluar el rendimiento del modelo en un conjunto de datos de prueba:

resultados = modelo.evaluate(x_test, y_test, verbose=1)
print(f"Pérdida en test: {resultados[0]:.4f}")
print(f"Precisión en test: {resultados[1]:.4f}")

Y realizar predicciones con nuevos datos:

predicciones = modelo.predict(nuevos_datos)

Las arquitecturas de redes neuronales son muy diversas y se adaptan a diferentes tipos de problemas. Algunas arquitecturas fundamentales incluyen:

1. Redes fully-connected (MLP): Para datos tabulares y problemas sencillos
2. Redes convolucionales (CNN): Para procesar datos con estructura de rejilla como imágenes
3. Redes recurrentes (RNN, LSTM, GRU): Para secuencias y datos temporales
4. Redes con atención: Para capturar dependencias a larga distancia en secuencias
5. Autoencoders: Para reducción de dimensionalidad y aprendizaje no supervisado
6. Redes generativas adversarias (GAN): Para generar nuevos datos similares a los de entrenamiento

Keras facilita la implementación de estas arquitecturas mediante sus capas predefinidas. Por ejemplo, una red neuronal recurrente para procesamiento de texto:

modelo = keras.Sequential([
    layers.Embedding(input_dim=10000, output_dim=128, input_length=100),
    layers.Bidirectional(layers.LSTM(64, return_sequences=True)),
    layers.Bidirectional(layers.LSTM(32)),
    layers.Dense(64, activation='relu'),
    layers.Dropout(0.5),
    layers.Dense(1, activation='sigmoid')
])

Una característica poderosa de Keras es la capacidad de crear capas personalizadas para implementar funcionalidades específicas:

class CapaPersonalizada(layers.Layer):
    def __init__(self, unidades=32, **kwargs):
        super(CapaPersonalizada, self).__init__(**kwargs)
        self.unidades = unidades
    
    def build(self, input_shape):
        self.w = self.add_weight(
            shape=(input_shape[-1], self.unidades),
            initializer='random_normal',
            trainable=True,
            name='pesos'
        )
        self.b = self.add_weight(
            shape=(self.unidades,),
            initializer='zeros',
            trainable=True,
            name='sesgo'
        )
    
    def call(self, inputs):
        return tf.matmul(inputs, self.w) + self.b
    
    def get_config(self):
        config = super(CapaPersonalizada, self).get_config()
        config.update({'unidades': self.unidades})
        return config

Además de las capas personalizadas, podemos crear funciones de pérdida y métricas personalizadas para problemas específicos:

## Función de pérdida personalizada
def focal_loss(gamma=2.0, alpha=0.25):
    def focal_loss_fn(y_true, y_pred):
        pt_1 = tf.where(tf.equal(y_true, 1), y_pred, tf.ones_like(y_pred))
        pt_0 = tf.where(tf.equal(y_true, 0), y_pred, tf.zeros_like(y_pred))
        
        pt_1 = tf.clip_by_value(pt_1, 1e-9, 1.0)
        pt_0 = tf.clip_by_value(pt_0, 1e-9, 1.0)
        
        return -tf.reduce_sum(alpha * tf.pow(1. - pt_1, gamma) * tf.math.log(pt_1)) - \
               tf.reduce_sum((1-alpha) * tf.pow(pt_0, gamma) * tf.math.log(1. - pt_0))
    
    return focal_loss_fn

## Métrica personalizada
class F1Score(keras.metrics.Metric):
    def __init__(self, name='f1_score', **kwargs):
        super(F1Score, self).__init__(name=name, **kwargs)
        self.precisión = keras.metrics.Precisión()
        self.recall = keras.metrics.Recall()
    
    def update_state(self, y_true, y_pred, sample_weight=None):
        self.precisión.update_state(y_true, y_pred, sample_weight)
        self.recall.update_state(y_true, y_pred, sample_weight)
    
    def result(self):
        p = self.precisión.result()
        r = self.recall.result()
        return (2 * p * r) / (p + r + keras.backend.epsilon())
    
    def reset_state(self):
        self.precisión.reset_st

El proceso de entrenamiento y evaluación representa el núcleo del desarrollo de modelos de aprendizaje profundo. En esta sección exploraremos en detalle cómo configurar, ejecutar y supervisar el entrenamiento de redes neuronales en TensorFlow, así como las técnicas más efectivas para evaluar su rendimiento.

TensorFlow proporciona herramientas robustas para implementar ciclos de entrenamiento, desde opciones de alto nivel hasta mecanismos personalizados que permiten un control granular sobre cada aspecto del proceso. Dominar estos conceptos es esencial para desarrollar modelos que no solo aprendan efectivamente sino que también generalicen bien a datos no vistos.

El ciclo de entrenamiento en TensorFlow

El entrenamiento de modelos en TensorFlow puede implementarse mediante dos enfoques principales: utilizando la API de alto nivel con model.fit() o creando bucles de entrenamiento personalizados con tf.GradientTape().

Entrenamiento con model.fit()

El método fit() proporciona una interfaz simplificada que maneja automáticamente la propagación hacia adelante, el cálculo de la pérdida y la retropropagación:

model = tf.keras.Sequential([
    tf.keras.layers.Dense(128, activation='relu', input_shape=(784,)),
    tf.keras.layers.Dense(64, activation='relu'),
    tf.keras.layers.Dense(10, activation='softmax')
])

model.compile(
    optimizer='adam',
    loss='sparse_categorical_crossentropy',
    metrics=['accuracy']
)

history = model.fit(
    x_train, y_train,
    epochs=10,
    batch_size=32,
    validation_data=(x_val, y_val),
    verbose=1
)

Este método ofrece parámetros adicionales para personalizar el proceso:

• shuffle: Controla si los datos se mezclan antes de cada época
• callbacks: Lista de callbacks para monitorear y modificar el entrenamiento
• class_weight: Diccionario para asignar pesos a clases desequilibradas
• sample_weight: Pesos por muestra para priorizar ciertos ejemplos

Bucles de entrenamiento personalizados

Para casos que requieren mayor flexibilidad, podemos implementar bucles de entrenamiento utilizando tf.GradientTape():

## Definir modelo, optimizador y función de pérdida
model = tf.keras.Sequential([
    tf.keras.layers.Dense(128, activation='relu', input_shape=(784,)),
    tf.keras.layers.Dense(10, activation='softmax')
])

optimizer = tf.keras.optimizers.Adam(learning_rate=0.001)
loss_fn = tf.keras.losses.SparseCategoricalCrossentropy()

## Métricas para seguimiento
train_accuracy = tf.keras.metrics.SparseCategoricalAccuracy()
val_accuracy = tf.keras.metrics.SparseCategoricalAccuracy()

## Preparación de datasets
train_dataset = tf.data.Dataset.from_tensor_slices((x_train, y_train)).batch(32)
val_dataset = tf.data.Dataset.from_tensor_slices((x_val, y_val)).batch(32)

## Bucle de entrenamiento
for epoch in range(5):
    # Reiniciar métricas
    train_accuracy.reset_states()
    
    # Ciclo de entrenamiento
    for x_batch, y_batch in train_dataset:
        with tf.GradientTape() as tape:
            # Propagación hacia adelante
            predictions = model(x_batch, training=True)
            # Cálculo de pérdida
            loss = loss_fn(y_batch, predictions)
        
        # Cálculo y aplicación de gradientes
        gradients = tape.gradient(loss, model.trainable_variables)
        optimizer.apply_gradients(zip(gradients, model.trainable_variables))
        
        # Actualizar métricas
        train_accuracy.update_state(y_batch, predictions)
    
    # Validación
    val_accuracy.reset_states()
    for x_batch, y_batch in val_dataset:
        predictions = model(x_batch, training=False)
        val_accuracy.update_state(y_batch, predictions)
    
    print(f"Epoch {epoch+1}: "
          f"Precisión entrenamiento: {train_accuracy.result().numpy():.4f}, "
          f"Precisión validación: {val_accuracy.result().numpy():.4f}")

Este enfoque permite:

• Implementar lógicas personalizadas durante el entrenamiento
• Modificar gradientes antes de aplicarlos
• Calcular métricas intermedias
• Implementar técnicas avanzadas como aprendizaje por currículum

Optimizadores

Los optimizadores determinan cómo se actualizan los pesos del modelo durante el entrenamiento en función de los gradientes calculados.

Tipos de optimizadores

TensorFlow ofrece varios optimizadores con características específicas:

• SGD (Stochastic Gradient Descent): El optimizador clásico que puede incorporar momentum para acelerar la convergencia.

optimizer = tf.keras.optimizers.SGD(
    learning_rate=0.01,
    momentum=0.9,
    nesterov=True
)

• Adam: Combina ideas de AdaGrad y RMSProp, adaptando las tasas de aprendizaje por parámetro y utilizando estimaciones del primer y segundo momento.

optimizer = tf.keras.optimizers.Adam(
    learning_rate=0.001,
    beta_1=0.9,    # Coeficiente de decaimiento para primer momento
    beta_2=0.999,  # Coeficiente de decaimiento para segundo momento
    epsilon=1e-07  # Constante para estabilidad numérica
)

• RMSProp: Adapta las tasas de aprendizaje dividiendo por una media móvil de gradientes al cuadrado.

optimizer = tf.keras.optimizers.RMSprop(
    learning_rate=0.001,
    rho=0.9,       # Factor de decaimiento
    momentum=0.0,
    epsilon=1e-07
)

Programación de tasas de aprendizaje

La modificación de la tasa de aprendizaje durante el entrenamiento puede mejorar significativamente el rendimiento:

## Reducción al estancarse
reduce_lr = tf.keras.callbacks.ReduceLROnPlateau(
    monitor='val_loss',
    factor=0.2,     # Factor de reducción
    patience=5,     # Épocas de espera antes de reducir
    min_lr=0.0001   # Tasa mínima
)

## Programación escalonada
lr_schedule = tf.keras.optimizers.schedules.PiecewiseConstantDecay(
    boundaries=[100, 200, 300],
    values=[1.0, 0.1, 0.01, 0.001]
)
optimizer = tf.keras.optimizers.Adam(learning_rate=lr_schedule)

## Decaimiento exponencial
lr_schedule = tf.keras.optimizers.schedules.ExponentialDecay(
    initial_learning_rate=0.1,
    decay_steps=10000,
    decay_rate=0.9,
    staircase=True   # Si True, produce decrementos escalonados
)
optimizer = tf.keras.optimizers.SGD(learning_rate=lr_schedule)

Funciones de pérdida

Las funciones de pérdida cuantifican la diferencia entre las predicciones del modelo y los valores reales, estableciendo el objetivo que el optimizador intentará minimizar.

Pérdidas para clasificación

• Binary Crossentropy: Para problemas de clasificación binaria.

loss = tf.keras.losses.BinaryCrossentropy(from_logits=False)

• Categorical Crossentropy: Para clasificación multiclase con etiquetas one-hot.

loss = tf.keras.losses.CategoricalCrossentropy(from_logits=False)

• Sparse Categorical Crossentropy: Para clasificación multiclase con etiquetas enteras.

loss = tf.keras.losses.SparseCategoricalCrossentropy(from_logits=False)

Pérdidas para regresión

• Mean Squared Error (MSE): Penaliza errores grandes cuadráticamente.

loss = tf.keras.losses.MeanSquaredError()

• Mean Absolute Error (MAE): Menos sensible a valores atípicos.

loss = tf.keras.losses.MeanAbsoluteError()

• Huber Loss: Combina MSE y MAE para mayor robustez.

loss = tf.keras.losses.Huber(delta=1.0)  # Delta controla la transición entre regímenes

Funciones de pérdida personalizadas

Para necesidades específicas, podemos implementar pérdidas personalizadas:

def focal_loss(gamma=2.0, alpha=0.25):
    """
    Implementa la pérdida focal que da mayor peso a ejemplos difíciles.
    Útil para clasificación con clases desequilibradas.
    
    Args:
        gamma: Factor de enfoque (higher -> más enfoque en ejemplos difíciles)
        alpha: Factor de balanceo para clases
    """
    def loss_function(y_true, y_pred):
        y_pred = tf.convert_to_tensor(y_pred)
        y_true = tf.cast(y_true, y_pred.dtype)
        
        # Calcular pérdida focal
        ce = tf.keras.backend.binary_crossentropy(y_true, y_pred)
        p_t = (y_true * y_pred) + ((1 - y_true) * (1 - y_pred))
        alpha_factor = y_true * alpha + (1 - y_true) * (1 - alpha)
        modulating_factor = tf.pow(1.0 - p_t, gamma)
        
        return tf.reduce_mean(alpha_factor * modulating_factor * ce)
    
    return loss_function

## Uso
model.compile(
    optimizer='adam',
    loss=focal_loss(gamma=2.0, alpha=0.25),
    metrics=['accuracy']
)

Las Redes Neuronales Convolucionales (CNN) son la arquitectura dominante en visión por computador. Aprenden a extraer características espaciales jerárquicas de las imágenes: bordes y texturas en las primeras capas, formas y patrones complejos en las capas más profundas.

Componentes de una CNN

• Conv2D: aplica filtros convolucionales para detectar características locales.
• MaxPooling2D: reduce la dimensión espacial conservando las activaciones máximas.
• BatchNormalization: estabiliza y acelera el entrenamiento normalizando las activaciones.
• GlobalAveragePooling2D: reduce la salida convolucional a un vector promediando espacialmente.
• Dropout: regularización que desactiva neuronas aleatoriamente para evitar sobreajuste.

Data augmentation

La augmentación de datos genera variaciones sintéticas de las imágenes durante el entrenamiento: volteos, rotaciones, zoom, cambios de brillo y contraste. Esto amplía efectivamente el tamaño del dataset y mejora la generalización del modelo.

Transfer learning y fine-tuning

Entrenar una CNN desde cero requiere grandes cantidades de datos. Transfer learning permite aprovechar modelos preentrenados en ImageNet (EfficientNetV2, MobileNetV3, ResNet50V2) como extractores de características, añadiendo solo una nueva cabeza de clasificación. El fine-tuning desbloquea gradualmente capas para adaptar el modelo al dominio específico.

Las Redes Neuronales Recurrentes (RNN) y sus variantes modernas (LSTM, GRU) procesan datos secuenciales manteniendo un estado interno que captura el contexto temporal. Son fundamentales para tareas de Procesamiento de Lenguaje Natural (NLP), series temporales y cualquier dato donde el orden importa.

Por qué LSTM y GRU

Las RNN simples sufren el problema del gradiente que desaparece o explota con secuencias largas. Las LSTM (Long Short-Term Memory) resuelven esto mediante tres puertas de control (olvido, entrada, salida) que regulan el flujo de información. Las GRU son una versión simplificada con dos puertas, más eficiente computacionalmente.

Pipeline de NLP en TensorFlow

1. TextVectorization: tokeniza y convierte texto a índices enteros. El método adapt() construye el vocabulario a partir del corpus.
2. Embedding: transforma índices en vectores densos de dimensión reducida que capturan similitudes semánticas.
3. LSTM/GRU bidireccional: procesa la secuencia en ambas direcciones para capturar contexto global.
4. Dense + softmax/sigmoid: clasificación final.

Generación de texto

Los modelos de lenguaje a nivel de carácter aprenden a predecir el siguiente carácter dado el contexto previo. El parámetro de temperatura controla la creatividad de las muestras generadas: valores bajos producen texto más predecible, valores altos generan texto más variado y creativo.

Las arquitecturas avanzadas de deep learning amplían las capacidades de las redes densas y convolucionales estándar, abordando problemas de mayor complejidad como la generación de contenido, la detección de anomalías y el modelado de dependencias de largo alcance.

Transformers y atención

Los Transformers han revolucionado tanto NLP como visión por computador. La capa MultiHeadAttention de Keras permite construir bloques Transformer que capturan relaciones entre todos los elementos de una secuencia simultáneamente, sin recurrencia. Son la base de modelos como BERT, GPT y Visión Transformer (ViT).

Autoencoders y VAE

Los autoencoders aprenden a comprimir datos en un espacio latente de menor dimensión y a reconstruirlos. Son útiles para detección de anomalías: muestras que el modelo no sabe reconstruir bien son probablemente anómalas. Los autoencoders variacionales (VAE) aprenden distribuciones probabilísticas en el espacio latente, lo que permite generar nuevas muestras realistas.

GANs (Redes Generativas Adversariales)

Las GANs entrenan simultáneamente un generador (crea muestras sintéticas) y un discriminador (distingue muestras reales de sintéticas). El equilibrio adversarial produce generadores capaces de crear imágenes, audio o datos tabulares de alta calidad. El principal reto es el mode collapse, donde el generador produce poca variedad.

El entrenamiento personalizado en TensorFlow te da control total sobre cada paso del ciclo de aprendizaje, más allá de las abstracciones de alto nivel de model.fit(). Esto es esencial para investigación, algoritmos no estándar y requisitos específicos de producción.

tf.GradientTape

tf.GradientTape registra las operaciones dentro de su contexto para calcular gradientes automáticamente. El patrón básico es:

1. Forward pass dentro del bloque with tf.GradientTape() as tape.
2. Calcular la pérdida.
3. tape.gradient(loss, variables) para obtener los gradientes.
4. optimizer.apply_gradients(zip(gradients, variables)) para actualizar los pesos.

Capas y métricas personalizadas

Subclasear tf.keras.layers.Layer permite crear capas con lógica arbitraria: el método build() inicializa los parámetros y call() implementa el paso hacia delante. Subclasear tf.keras.metrics.Metric permite definir métricas de evaluación no estándar como F1-Score o MCC.

Entrenamiento distribuido

tf.distribute.MirroredStrategy replica el modelo en múltiples GPUs del mismo equipo con sincronización de gradientes por AllReduce. MultiWorkerMirroredStrategy escala a múltiples máquinas. Al escalar, el batch size global debe crecer proporcionalmente al número de GPUs, y suele ser necesario ajustar la tasa de aprendizaje en consecuencia.

Desplegar modelos de deep learning en producción requiere optimizar para tamaño, velocidad y compatibilidad con el entorno de destino. TensorFlow ofrece un ecosistema completo de herramientas para cada caso de uso.

Formatos de guardado

El formato SavedModel es el estándar para producción: guarda arquitectura, pesos y funciones computacionales en un directorio portable. El formato .keras es el recomendado para uso general durante el desarrollo.

TensorFlow Lite

TFLite es el runtime optimizado para dispositivos móviles, IoT y edge. La cuantización reduce el modelo de float32 a int8 o float16, disminuyendo el tamaño ~75% y acelerando la inferencia 3-4× en hardware compatible. La cuantización full int8 requiere datos de calibración para determinar los rangos de activación.

TensorFlow Serving

TF Serving es un servidor de producción con API REST y gRPC que gestiona automáticamente el versionado de modelos. Se despliega fácilmente con Docker y es la solución estándar para inferencia a escala en la nube.