Creación de un Modelo de Clasificación de Imágenes con TensorFlow y Keras

Paso 1: Configuración del Entorno

Antes de comenzar, asegúrate de tener TensorFlow y otras bibliotecas necesarias instaladas. Este paso se encarga de importar las bibliotecas esenciales y cargar el conjunto de datos CIFAR-10.

import tensorflow as tf
from tensorflow.keras import layers, models
from tensorflow.keras.datasets import cifar10
import matplotlib.pyplot as plt

# Cargar y normalizar el conjunto de datos CIFAR-10
(train_images, train_labels), (test_images, test_labels) = cifar10.load_data()
train_images, test_images = train_images / 255.0, test_images / 255.0

import: Importa las bibliotecas necesarias, incluyendo TensorFlow y Matplotlib para visualización.
cifar10.load_data(): Carga el conjunto de datos CIFAR-10, que contiene imágenes de 10 clases diferentes.

Paso 2: Visualización de Ejemplos del Conjunto de Datos

Este paso visualiza algunas imágenes del conjunto de datos CIFAR-10.

# Visualizar algunas imágenes del conjunto de datos
class_names = ['Avión', 'Automóvil', 'Pájaro', 'Gato', 'Ciervo', 'Perro', 'Rana', 'Caballo', 'Barco', 'Camión']

plt.figure(figsize=(10, 10))
for i in range(25):
    plt.subplot(5, 5, i + 1)
    plt.imshow(train_images[i])
    plt.title(class_names[train_labels[i][0]])
    plt.axis('off')
plt.show()

class_names: Etiquetas de las clases correspondientes a los índices de las imágenes.
plt.imshow(): Visualiza las imágenes del conjunto de datos.
plt.title(): Etiqueta cada imagen con su clase correspondiente.

Paso 3: Construcción del Modelo

Construye un modelo de red neuronal convolucional (CNN) utilizando capas de convolución y pooling.

# Construir el modelo de red neuronal convolucional (CNN)
model = models.Sequential([
    layers.Conv2D(32, (3, 3), activation='relu', input_shape=(32, 32, 3)),
    layers.MaxPooling2D((2, 2)),
    layers.Conv2D(64, (3, 3), activation='relu'),
    layers.MaxPooling2D((2, 2)),
    layers.Conv2D(64, (3, 3), activation='relu'),
    layers.Flatten(),
    layers.Dense(64, activation='relu'),
    layers.Dense(10, activation='softmax')
])

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

layers.Conv2D: Capa de convolución que aprende patrones en las imágenes.
layers.MaxPooling2D: Capa de pooling que reduce la dimensionalidad de la representación.
layers.Flatten: Capa que aplanará la salida para la capa densa.
layers.Dense: Capas densas que realizan la clasificación final.

Paso 4: Entrenamiento del Modelo

Entrena el modelo con el conjunto de datos de entrenamiento.

# Entrenar el modelo
history = model.fit(train_images, train_labels, epochs=10, validation_data=(test_images, test_labels))

model.fit(): Entrena el modelo con los datos de entrenamiento y valida con los datos de prueba.

Paso 5: Evaluación del Modelo y Visualización de Métricas
Evalúa el rendimiento del modelo y visualiza métricas de precisión.

# Evaluar el modelo con el conjunto de prueba
test_loss, test_acc = model.evaluate(test_images, test_labels)
print(f'\nPrecisión en el conjunto de prueba: {test_acc}')

# Visualizar las métricas de entrenamiento y validación a lo largo del tiempo
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.legend()
plt.show()

model.evaluate(): Evalúa el modelo con el conjunto de prueba y devuelve la pérdida y precisión.
Visualiza las métricas a lo largo de las épocas.

Paso 6: Hacer Predicciones y Visualizar Resultados
Hace predicciones con el modelo entrenado y visualiza las imágenes con las etiquetas predichas.

# Hacer predicciones con el modelo entrenado
predictions = model.predict(test_images[:5])

# Imprimir las predicciones
for i in range(5):
    predicted_label = tf.argmax(predictions[i])
    actual_label = test_labels[i][0]
    print(f'\nImagen {i + 1}:')
    print(f'Etiqueta predicha: {class_names[predicted_label.numpy()]}')
    print(f'Etiqueta real: {class_names[actual_label]}')

# Visualizar las imágenes y las predicciones
plt.figure(figsize=(10, 5))
for i in range(5):
    plt.subplot(1, 5, i + 1)
    plt.imshow(test_images[i])
    plt.title(f'Predicción: {class_names[tf.argmax(predictions[i])]}')
    plt.axis('off')
plt.show()

model.predict(): Realiza predicciones con el conjunto de prueba.
Visualiza las imágenes junto con las etiquetas predichas y reales.

Recuerda personalizar las URL, descripciones y demás según tu contenido específico.