Machine & Deep Learning

Python TensorFlow Keras: los 9 pasos clave para pasar de cero a operativo

Python TensorFlow Keras: lo esencial en un artículo — código real, diagramas y pasos concretos, extractos de un curso de 34 lecciones.

REHOUMA Haythem

12 Jun 2026 • 12 min read

Todo el mundo puede aprender Python TensorFlow Keras — siempre que siga los pasos en el orden correcto. Hemos condensado un curso completo de 34 lecciones en un recorrido claro, con los extractos de código más útiles.

tl;dr

Introducción e instalación
Bases de TensorFlow
Keras Sequential API
Red densa MLP
Redes neuronales convolucionales

~$ cat ./parcours.md # Python TensorFlow Keras — 10 capítulos

Introducción e instalación

→ ¿Qué es el deep learning ?→ Instalar TensorFlow 2.x+ 1 más lecciones

Fundamentos de TensorFlow

→ Tensores y operaciones→ GradientTape y autodiff+ 1 más lecciones

Keras Sequential API

→ Sequential — apilar capas→ Compilar — optimizer, loss, metrics+ 1 más lecciones

Red densa MLP

→ Arquitectura MLP (Multi-Layer Perceptron)→ Clasificación MNIST con MLP+ 1 más lecciones

Convolutional Neural Networks

→ Convoluciones y pooling→ CNN en CIFAR-10+ 2 más lecciones

Redes recurrentes y NLP

→ RNN, LSTM, GRU→ Embeddings para el texto+ 2 más lecciones

Transfer learning

→ Por qué y cuándo usar el transfer learning→ Fine-tuning MobileNet+ 1 más lecciones

Tuning y optimización

→ Optimizers SGD, Adam, RMSprop→ Learning rate scheduling+ 2 más lecciones

🏁

Proyecto final (+ 2 capítulos en el camino)

→ Te vas con un proyecto concreto y demostrable

Por qué y cuándo usar el transfer learning

NOTEObjetivo — Comprender cómo reutilizar modelos preentrenados en ImageNet para tus propias tareas.

La idea

En lugar de entrenar un modelo from scratch (cuesta días y requiere millones de imágenes), tomamos un modelo ya entrenado en ImageNet (1,4 M de imágenes, 1000 clases) y lo adaptamos.

¿Por qué funciona?

TIPResultado mágico — Alcanzar un 95 % de accuracy con 1000 imágenes personalizadas en lugar del 70 % from scratch.

2 estrategias principales

Estrategia	Cuándo	Cómo
Feature extraction	Dataset pequeño (<1000)	Congelar la base, entrenar una cabeza
Fine-tuning	Dataset medio (1k-10k)	Descongelar las últimas capas

Modelos preentrenados populares

Modelo	Dominio	Tamaño
MobileNetV2 / V3	Imágenes, móvil	3-5 MB
EfficientNet B0-B7	Imágenes, máxima precisión	20-200 MB
ResNet50 / 152	Imágenes, clásico	100-200 MB
VGG16 / 19	Imágenes, vintage	500 MB+
BERT	NLP	400 MB
DistilBERT	NLP rápido	250 MB

Cargar un modelo preentrenado

output

from tensorflow.keras.applications import MobileNetV2

base = MobileNetV2(
    input_shape=(224, 224, 3),
    include_top=False,    # eliminar la cabeza ImageNet
    weights="imagenet"
)
base.trainable = False     # congelar los pesos

print(base.summary())

Construir el nuevo modelo

output

from tensorflow.keras import models, layers

n_classes = 5   # tus clases

model = models.Sequential([
    layers.Input(shape=(224, 224, 3)),
    
    # Preprocesamiento específico del modelo
    tf.keras.applications.mobilenet_v2.preprocess_input,
    
    # Base congelada
    base,
    
    # Nueva cabeza
    layers.GlobalAveragePooling2D(),
    layers.Dropout(0.3),
    layers.Dense(n_classes, activation="softmax")
])

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

Preprocesamiento por modelo

MobileNet	`preprocess_input` : [-1, 1]
ResNet	Media de ImageNet restada
EfficientNet	`preprocess_input` : [0, 255]

