Basic KERAS Tutorial

Keras es una de las bibliotecas de aprendizaje profundo más populares en Python. Es una interfaz de alto nivel para TensorFlow, CNTK y Theano que facilita la creación y entrenamiento de redes neuronales. En este tutorial básico de Keras, aprenderás a construir y entrenar una red neuronal utilizando esta biblioteca.

Paso 1: Instalación de Keras
Antes de comenzar, primero debes asegurarte de tener instalada la biblioteca de Keras en tu entorno de Python. Puedes instalar Keras utilizando pip, el administrador de paquetes de Python. Simplemente ejecuta el siguiente comando en tu terminal:

pip install keras

Paso 2: Importar las bibliotecas necesarias
Una vez que tengas Keras instalado, el siguiente paso es importar las bibliotecas necesarias en tu script de Python. Para crear y entrenar una red neuronal con Keras, necesitarás importar keras y numpy, que es una biblioteca de Python para el cálculo numérico. También es útil importar otras bibliotecas como matplotlib para visualización y sklearn para dividir el conjunto de datos en entrenamiento y prueba.

import keras
import numpy as np
import matplotlib.pyplot as plt
from sklearn.model_selection import train_test_split

Paso 3: Cargar y preprocesar los datos
Para este tutorial, utilizaremos un conjunto de datos de dígitos escritos a mano llamado MNIST. Este conjunto de datos contiene imágenes de dígitos del 0 al 9 escritos a mano, y el objetivo es construir un modelo que pueda identificar qué dígito se muestra en la imagen.

Keras proporciona una función conveniente para cargar el conjunto de datos MNIST. Puedes cargar los datos de la siguiente manera:

from keras.datasets import mnist

(x_train, y_train), (x_test, y_test) = mnist.load_data()

Una vez que hayas cargado los datos, es importante preprocesarlos antes de entrenar la red neuronal. En este caso, normalizaremos las imágenes dividiendo los valores de píxeles por 255 (el valor máximo de píxel). También reformatearemos las imágenes para que tengan la forma (número de imágenes, ancho de la imagen, altura de la imagen, número de canales).

x_train = x_train.reshape(x_train.shape[0], 28, 28, 1)
x_test = x_test.reshape(x_test.shape[0], 28, 28, 1)
x_train = x_train.astype('float32') / 255
x_test = x_test.astype('float32') / 255

También convertiremos las etiquetas de las clases en formato one-hot encoding. Esto significa que cada etiqueta se convertirá en un vector binario donde un valor es 1 y el resto son 0.

from keras.utils import to_categorical

y_train = to_categorical(y_train)
y_test = to_categorical(y_test)

Paso 4: Construir el modelo de la red neuronal
Ahora que hemos cargado y preprocesado los datos, es hora de construir el modelo de nuestra red neuronal. En este ejemplo, utilizaremos un modelo secuencial de Keras, que es una pila lineal de capas neuronales.

from keras.models import Sequential
from keras.layers import Conv2D, MaxPooling2D, Flatten, Dense

model = Sequential()
model.add(Conv2D(32, (3, 3), activation='relu', input_shape=(28, 28, 1)))
model.add(MaxPooling2D((2, 2)))
model.add(Conv2D(64, (3, 3), activation='relu'))
model.add(MaxPooling2D((2, 2)))
model.add(Flatten())
model.add(Dense(10, activation='softmax'))

En este modelo, hemos utilizado capas convolucionales para extraer características de las imágenes, seguidas de capas de pooling para reducir la dimensionalidad. Luego hemos aplanado las características extraídas para alimentarlas a la capa de salida, que tiene 10 neuronas correspondientes a las 10 clases de dígitos.

Paso 5: Compilar y entrenar el modelo
Una vez que hayas construido el modelo, es importante compilarlo antes de entrenarlo. Durante la compilación, debes especificar la función de pérdida, el optimizador y las métricas que se utilizarán para evaluar el rendimiento del modelo.

model.compile(optimizer='adam', loss='categorical_crossentropy', metrics=['accuracy'])

Después de compilar el modelo, puedes entrenarlo utilizando el método fit de Keras. Especifica el conjunto de datos de entrenamiento, el número de épocas y el tamaño del lote.

model.fit(x_train, y_train, epochs=5, batch_size=128)

Paso 6: Evaluar el rendimiento del modelo
Una vez que hayas entrenado el modelo, es importante evaluar su rendimiento en un conjunto de datos de prueba. Puedes hacerlo utilizando el método evaluate de Keras.

loss, accuracy = model.evaluate(x_test, y_test)
print(f'Loss: {loss}, Accuracy: {accuracy}')

También puedes hacer predicciones en un conjunto de datos de prueba utilizando el método predict.

predictions = model.predict(x_test)

Paso 7: Visualización de resultados
Una vez que hayas evaluado el rendimiento del modelo, es útil visualizar las predicciones para comprender mejor cómo se comporta el modelo en datos de prueba.

for i in range(10):
    plt.imshow(x_test[i].reshape(28, 28), cmap='gray')
    plt.title(f'Predicted: {np.argmax(predictions[i])}, Actual: {np.argmax(y_test[i])}')
    plt.show()

¡Y eso es todo! Has completado este tutorial básico de Keras, donde has aprendido a construir, entrenar y evaluar una red neuronal utilizando esta biblioteca popular en Python. Ahora estás listo para explorar más complejidades en el mundo del aprendizaje profundo con Keras. ¡Buena suerte!