Otro ejemplo imágenes

Vamos a usar el dataset CIFAR-10, que es otro dataset clásico y ampliamente utilizado en clasificación de imágenes. Este dataset contiene 60,000 imágenes en color de 32×32 píxeles, divididas en 10 clases diferentes (por ejemplo, aviones, automóviles, gatos, perros, etc.). Aquí te dejo un ejemplo de cómo crear y entrenar una red neuronal convolucional (CNN) en Keras utilizando este dataset:

import tensorflow as tf
from tensorflow.keras.datasets import cifar10
from tensorflow.keras.models import Sequential
from tensorflow.keras.layers import Conv2D, MaxPooling2D, Flatten, Dense, Dropout
import matplotlib.pyplot as plt

# Cargar y preprocesar el dataset CIFAR-10
(X_train, y_train), (X_test, y_test) = cifar10.load_data()

# Normalizar los datos a un rango de [0, 1]
X_train, X_test = X_train / 255.0, X_test / 255.0

# Crear el modelo de red neuronal convolucional
model = Sequential([
    Conv2D(32, (3, 3), activation='relu', input_shape=(32, 32, 3)),
    MaxPooling2D((2, 2)),

    Conv2D(64, (3, 3), activation='relu'),
    MaxPooling2D((2, 2)),

    Conv2D(64, (3, 3), activation='relu'),

    Flatten(),

    Dense(64, activation='relu'),
    Dropout(0.5),
    Dense(10, activation='softmax')  # 10 clases para CIFAR-10
])

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

# Entrenar el modelo
history = model.fit(X_train, y_train, epochs=10, validation_data=(X_test, y_test))

# Evaluar el modelo en el conjunto de prueba
test_loss, test_acc = model.evaluate(X_test, y_test, verbose=2)
print(f"Accuracy en el conjunto de prueba: {test_acc}")
cifar10_classes = [
    "airplane",   # 0
    "automobile", # 1
    "bird",       # 2
    "cat",        # 3
    "deer",       # 4
    "dog",        # 5
    "frog",       # 6
    "horse",      # 7
    "ship",       # 8
    "truck"       # 9
]
# Graficar algunas imágenes del conjunto de prueba y sus predicciones
fig, axes = plt.subplots(1, 8, figsize=(15, 5))
for i in range(8):
    ax = axes[i]
    ax.imshow(X_test[i])
    ax.set_title(f"Predicción: {cifar10_classes[model.predict(X_test[i:i + 1]).argmax()]}")
    ax.axis('off')
plt.show()

# Graficar la precisión durante el entrenamiento
plt.plot(history.history['accuracy'], label='Precisión en entrenamiento')
plt.plot(history.history['val_accuracy'], label='Precisión en validación')
plt.xlabel('Épocas')
plt.ylabel('Precisión')
plt.title('Precisión del Modelo')
plt.legend()
plt.show()

Explicación:

1. Carga y preprocesamiento de datos:
   • cifar10.load_data() carga el dataset de CIFAR-10.
   • Normalizamos las imágenes para que estén en un rango de [0, 1].
