TensorFlow / Python: Reconocimiento de Dígitos Manuscritos con Redes Neuronales Convolucionales

by Beastieux, posted in Redes Neuronales, TensorFlow

Ejemplo simple de código en Python utilizando la biblioteca Keras y TensorFlow, para construir y entrenar una red neuronal para la clasificación de dígitos escritos a mano, usando el dataset MNIST.

# Importar bibliotecas necesarias
import tensorflow as tf
from tensorflow import keras
from tensorflow.keras import layers
from tensorflow.keras.datasets import mnist
import matplotlib.pyplot as plt

# Cargar y preprocesar los datos
(x_train, y_train), (x_test, y_test) = mnist.load_data()
x_train, x_test = x_train / 255.0, x_test / 255.0  # Normalizar los valores de píxeles

# Crear el modelo de red neuronal convolucional (CNN)
model = keras.Sequential([
    layers.Input(shape=(28, 28, 1)),  # Capa de entrada con imágenes en escala de grises
    layers.Conv2D(32, kernel_size=(3, 3), activation='relu'),  # Capa convolucional con 32 filtros
    layers.MaxPooling2D(pool_size=(2, 2)),  # Capa de max-pooling para reducir el tamaño
    layers.Conv2D(64, kernel_size=(3, 3), activation='relu'),  # Otra capa convolucional con 64 filtros
    layers.MaxPooling2D(pool_size=(2, 2)),  # Otra capa de max-pooling
    layers.Flatten(),  # Capa de aplanamiento para convertir la salida en un vector
    layers.Dense(128, activation='relu'),  # Capa oculta con 128 neuronas y ReLU
    layers.Dropout(0.5),  # Regularización Dropout
    layers.Dense(10, activation='softmax')  # Capa de salida con 10 neuronas y activación softmax
])

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

# Entrenar el modelo
history = model.fit(x_train, y_train, epochs=5, validation_data=(x_test, y_test))

# Evaluar el modelo con los datos de prueba
test_loss, test_acc = model.evaluate(x_test, y_test)
print(f'Precisión en datos de prueba: {test_acc*100:.2f}%')

# Visualizar la precisión y la pérdida durante el entrenamiento
plt.plot(history.history['accuracy'], label='Precisión de entrenamiento')
plt.plot(history.history['val_accuracy'], label='Precisión de prueba')
plt.xlabel('Épocas')
plt.ylabel('Precisión')
plt.legend(loc='lower right')
plt.show()

Precisión en datos de prueba: 99.03%

Este código realiza lo siguiente:

Importación de bibliotecas: Se importan las bibliotecas necesarias, incluyendo TensorFlow, Keras y Matplotlib para trabajar con redes neuronales y visualización.

Carga y preprocesamiento de datos: Se cargan los datos del conjunto de datos MNIST, que contiene imágenes de dígitos escritos a mano y sus etiquetas asociadas. Las imágenes se escalan normalizándolas, dividiendo cada valor de píxel por 255.0 para que estén en el rango de 0 a 1.

Definición del modelo de red neuronal convolucional (CNN): Se crea un modelo secuencial de Keras, que es una pila lineal de capas de red neuronal.

  • La capa de entrada (Input) se define con un tamaño de (28, 28, 1) para imágenes en escala de grises de 28×28 píxeles.
  • El modelo consta de capas convolucionales (Conv2D) con filtros y activaciones ReLU, seguidas de capas de max-pooling (MaxPooling2D) para reducir el tamaño de las características extraídas.
  • Después de las capas convolucionales, hay una capa de aplanamiento (Flatten) que convierte la salida en un vector unidimensional.
  • Luego, se agregan capas completamente conectadas (Dense) con activaciones ReLU y una capa de dropout (Dropout) para la regularización.
  • Finalmente, se agrega una capa de salida con 10 neuronas y activación softmax para clasificar los dígitos del 0 al 9.

Compilación del modelo: Se compila el modelo especificando el optimizador (en este caso, ‘adam’), la función de pérdida (‘sparse_categorical_crossentropy’ para clasificación) y las métricas a seguir (en este caso, la precisión).

Entrenamiento del modelo: El modelo se entrena usando el conjunto de entrenamiento (las imágenes de dígitos y sus etiquetas) durante 5 épocas (puedes ajustar este valor según tus necesidades). El entrenamiento se realiza utilizando el método fit, y la historia del entrenamiento se almacena en la variable history.

Evaluación del modelo: El modelo se evalúa en el conjunto de datos de prueba (x_test e y_test) para medir su rendimiento en datos no vistos. La precisión en datos de prueba y la pérdida se imprimen en la consola.

Visualización de resultados: Se utiliza Matplotlib para graficar la precisión del entrenamiento y la precisión en el conjunto de datos de prueba a lo largo de las épocas.

import matplotlib.pyplot as plt

# Función para mostrar imágenes y predicciones
def visualize_images_with_predictions(model, images, labels, num_images=5):
    predictions = model.predict(images)
    plt.figure(figsize=(12, 8))
    for i in range(num_images):
        plt.subplot(1, num_images, i + 1)
        plt.imshow(images[i].reshape(28, 28), cmap='gray')
        predicted_label = predictions[i].argmax()
        true_label = labels[i]
        title = f"Predicción: {predicted_label}\nEtiqueta real: {true_label}"
        plt.title(title)
        plt.axis('off')
    plt.show()

# Elegir un número de imágenes para visualizar
num_images_to_visualize = 5
visualize_images_with_predictions(model, x_test[:num_images_to_visualize], y_test[:num_images_to_visualize])

    Este código es un ejemplo típico de entrenamiento de una red neuronal convolucional para la clasificación de imágenes y es aplicable a tareas como el reconocimiento de dígitos escritos a mano. La visualización de la precisión y la pérdida durante el entrenamiento es útil para evaluar el rendimiento del modelo.

    Deja un comentario