El Proyecto | Sobre nosotros | Contribuir | Donaciones | Licencia
HOME Mis cursos Finalizados
◄ Anterior
◄

Comparación de frameworks

Siguiente ►
►

En las dos lecciones anteriores construiste el mismo gradiente y la misma red MNIST en TensorFlow/Keras y en PyTorch, y comprobaste que llegan al mismo resultado. Ahora toca la pregunta que todo el mundo hace tarde o temprano —y que el equipo de TecnoMarket tiene apuntada en su pizarra—: ¿cuál elegir? Esta lección responde con honestidad: sin bandos, con criterios. Compararemos filosofía, curva de aprendizaje, depuración, ecosistemas y adopción real; pondremos el mismo mini-modelo lado a lado; presentaremos brevemente a los otros actores del panorama (JAX, Hugging Face, ONNX); y cerraremos con una guía de decisión práctica. Spoiler del final: la elección importa menos de lo que parece, porque lo valioso —los conceptos que llevas cinco módulos aprendiendo— es transferible.

Contenido

  1. Dos filosofías, un mismo objetivo
  2. Curva de aprendizaje y depuración
  3. Ecosistemas: qué rodea a cada framework
  4. Adopción: industria vs. investigación
  5. Rendimiento: el empate práctico
  6. Tabla comparativa detallada
  7. El mismo modelo, lado a lado
  8. Otros actores del panorama
  9. Guía de decisión: para ti y para TecnoMarket

Dos filosofías, un mismo objetivo

Si tuviéramos que resumir cada framework en una frase:

  • TensorFlow/Keras: "lo común debe ser trivial". Optimizado para el camino estándar: definir, compilar, entrenar, desplegar. Nació en Google (2015) pensando en producción a gran escala.
  • PyTorch: "todo debe ser visible". Optimizado para experimentar: cada paso del entrenamiento está en tu código, modificable. Nació en Meta (2017) pensando en investigación.

Ninguna filosofía es superior; responden a necesidades distintas. La analogía del curso: Keras es el electrodoméstico con programas predefinidos; PyTorch es la cocina profesional donde controlas cada fuego. En el 90 % de los platos el resultado es el mismo; en el 10 % experimental (una GAN con bucle a medida como la de 05-01, una pérdida exótica, un paper recién publicado), la cocina profesional se agradece — aunque Keras también permite bajar a ese nivel con GradientTape, como viste en 06-01, simplemente no es su camino por defecto.

Curva de aprendizaje y depuración

Curva de aprendizaje. Keras gana en las primeras horas: tu primera red de 02-05 fueron cinco líneas (Sequential, compile, fit). En PyTorch esa misma red exige entender nn.Module, DataLoader y el bucle de cinco pasos antes de ver un solo resultado. Pero la curva se cruza: el usuario de PyTorch entiende antes qué está pasando (porque lo escribió él), mientras que el de Keras puede tardar más en salir de la "magia" de fit(). Este curso siguió deliberadamente ese orden: primero productividad con Keras, después transparencia con PyTorch.

Depuración. Aquí PyTorch tiene ventaja estructural gracias al define-by-run: el forward pass es código Python normal, así que puedes poner print(x.shape) dentro de forward(), usar el depurador de tu IDE paso a paso, e inspeccionar cualquier tensor intermedio. En TensorFlow, el modo eager (el que usaste en 06-01) permite lo mismo, pero cuando Keras compila el modelo a grafo para acelerar (tf.function, que fit() aplica por defecto), los errores llegan envueltos en trazas largas y menos legibles. Traducción práctica: en Keras depuras sobre todo leyendo mensajes; en PyTorch depuras ejecutando línea a línea.

Ecosistemas: qué rodea a cada framework

Un framework no es solo su API: es todo lo que se ha construido alrededor.

El ecosistema TensorFlow: fuerte en despliegue

Pieza Para qué sirve
TFLite (LiteRT) Ejecutar modelos en móviles y dispositivos embebidos (Android, iOS, microcontroladores)
TF.js Ejecutar y entrenar modelos en el navegador, en JavaScript
TF Serving Servidor de modelos de alto rendimiento para producción
TFX Pipelines completos de ML en producción (validación de datos, entrenamiento, despliegue)
TensorBoard Visualización de entrenamientos (lo usarás en 06-04; también funciona con PyTorch)

El hilo común: llevar el modelo a donde está el usuario. Del despliegue hablaremos en detalle en 06-05.

El ecosistema PyTorch: fuerte en modelos y investigación

Pieza Para qué sirve
torchvision / torchaudio / torchtext Datasets, transformaciones y modelos preentrenados por dominio
transformers (Hugging Face) Miles de modelos preentrenados (BERT, GPT y familia — los de 05-05) listos para fine-tuning
PyTorch Lightning Estructura el bucle de entrenamiento explícito (recupera parte de la comodidad de fit())
TorchServe Servidor de modelos (equivalente a TF Serving)