WARNINGSiempre aplica el preprocesamiento del modelo original. Sin ello, el rendimiento será malo.

Cuándo usar el transfer learning

SÍ

NO

Resumen

NOTEPara recordar

Transfer learning = reutilizar un modelo preentrenado
Feature extraction si hay pocos datos
Fine-tuning si el dataset es medio
Siempre aplicar el preprocesamiento del modelo
tf.keras.applications = modelos listos

Próximo paso : Parte 2 — Fine-tuning de MobileNet

¿Qué es el deep learning?

NOTEObjetivo — Comprender qué distingue al deep learning del ML clásico y cuándo utilizarlo.

Definición

El deep learning es una subrama del machine learning que utiliza redes neuronales profundas (varias capas ocultas) para aprender representaciones jerárquicas de los datos.

ML clásico vs Deep Learning

Aspecto	ML clásico	Deep Learning
Datos	Cientos a miles	Miles a millones
Features	Manuales (ingeniería)	Aprendidas automáticamente
Hardware	CPU suficiente	GPU/TPU recomendado
Tiempo de entrenamiento	Segundos a minutos	Horas a días
Interpretabilidad	Buena	Baja (caja negra)
Casos de uso	Tabular	Imágenes, audio, texto

Una neurona artificial

output

# Salida = activación(suma(pesos * entradas) + sesgo)
y = activation(w1*x1 + w2*x2 + ... + w_n*x_n + b)

Varios neuronas en paralelo = capa. Varias capas = red profunda.

Anatomía de una red densa

output

Input (28x28=784)
   |
   v
Capa oculta 1 (128 neuronas, ReLU)
   |
   v
Capa oculta 2 (64 neuronas, ReLU)
   |
   v
Capa de salida (10 neuronas, Softmax)
   |
   v
Probabilidades de las 10 clases

Arquitecturas principales

MLP (Dense)

Tabular, clasificación simple. Base del DL.

CNN (Convolutional)

Imágenes. Detecta patrones locales mediante convoluciones.

RNN / LSTM / GRU

Secuencias: texto, audio, series temporales.

Transformers

NLP moderno (BERT, GPT). Mecanismo de atención.

¿Cuándo usar DL?

TIPBuenos casos

Imágenes, audio, vídeo, texto
Muchos datos (10k+ ejemplos)
Búsqueda de máximo rendimiento
Patrones complejos no lineales

WARNINGMalos casos

Datos tabulares < 10k filas (prefiere GBM)
Interpretabilidad crítica
No hay GPU disponible
Problema simple linealmente separable

TensorFlow vs PyTorch

TensorFlow / Keras	Listo para producción, despliegue fácil, móvil (TFLite)
PyTorch	Investigación, más pythonic, dominante en NLP
JAX	Rendimiento bruto, interno de Google

Resumen

NOTEPara recordar

DL = redes profundas que aprenden las features por sí mismas
Excelente para imágenes, audio, texto
Necesita GPU y muchos datos
4 familias: MLP, CNN, RNN, Transformer
TensorFlow + Keras = listo para producción

API FastAPI + despliegue Docker

Proyecto final • FastAPI • Docker • producción

NOTEObjetivo — Servir el modelo de detección de máscaras mediante una API FastAPI, empaquetarlo en un contenedor Docker y probarlo en producción.

Estructura del proyecto

output

mask-api/
  â“œâ”€â”€ app/
  â”‚   â“œâ”€â”€ main.py          # FastAPI
  â”‚   â“œâ”€â”€ mask_final.keras # modelo
  â”‚   â””â”€â”€ __init__.py
  â“œâ”€â”€ requirements.txt
  â“œâ”€â”€ Dockerfile
  â””â”€â”€ README.md

requirements.txt

output

fastapi==0.109.0
uvicorn[standard]==0.27.0
tensorflow==2.16.1
pillow==10.2.0
python-multipart==0.0.6

app/main.py

output

from fastapi import FastAPI, UploadFile, File, HTTPException
from fastapi.responses import JSONResponse
import tensorflow as tf
import numpy as np
from PIL import Image
import io

