Red neuronal con sklearn

Construiremos una red neuronal para clasificar dígitos escritos a mano en el conjunto de datos MNIST, que es un problema de clasificación de imágenes.

Importamos los módulos necesarios

import numpy as np
import tensorflow as tf
import seaborn as sns
import matplotlib.pyplot as plt

from sklearn.datasets import load_digits
from sklearn.model_selection import train_test_split
from sklearn.preprocessing import MinMaxScaler
from sklearn.metrics import confusion_matrix, recall_score
from tensorflow.keras.models import Sequential
from tensorflow.keras.layers import Dense, Flatten

MNIST Dataset

Cargar el conjunto de datos MNIST de dígitos escritos a mano

digits = load_digits()

Exploramos el dataset

digits.keys()

El resultado es:

dict_keys([
    'data', 'target', 'frame',
    'feature_names', 'target_names', 'images', 
    'DESCR'
])

Imprimimos la llave DESCR para obtener la información del conjuto de datos

print(digits.DESCR)

Visualización de una imagen

Es necesario fijar el índice de la imagen que vamos a visualizar

index = 0

Obtener la imagen del dígito y su etiqueta

image = digits.images[index]
label = digits.target[index]

Imprimimos la representación matricial (numérica) de la imagen

print(image)

Mostramos la imagen con Matplotlib

plt.figure(figsize=(3, 3))
plt.imshow(image, cmap=plt.cm.gray)
plt.title(f'Dígito: {label}')
plt.show()

Preprocesamiento de datos

Dividir los datos en conjuntos de entrenamiento y prueba

X_train, X_test, y_train, y_test = train_test_split(
    digits.data, digits.target,
    test_size=0.2, random_state=42
)

Red neuronal multicapa

Crear un modelo de red neuronal multicapa

mlp = MLPClassifier(hidden_layer_sizes=(100, 50), max_iter=1000, random_state=42)

Esta línea de código se utiliza para crear una instancia de la clase MLPClassifier en scikit-learn, que es un clasificador de redes neuronales multicapa para tareas de clasificación.

• hidden_layer_sizes: Este argumento especifica la arquitectura de la red neuronal multicapa. En este caso, se crean dos capas ocultas. La tupla (100, 50) indica que la primera capa oculta tiene 100 neuronas y la segunda capa oculta tiene 50 neuronas.

• max_iter: Este argumento especifica el número máximo de épocas durante el entrenamiento de la red neuronal. En este caso, se establece en 1000, lo que significa que el entrenamiento se detendrá después de 1000 iteraciones o cuando se alcance la convergencia del modelo.

• random_state: Este argumento establece una semilla (seed) para la generación de números aleatorios.

  Al fijar random_state en un valor específico (en este caso, 42), aseguras que el entrenamiento de la red neuronal sea reproducible.

Entrenamiento

Entrenar el modelo en el conjunto de entrenamiento

mlp.fit(X_train, y_train)

Predicciones

Realizar predicciones en el conjunto de prueba Predicciones

y_pred = mlp.predict(X_test)

Ejemplo de una predicción

Realizamos la predicción de un elemento

Elegir el índice de la imagen que deseas evaluar

index = 9

Obtener la imagen individual y su etiqueta verdadera

# Obtener la imagen del conjunto de prueba
image_to_evaluate = X_test[index]

# Obtener la etiqueta verdadera
true_label = y_test[index]

Realizar una predicción en la imagen individual

# Utiliza el modelo para hacer una predicción
predicted_label = mlp.predict([image_to_evaluate])[0]

Comparar la etiqueta verdadera con la etiqueta predicha

if predicted_label == true_label:
    print(f"Predicción Correcta: El dígito es un {predicted_label}")
else:
    print(f"Predicción Incorrecta: El dígito es un {true_label}, pero se predijo como un {predicted_label}")

Calcular la precisión del modelo.

accuracy = accuracy_score(y_test, y_pred)
print(f"Precisión del modelo: {accuracy}")

Calculamos la matriz de confusión.

# Importa las bibliotecas necesarias
from sklearn.metrics import confusion_matrix

# Calcula la matriz de confusión
matriz_confusion = confusion_matrix(y_test, y_pred)

print("Matriz de confusión:")
print(matriz_confusion)