Blog
Desarrolla tu Primera Red Neural en Python con Keras Paso a Paso
- Publicado por: Rafael Fernandez
- Categoría: Deep Learning
-Entenderemos todo sobre Keras, ademas te explicamos como instalarlo y como construir tu primer modelo de red neuronal en Python usando Keras.
Keras es una librería Python potente y fácil de usar para desarrollar y evaluar los modelos de Deep Learning. Envuelve las bibliotecas de computación numérica Theano y TensorFlow y le permite desentrenar y entrenar modelos de redes neuronales en unas pocas líneas de código.
Descripción del tutorial -> Crea tu Primera Red Neural
No se necesita mucho código, pero vamos a ir paso a paso para que sepas cómo crear tus propios modelos en el futuro.
Los pasos que va a cubrir en este tutorial son los siguientes:
- Cargar datos.
- Definir modelo.
- Modelo de compilación.
- Modelo de ajuste.
- Evaluar modelo.
- Ponlo todo junto.
Este tutorial tiene algunos requisitos:
- Tienes Python 2 o 3 instalado y configurado. En caso contrario ve aquí.
- Usted tiene SciPy (incluyendo NumPy) instalado y configurado (Si tienes Python Anaconda los tienes).
- Usted tiene Keras y un backend (Theano o TensorFlow) instalado y configurado. En caso contrario ve aquí.
Conjunto de datos sobre la diabetes de indios Pima
En este tutorial vamos a utilizar el conjunto de datos sobre el inicio de la diabetes en los indios Pima. Este es una conjunto de datos de machine learning estándar disponible para su descarga gratuita desde el sitio web de Machine Learning de UCI repositorio (pima-indians-diabetes). Describe los datos de los registros médicos de los pacientes de los indios Pima y si tenían la aparición de la diabetes en un plazo de cinco años. Se trata de un problema de clasificación binaria (aparición de diabetes como 1 o no como 0). Las variables de entrada que describen a cada paciente son numéricas y tienen variables de escalas. A continuación se enumeran los ocho atributos del set de datos:
1. Número de embarazos.
2. Concentración de glucosa en plasma a 2 horas en una prueba oral de tolerancia a la glucosa.
3. Presión arterial diastólica (mm Hg).
4. Grosor del pliegue de la piel del tríceps (mm).
5. Insulina sérica de 2 horas (mu U/ml).
6. Índice de masa corporal.
7. Función del pedigrí de la diabetes.
8. Edad (años).
9. Clase, aparición de diabetes en un plazo de cinco años.
Dado que todos los atributos son todos numéricos hace que sea fácil de usar directamente las redes neuronales ya que éstas esperan entradas y salidas numéricas. Por lo tanto estos datos son ideales para nuestra primera red neuronal en Keras. Este conjunto de datos también se utilizará para un número de lecciones adicionales que aparecen en este curso, así que manténgalo a mano. A continuación se muestra una imagen del conjunto de datos que muestra las primeras 20 filas de las 768 instancias:
Crea tu Primera Red Neural con Keras Paso a Paso
1. Datos de carga de la Red Neuronal
Siempre que trabajemos con algoritmos de machine learning que utilicen un proceso estocástico (por ejemplo, números aleatorios), es una buena idea establecer la semilla del número aleatorio.
Esto es para que pueda ejecutar el mismo código una y otra vez y obtener el mismo resultado. Esto es útil si necesita demostrar un resultado, comparar algoritmos usando la misma fuente de aleatoriedad o depurar una parte de su código.
Puede inicializar el generador de números aleatorios con cualquier semilla que desee, por ejemplo:
# Crea tu primer MLP en Keras from keras.models import Sequential from keras.layers import Dense import numpy # Fija las semillas aleatorias para la reproducibilidad numpy.random.seed(7)
Ahora podemos cargar nuestros datos. En este tutorial, vamos a utilizar el conjunto de datos sobre el inicio de la diabetes en los indígenas Pima. Ahora puede cargar el archivo directamente usando la función loadtxt() de NumPy. Hay ocho variables de entrada y una variable de salida (la última columna). Una vez cargado podemos dividir el conjunto de datos en variables de entrada (X) y la variable de clase de salida (Y).
# carga los datos dataset = numpy.loadtxt("pima-indians-diabetes.csv", delimiter=",") # dividido en variables de entrada (X) y salida (Y) X = dataset[:,0:8] Y = dataset[:,8]
Hemos inicializado nuestro generador de números aleatorios para asegurarnos de que nuestros resultados sean reproducibles y cargamos nuestros datos. Ahora estamos listos para definir nuestro modelo de red neuronal.
Tenga en cuenta que el conjunto de datos tiene 9 columnas y el rango 0:8 seleccionará las columnas de 0 a 7, deteniéndose antes del índice 8 (ya que éste es el resultado final, el cual es conocido).
2. Definir el modelo de la Red Neuronal
Los modelos en Keras se definen como una secuencia de capas. Creamos un modelo secuencial y añadimos capas una a una hasta que estamos satisfechos con nuestra topología de red. Lo primero que hay que hacer es asegurarse de que la capa de entrada tiene el número correcto de entradas. Esto se puede especificar al crear la primera capa con el argumento input_dim y establecerlo en 8 para las 8 variables de entrada.
¿Cómo sabemos el número de capas y sus tipos?
Esta es una pregunta muy difícil. Hay estructuras de redes expertas que podemos utilizar y a menudo la mejor estructura de red se encuentra a través de un proceso de experimentación de ensayo y error. Por lo general, se necesita una red lo suficientemente grande para capturar la estructura del problema.
En este ejemplo, utilizaremos una estructura de red conectada con tres capas.
Las capas completamente conectadas se densifican utilizando la clase Dense. Podemos especificar el número de neuronas en la capa como el primer argumento y especificar la función de activación usando el argumento de activación. Usaremos la función de activación del rectificador (relu) en las dos primeras capas y la función de activación sigmoide en la capa de salida. Antes las funciones de activación sigmoide y tanh eran preferidas para todas las capas. Hoy en día, se observa un mejor rendimiento utilizando la función de activación del rectificador. Utilizamos una función de activación sigmoide en la capa de salida para asegurarnos de que nuestra salida de red está entre 0 y 1 y es fácil de mapear a cualquier probabilidad de clase 1 o encajar en una clase dura de cualquiera de las dos clases con un umbral por defecto de 0,5. Unimos todo sumando cada capa. La primera capa oculta tiene 12 neuronas y espera 8 variables de entrada (p. ej. entrada dim=8). La segunda capa oculta tiene 8 neuronas y finalmente la capa de salida que tiene 1 neurona para predecir la clase (inicio de diabetes o no).
# crea el modelo model = Sequential() model.add(Dense(12, input_dim=8, activation='relu')) model.add(Dense(8, activation='relu')) model.add(Dense(1, activation='sigmoid'))
Aquí podemos ver la estructura de la red neuronal:
Capa visible (8 entradas)>>Capa oculta (12 neuronas)>>Capa oculta (8 neuronas)>>Capa de salida (1)
3. Modelo de compilación de la Red Neuronal
Ahora que el modelo está definido, podemos compilarlo.
La compilación del modelo utiliza las eficientes librerías numéricas de backend como Theano o TensorFlow. El backend elige automáticamente la mejor manera de representar la red para entrenar y hacer predicciones para que se ejecuten en su hardware, como CPU o GPU o incluso distribuidas.
Al compilar, debemos especificar algunas propiedades adicionales necesarias para la formación de la red. Recuerde que entrenar una red significa encontrar el mejor conjunto de pesos para hacer predicciones para este problema.
Debemos especificar la función de pérdida a utilizar para evaluar un conjunto de pesos, el optimizador utilizado para buscar a través de diferentes pesos para la red y cualquier métrica opcional que nos gustaría recopilar y reportar durante el entrenamiento.
En este caso, utilizaremos la pérdida logarítmica, que para un problema de clasificación binaria se define en Keras como “binary_crossentropy”. También utilizaremos el algoritmo de descenso de gradiente eficiente “adam” por su alta eficiencia en estos problemas.
Finalmente, debido a que es un problema de clasificación, recopilaremos y reportaremos la exactitud de la clasificación como la métrica.
# Compila el modelo model.compile(loss='binary_crossentropy', optimizer='adam', metrics=['accuracy'])
4. Modelo de ajuste de la Red Neuronal
Hemos definido nuestro modelo y lo hemos compilado listo para un cálculo eficiente. Ahora es el momento de ejecutar el modelo sobre algunos datos. Podemos entrenar o ajustar nuestro modelo a los datos cargados llamando a la función fit() en el modelo.
El proceso de entrenamiento se ejecutará para un número fijo de iteraciones denominado epochs o épocas. También podemos establecer el número de instancias que se evalúan antes de que se realice una actualización de peso en la red llamada batch_size y establecerlo mediante el argumento batch_size. Para este problema utilizaremos un pequeño número de epochs (150) y un batch_size relativamente pequeño (10). Una vez más, estos pueden ser elegidos experimentalmente por ensayo y error.
# Ajusta el modelo model.fit(X, Y, epochs=150, batch_size=10)
Aquí es donde se realiza el trabajo en la CPU o GPU pero no se necesita ninguna GPU para este ejemplo.
5. Evaluar el modelo de la Red Neuronal
Hemos entrenado nuestra red neuronal en todo el conjunto de datos y podemos evaluar el rendimiento de la red en el mismo conjunto de datos.
Esto sólo nos dará una idea de lo bien que hemos modelado el conjunto de datos, pero no nos dará una idea de lo bien que el algoritmo podría funcionar con los nuevos datos. Hemos hecho esto por simplicidad, pero lo ideal sería que separara sus datos en conjuntos de datos de entreno y de prueba para la formación y evaluación de su modelo. Resaltamos esta frase ya que es importante:
lo ideal sería que separara sus datos en conjuntos de datos de entreno y de prueba para la formación y evaluación de su modelo.
Usted puede evaluar su modelo en su conjunto de datos de entrenamiento usando la función evaluate() y pasarle la misma entrada y salida usada para entrenar el modelo.
Esto generará una predicción para cada par de entrada y salida y recogerá las puntuaciones, incluyendo la pérdida media y cualquier métrica que haya configurado, como la precisión.
# evalua el modelo scores = model.evaluate(X, Y) print("\n%s: %.2f%%" % (model.metrics_names[1], scores[1]*100))
6. Nuestra Primera Red Neural
Acaba de ver cómo puede crear fácilmente su primer modelo de red neuronal en Keras.
Vamos a enlazarlo todo en un ejemplo con el código completo.
# Crea tu primer MLP en Keras from keras.models import Sequential from keras.layers import Dense import numpy # Fija las semillas aleatorias para la reproducibilidad numpy.random.seed(7) # carga los datos dataset = numpy.loadtxt("pima-indians-diabetes.csv", delimiter=",") # dividido en variables de entrada (X) y salida (Y) X = dataset[:,0:8] Y = dataset[:,8] # crea el modelo model = Sequential() model.add(Dense(12, input_dim=8, activation='relu')) model.add(Dense(8, activation='relu')) model.add(Dense(1, activation='sigmoid')) # Compila el modelo model.compile(loss='binary_crossentropy', optimizer='adam', metrics=['accuracy']) # Ajusta el modelo model.fit(X, Y, epochs=150, batch_size=10) # evalua el modelo scores = model.evaluate(X, Y) print("\n%s: %.2f%%" % (model.metrics_names[1], scores[1]*100))
Al ejecutar este ejemplo, debería ver un mensaje para cada una de los 150 épocas que imprimen la pérdida y la precisión de cada uno, seguido de la evaluación final del modelo entrenado en el conjunto de datos de entrenamiento.
Se tarda unos 10 segundos en ejecutarse en mi PC que se ejecuta en la CPU con un backend de TensorFlow y por la consola tienes que ver un resultado así:
Epoch 145/150 768/768 [==============================] - 0s - loss: 0.5105 - acc: 0.7396 Epoch 146/150 768/768 [==============================] - 0s - loss: 0.4900 - acc: 0.7591 Epoch 147/150 768/768 [==============================] - 0s - loss: 0.4939 - acc: 0.7565 Epoch 148/150 768/768 [==============================] - 0s - loss: 0.4766 - acc: 0.7773 Epoch 149/150 768/768 [==============================] - 0s - loss: 0.4883 - acc: 0.7591 Epoch 150/150 768/768 [==============================] - 0s - loss: 0.4827 - acc: 0.7656 32/768 [>.............................] - ETA: 0s acc: 78.26%
Nota: Si intenta ejecutar este ejemplo en IPython o Jupyter, es posible que obtenga un error. La razón son las barras de progreso de salida durante el entrenamiento. Puede desactivarlas fácilmente configurando verbose=0 en la llamada a model.fit().
Tenga en cuenta que la habilidad de su modelo puede variar.
Las redes neuronales son un algoritmo estocástico, lo que significa que el mismo algoritmo con los mismos datos puede entrenar un modelo diferente con habilidades diferentes. Esto es una característica, no un error.
7. Hacer predicciones
La pregunta número 1 que me hacen es:
Después de entrenar a mi modelo, ¿cómo puedo usarlo para hacer predicciones sobre nuevos datos?
Podemos adaptar el ejemplo anterior y usarlo para generar predicciones sobre el conjunto de datos de entrenamiento, pretendiendo que es un nuevo conjunto de datos que no hemos visto antes.
Hacer predicciones es tan fácil como llamar a model.predict(). Estamos utilizando una función de activación sigmoide en la capa de salida, por lo que las predicciones estarán en el rango entre 0 y 1. Podemos convertirlas fácilmente en una predicción binaria nítida para esta tarea de clasificación redondeándolas.
El ejemplo completo que hace predicciones para cada registro en los datos de entrenamiento se enumeran a continuación.
# Crea tu primer MLP en Keras from keras.models import Sequential from keras.layers import Dense import numpy # Fija las semillas aleatorias para la reproducibilidad numpy.random.seed(7) # carga los datos dataset = numpy.loadtxt("pima-indians-diabetes.csv", delimiter=",") # dividido en variables de entrada (X) y salida (Y) X = dataset[:,0:8] Y = dataset[:,8] # crea el modelo model = Sequential() model.add(Dense(12, input_dim=8, activation='relu')) model.add(Dense(8, activation='relu')) model.add(Dense(1, activation='sigmoid')) # Compila el modelo model.compile(loss='binary_crossentropy', optimizer='adam', metrics=['accuracy']) # Ajusta el modelo model.fit(X, Y, epochs=150, batch_size=10) # calcula las predicciones predictions = model.predict(X) # redondeamos las predicciones rounded = [round(x[0]) for x in predictions] print(rounded)
Al ejecutar este ejemplo modificado ahora se imprimen las predicciones para cada patrón de entrada. Podríamos usar estas predicciones directamente en nuestra aplicación si fuera necesario. Esto es lo que me sale por consola:
[1.0, 0.0, 1.0, 0.0, 1.0, 0.0, 0.0, 1.0, 1.0, 0.0, 0.0, 1.0, 1.0, 1.0, 1.0, 0.0, 1.0, 0.0, 0.0, 0.0, 1.0, 0.0, 1.0, 0.0, 1.0, 1.0, 1.0, 0.0, 1.0, 0.0, 0.0, 1.0, 0.0, 0.0, 1.0, 1.0, 1.0, 1.0, 0.0, 1.0, 1.0, 1.0, 0.0, 1.0, 1.0,....
Estos 1 o 0 que han salido por consola definen si el usuario tiene diabetes o no y lo podemos comparar con la última columna que tenemos del excel para ver si nuestra predicción es buena.
Resumen
En este post, usted descubrió cómo crear su primer modelo de red neuronal usando la poderosa librería Keras Python para un aprendizaje profundo.
Específicamente, usted aprendió los cinco pasos clave en el uso de Keras para crear una red neuronal o un modelo de aprendizaje profundo, incluyendo paso a paso:
- Cómo cargar datos.
- Cómo definir la red neuronal en Keras.
- Cómo compilar un modelo de Keras.
- Cómo entrenar a un modelo en datos.
- Cómo evaluar un modelo sobre los datos.
¿Tiene alguna pregunta sobre Keras o sobre este tutorial?
➡ Haga su pregunta en los comentarios y haré todo lo posible para responder.
Te recomendamos nuestro curso para adentrarte en el mundo de la IA:
[…] Keras da la posibilidad de guardar su arquitectura de modelo y guardar sus pesos de modelo. Los pesos de los modelos se guardan en formato HDF5. Este es un formato de cuadrícula que es ideal para almacenar matrices multidimensionales de números. La estructura modelo puede describirse y grabarse (y cargarse) utilizando dos formatos diferentes: JSON y YAML. Cada ejemplo también demostrará cómo guardar y cargar los pesos de sus modelos con formato HDF5. Los ejemplos utilizarán la misma red simple formada en el conjunto de datos de clasificación binaria de la diabetes de los indios Pima. […]
hola, quisiera saber como guardaste los datos .CSV localmente, tengo mis propios datos, pero al colocar la ruta y cargalos me arroja un error. saludos
Hola Jonathan, los datos los puedes descargar desde aquí pima-indians-diabetes
Hola, muy buen aporte muchas gracias tengo un par de preguntas, el vector de entrada son los primeras 7 columnas y el de salida es la 8?
y como podria probarlo?
de nuevo muchas gracias
Hola Edgar, los datos de entrada son desde la columna 1 a la 8, en python es X = dataset[:,0:8], ten en cuenta que el conjunto de datos tiene 9 columnas y el rango 0:8 seleccionará las columnas de 0 a 7, deteniéndose antes del índice 8 (ya que éste es el resultado final, el cual es conocido). A continuación seguimos con el tutorial y la última columna la usamos para comprobar si nuestra red neuronal hace bien el trabajo o no, ya que conocemos el resultado y podemos comparar el resultado final de nuestro código con el resultado real.
Muchas gracias
De nada Edgar, gracias por comentar.
[…] red neuronal para los indios Pima con el problema de clasificación binaria de la diabetes (ver el post). En el ejemplo se utiliza el 33% de los datos para la validación. La función Checkpointing está […]
[…] modelar la aparición del problema de clasificación binaria de la diabetes en los indios Pima (ver este post). El ejemplo recoge el historial, devuelto de la formación del modelo y crea dos […]
[…] Nota: Se asume que tiene una familiaridad básica con el aprendizaje profundo en Keras, este capítulo debería proporcionar una actualización de la API de Keras. La mayoría de los fragmentos de código en este tutorial son sólo de referencias y no son ejemplos completos. Para un ejemplos completo le recomendamos el post: Cómo hacer tu Primera Red Neural en Python con Keras Paso a Paso […]
Hola, quería saber si me podías ayudar con la última parte.
Quisiera hacer la comparación de la predicción con la última columna del excel para ver si la predicción es buena. ¿Cómo lo podría hacer?
Estaba probando en crear un archivo csv nuevo con las siguientes líneas:
with open(‘fichero_salida.csv’,’w’) as f: # crea el fichero fichero_salida.csv
f.write(‘aquí lo que quieras “imprimir” en el fichero, en una línea’) # escribe un texto en un fichero
f.write(‘aquí lo que quieras “imprimir” en el fichero, en otra línea’)
f.write(‘aquí lo que quieras “imprimir” en el fichero, etc.’)
Pero no sabría como coger la última columna del conjunto de datos y juntarlo con la predicción en un archivo nuevo para saber si es buena o no. ¿Me puede ayudar?
Gracias
Hola Juan lo que pretendes es posible si haces el Curso de Deep Learning – https://unipython.com/curso-de-deep-learning/
Hola.
Una consulta, si mi última columna no se clasifica en 0 y 1, sino en 0 a 10. Cómo haría para aplicar la este caso.
Gracias
Hola Jose, gracias por escribir. Si te sale de 0 a 10 la solución vuelve a revisar el código porque algo estará incorrecto ya que este ejemplo se trata de un problema de clasificación binaria (aparición de diabetes como 1 o no como 0).
Felicitaciones Edgar, simple y conciso,
Buen articulo, como podría agregar datos de validación diferentes a los de entrenamiento.
Hola, Buen articulo.
Después de revisar mucho en Internet, veo que hay mucho ejemplos de intro que les hace falta el how to de pasar del “simple” entrenamiento, a predecir un string que le pase a una función de por ejemplo calificación, pero desde el punto de vista de un modelo finalizado, es decir, entrenar, almacenar el modelo con Picklr, y desde otro programa python independiente, poder cargar el modelo y hacer una predicción. A ello sumar el obtener el accuracy o alguna métrica que me sirva para determinar si una ŕedicción está dentro de un margen que necesite…
Si alguien tiene una guía completa (entrenamiento y paso a prod) por favor me lo haga saber).
Gracias.
Buen día excelente aporte, estoy intentando crear una red neuronal que haga predicciones sobre posibles complicaciones de la diabetes, ya sea retinopatia, pie diabetico, insuficiencia renal, etc, teniendo como base datos tales cuales, edad, sexo, almentacion, ejercicio, niveles de azúcar, ejercicio, etc, quiero introducir los datos que seria mejor, mediante archivo XML, o Json?
Hola Fersho, en realidad introducir los datos en XML o Json es solo una manera y no es ni mejor ni peor a priori.
Muchas gracias por tu respuesta, una pregunta mas , si me permites, una recomendación por favor, sobre tensorflow, keras, numpy, tomando en cuenta que soy nuevo en esto.
[…] Keras da la posibilidad de guardar su arquitectura de modelo y guardar los pesos del modelo. Los pesos de los modelos se guardan en formato HDF5. Este es un formato de cuadrícula que es ideal para almacenar matrices multidimensionales de números. La estructura modelo puede describirse y grabarse (y cargarse) utilizando dos formatos diferentes: JSON y YAML. Cada ejemplo también demostrará cómo guardar y cargar los pesos de sus modelos con formato HDF5. Los ejemplos utilizarán la misma red simple formada en el conjunto de datos de clasificación binaria de la diabetes de los indios Pima. […]
[…] Se asume que el lector tiene una familiaridad básica con Deep Learning en Keras, este capítulo debería proporcionar una actualización de la API de Keras. La mayoría de los fragmentos de código en este tutorial son sólo de referencias y no son ejemplos completos. Para un ejemplo completo le recomendamos el post: Cómo hacer tu Primera Red Neural en Python con Keras Paso a Paso […]
Hola!!! Muchas gracias por la explicación, solo me quedo la duda de como escogemos cuantas neuronas deben ir en cada capa y por qué usar binary_crossentropy y no categorical_entropy?
Buenas Cynthia, en ese ejemplo es facil ya que es un problema binario (si / no) por lo que hemos usado binary_crossentropy, saludos!
Muchas gracias por las respuestas. Tengo otra duda! Siempre que cree una red neuronal necesito normalizar mis datos con StandarScaler?
Popr ejemplo, con el dataset anterior de la diabetes, lo he separado en entrenamiento y testeo, pero tendria luego que normalizar los datos asi:
from sklearn.preprocessing import StandardScaler
sc = StandardScaler()
x_train = sc.fit_transform(x_train)
x_test = sc.fit_transform(x_test)
¿Es innecesario?
Hola, estoy utilizando la red pero con otro .csv con datos reales los cuales estoy intentando clasificar, me gustaría saber cual es el rango de datos para poder saber si la clasificación esta correcta o no?
Gracias!
Hola Sheyla, cuando se comparan los resultados de la red neuronal con los resultados reales se calcula un porcentage de precisión. Mientras más cercano al 100% mejor clasifica tu red neuronal. Gracias por comentar 🙂
Hola.
Podéis ayudarme para poder sacar un esquema de la red entrenada? Sería una figura que represente el numero de capas y neuronas de cada una de ellas , así como las entradas y salidas. Imagino que hay algún comando, pero la verdad lo desconzco.
Muchas gracias
Que tal… Excelente información la que nos aportan, pero tengo algunas dudas, me gustaría hacer clasificación de datos desde un .csv y no se de que manera hacerlo, tomando como referencia esta red neuronal, creen poderme ayudar con eso?
De ante mano, Gracias.
Como determina el porcentaje pues al ejecutarlo muestra imprimen las predicciones para cada patrón de entrada?.
Hola Car, si te refieres a calcular el % de acierto de la red neuronal es tan sencillo como hacer una regla de 3, si suponemos que hay 80 predicciones y acertamos las 80 pues tenemos un 100% de acierto y si tenemos 80 predicciones y acertamos 60 pues tenemos un 75% de acierto. Saludos!
buenos días gracias por la informacion tengo un apregunta si yo quiero mi primera red neuronal de pregutas y respuestas con documentos creados por mi tensorflow de que manera me ayudaria