app = FastAPI(title="Face Mask Detection", version="1.0")
model = tf.keras.models.load_model("app/mask_final.keras")
LABELS = ["with_mask", "without_mask"]

@app.get("/")
def root():
    return {"service": "face-mask-detection", "version": "1.0"}

@app.get("/health")
def health():
    return {"status": "ok", "model_loaded": True}

@app.post("/predict")
async def predict(file: UploadFile = File(...)):
    if file.content_type not in ["image/jpeg", "image/png"]:
        raise HTTPException(400, "Only JPEG/PNG allowed")
    
    contents = await file.read()
    img = Image.open(io.BytesIO(contents)).convert("RGB").resize((224, 224))
    arr = np.expand_dims(np.array(img), axis=0).astype("float32")
    
    proba = float(model.predict(arr, verbose=0)[0][0])
    label = LABELS[int(proba > 0.5)]
    confidence = proba if proba > 0.5 else 1 - proba
    
    return {
        "prediction": label,
        "confidence": round(confidence, 4),
        "with_mask_proba": round(1 - proba, 4),
        "without_mask_proba": round(proba, 4)
    }

Probar en local

output

uvicorn app.main:app --host 0.0.0.0 --port 8000 --reload

# Documentación automática en http://localhost:8000/docs

# Prueba con curl
curl -X POST "http://localhost:8000/predict" \
     -F "file=@test.jpg"

Dockerfile

output

FROM python:3.11-slim

WORKDIR /app

COPY requirements.txt .
RUN pip install --no-cache-dir -r requirements.txt

COPY app/ ./app/

EXPOSE 8000

HEALTHCHECK --interval=30s --timeout=10s \
    CMD curl -f http://localhost:8000/health || exit 1

CMD ["uvicorn", "app.main:app", "--host", "0.0.0.0", "--port", "8000"]

Build y run

output

docker build -t mask-detection:1.0 .
docker run -d -p 8000:8000 --name mask-api mask-detection:1.0

# Verificar
docker logs mask-api
curl http://localhost:8000/health

va-plus-loin

Este artículo cubre los extractos más útiles: el curso completo Python TensorFlow Keras (10 capítulos, 34 lecciones, ejercicios corregidos y proyecto final) te lleva hasta el final.

./acceder-au-cours-complet cours gratuit : Maîtriser Claude Code

FAQ

¿Cuánto tiempo se necesita para aprender Python TensorFlow Keras?

Con una progresión estructurada (10 capítulos, 34 lecciones cortas y prácticas), se alcanza un nivel operativo en unas semanas dedicando 30-60 minutos al día. Lo importante es practicar cada concepto de inmediato.

¿Se necesitan requisitos previos?

Con nociones básicas de informática basta. Si sabes usar un terminal y leer código sencillo, estás listo.

¿Por dónde empezar de forma concreta?

Reproduce los comandos de este artículo y sigue el curso completo Python TensorFlow Keras: encadena las 34 lecciones en orden, con ejercicios y proyecto final.

./a-lire-aussi

→ Lance-toi en Machine Learning Débutants : ton premier pas concret aujourd'hui → Machine Learning Simplifié en pratique : le code et les commandes qui comptent vraiment → Apprentissage Automatique Python : les 9 étapes clés pour passer de zéro à opérationnel

📬 ¿Quieres recibir este tipo de guía cada semana? Suscríbete gratis — código real, cero palabrería.

Por qué y cuándo usar el transfer learning

La idea

¿Por qué funciona?

2 estrategias principales

Modelos preentrenados populares

Cargar un modelo preentrenado

Construir el nuevo modelo

Preprocesamiento por modelo

Cuándo usar el transfer learning

SÍ

NO

Resumen

¿Qué es el deep learning?

Definición

ML clásico vs Deep Learning

Una neurona artificial

Anatomía de una red densa

Arquitecturas principales

MLP (Dense)

CNN (Convolutional)

RNN / LSTM / GRU

Transformers

¿Cuándo usar DL?

TensorFlow vs PyTorch

Resumen

API FastAPI + despliegue Docker

Estructura del proyecto

requirements.txt

app/main.py

Probar en local

Dockerfile

Build y run

FAQ

Stay up to date