Curso TensorFlow

TensorFlow es una biblioteca de código abierto desarrollada por Google para realizar tareas de machine learning y deep learning.

Fue creada con el objetivo de facilitar la implementación de algoritmos de aprendizaje automático, especialmente redes neuronales, y proporcionar una plataforma robusta y escalable para construir modelos complejos.

Características principales de TensorFlow

1. Flexibilidad: Permite definir y entrenar modelos desde un nivel bajo (construyendo la red neuronal a mano con GradientTape) hasta un nivel alto (usando APIs como Keras para construir modelos rápidamente).
2. Escalabilidad: TensorFlow está diseñado para ser escalable, lo que permite que los modelos se entrenen y ejecuten en una variedad de dispositivos, desde CPUs y GPUs hasta TPUs y dispositivos móviles.
3. Ecosistema amplio: Incluye herramientas y librerías complementarias como TensorBoard para visualización, TensorFlow Lite para desplegar modelos en dispositivos móviles, TensorFlow.js para ejecutar modelos en navegadores web y TF Serving para producción.
4. Keras integrado: TensorFlow 2.x incorpora Keras como su API principal de alto nivel, ofreciendo tres formas de construir modelos: Sequential, Functional y Subclassing.
5. Eager execution: La ejecución inmediata permite evaluar operaciones al instante, facilitando la depuración y el desarrollo iterativo.

APIs de construcción de modelos

Modelo Sequential

El modelo Sequential es una pila lineal de capas, ideal para redes sencillas.

import tensorflow as tf

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

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

API Funcional

La API Funcional permite construir modelos con arquitecturas complejas, como múltiples entradas y salidas.

inputs = tf.keras.Input(shape=(784,))
x = tf.keras.layers.Dense(128, activation='relu')(inputs)
x = tf.keras.layers.Dropout(0.2)(x)
outputs = tf.keras.layers.Dense(10, activation='softmax')(x)

model = tf.keras.Model(inputs=inputs, outputs=outputs)

Subclassing

El subclassing ofrece control total sobre la arquitectura del modelo.

class MiModelo(tf.keras.Model):
    def __init__(self):
        super().__init__()
        self.dense1 = tf.keras.layers.Dense(128, activation='relu')
        self.dropout = tf.keras.layers.Dropout(0.2)
        self.dense2 = tf.keras.layers.Dense(10, activation='softmax')

    def call(self, inputs, training=False):
        x = self.dense1(inputs)
        x = self.dropout(x, training=training)
        return self.dense2(x)

Usos comunes de TensorFlow

• Clasificación de imágenes: Entrenar modelos de redes neuronales convolucionales (CNN) con transfer learning para tareas de visión por computador.
• Procesamiento de lenguaje natural (NLP): Implementar modelos para análisis de sentimientos, clasificación de texto y generación de lenguaje con Transformers.
• Series temporales: Utilizar redes recurrentes (LSTM, GRU) para predicción y forecasting.
• Generación de contenido: Utilizar redes generativas adversariales (GANs) y autoencoders para crear imágenes y datos sintéticos.
• Despliegue en producción: Servir modelos con TF Serving, TensorFlow Lite para móviles y TensorFlow.js para navegadores.

Pipeline de datos con tf.data

dataset = tf.data.Dataset.from_tensor_slices((features, labels))
dataset = dataset.shuffle(1000).batch(32).prefetch(tf.data.AUTOTUNE)

Callbacks para monitorizar el entrenamiento

callbacks = [
    tf.keras.callbacks.EarlyStopping(patience=5, restore_best_weights=True),
    tf.keras.callbacks.ModelCheckpoint('mejor_modelo.keras', save_best_only=True),
    tf.keras.callbacks.TensorBoard(log_dir='./logs')
]

model.fit(train_data, epochs=100, callbacks=callbacks, validation_split=0.2)

Transfer learning

base_model = tf.keras.applications.EfficientNetV2B0(
    weights='imagenet', include_top=False, input_shape=(224, 224, 3)
)
base_model.trainable = False

model = tf.keras.Sequential([
    base_model,
    tf.keras.layers.GlobalAveragePooling2D(),
    tf.keras.layers.Dense(128, activation='relu'),
    tf.keras.layers.Dense(num_classes, activation='softmax')
])

Recursos adicionales

• Documentación oficial: tensorflow.org
• Tutoriales oficiales: tensorflow.org/tutorials
• TensorBoard: tensorboard.dev