Una sencilla Red Neuronal en Python con Keras y Tensorflow

Crearemos una red neuronal artificial muy sencilla en Python con Keras y Tensorflow para comprender su uso. Implementaremos la compuerta XOR e intentaré comparar las ventajas del aprendizaje automático frente a la programación tradicional.

Requerimientos para el ejercicio

Puedes simplemente leer el código y comprenderlo o si quieres ejecutarlo deberás tener un ambiente de desarrollo Python como Anaconda para ejecutar el Jupyter Notebook (también funciona con python en línea de comandos). Sigue el tutorial para tener tu suite preparada e instalar Keras y Tensorflow. Al final del artículo podrás ver y descargar el código de GitHub.

Si aún no tienes muy claro qué son o cómo funcionan las Redes Neuronales, pues leer mi Guía Rápida sobre Deep Learning y luego volver aquí.

Las compuertas XOR

Para el ejemplo, utilizaremos las compuertas XOR. Si no las conoces o no las recuerdas, funcionan de la siguiente manera:

Tenemos dos entradas binarias (1 ó 0) y la salida será 1 sólo si una de las entradas es verdadera (1) y la otra falsa (0).

Es decir que de cuatro combinaciones posibles, sólo dos tienen salida 1 y las otras dos serán 0, como vemos aquí:

  • XOR(0,0) = 0
  • XOR(0,1) = 1
  • XOR(1,0) = 1
  • XOR(1,1) = 0

Una Red Neuronal Artificial sencilla con Python y Keras

Veamos el código completo en donde creamos una red neuronal con datos de entrada las 4 combinaciones de XOR y sus 4 salidas ordenadas. Luego analizamos el código linea a linea.

¿Keras y Tensorflow? What??

Utilizaremos Keras que es una librería de alto nivel, para que nos sea más fácil describir las capas de la red que creamos y en background es decir, el motor que ejecutará la red neuronal y la entrenará estará la implementación de Google llamada Tensorflow, que es la mejor que existe hoy en día.

¿Quieres crear una Red Neuronal desde cero y sin librerías? Aquí el código Python!

Analicemos la red neuronal que hicimos

Primero importamos las clases que utilizaremos:

Utilizaremos numpy para el manejo de arrays. De Keras importamos el tipo de modelo Sequential y el tipo de capa Dense que es la “normal”.

Creamos los arrays de entrada y salida.

Como se puede ver son las cuatro entradas posibles de la función XOR [0,0], [0,1], [1,0],[1,1] y sus cuatro salidas: 0, 1,1,0.

Ahora crearemos la arquitectura de nuestra red neuronal:

Primero creamos un modelo vació de tipo Sequential. Este modelo se refiere a que crearemos una serie de capas de neuronas secuenciales, “una delante de otra”.

Agregamos dos capas Dense con “model.add()”. Realmente serán 3 capas, pues al poner input_dim=2 estamos definiendo la capa de entrada con 2 neuronas (para nuestras entradas de la función XOR) y la primer capa oculta (hidden) de 16 neuronas. Como función de activación utilizaremos “relu” que sabemos que da buenos resultados. Podría ser otra función, esto es un mero ejemplo, y según la implementación de la red que haremos, deberemos variar la cantidad de neuronas, capas y sus funciones de activación.

Y agregamos una capa con 1 neurona de salida y función de activación sigmoid.

Visualización de la red Neuronal

Veamos que hemos hecho hasta ahora:

La arquitectura de 3 capas que creamos para esta Red Neuronal Artificial

A Entrenar la red!

Antes de de entrenar la red haremos unos ajustes de nuestro modelo:

Con esto indicamos el tipo de pérdida (loss) que utilizaremos, el “optimizador” de los pesos de las conexiones de las neuronas y las métricas que queremos obtener.

Ahora sí que entrenaremos la red:

Indicamos con model.fit() las entradas y sus salidas y la cantidad de iteraciones de aprendizaje (epochs) de entrenamiento. Este es un ejemplo sencillo, pero recuerda que en modelos más grandes y complejos, necesitarán más iteraciones y a la vez será más lento el entrenamiento.

Resultados del Entrenamiento

Si vemos las salidas del entrenamiento, vemos que las primeras linea pone:

con esto vemos que la primer iteración “tuvo algo de suerte” y acierto la mitad de las salidas (0.5) pero a partir de la segunda, sólo acierta 1 de cada 4 (0.25).

Luego en la “epoch” 24 recupera el 0.5 de aciertos, ya no es “por suerte”, si no por haber ajustado correctamente los pesos de la red.

