Cómo generar la arquitectura de modelo en Deep Learning es uno de los conocimientos base para un análisis de redes neuronales profundas. Por ello, en este post, te compartimos cómo funcionan las dos formas de generar la arquitectura de modelo en Deep Learning a partir de la biblioteca Keras.
¿Cómo generar la arquitectura de modelo en Deep Learning?
Existen dos formas de generar la arquitectura de un modelo en Deep Learning en la biblioteca Keras:
- Modo (o API) secuencial: se instancia un objeto del tipo Model y a este se le van añadiendo las capas que conforman la arquitectura una detrás de otra.
- Modo (o API) funcional: se define una entrada y, a partir de ella, se va definiendo la arquitectura indicando cuál es la entrada a cada capa. Una vez definida la arquitectura, se crea el objeto modelo pasándole las entradas y las salidas (última capa definida).
Ejemplo de Modo secuencial
Ahora vamos a implementar una red profunda (con dos capas ocultas de 256 y 60 neuronas) empleando Keras. Para ello, vamos a clasificar el dataset de dígitos manuscritos denominado MNIST:
## Imports necesarios
import numpy as np
from sklearn.metrics import classification_report
from tensorflow.keras.models import Sequential
from tensorflow.keras.layers import Dense, Flatten
from tensorflow.keras.optimizers import SGD
import matplotlib.pyplot as plt
from tensorflow.keras.utils import to_categorical
# Importamos el dataset MNIST y cargamos los datos
from tensorflow.keras.datasets import mnist
(X_train, Y_train), (X_test, Y_test) = mnist.load_data()
##Pasamos a one-hot-encoding
Y_train=to_categorical(Y_train,num_classes=10)
Y_test=to_categorical(Y_test,num_classes=10)
# Implementamos la red empleando Keras (modelo secuencial)
model = Sequential()
model.add(Flatten(input_shape=(28,28)))
model.add(Dense(256, input_shape=(784,), activation="relu"))
model.add(Dense(60, activation="relu"))
model.add(Dense(10, activation="softmax"))
# Compilamos y entrenamos el modelo SGD
print("[INFO]: Entrenando red neuronal...")
model.compile(loss="categorical_crossentropy", optimizer=SGD(0.001), metrics=["accuracy"])
H = model.fit(X_train, Y_train, validation_data=(X_test, Y_test), epochs=30, batch_size=64)
# Evaluando el modelo de predicción con las imágenes de test
print("[INFO]: Evaluando red neuronal...")
predictions = model.predict(X_test, batch_size=128)
print(classification_report(Y_test.argmax(axis=1), predictions.argmax(axis=1)))
# Muestro gráfica de accuracy y losses
plt.style.use("ggplot")
plt.figure()
plt.plot(np.arange(0, 30), H.history["loss"], label="train_loss")
plt.plot(np.arange(0, 30), H.history["val_loss"], label="val_loss")
plt.plot(np.arange(0, 30), H.history["accuracy"], label="train_acc")
plt.plot(np.arange(0, 30), H.history["val_accuracy"], label="val_acc")
plt.title("Training Loss and Accuracy")
plt.xlabel("Epoch #")
plt.ylabel("Loss/Accuracy")
plt.legend()
Ejemplo de Modo funcional
En el último ejemplo, hemos diseñado una arquitectura en modo secuencial. Veamos los cambios necesarios para generar la arquitectura de modelo en Deep Learning en modo funcional:
## Imports necesarios
import numpy as np
from sklearn.metrics import classification_report
from tensorflow.keras.layers import Dense, Input,Flatten
from tensorflow.keras.optimizers import SGD
import matplotlib.pyplot as plt
# Importamos el dataset MNIST y cargamos los datos
# Importamos el dataset MNIST y cargamos los datos
from tensorflow.keras.datasets import mnist
(X_train, Y_train), (X_test, Y_test)= mnist.load_data()
#Pasamos a one-hot-encoding
Y_train=to_categorical(Y_train,num_classes=10)
Y_test=to_categorical(Y_test,num_classes=10)
# Implementamos la red empleando Keras (modelo funcional)
inputs= Input(shape=(28,28))
x=Flatten(input_shape=(784,))(inputs)
x=Dense(256, activation="relu") (x)
x=Dense(60, activation="relu") (x)
x=Dense(10, activation="softmax")(x)
# Compilamos y entrenamos el modelo SGD
print("[INFO]: Entrenando red neuronal...")
model.compile(loss="categorical_crossentropy", optimizer=SGD(0.001), metrics=["accuracy"])
H = model.fit(X_train,Y_train, validation_data=(X_test, Y_test), epochs=30, batch_size=128)
# Evaluando el modelo de predicción con las imágenes de test
print("[INFO]: Evaluando red neuronal...")
predictions = model.predict(X_test, batch_size=128)
print(classification_report(Y_test.argmax(axis=1), predictions.argmax(axis=1)))
# Muestro gráfica de accuracy y losses
plt.style.use("ggplot")
plt.figure()
plt.plot(np.arange(0, 30), H.history["loss"], label="train_loss")
plt.plot(np.arange(0, 30), H.history["val_loss"], label="val_loss")
plt.plot(np.arange(0, 30), H.history["accuracy"], label="train_acc")
plt.plot(np.arange(0, 30), H.history["val_accuracy"], label="val_acc")
plt.title("Training Loss and Accuracy")
plt.xlabel("Epoch #")
plt.ylabel("Loss/Accuracy")
plt.legend()
Como se puede observar en la anterior ejecución, el perceptrón multicapa utilizado permite resolver con satisfacción la tarea de clasificación propuesta. Sin embargo, en la mayoría de problemas de clasificación de imagen, no es suficiente con crear un modelo de predicción basado en un perceptron multicapa.
Para problemas de cierta dificultad, este tipo de arquitectura no ofrece una solución precisa. Por este motivo se propusieron las redes neuronales convolucionales. Dichas formas de generar la arquitectura de modelo en Deep Learning de red extraen la información relevante automáticamente de la imagen por medio de la operación convolución de manera local (en la práctica dicha operación es la correlación cruzada).
¿Cómo continuar aprendiendo sobre el Big Data?
En este post, te explicamos cómo generar la arquitectura de modelo en Deep Learning en el desarrollo de un procesamiento de los macrodatos en este amplio mundo del aprendizaje profundo. Si quieres continuar aprendiendo sobre Deep Learning, arquitecturas y mucho más, como puede ser la arquitectura VGG16 y VGG19 en Deep Learning, con el Bootcamp Big Data de KeepCoding podrás aprender esto y mucho más para convertirte en un data scientist profesional en solo unos pocos meses. ¡No esperes más para inscribirte!