El hilo común: acceso inmediato a lo último. Cuando sale un paper, su código suele estar en PyTorch; cuando sale un modelo de lenguaje abierto, está en Hugging Face. Nota importante: Hugging Face soporta también TensorFlow en muchos modelos, pero su ciudadano de primera clase es PyTorch.

Adopción: industria vs. investigación

Los datos gruesos, sin entrar en porcentajes que caducan:

  • Investigación: PyTorch domina con claridad desde ~2020. En las grandes conferencias (NeurIPS, ICML, CVPR), la inmensa mayoría de implementaciones publicadas son PyTorch. Si tu trabajo consiste en reproducir papers, PyTorch es casi obligatorio.
  • Industria: mucho más repartido. TensorFlow tiene una base instalada enorme (especialmente en empresas que montaron su infraestructura entre 2016 y 2020, y en móvil/edge gracias a TFLite), mientras PyTorch crece con fuerza empujado por el boom de los LLMs y Hugging Face.
  • Ofertas de empleo: la mayoría de puestos de deep learning citan ambos o "alguno de los dos". Saber los dos —como tú ahora— es la posición más cómoda.

Rendimiento: el empate práctico

¿Cuál entrena más rápido? Respuesta honesta: empate práctico. Ambos delegan el trabajo pesado en las mismas librerías de NVIDIA (cuDNN) para GPU; ambos compilan grafos para optimizar (TF con tf.function, PyTorch con torch.compile); y los benchmarks se alternan según modelo, hardware y versión. Las diferencias típicas (±10 %) son menores que el efecto de un buen pipeline de datos (el prefetch de 06-01) o un batch size adecuado. Conclusión: no elijas framework por velocidad; elige por equipo, ecosistema y destino del modelo.

Tabla comparativa detallada

Criterio TensorFlow / Keras PyTorch
Creador y año Google, 2015 Meta, 2017
Filosofía Alto nivel por defecto, producción Explícito por defecto, investigación
Definición del modelo Sequential / funcional / subclassing Subclassing (nn.Module) como norma
Bucle de entrenamiento fit() automático (GradientTape si quieres control) Siempre explícito (Lightning si quieres estructura)
Curva inicial Muy suave (5 líneas y entrenas) Más exigente (bucle de 5 pasos)
Depuración Buena en eager; trazas duras en modo grafo Excelente: Python puro, depurador estándar
Datos tf.data (map/shuffle/batch/prefetch) Dataset + DataLoader
Móvil / navegador TFLite, TF.js (madurísimos) ExecuTorch (más reciente)
Servir en producción TF Serving, TFX TorchServe, servidores genéricos (FastAPI)
Modelos preentrenados Keras Applications (MobileNetV2 de 05-03), TF Hub torchvision, Hugging Face (enorme)
Comunidad investigadora Minoritaria hoy Dominante
Base instalada en empresa Muy grande Grande y creciendo
Rendimiento Equivalente Equivalente
Lo que ya hiciste en el curso Módulos 2–5 completos y 06-01 06-02 (MNIST reescrita)

El mismo modelo, lado a lado

Los fragmentos ya los viste en 06-01 y 06-02; aquí van condensados para verlos de un vistazo. La red 784-128-64-10 de 02-05:

# ---------- KERAS ----------
from tensorflow import keras

model = keras.Sequential([
    keras.layers.Dense(128, activation="relu"),
    keras.layers.Dense(64, activation="relu"),
    keras.layers.Dense(10, activation="softmax"),
])
model.compile(optimizer="adam",
              loss="sparse_categorical_crossentropy",
              metrics=["accuracy"])
model.fit(x_train, y_train, epochs=5, batch_size=32)
# ---------- PYTORCH ----------
import torch
from torch import nn

class RedMNIST(nn.Module):
    def __init__(self):
        super().__init__()
        self.red = nn.Sequential(          # sí, PyTorch también tiene Sequential
            nn.Linear(784, 128), nn.ReLU(),
            nn.Linear(128, 64), nn.ReLU(),
            nn.Linear(64, 10))             # logits, sin softmax (ver 06-02)

    def forward(self, x):
        return self.red(x)

model = RedMNIST()
loss_fn = nn.CrossEntropyLoss()
optimizer = torch.optim.Adam(model.parameters(), lr=0.001)

for epoch in range(5):
    for x, y in train_loader:
        logits = model(x.view(x.size(0), -1))
        loss = loss_fn(logits, y)
        optimizer.zero_grad()
        loss.backward()
        optimizer.step()