Y -en mi caso- en la iteración 107 aumenta los aciertos al 0,75 (son 3 de 4) y en la iteración 169 logra el 100% de aciertos y se mantiene así hasta finalizar. Como los pesos iniciales de la red son aleatorios, puede que las salidas que tengas en tu ordenador sean levemente distintas en cuanto a las iteraciones, pero llegarás a la “precisión binaria” (binara_accuracy) de 1.0.

Evaluamos y Predecimos

Primero evaluamos el modelo

Y vemos que tuvimos un 100% de precisión (recordemos lo trivial de este ejemplo).

Y hacemos las 4 predicciones posibles de XOR, pasando nuestras entradas:

y vemos las salidas 0,1,1,0 que son las correctas.

Afinando parámetros de la red neuronal

Recordemos que este es un ejemplo muy sencillo y con sólo 4 entradas posibles. Pero si en la realidad tuviéramos una red compleja, deberemos poder ajustar muchos parámetros, repasemos:

  • Cantidad de capas de la red (en nuestro caso son 3)
  • Cantidad de neuronas en cada red (nosotros tenemos 2 de entrada, 16 en capa oculta y 1 de salida)
  • Funciones de activación de cada capa. Nosotros utilizamos relu y sigmoid
  • Al compilar el modelo definir las funciones de pérdida, optimizer y métricas.
  • Cantidad de iteraciones de entrenamiento.

En este ejemplo que es muy sencillo, puedes intentar variar por ejemplo la cantidad de neuronas de entrada, probar con 8 o con 32 y ver qué resultados obtienes. Por ejemplo, si necesita más o menos iteraciones para alcanzar el 100% de aciertos. Realmente podemos apreciar que hay muchos meta-parámetros para ajustar. Si hiciéramos la combinatoria de todos ellos, tendríamos una cantidad terrible de ajustes posibles. Y queda sobretodo en ti, decidir esos parámetros y ajustarlos.

Guardar la red y usarla -de verdad-

Si esto fuera un caso real, en el cual entrenamos una red, la ajustamos y obtenemos buenos resultados, ahora deberíamos Guardar esa red ya que esa red óptima, tiene los pesos que estábamos buscando. Sería tonto y lento entrenar cada vez la red antes de “publicar en producción”.

Lo que hacemos es guardar esa red y en OTRO código cargaríamos la red y la utilizamos como si fuera una librería o una funcion que creamos. Pasándole entradas y obteniendo las predicciones.

Para guardar y cargar nuestra red, utilizaremos el siguiente código de ejemplo:

Luego de esto, ya usaríamos normalmente loaded_model.predict() y listo!

¿Vale la pena una red neuronal? ¿porqué no programar con if-then-else?

Luego de visto todo esto, ¿no conviene hacer una programación “tradicional” en vez de entrenar una red neuronal? Pues siempre dependerá del caso. Por ejemplo para la función XOR tendríamos algo así:

Vemos que es una función con “4 ifs” que evalúa cada condición (se podría mejorar, lo sé). ¿Pero que pasaría si en vez de 2 entradas tuviéramos más parámetros?… pues seguramente la cantidad de “ifs” aumentaría creando un código caótico y propenso a errores, difícil de mantener. Piénsalo un momento. No quiere decir que haya que reemplazar todo el código del mundo con redes neuronales, pero sí pensar en que casos las redes neuronales nos brindan una flexibilidad y un poder de predicción increíbles -y que se justifican el tiempo de desarrollo-.

Para más ejemplo de Algoritmos de Machine Learning completos y en Español, visita la categoría de Práctica

Conclusión

Hemos creado nuestra primera red neuronal artificial con 3 capas para recrear la función XOR. Hemos utilizado la librería Keras -y a través de ella, Tensorflow como backend- y creamos el modelo, entrenamos los datos y obtuvimos un buen resultado. Este es el puntapié inicial para seguir viendo diversas arquitecturas de Redes Neuronales e ir aprendiendo poco a poco con Python.

Espero les haya gustado el artículo y más adelante vendrán nuevos ejemplos y ejercicios prácticos como el de crear una red con reconocimiento de imágenes-próximamente-.

Les invito a Suscribirse al blog y seguir de cerca todos los ejercicios y artículos que vendrán.

Suscribirme al Blog

Recibir los nuevos artículos (quincenal) sobre Machine Learning y ejemplos en Python

Recursos Adicionales y Descarga del código

Pueden ver el código en mi cuenta de GitHub aqui.

O pueden descargar el código de la Notebook Jupyter desde aqui.

Otros recursos Keras y Tensorflow.