2. Red neuronal convolucional:
   1. Sequential():
      • El modelo se crea usando la clase Sequential, que representa una pila lineal de capas. Es el tipo de modelo más común cuando las capas están apiladas de manera secuencial, donde la salida de una capa es la entrada de la siguiente.
   2. Primera capa: Conv2D(32, (3, 3), activation='relu', input_shape=(32, 32, 3)):
      • Conv2D: Es una capa convolucional bidimensional. Las capas convolucionales son el corazón de las redes neuronales convolucionales (CNNs) y se utilizan para extraer características de las imágenes.
      • 32: Es el número de filtros (o kernels). Cada filtro aprende a detectar características específicas de la imagen (por ejemplo, bordes, texturas, etc.). En este caso, se están utilizando 32 filtros.
      • (3, 3): Es el tamaño del filtro. En este caso, cada filtro es una matriz de 3×3 que se mueve (desliza) sobre la imagen.
      • activation='relu': La función de activación ReLU (Rectified Linear Unit) se utiliza para introducir no linealidades en el modelo, ayudando a aprender representaciones más complejas.
      • input_shape=(32, 32, 3): Define la forma de la imagen de entrada. En este caso, cada imagen tiene un tamaño de 32×32 píxeles con 3 canales de color (RGB).
   3. MaxPooling2D((2, 2)):
      • MaxPooling2D: Es una capa de agrupamiento (pooling). El max pooling toma la máxima activación de cada bloque de valores en la imagen (en este caso, bloques de 2×2 píxeles). Esto reduce la resolución espacial de la imagen, lo que ayuda a reducir la complejidad computacional y el sobreajuste.
      • (2, 2): Define el tamaño del bloque. En este caso, el tamaño del bloque es de 2×2, lo que significa que tomamos el valor máximo en cada bloque de 2×2 píxeles.
   4. Segunda capa convolucional: Conv2D(64, (3, 3), activation='relu'):
      • Similar a la primera capa convolucional, pero esta vez se utilizan 64 filtros en lugar de 32. Esto permite al modelo aprender características más complejas. Además, no se especifica input_shape, ya que Keras puede inferir la forma de entrada de las capas anteriores.
   5. MaxPooling2D((2, 2)):
      • Otra capa de MaxPooling2D con el mismo tamaño de bloque de 2×2.
   6. Tercera capa convolucional: Conv2D(64, (3, 3), activation='relu'):
      • Esta capa también utiliza 64 filtros y realiza una convolución sobre la salida de la segunda capa de pooling. Es común agregar más capas convolucionales para que el modelo pueda aprender características aún más abstractas de las imágenes.
   7. Flatten():
      • Flatten: Convierte la salida 2D de las capas convolucionales y de pooling en un vector unidimensional. Esto es necesario para pasar los datos a través de las capas densas (totalmente conectadas). Después de esta capa, los datos tendrán una forma de vector, no de matriz.
   8. Capa densa: Dense(64, activation='relu'):
      • Dense: Es una capa completamente conectada. Cada neurona de esta capa está conectada a todas las neuronas de la capa anterior.
      • 64: Es el número de neuronas en esta capa.
      • activation='relu': La función de activación ReLU se aplica a la salida de cada neurona. Esto introduce no linealidad en el modelo, lo que le permite aprender representaciones más complejas.
   9. Dropout(0.5):
      • Dropout: Es una técnica de regularización que ayuda a prevenir el sobreajuste. Durante el entrenamiento, el 50% de las neuronas de esta capa se “apagan” aleatoriamente en cada paso de entrenamiento. Esto obliga al modelo a no depender demasiado de ninguna neurona en particular y mejora la generalización.
      • 0.5: Esto significa que el 50% de las neuronas serán desactivadas en cada paso de entrenamiento.
   10. Capa de salida: Dense(10, activation='softmax'):
       • Dense(10): Esta es la capa final del modelo, que tiene 10 neuronas, una por cada clase en el dataset CIFAR-10 (es decir, 10 clases diferentes como “perro”, “gato”, “automóvil”, etc.).
       • activation='softmax': La función de activación softmax convierte las salidas de las neuronas en probabilidades, y la clase predicha será la que tenga la mayor probabilidad. Es ideal para tareas de clasificación multiclase.
3. Entrenamiento y evaluación:
   • El modelo se entrena con fit() durante 10 épocas.
   • Después de entrenar, se evalúa el modelo en el conjunto de prueba y se imprime la precisión.
4. Visualización:
   • Se grafican las imágenes del conjunto de prueba con sus predicciones.
   • También se muestra la precisión durante las épocas de entrenamiento.

Resultado:

• Precisión en el conjunto de prueba: Obtendrás la precisión del modelo después de entrenarlo.
• Predicciones visualizadas: Se mostrarán 5 imágenes del conjunto de prueba junto con las predicciones del modelo.
• Gráfica de precisión: Verás cómo cambia la precisión a lo largo del entrenamiento y la validación.

Este es un modelo simple pero efectivo para comenzar a trabajar con redes neuronales convolucionales y datasets de imágenes. Puedes experimentar con más capas o diferentes técnicas de regularización para mejorar la precisión.