Lectura del lado a lado:

  • La definición del modelo es casi un calco (fíjate en nn.Sequential: para pilas lineales, PyTorch también ofrece atajo).
  • La diferencia está en el entrenamiento: 3 líneas (compile + fit) contra ~10 (el bucle). Ese es, en esencia, todo el debate entre frameworks condensado en pantalla.
  • Y las dos diferencias "de detalle" que ya conoces: softmax en la salida (Keras) vs. logits crudos (PyTorch), y el flatten explícito.

Otros actores del panorama

El mundo no acaba en TF y PyTorch. Tres nombres que conviene ubicar:

Actor Qué es Cuándo te lo cruzarás
JAX Librería de Google: numpy + diferenciación automática + compilación XLA. Estilo funcional puro Investigación puntera y modelos gigantes; Keras 3 puede usarlo como backend
Hugging Face No compite: es una capa superior con miles de modelos preentrenados (transformers de 05-05) y datasets, sobre PyTorch (principalmente) y TF En cuanto quieras usar un BERT/GPT sin entrenarlo tú (lo harás en 07-05)
ONNX No es un framework: es un formato de intercambio de modelos. Exportas de PyTorch, ejecutas en cualquier runtime compatible Como puente entre frameworks y hacia producción; lo usaremos en 06-05

Mención final: Keras 3 es hoy multi-backend — el mismo código Keras puede ejecutarse sobre TensorFlow, JAX o incluso PyTorch. La frontera entre frameworks se difumina año a año, otro motivo para no obsesionarse con la elección.

Guía de decisión: para ti y para TecnoMarket

Preguntas que sí deciden (en orden de peso):

  1. ¿Qué usa tu equipo / tu empresa? El mejor framework es el que usan las personas que te van a ayudar y el código que vas a heredar.
  2. ¿Vas a partir de modelos preentrenados de investigación reciente (LLMs, difusión, lo último de Hugging Face)? → PyTorch te dará menos fricción.
  3. ¿El destino es móvil, navegador o edge? → El ecosistema TFLite/TF.js de TensorFlow sigue siendo el más maduro.
  4. ¿Priorizas prototipar rápido flujos estándar (clasificación, regresión, transfer learning como el de 05-03)? → Keras es difícil de batir.
  5. ¿Necesitas bucles de entrenamiento a medida (GANs como 05-01, pérdidas múltiples, investigación)? → El estilo explícito de PyTorch resulta más natural.

La decisión de TecnoMarket. El equipo de datos lo debate y decide:

  • Keras/TensorFlow como base de producción: sus sistemas actuales (clasificador de fotos con MobileNetV2 de 05-03, clasificador de reseñas de 04-03, predicción de demanda de 04-04) ya están escritos en Keras, funcionan, y el plan de llevar el clasificador de productos a la app móvil de los operarios de almacén encaja con TFLite.
  • PyTorch como herramienta de exploración: el proyecto de generación de descripciones e imágenes promocionales (módulo 7) partirá de modelos de Hugging Face, y ahí PyTorch es el camino corto.
  • Regla de equipo: todo modelo que pase a producción se valida contra el mismo conjunto de test congelado, sea cual sea el framework — y ONNX queda anotado como puente si algún día hay que mover un modelo de un mundo al otro (lo veremos en 06-05).

Es una decisión pragmática, no religiosa. Y es la misma que te recomendamos a ti: profundiza en uno, mantente funcional en el otro.

Errores Comunes y Consejos

  • Elegir por titulares ("X está muerto", "todo el mundo usa Y"): los dos frameworks tienen desarrollo activo, comunidades enormes y años de futuro. Decide por tu contexto, no por Twitter.
  • Cambiar de framework a mitad de proyecto: el coste de migrar (reescribir, revalidar, formar al equipo) casi nunca compensa una ventaja marginal. Termina con lo que empezaste; migra, si acaso, entre proyectos.
  • Aprender el framework en vez de los conceptos: quien entiende backprop (02-03), regularización (05-04) o atención (05-05) migra de framework en días; quien solo memorizó APIs empieza de cero. Invierte en conceptos.
  • Comparar rendimiento con benchmarks ajenos: si de verdad te importa la velocidad, mide tu modelo con tus datos en tu hardware. Los benchmarks genéricos no capturan tu caso.
  • Consejo: leer código del "otro" framework es un ejercicio buenísimo. Con las tablas de equivalencias de 06-02 puedes traducir mentalmente casi cualquier ejemplo, y eso duplica la documentación y los tutoriales a tu alcance.

Ejercicios

Ejercicio 1: traducción mental

Sin ejecutar nada, empareja cada elemento de Keras con su equivalente PyTorch: (a) model.fit(...), (b) Dense(64, activation="relu"), (c) tf.data.Dataset con shuffle().batch(), (d) model.evaluate(...), (e) compile(optimizer="adam", loss=...).

Ejercicio 2: recomendación razonada