8 Replies to “Una sencilla Red Neuronal en Python con Keras y Tensorflow”

  1. Realmente no me ha gustado tu artículo. El sólo ver que codificas una función XOR con 4 ifs me hace pensar que no tienes muy claro el tema. Para una función XOR es suficiente con 1 if.

    function predecir_XOR(entrada1, entrada2){

    if(entrada1 != entrada2){
    return 1;
    }else {
    return 0;
    }
    }

    Entiendo que el caso que planteas es trivial, pero es necesario ser riguroso en lo que hace a las comparaciones entre programación imperativa tradicional y el uso de redes neuronales para poder ponderar adecuadamente cuando es beneficioso usar una u otra metodología.

    Por otra parte, si este es tu “primera red neuronal” debo decirte que tu redacción da por sobreentendidos demasiados aspectos, por lo que, no es un artículo para personas recién iniciadas en el tema, ni hablar considerando los errores conceptuales respecto de los ifs necesarios en el caso de la programación imperativa tradicional.

    Mi sugerencia es que intentes escribir los artículos como si se lo tuvieras que explicar a tu abuelita, es decir, con todos los detalles y precisiones posibles para asegurarte que tu lector pueda comprender las ideas que intentas transmitir.

    Por último, trata de mejorar tu sintaxis, por ejemplo, no es lo mismo un “sobretodo” que “sobre todo”. Y este no es el único error. Este aspecto, junto con las demás observaciones anteriores dan por tierra con tu artículo.

    Revísalo y tendrás más éxito.

    Saludos

    1. Hola, primero que nada te agradezco que hayas visitado mi web y hayas leído mi artículo. Ahora te contesto algunas de tus críticas:
      Obviamente la función XOR se puede hacer con un sólo if, era un mero ejemplo. Lo aclararé en el artículo para que no haya confusión.
      Mi intención con este artículo era mostrar una sencilla implementación al crear una red neuronal, no pretendía explicar la teoría completa. Para ayudar en eso, cuento con otro artículo sobre Deep Learning (enlazado en el post) que aclaro, tampoco es suficiente. Este post va dirigido a programadores con algo de conocimiento de la teoría de RN y que quieren poder implementar rápido un código Python para experimentar.
      Los errores de ortografía/sintaxis, agradezco que tu (u otros usuarios) me envíen los que encuentren para poder corregirlos. Por supuesto siempre intento hacer revisión del texto, código y de las imágenes que publico -pues me encargo de todo, con mi escaso tiempo- pero hay cosas que se me pasan.
      Saludos y gracias por la visita y tus comentarios.

  2. Hola Juan, muy buen artículo!

    Había intentado otras veces sin éxito seguir algún tutorial sobre redes neuronales, pero este está bien explicado, de forma sencilla y paso a paso y me ha sido muy sencillo seguirlo.

    Cuando explicas cómo importar una red neuronal, hecho en falta la siguiente línea:

    from keras.models import model_from_json

    Por lo demás un 10. Ahora toca aprender qué diferencia hay entre las distintas funciones, cuántas capas debería usar, como funcionan el optimizador y la pérdida, etc.

    ¡Muchas gracias!

    1. Hola Marc, muchas gracias y me alegro que te sirviera este tutorial!. Gracias por la línea de import que agregas en tu comentario, puede ayudar a otros usuarios.
      Los otros temas que comentas intentaré ir cubriéndolos con diversos artículos.
      Saludos y seguimos en contacto!

  3. Amigo y como puedo usar esto para coger una base de datos , la cual quiero hacer un par de preguntas y esta me responda agarrando la base de datos que tenga.

    1. Hola Jossef, gracias por escribir.
      Mira, tienes diversas opciones según tu necesidad y el grado de complejidad que tengas en tus datos:

      Lo más sencillo y rápido sería convertir los datos que fueras a usar con tu base de datos a csv e importarlos -como siempre- con Pandas. Pero la contra es que si agregas filas, deberás importar cada vez. Se puede automatizar si por ejemplo es un proceso de 1 vez al día.

      Otra opción sería conectar directamente tu base de datos con Python. Supongamos que tienes Mysql, puedes ver ejemplos de como conectar en estos enlaces Use Mysql in Python ó Python Mysql y luego haces tus queries como siempre, lo usas de entradas en tu maquinas de aprendizaje.

      Finalmente, si te enfrentas con bigdata, conviene utilizar paquetes más profesionales y con soporte como Apache Spark Hadoop,Casandra, etc

  4. Gracias, me ha parecido un buen ejemplo. No entiendo las críticas, el autor no intenta explicar los fundamentos de las redes neuronales, sino una implementación concreta de un ejemplo.

    1. Hola Eustaquio, muchas gracias por escribir!
      Veo que tu captas correctamente la esencia del artículo y me alegro 🙂
      Espero que sigamos en contacto!
      Saludos

Leave a Reply