# deep-learning-en-python-y-tensorflow

Deep Learning en Python y Tensorflow

Volver a la portada del curso
Proyecto

Proyecto Final: Clasificación de Imágenes

Sección 6 · Proyecto Final

Proyecto final: clasificador de prendas de PyShop

Vas a construir, evaluar y entregar una red que etiqueta sola las fotos de ropa del catálogo de PyShop. Se usan Python 3.10 a 3.13, TensorFlow 2.21 con Keras 3, NumPy y Matplotlib. El notebook proyecto-clasificador-de-prendas tiene una solución de referencia: consúltalo al terminar.

Contexto

Los vendedores de PyShop suben miles de fotos de prendas y hoy alguien las etiqueta a mano. El equipo quiere un modelo que ponga la etiqueta sola y diga cuándo duda, más un informe de qué tan bien funciona y dónde falla.

Datos

Se usa Fashion-MNIST (Zalando Research, 2017): 70,000 fotos de 28×28 en escala de grises de 10 tipos de prenda, 60,000 para entrenar y 10,000 de prueba. Keras la descarga la primera vez (unos 30 MB). Copia este código en la primera celda:

import os
os.environ["TF_CPP_MIN_LOG_LEVEL"] = "2"

import keras
import numpy as np
import tensorflow as tf

CLASES = ["camiseta", "pantalon", "sueter",
          "vestido", "abrigo", "sandalia", "camisa",
          "tenis", "bolsa", "botin"]


def cargar_moda(normalizar=True):
    moda = keras.datasets.fashion_mnist
    (x_tr, y_tr), (x_te, y_te) = moda.load_data()
    if normalizar:
        x_tr = x_tr.astype("float32") / 255.0
        x_te = x_te.astype("float32") / 255.0
    return (x_tr, y_tr), (x_te, y_te)


def semillas(semilla=42):
    keras.utils.set_random_seed(semilla)
    tf.config.experimental.enable_op_determinism()


(x_tr, y_tr), (x_te, y_te) = cargar_moda()
print(x_tr.shape, x_te.shape)
# (60000, 28, 28) (10000, 28, 28)

Llama a semillas(42) justo antes de crear cada modelo para que cada corrida dé los mismos números. Salvo que se indique otra cosa, compila con optimizer="adam", loss="sparse_categorical_crossentropy" y metrics=["accuracy"], y entrena con batch_size=64 y validation_split=0.1.

Tareas

  1. Explorar. Con normalizar=False, reporta formas, tipo, rango y media de los píxeles y fotos por clase. Dibuja una cuadrícula con un ejemplo de cada prenda.
  2. Preparar. Normaliza a $[0, 1]$ y comprueba que la media pase de 72.94 a 0.286. Crea las versiones con canal para la CNN: x_tr[..., None].
  3. Modelo base. Entrena Flatten → Dense(10, softmax) durante 5 épocas. Reporta parámetros y accuracy en prueba.
  4. MLP. Entrena Flatten → Dense(128, relu) → Dense(10, softmax) durante 10 épocas. Explica de dónde salen sus 101,770 parámetros.
  5. CNN. Entrena la red Conv2D(32, 3) → MaxPooling2D → Conv2D(64, 3) → MaxPooling2D → Flatten → Dropout(0.3) → Dense(10), con ReLU en las convoluciones y softmax en la salida, durante 10 épocas y con EarlyStopping(patience=3, restore_best_weights=True). Incluye su summary().
  6. Curvas. Grafica pérdida y accuracy de entrenamiento y validación por época para el MLP y la CNN. Di si hay sobreajuste y en qué te basas.
  7. Evaluar. Calcula la matriz de confusión de la CNN con tf.math.confusion_matrix, dibújala como mapa de calor y reporta el acierto por clase del MLP y de la CNN en una tabla.
  8. Analizar errores. Encuentra la confusión más frecuente, muestra al menos 8 fotos mal clasificadas con su etiqueta real y la predicha, y explica por qué crees que el modelo falla en ellas.
  9. Guardar y cargar. Guarda la CNN con model.save("moda_cnn.keras"), cárgala con keras.models.load_model y comprueba que da la misma accuracy.
  10. Predecir. Con el modelo cargado, predice 5 fotos del conjunto de prueba como si fueran fotos nuevas y muestra para cada una la imagen y sus 3 prendas más probables con su probabilidad.

Pistas de implementación

pred = cnn.predict(xc_te, verbose=0).argmax(1)
cm = tf.math.confusion_matrix(y_te, pred).numpy()
acierto = cm.diagonal() / cm.sum(axis=1)
fuera = cm.copy()
np.fill_diagonal(fuera, 0)
i, j = np.unravel_index(fuera.argmax(), fuera.shape)
print(CLASES[i], "->", CLASES[j], fuera[i, j])

p = cargado.predict(xc_te[:1], verbose=0)[0]
top3 = p.argsort()[::-1][:3]
print([(CLASES[k], round(float(p[k]), 3))
       for k in top3])

Para comprobar: base 7,850 parámetros y 0.8366; MLP 0.8746; CNN 34,826 parámetros y 0.902; camisa → camiseta, 174 fotos; errores: MLP 1254, CNN 980; archivo de unos 442 KB; la primera foto de prueba es un botín y la CNN le da 0.998. La CNN tarda bastante más en entrenar que el MLP.

Extras opcionales

  • Aumento de datos. Agrega RandomFlip("horizontal") y RandomTranslation(0.1, 0.1) al inicio de la CNN y entrena más épocas. Reporta si cambia el acierto en camisa.
  • BatchNormalization. Inserta BatchNormalization después de cada Conv2D y compara curvas y accuracy.
  • Tercera capa convolucional. Agrega otra Conv2D y revisa las formas con summary().
  • Regla de revisión. Elige un umbral de probabilidad máxima y reporta qué fracción de fotos se etiquetaría sola y con qué accuracy, y cuántas irían a revisión humana.

Entregables

  1. proyecto.ipynb, ejecutado de principio a fin sin errores, con las gráficas a la vista y semillas(42) antes de cada modelo.
  2. moda_cnn.keras, el modelo final guardado.
  3. INFORME.md (una página): tabla comparativa de los tres modelos (parámetros, accuracy, errores), curvas, la confusión principal con su explicación, las predicciones de las 5 fotos, una recomendación para PyShop sobre cuándo confiar en la etiqueta automática y dos limitaciones del modelo.

Rúbrica (100 puntos, más 10 de extras)

  • Exploración y preparación (10 puntos): formas, rango, balance de clases, cuadrícula y normalización comprobada.
  • Modelos base y MLP (15 puntos): entrenados con semilla, parámetros explicados y accuracy reportada.
  • CNN (20 puntos): arquitectura correcta, canal añadido, EarlyStopping con restore_best_weights y resultado cercano a 0.90.
  • Curvas y sobreajuste (10 puntos): gráficas legibles y diagnóstico justificado con la validación.
  • Evaluación y análisis de errores (20 puntos): matriz de confusión, acierto por clase, confusión principal y ejemplos con una explicación razonada.
  • Guardar, cargar y predecir (10 puntos): misma accuracy tras cargar y top-3 de 5 fotos.
  • Informe (15 puntos): tabla comparativa, recomendación con cifras y limitaciones honestas.
  • Extras (hasta 10 puntos): aumento de datos, BatchNormalization, tercera capa o regla de revisión, bien medidos e interpretados.

Recursos