Tres escenarios; para cada uno, recomienda framework y justifica en 2-3 líneas usando los criterios de la guía de decisión: (1) una startup quiere detectar defectos de fabricación con la cámara de una tablet Android en la propia fábrica, sin conexión; (2) un grupo universitario quiere modificar el mecanismo de atención de un transformer publicado el mes pasado; (3) TecnoMarket quiere un clasificador estándar de tickets de soporte en 2 semanas, con un equipo que solo ha hecho este curso.

Ejercicio 3: leer el otro idioma

Este fragmento PyTorch te llega en un paper. Descríbelo en "idioma Keras": ¿qué modelo es y cómo lo escribirías con Sequential?

class Net(nn.Module):
    def __init__(self):
        super().__init__()
        self.fc1 = nn.Linear(20, 8)
        self.drop = nn.Dropout(0.3)
        self.fc2 = nn.Linear(8, 1)

    def forward(self, x):
        x = torch.relu(self.fc1(x))
        x = self.drop(x)
        return self.fc2(x)

Soluciones

Solución 1:

  • (a) fit() → el bucle explícito completo: for epoch → forward → loss → zero_grad → backward → step.
  • (b) Dense(64, activation="relu") → nn.Linear(entrada, 64) seguido de nn.ReLU() (en PyTorch la entrada es explícita y la activación va aparte).
  • (c) tf.data con shuffle().batch() → DataLoader(dataset, batch_size=..., shuffle=True).
  • (d) evaluate() → bucle con model.eval() + torch.no_grad() calculando métricas a mano.
  • (e) compile(...) → crear torch.optim.Adam(model.parameters()) y la función de pérdida (nn.CrossEntropyLoss(), etc.) como objetos sueltos.

Solución 2:

  1. TensorFlow/Keras: destino edge/móvil sin conexión → TFLite es el ecosistema más maduro para Android (criterio 3). Entrenarían con Keras (probablemente transfer learning como en 05-03) y exportarían a TFLite.
  2. PyTorch: reproducir y modificar un paper reciente → el código publicado estará casi seguro en PyTorch (criterio 2), y el bucle explícito facilita tocar el interior del modelo (criterio 5).
  3. Keras: flujo estándar, plazo corto, equipo formado en este curso donde Keras es el idioma principal (criterios 1 y 4). TextVectorization + red densa como en 04-03 y a producción.

Solución 3: Es un MLP binario con dropout (como los de 05-04): entrada de 20 características, capa oculta de 8 con ReLU, dropout del 30 % y salida de 1 logit (la pérdida sería BCEWithLogitsLoss). En Keras:

model = keras.Sequential([
    keras.layers.Dense(8, activation="relu", input_shape=(20,)),
    keras.layers.Dropout(0.3),
    keras.layers.Dense(1, activation="sigmoid"),   # o sin sigmoide + from_logits=True
])

Único matiz: la versión Keras habitual pone sigmoid en la salida y usa BinaryCrossentropy normal; la equivalencia exacta con el fragmento PyTorch (logit crudo) sería sin activación final y from_logits=True.

Conclusión

Ya tienes la comparación completa: Keras/TensorFlow brilla en productividad y despliegue (TFLite, TF.js, TF Serving); PyTorch brilla en transparencia, depuración e investigación (Hugging Face, papers); el rendimiento es un empate práctico; y alrededor orbitan JAX, Hugging Face como capa superior y ONNX como formato puente. TecnoMarket eligió pragmáticamente: Keras para su producción existente, PyTorch para explorar modelos preentrenados, y validación común para todo. La lección de fondo es la que cierra el debate: los conceptos del curso —tensores, gradientes, capas, regularización, atención— son transferibles; el framework es una herramienta, y tú ya manejas las dos principales.

Antes de llevar nada a producción, falta profesionalizar el entorno donde trabajas: en la próxima lección saldremos del notebook —GPUs locales y en la nube, estructura de proyecto, reproducibilidad, control de versiones para ML y monitorización con TensorBoard— para que el trabajo del equipo de TecnoMarket deje de vivir en pestañas de Colab sueltas.

◄ Anterior
◄
Siguiente ►
►

Curso de Deep Learning

Módulo 1: Introducción a Deep Learning

Módulo 2: Fundamentos de Redes Neuronales

Módulo 3: Redes Neuronales Convolucionales (CNN)

Módulo 4: Redes Neuronales Recurrentes (RNN)

Módulo 5: Técnicas Avanzadas en Deep Learning

Módulo 6: Herramientas y Frameworks

Módulo 7: Proyectos Prácticos

Módulo 8: Consideraciones Éticas y Futuro del Deep Learning

El Proyecto | Sobre nosotros | Contribuir | Donaciones | Licencia
© Copyright 2026. Todos los derechos reservados