¿Red neuronal en Keras y por qué la biblioteca Keras?
Para una Red neuronal en Keras se utiliza la biblioteca Keras que es la recomendada para principiantes, ya que su curva de aprendizaje es muy fluida en comparación con otras, y por el momento es una de las middleware popular para implementar redes neuronales.
Keras es una biblioteca de Python que proporciona, de manera simple. La creación de una amplia gama de modelos de Deep Learning utilizando como backend otras bibliotecas como TensorFlow, Theano o CNTK.
Fue desarrollado y mantenido por François Chollet un ingeniero de Google, y su código ha sido lanzado bajo la licencia permisiva de MIT.
También es importante que Keras esté incluido en TensorFlow como API . Aunque la biblioteca Keras se incluye actualmente en el paquete Tensorflow, pero también se puede utilizar como una biblioteca de Python. Para comenzar en el tema, considero que esta segunda opción es la más adecuada.
El código en esta publicación está disponible en forma de cuadernos Jupyter en GitHub ( https://github.com/JordiTorresBCN/DEEP -LEARNING-practical-introduction-with-Keras ), aunque puede ejecutarse como un programa normal en Python.
Esta publicación mostrará cómo el ejemplo de reconocimiento de dígitos, presentado en una publicación previa (recomiendo leerlo previamente), está codificado con Keras para ofrecer al lector un primer contacto práctico con Deep Learning usando esta biblioteca de Python.
Entorno colaborativo
En esta publicación, usaremos Colaboratory ofrecido por Google .
Es un proyecto de investigación de Google creado para ayudar a difundir la educación e investigación sobre Machine Learning.
Es un entorno de notebook Jupyter que no requiere configuración y se ejecuta completamente en la nube, lo que permite el uso de biblioteca Keras, TensorFlow y PyTorch.
La característica más importante que distingue a Colab de otros servicios gratuitos en la nube es; Colab proporciona GPU y es totalmente gratuito.
Los portátiles se almacenan en Google Drive y se pueden compartir como lo haría con Google Docs.
Este entorno es de uso gratuito, que solo requiere una cuenta de Google. Además, el entorno permite el uso de una GPU NVIDIA K80 de forma gratuita.
Al ingresar por primera vez, verá una ventana como la que se muestra a continuación. En esta ventana, debe seleccionar la pestaña GITHUB y completar el campo URL con “JordiTorresBCN” y el campo Repositorio con “jorditorresBCN / DEEP-LEARNING-practical-introduction-with-Keras”.
Para cargar un cuaderno, haga clic en el botón que aparece a su derecha (abrir el cuaderno en una nueva pestaña):
De forma predeterminada, los cuadernos Colab se ejecutan en la CPU. Puede cambiar su computadora portátil para que se ejecute con GPU.
Para obtener acceso a una GPU, debemos elegir la pestaña Runtime y luego seleccionar “Cambiar el tipo de tiempo de ejecución” como se muestra en la siguiente figura:
Cuando aparece una ventana emergente, seleccione la GPU. Asegúrese de que “acelerador de hardware” esté configurado en GPU (el valor predeterminado es CPU).
Puede aparecer una advertencia que indique que el código no ha sido creado por Google. ¡Espero que confíes en mi código y lo ejecutes de todos modos!
Después, asegúrese de estar conectado al tiempo de ejecución (hay una marca verde al lado de “conectado” en la cinta del menú):
Ahora puede ejecutar el repositorio de GitHub en Google Colab. Enjoy!
Datos para alimentar una red neuronal en Keras
Conjunto de datos para entrenamiento, validación y pruebas
Antes de presentar la implementación en biblioteca Keras del ejemplo anterior, repasemos cómo debemos distribuir los datos disponibles para configurar y evaluar el modelo correctamente.
Para la configuración y evaluación de un modelo en Machine Learning, y por lo tanto Deep Learning, los datos disponibles se dividen generalmente en tres conjuntos: datos de entrenamiento, datos de validación y datos de prueba.
Los datos de entrenamiento son los utilizados para el algoritmo de aprendizaje para obtener los parámetros del modelo con el método iterativo que ya hemos mencionado.
Si el modelo no se adapta completamente a los datos de entrada (por ejemplo, si presentaba un ajuste excesivo).
En este caso, modificaríamos el valor de ciertos hiperparámetros y después de entrenarlo de nuevo con los datos de entrenamiento lo evaluaríamos nuevamente con los de validación.
Podemos hacer estos ajustes de los hiperparámetros guiados por los datos de validación hasta que obtengamos resultados de validación que consideramos correctos. Si hemos seguido este procedimiento, debemos ser conscientes de que, de hecho, los datos de validación han influido en el modelo para que también se ajuste a los datos de validación.
Por este motivo, siempre reservamos un conjunto de datos de prueba para la evaluación final del modelo que solo se utilizará al final de todo el proceso. Cuando consideramos que el modelo ya está afinado y ya no modificaremos ninguno de los modelos. sus hiperparámetros.
Dado el carácter introductorio de esta publicación y que no vamos a entrar en detalles para ajustar los hiperparámetros, en los ejemplos ignoraremos los datos de validación y solo utilizaremos los datos de entrenamiento y prueba.
Datos precargados en biblioteca Keras
En biblioteca Keras, el conjunto de datos MNIST se precarga en forma de cuatro matrices Numpy y se puede obtener con el siguiente código:
import keras from keras.datasets import mnist (x_train, y_train), (x_test, y_test) = mnist.load_data ()
x_train y y_train contienen el conjunto de entrenamiento, mientras que x_test y y_test contienen la prueba datos. Las imágenes están codificadas como matrices Numpy y sus etiquetas correspondientes van de 0 a 9.
Siguiendo la estrategia de la publicación de introducir gradualmente los conceptos del tema, como hemos indicado, no veremos aún cómo separar una parte del entrenamiento. datos para usarlos como datos de Validación.
Solo tomaremos en cuenta los datos de entrenamiento y prueba.
Si queremos verificar qué valores hemos cargado, podemos elegir cualquiera de las imágenes del conjunto MNIST.
Por ejemplo, la imagen 8, y usando el siguiente código de Python:
import matplotlib.pyplot as plt plt.imshow(x_train[8], cmap=plt.cm.binary)
Obtenemos la siguiente imagen:
Y si queremos ver su etiqueta correspondiente podemos hacerlo a través de:
print(y_train[8]) 1
Eso, como vemos, devuelve el valor de “1”, como se esperaba.
Representación de datos en biblioteca Keras, que como hemos visto usa una matriz multidimensional de Numpy como estructura de datos básica, llama a esta estructura de datos un tensor .
En resumen, podríamos decir que un tensor tiene tres atributos principales:
- Número de ejes ( Rango ): un tensor que contiene un solo número se llamará escalar (o un tensor de 0 dimensiones) , o tensor 0D). Una matriz de números que llamamos vector o tensor 1D. Una matriz de vectores será una matriz o un tensor 2D. Si empaquetamos esta matriz en una nueva matriz, obtenemos un tensor 3D, que podemos interpretar visualmente como un cubo de números. Al empacar un tensor 3D en una matriz, podemos crear un tensor 4D, y así sucesivamente. En la biblioteca de Python Numpy esto se llama tensor’s ndim .
- Shape : es una tupla de enteros que describe cuántas dimensiones tiene el tensor a lo largo de cada eje. En la biblioteca Numpy este atributo se llama forma .
- D tipo ata : este atributo indica el tipo de datos que contiene el tensor, que puede ser, por ejemplo uint8 float32 float64 etc. En la biblioteca Numpy este atributo se llama dtype .
Propongo que obtengamos el número de ejes y dimensiones del tensor train_images de nuestro ejemplo anterior:
print(x_train.ndim) 3 print(x_train.shape) (60000, 28, 28)
Y si queremos saber qué tipo de datos contiene:
print(x_train.dtype) uint8
Normalización de datos en Keras
Estas imágenes MNIST de 28 × 28 píxeles son representado como una matriz de números cuyos valores van desde [0, 255] de tipo uint8. Pero es normal escalar los valores de entrada de las redes neuronales a ciertos rangos.
En el ejemplo de esta publicación, los valores de entrada se deben escalar a valores de tipo float32 dentro del intervalo [0, 1].
Podemos lograr esta transformación con las siguientes líneas de código:
x_train = x_train.astype(‘float32’) x_test = x_test.astype(‘float32’) x_train /= 255 x_test /= 255
Por otro lado, para facilitar la entrada de datos en nuestra red neuronal en Keras(veremos que en convolucionales no es necesario) debemos hacer una transformación del tensor (imagen) de 2 dimensiones (2D) a un vector de 1 dimensión (1D).
Es decir, la matriz de 28 × 28 números se puede representar mediante un vector (matriz) de 784 números (concatenando fila por fila), que es el formato que acepta como entrada una red neuronal en Keras densamente conectada como la que veremos en este enviar.
En Python, convertir todas las imágenes del conjunto de datos MNIST en vector con 784 componentes se puede lograr de la siguiente manera:
x_train = x_train.reshape(60000, 784) x_test = x_test.reshape(10000, 784)
Después de ejecutar estas instrucciones Python, podemos verificar que x_train.shape tome la forma de (60000, 784) y x_test.shape tome la forma de (10000, 784),
Donde el la primera dimensión indexa la imagen y la segunda indexa el píxel en cada imagen (ahora la intensidad del píxel es un valor entre 0 y 1):
print(x_train.shape) (60000, 784) print(x_test.shape) (10000, 784)
Además de eso, tenemos las etiquetas para cada dato de entrada (recuerde que en nuestro caso son números entre 0 y 9 que indican qué dígito representa la imagen , es decir, a qué clase está asociado).
En este ejemplo, y como ya hemos avanzado, representaremos esta etiqueta con un vector de 10 posiciones, donde la posición correspondiente al dígito que representa la imagen contiene un 1 y las posiciones restantes del vector contienen el valor 0.
En este ejemplo utilizaremos lo que se conoce como codificación única que ya hemos mencionado, que consiste en transformar las etiquetas en un vector de tantos ceros como el número de etiquetas diferentes, y que contiene el valor de 1 en el índice que corresponde al valor de la etiqueta.
La biblioteca Keras ofrece muchas funciones de soporte, incluyendo to_categorical para realizar precisamente esta transformación, que podemos importar desde keras.utils :
from keras.utils import to_categorical
Para ver la efecto de la transformación podemos ver los valores antes y después de aplicar to_categorical :
print(y_test[0]) 7 print(y_train[0]) 5 print(y_train.shape) (60000,) print(x_test.shape) (10000, 784) y_train = to_categorical(y_train, num_classes=10) y_test = to_categorical(y_test, num_classes=10) print(y_test[0]) [0. 0. 0. 0. 0. 0. 0. 1. 0. 0.] print(y_train[0]) [0. 0. 0. 0. 0. 1. 0. 0. 0. 0.] print(y_train.shape) (60000, 10) print(y_test.shape) (10000, 10)
Ahora tenemos listos los datos para usar en nuestro ejemplo de modelo simple que vamos para programar en Keras en la próxima sección.
Redes conectadas densamente en Keras
En esta sección, presentaremos cómo especificar en Keras el modelo que hemos definido en las secciones anteriores.
Clase secuencial en Keras
La estructura de datos principal en Keras es la clase Secuencial que permite la creación de una red neuronal en Keras básica. Keras también ofrece una API que permite implementar modelos más complejos en forma de un gráfico que puede tener múltiples entradas, múltiples salidas, con conexiones arbitrarias intermedias, pero está más allá del alcance de esta publicación. La clase Secuencial de la biblioteca Keras es una envoltura para el modelo de red neuronal en Keras ofrece y puede crearse de la siguiente manera:
from keras.models import Sequential model = Sequential()
En este caso, el modelo en Keras se considera como una secuencia de capas y cada una de ellas “destila” gradualmente los datos de entrada para obtener el resultado deseado. En Keras podemos encontrar todos los tipos de capas requeridos que se pueden agregar fácilmente al modelo a través del método add () .
Definir el modelo
La construcción en biblioteca Keras de nuestro modelo para reconocer las imágenes de los dígitos podrían ser las siguientes:
from keras.models import Sequential from keras.layers.core import Dense, Activation model = Sequential() model.add(Dense(10, activation=’sigmoid’, input_shape=(784,))) model.add(Dense(10, activation=’softmax’))
Aquí, la red neuronal en Keras se ha definido como una secuencia de dos capas que están densamente conectados (o totalmente conectados), lo que significa que todas las neuronas de cada capa están conectadas a todas las neuronas de la siguiente capa.
Visualmente podríamos representarlo de la siguiente manera:
En el código anterior expresamos explícitamente en el argumento input_shape de la primera capa cómo son los datos de entrada:
Un tensor que indica que tenemos 784 características del modelo (de hecho, el tensor que se está definiendo es (Ninguno, 784,) como veremos más adelante).
Una característica muy interesante de la biblioteca Keras es que deducirá automáticamente la forma de los tensores entre capas después de la primera.
Esto significa que el programador solo tiene que establecer esta información para el primero de ellos. Además, para cada capa indicamos el número de nodos que tiene y la función de activación que aplicaremos en él (en este ejemplo, sigmoide ).
La segunda capa en este ejemplo es un softmax capa de 10 neuronas, lo que significa que devolverá una matriz de 10 valores de probabilidad que representan los 10 dígitos posibles (en general, la capa de salida de una red de clasificación tendrá tantas neuronas como clases, excepto en un clasificación binaria, donde solo se necesita una neurona).
Cada valor será la probabilidad de que la imagen del dígito actual pertenezca a cada uno de ellos.
Un método muy útil que la biblioteca Keras proporciona para verificar la arquitectura de nuestro modelo es summary () : model.summary ()
model.summary() _________________________________________________________________ Layer (type) Output Shape Param # ================================================================= dense_1 (Dense) (None, 10) 7850 _________________________________________________________________ dense_2 (Dense) (None, 10) 110 ================================================================= Total params: 7,960 Trainable params: 7,960 Non-trainable params: 0
Más adelante veremos más detalles con la información que devuelve el método resumen () porque este cálculo de parámetros y tamaños de los datos que los neurales la red tiene cuando comenzamos a construir v Los modelos de redes grandes son muy valiosos.
Para nuestro ejemplo simple, vemos que indica que se requieren 7,960 parámetros (columna Param # ), que corresponden a 7,850 parámetros a la primera capa y 110 a la segunda.
En la primera capa, para cada neurona i (entre 0 y 9) se requieren 784 parámetros para los pesos wij y, por lo tanto, 10 × 784 parámetros para almacenar los pesos de las 10 neuronas. Además de los 10 parámetros adicionales para los 10 bj sesgos correspondientes a cada uno de ellos. En la segunda capa, al ser una función de softmax, se requiere conectar las 10 neuronas con las 10 neuronas de la capa previa. Por lo tanto, se requieren 10×10 wi parámetros y además 10 bj sesgos correspondientes a cada nodo.
Los detalles de los argumentos que podemos indicar para el Denso capa se puede encontrar en el manual de Keras.
En nuestro ejemplo, aparecen los más relevantes. El primer argumento indica la cantidad de neuronas en la capa; la siguiente es la función de activación que usaremos en ella.
En la próxima publicación (próximamente :-)) discutiremos más detalladamente otras posibles funciones de activación más allá de las dos presentadas aquí: sigmoid y softmax.
La inicialización de los pesos también se indica a menudo como un argumento de la Denso capas. Los valores iniciales deben ser adecuados para que el problema de optimización converja lo más rápido posible. Las diversas opciones de inicialización también se pueden encontrar en el manual de Keras.
Pasos básicos para implementar una red neuronal en Keras
A continuación, presentaremos una breve descripción de los pasos que debemos realizar para implementar una red neuronal en Keras básica y, en las siguientes publicaciones (próximamente), introduciremos gradualmente más detalles sobre cada uno de estos pasos.
Configuración del proceso de aprendizaje
A partir del Modelo secuencial podemos defina las capas de una manera simple con el método add () como hemos avanzado en la sección anterior.
Una vez que tenemos nuestro modelo definido, podemos configurar cómo será su proceso de aprendizaje con el método compilar () con el cual podemos especificar algunas propiedades a través de los argumentos del método.
El primero de estos argumentos es el función de pérdida que usaremos para evaluar el grado de error entre las salidas calculadas y las salidas deseadas de los datos de entrenamiento.
Por otro lado, especificamos un optimizador que, como veremos, es la forma en que tenemos que especificar el algoritmo de optimización que permite a la red neuronal en Keras calcular el peso de los parámetros de los datos de entrada y el función de pérdida definida.
Más detalles sobre el propósito exacto de la función de pérdida y el optimizador se presentarán en la próxima publicación (próximamente).
Y finalmente debemos indicar la métrica que usaremos para monitorear el proceso de aprendizaje (y prueba) de nuestra red neuronal.
En este primer ejemplo solo consideraremos la precisión (fracción de imágenes que están clasificadas correctamente).
Por ejemplo, en nuestro caso podemos especificar los siguientes argumentos en el método compilar () para probarlo en nuestra computadora:
model.compile(loss=”categorical_crossentropy”, optimizer=”sgd”, metrics = [‘accuracy’])
En este ejemplo especificamos que la función de pérdida es categórica_crossentropy el optimizador utilizado es el pendiente de gradiente estocástica (sgd) y la métrica es precisión con la cual evaluaremos el porcentaje de conjeturas correctas.
Modelo de entrenamiento
Una vez que nuestro modelo ha sido definido y el método de aprendizaje configurado, está listo para ser entrenado. Para esto podemos entrenar o “ajustar” el modelo a los datos de entrenamiento disponibles invocando el método fit () del modelo:
model.fit(x_train, y_train, batch_size=100, epochs=5)
En los primeros dos argumentos, hemos indicado los datos con los que formaremos el modelo en forma de matrices Numpy.
El argumento batch_size indica el número de datos que usaremos para cada actualización de los parámetros del modelo y con epochs indicamos el número de veces que utilizaremos todos los datos en el aprendizaje proceso.
Estos dos últimos argumentos se explicarán con mucho más detalle en la siguiente publicación (próximamente).
Este método encuentra el valor de los parámetros de la red a través del algoritmo de entrenamiento iterativo que mencionamos y presentaremos con un poco más de detalle en la próxima publicación (pronto).
Aproximadamente, en cada iteración de este algoritmo, este algoritmo toma datos de entrenamiento de x_train los pasa a través de la red neuronal en Keras(con los valores que tienen sus parámetros en ese momento).
Compara el resultado obtenido con el esperado (indicado en y_train ) y calcula la pérdida para guiar el proceso de ajuste de los parámetros del modelo, que intuitivamente consiste en aplicar el optimizador especificado anteriormente en la compilación () método para calcular un nuevo valor de cada uno de los parámetros del modelo (ponderaciones y sesgos) en cada iteración de tal manera que la pérdida se reduce.
Este es el método que, como veremos, puede tomar más tiempo y Keras nos permite ver su progreso usando el argumento detallado (por defecto, igual a 1), además de indicar un estimado de cuánto dura cada época :
Epoch 1/5 60000/60000 [========] — 1s 15us/step — loss: 2.1822 — acc: 0.2916 Epoch 2/5 60000/60000 [========] — 1s 12us/step — loss: 1.9180 — acc: 0.5283 Epoch 3/5 60000/60000 [========] — 1s 13us/step — loss: 1.6978 — acc: 0.5937 Epoch 4/5 60000/60000 [========] — 1s 14us/step — loss: 1.5102 — acc: 0.6537 Epoch 5/5 60000/60000 [========] — 1s 13us/step — loss: 1.3526 — acc: 0.7034 10000/10000 [========] — 0s 22us/step
Este es un ejemplo simple, al final de la publicación ya se ha podido programar su primera red neuronal en Keras pero, como veremos, el método fit () permite muchos más argumentos que tienen un impacto muy importante en el resultado del aprendizaje.
Además, este método devuelve un objeto History que hemos omitido en este ejemplo. Su atributo History.history es el registro de los valores de pérdida para los datos de entrenamiento y otras métricas en sucesivas épocas así como otras métricas para los datos de validación si se han especificado.
Evaluación del modelo
En este punto, la red neuronal en Keras se ha entrenado y su comportamiento con los nuevos datos de prueba ahora se puede evaluar utilizando el método de evaluación () . Este método devuelve dos valores:
test_loss, test_acc = model.evaluate(x_test, y_test)
Estos valores indican qué tan bien o mal se comporta nuestro modelo con los nuevos datos que nunca ha visto.
Estos datos han sido almacenados en x_test y y_test cuando hemos realizado mnist.load_data () y los pasamos al método como argumentos.
En el alcance de esta publicación solo veremos uno de ellos, la precisión:
print(‘Test accuracy:’, test_acc) Test accuracy: 0.9018
La exactitud nos dice que el modelo que creado en esta publicación. Aplicado a datos que el modelo nunca había visto antes, clasifica el 90% de ellos correctamente.
Debemos tener en cuenta que, en este ejemplo, para evaluar el modelo solo nos hemos centrado en su precisión. Que es la relación entre las predicciones correctas que el modelo ha hecho sobre las predicciones totales. Independientemente de la categoría en que se encuentre.
Sin embargo, aunque en este caso es suficiente, a veces es necesario ahondar un poco más y tener en cuenta los tipos de predicciones correctas e incorrectas realizadas por el modelo en cada una de sus categorías.
En Machine Learning, una herramienta muy útil para evaluar modelos es la matriz de confusión. Una tabla con filas y columnas que cuentan las predicciones en comparación con los valores reales.
Utilizamos esta tabla para comprender mejor cómo se comporta el modelo y es muy útil mostrarlo explícitamente cuando una clase se confunde con otra.
Una matriz de confusión para un clasificador binario como el explicado en la publicación anterior tiene esta estructura:
Verdaderos positivos (TP), verdaderos negativos (TN), falsos positivos (FP) y falsos negativos ( FN), son los cuatro resultados posibles diferentes de una predicción única para un caso de dos clases con clases “1” (“positivo”) y “0” (“negativo”).
Un falso positivo es cuando el resultado es incorrectamente clasificado como positivo, cuando de hecho es negativo.
Un falso negativo es cuando el resultado se clasifica incorrectamente como negativo cuando de hecho es positivo. Verdaderos positivos y verdaderos negativos son obviamente clasificaciones correctas.
Con esta matriz de confusión, la exactitud se puede calcular sumando los valores de la diagonal y dividiéndolos por el total:
Precisión = (TP + TN) / (TP + FP + FN + TN)
Sin embargo, la precisión puede ser engañosa en términos de la calidad del modelo porque, al medirlo para el modelo concreto, no distinguimos entre falso positivo y errores de tipo falso negativo, como si ambos tuvieran la misma importancia.
Por ejemplo, piense en un modelo que prediga si un hongo es venenoso.
En este caso, el costo de un falso negativo, es decir, un hongo venenoso dado para el consumo podría ser dramático. Por el contrario, un falso positivo tiene un costo muy diferente.
Por esta razón tenemos otra métrica llamada Sensibilidad (o recuerdo ) que nos dice qué tan bien el modelo evita las falsas negativos:
Sensibilidad = TP / (TP + FN)
En otras palabras, del total de observaciones positivas (hongos venenosos), cuántos detecta el modelo.
De la confusión matriz, se pueden obtener varias métricas para enfocar otros casos como se muestra en este enlace pero está más allá del alcance de esta publicación entrar más en detalle sobre este tema.
La conveniencia de usar una métrica u otra dependerá de cada caso particular y, en particular, del “costo” asociado con cada error de clasificación del modelo.
Se preguntará cómo es esta matriz de confusión en nuestro clasificador, donde hay 10 clases en lugar de 2.
En este caso, sugiero usar el paquete Scikit-learn para evaluar la calidad del modelo al calcular la matriz de confusión presentada en la siguiente figura:
En este caso, los elementos de la diagonal representan el número de puntos en los que la etiqueta predicha por el modelo coincide con el valor real de la etiqueta, mientras que los otros valores indican los casos en los que el modelo tiene clasificado incorrectamente.
Por lo tanto, cuanto más altos sean los valores de la diagonal, mejor será la predicción.
En este ejemplo, si calculamos la suma de los valores de la diagonal divididos por los valores totales de la matriz, verá que coincide con la precisión que ha devuelto el método evaluar () .
En GitHub de la publicación, puede encontrar el código usado para calcular esta matriz de confusión.
Generar predicciones
Finalmente, los lectores necesitan saber cómo podemos usar el modelo capacitado en la sección anterior para hacer predicciones.
En nuestro ejemplo, consiste en predecir qué dígito representa una imagen. Para ello, la biblioteca Keras proporciona el método predict () .
Si queremos probar este método, podemos elegir cualquier elemento. Para facilitar, tomemos uno del conjunto de datos de prueba x_test . Por ejemplo, elijamos el elemento 11 de este conjunto de datos x_test .
Antes de ver la predicción, veamos la imagen para poder verificar si el modelo está haciendo una predicción correcta (antes de hacer la reforma anterior) ):
plt.imshow(x_test[11], cmap=plt.cm.binary)
Creo que aceptaremos que en este caso corresponde al número 6.
Ahora veamos que predict () método del modelo, que ejecuta el siguiente código, predice correctamente el valor que acabamos de estimar que debe predecir.
predictions = model.predict(x_test)
The predict () método devuelve un vector con las predicciones para los elementos del conjunto de datos completo. Podemos saber qué clase da la mayor probabilidad de pertenencia mediante la función argmax de Numpy. Que devuelve el índice de la posición que contiene el valor más alto del vector.
Específicamente, para el ítem 11:
np.argmax(predictions[11]) 6
Podemos verificarlo imprimiendo el vector devuelto por el método:
print(predictions[11]) [0.06 0.01 0.17 0.01 0.05 0.04 0.54 0. 0.11 0.02]
Vemos que el valor más alto en el vector está en la posición 6. También podemos verificar que el resultado de la predicción es un vector cuya suma de todos sus componentes es igual a 1, como se esperaba.
Para esto podemos usar:
np.sum(predictions[11]) 1.0
Hasta ahora, hemos podido crear nuestro primer modelo en Keras que clasifica correctamente los dígitos MNIST el 90% del tiempo .
En la próxima publicación (próximamente), presentaremos cómo funciona el proceso de aprendizaje y varios de los hiperparámetros que podemos usar en una red neuronal en Keras para mejorar estos resultados.
