Deep Learning con Keras: preparación de datos

Antes de que alimentemos los datos a nuestra red, deben convertirse al formato requerido por la red. A esto se le llama preparar datos para la red. Por lo general, consiste en convertir una entrada multidimensional en un vector unidimensional y normalizar los puntos de datos.

Vector de entrada de remodelación

Las imágenes de nuestro conjunto de datos constan de 28 x 28 píxeles. Esto debe convertirse en un vector unidimensional de tamaño 28 * 28 = 784 para alimentarlo en nuestra red. Lo hacemos llamando alreshape método en el vector.

X_train = X_train.reshape(60000, 784)
X_test = X_test.reshape(10000, 784)

Ahora, nuestro vector de entrenamiento constará de 60000 puntos de datos, cada uno de los cuales constará de un vector de una sola dimensión de tamaño 784. De manera similar, nuestro vector de prueba constará de 10000 puntos de datos de un vector de una sola dimensión de tamaño 784.

Normalizar datos

Los datos que contiene el vector de entrada tienen actualmente un valor discreto entre 0 y 255, los niveles de escala de grises. Normalizar estos valores de píxeles entre 0 y 1 ayuda a acelerar el entrenamiento. Como vamos a utilizar el descenso de gradiente estocástico, la normalización de los datos también ayudará a reducir la posibilidad de quedarse atascado en los óptimos locales.

Para normalizar los datos, los representamos como tipo flotante y los dividimos por 255 como se muestra en el siguiente fragmento de código:

X_train = X_train.astype('float32')
X_test = X_test.astype('float32')
X_train /= 255
X_test /= 255

Veamos ahora cómo se ven los datos normalizados.

Examinar datos normalizados

Para ver los datos normalizados, llamaremos a la función de histograma como se muestra aquí:

plot.hist(X_train[0])
plot.title("Digit: {}".format(y_train[0]))

Aquí, trazamos el histograma del primer elemento del X_trainvector. También imprimimos el dígito representado por este punto de datos. El resultado de ejecutar el código anterior se muestra aquí:

Notará una gran densidad de puntos que tienen un valor cercano a cero. Estos son los puntos negros de la imagen, que obviamente son la mayor parte de la imagen. El resto de los puntos de la escala de grises, que están cerca del color blanco, representan el dígito. Puede consultar la distribución de píxeles para otro dígito. El siguiente código imprime el histograma de un dígito en el índice 2 en el conjunto de datos de entrenamiento.

plot.hist(X_train[2])
plot.title("Digit: {}".format(y_train[2])

El resultado de ejecutar el código anterior se muestra a continuación:

Al comparar las dos cifras anteriores, notará que la distribución de los píxeles blancos en dos imágenes difiere, lo que indica una representación de un dígito diferente: "5" y "4" en las dos imágenes anteriores.

A continuación, examinaremos la distribución de datos en nuestro conjunto de datos de entrenamiento completo.

Examinar la distribución de datos

Antes de entrenar nuestro modelo de aprendizaje automático en nuestro conjunto de datos, debemos conocer la distribución de dígitos únicos en nuestro conjunto de datos. Nuestras imágenes representan 10 dígitos distintos que van del 0 al 9. Nos gustaría saber el número de dígitos 0, 1, etc., en nuestro conjunto de datos. Podemos obtener esta información utilizando elunique método de Numpy.

Utilice el siguiente comando para imprimir el número de valores únicos y el número de ocurrencias de cada uno

print(np.unique(y_train, return_counts=True))

Cuando ejecute el comando anterior, verá el siguiente resultado:

(array([0, 1, 2, 3, 4, 5, 6, 7, 8, 9], dtype=uint8), array([5923, 6742, 5958, 6131, 5842, 5421, 5918, 6265, 5851, 5949]))

Muestra que hay 10 valores distintos, del 0 al 9. Hay 5923 ocurrencias del dígito 0, 6742 ocurrencias del dígito 1, y así sucesivamente. La captura de pantalla de la salida se muestra aquí:

Como paso final en la preparación de datos, necesitamos codificar nuestros datos.

Codificación de datos

Tenemos diez categorías en nuestro conjunto de datos. Por lo tanto, codificaremos nuestra salida en estas diez categorías mediante la codificación one-hot. Usamos el método to_categorial de las utilidades de Numpy para realizar la codificación. Después de codificar los datos de salida, cada punto de datos se convertiría en un vector unidimensional de tamaño 10. Por ejemplo, el dígito 5 ahora se representará como [0,0,0,0,0,1,0,0,0 , 0].

Codifique los datos utilizando el siguiente fragmento de código:

n_classes = 10
Y_train = np_utils.to_categorical(y_train, n_classes)

Puede comprobar el resultado de la codificación imprimiendo los primeros 5 elementos del vector Y_train categorizado.

Utilice el siguiente código para imprimir los primeros 5 vectores:

for i in range(5):
   print (Y_train[i])

Verá la siguiente salida:

[0. 0. 0. 0. 0. 1. 0. 0. 0. 0.]
[1. 0. 0. 0. 0. 0. 0. 0. 0. 0.]
[0. 0. 0. 0. 1. 0. 0. 0. 0. 0.]
[0. 1. 0. 0. 0. 0. 0. 0. 0. 0.]
[0. 0. 0. 0. 0. 0. 0. 0. 0. 1.]

El primer elemento representa el dígito 5, el segundo representa el dígito 0 y así sucesivamente.

Finalmente, también tendrá que categorizar los datos de prueba, lo cual se hace usando la siguiente declaración:

Y_test = np_utils.to_categorical(y_test, n_classes)

En esta etapa, sus datos están completamente preparados para ingresar a la red.

A continuación, viene la parte más importante y es entrenar nuestro modelo de red.