historCrearemos 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.
|
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 |
import numpy as np from keras.models import Sequential from keras.layers.core import Dense # cargamos las 4 combinaciones de las compuertas XOR training_data = np.array([[0,0],[0,1],[1,0],[1,1]], "float32") # y estos son los resultados que se obtienen, en el mismo orden target_data = np.array([[0],[1],[1],[0]], "float32") model = Sequential() model.add(Dense(16, input_dim=2, activation='relu')) model.add(Dense(1, activation='sigmoid')) model.compile(loss='mean_squared_error', optimizer='adam', metrics=['binary_accuracy']) model.fit(training_data, target_data, epochs=1000) # evaluamos el modelo scores = model.evaluate(training_data, target_data) print("\n%s: %.2f%%" % (model.metrics_names[1], scores[1]*100)) print (model.predict(training_data).round()) |
¿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:
|
1 2 3 |
import numpy as np from keras.models import Sequential from keras.layers.core import Dense |
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.
|
1 2 3 4 5 |
# cargamos las 4 combinaciones de las compuertas XOR training_data = np.array([[0,0],[0,1],[1,0],[1,1]], "float32") # y estos son los resultados que se obtienen, en el mismo orden target_data = np.array([[0],[1],[1],[0]], "float32") |
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:
|
1 2 3 |
model = Sequential() model.add(Dense(16, input_dim=2, activation='relu')) model.add(Dense(1, activation='sigmoid')) |
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:
A Entrenar la red!
Antes de de entrenar la red haremos unos ajustes de nuestro modelo:
|
1 2 3 |
model.compile(loss='mean_squared_error', optimizer='adam', metrics=['binary_accuracy']) |
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:
|
1 |
model.fit(training_data, target_data, epochs=1000) |
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:
|
1 2 3 4 |
Epoch 1/1000 4/4 [==============================] - 0s 43ms/step - loss: 0.2634 - binary_accuracy: 0.5000 Epoch 2/1000 4/4 [==============================] - 0s 457us/step - loss: 0.2630 - binary_accuracy: 0.2500 |
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.
|
1 2 3 4 5 6 7 8 |
Epoch 24/1000 4/4 [==============================] - 0s 482us/step - loss: 0.2549 - binary_accuracy: 0.5000 Epoch 107/1000 4/4 [==============================] - 0s 621us/step - loss: 0.2319 - binary_accuracy: 0.7500 Epoch 169/1000 4/4 [==============================] - 0s 1ms/step - loss: 0.2142 - binary_accuracy: 1.0000 |
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
|
1 2 |
scores = model.evaluate(training_data, target_data) print("\n%s: %.2f%%" % (model.metrics_names[1], scores[1]*100)) |
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:
|
1 |
print (model.predict(training_data).round()) |
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:
|
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 |
# serializar el modelo a JSON model_json = model.to_json() with open("model.json", "w") as json_file: json_file.write(model_json) # serializar los pesos a HDF5 model.save_weights("model.h5") print("Modelo Guardado!") # mas tarde... # cargar json y crear el modelo json_file = open('model.json', 'r') loaded_model_json = json_file.read() json_file.close() loaded_model = model_from_json(loaded_model_json) # cargar pesos al nuevo modelo loaded_model.load_weights("model.h5") print("Cargado modelo desde disco.") # Compilar modelo cargado y listo para usar. loaded_model.compile(loss='mean_squared_error', optimizer='adam', metrics=['binary_accuracy']) |
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í:
|
1 2 3 4 5 6 7 8 9 10 11 12 13 |
function predecir_XOR(entrada1, entrada2){ if(entrada1 == 0 && entrada2 == 0){ return 0; }else if(entrada1 == 0 && entrada2 == 1){ return 1; }else if(entrada1 == 1 && entrada2 == 0){ return 1; }else if(entrada1 == 1 && entrada2 == 1){ return 0; } } |
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.
Ya estás listo para crear otra Red Neuronal con Keras y Tensorflow: Pronóstico de Ventas
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
- Documentación Keras (en inglés)
- DNN and CNN of Keras with MINST data in Python
- Keras: Ultimate Beginers Guide to Deep Learning in python
- Keras and Convolutional Neural Networks
- Historia de las Redes Neuronales
El libro del Blog
Puedes colaborar con esta cuasa comprando el libro ó lo puedes descargar gratuitamente. Aún está en borrador, pero apreciaré mucho tu ayuda! Contiene Extras descargables como el “Lego Dataset” utilizado en el artículo de Detección de Objetos.
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
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.
Este blog es bueno e intenta explicar con ejemplos la programación de una red neuronal básica, sin embargo, utilizó un enfoque didáctico no adecuado. De igual manera, el que lo critica aquí, parece que no entiende los dos enfoques de programación. Cuando utilizas condiciones tales como if-else, en Inteligencia artificial, se le llama un agente activo simple. Su eficiencia dependerá de la cantidad de reglas que tenga. Esto no es práctico en un problema complejo en el cual pueden surgir muchas de ellas. Por otro lado, los sistemas de aprendizaje como las redes neuronales, son conocidos como agentes que aprenden y se basan en la utilización de modelos matemáticos muy simples en los cuales el objetivo es adaptar sus parámetros hasta que ofrezcan un resultado optimo. Resumen: If-Else depende de reglas; Redes neuronales infiere esas reglas por aprendizaje.
estimado, agradeciendo su comentario me gustaría consultarle por algún texto formal de inteligencia artificial, o como aprendió, yo estoy buscando aprender de forma formal mediante un texto validado de inteligencia artificial. Estoy atento. Saludos.
Hola Sebastian, gracias por escribir. Si miras los enlaces con libros que recomiendo en el sitio, por lo general son libros que yo mismo he comprado y leído. Si es para empezar, por lo general recomiendo el Hands on ML o el de Hundred Page Machine Learning“hundred page ML” que son muy buenos.
Saludos!
Nos podrias indicar tus investigaciones y pagina web para revisar con mas detencion lo que planteas por favor?. Creo que el sitio es buenisimo, no lo ensuciemos insertando comentarios que solo busquen conseguir validacion ( eso tiene que ver con tu autoestima), si quieren aportar, subanse articulos y ejemplos concretos que mejoren lo aprendido, sean grandes por favor, si no, mejor calladitos se ven mas bonitos. Comentar un if mas o menos, lleva a discutir forma y no fondo.
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!
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!
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.
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
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.
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
Hola buenos dias,
Soy un programador venezolano, te sigo desde Italia en donde estoy montando un proyecto para enseñarle programación a los niños (Si te interesa te puedo contar más).
En estos dias estudiando como funciona RabbitMQ me di cuenta que es una arquitectura que de alguna manera asemeja a una Red Neuronal.
Me estoy preguntando si es posible crear una red neuronal dentro de una red de nodos, en donde cada nodo sea un consumidor de data de sobre información ambiental y a la vez productor de data del ambiente local.
es una pregunta que me hice por pura ociocidad pues de momento no tengo necesidad de montar algo asi, aunqe seria una implementación interesante para los usuarios finales del proyecto que estoy desarrollando.
De tu articulo me gusto mucho como has comentado el código, pero muchas cosas me han quedado oscuras. Seguramente es un articulo para programadores con conocimientos previos de RM. No es mi caso.
Soy un programador full-stack de blockchain y me gustaria entender esto de la AI, del que me siento totalmente ignorante.
Creo que tu blog me va a servir de mucho.
Gracias por el esfurzo y la información.
Hola Germán, gracias por escribir y un placer conocerte!. Disculpas por tardar en responder, pero estuve muy complicado de tiempos estos días. El concepto que describes de crear “una red dentro de nodos donde unos sean consumidor y otros productor” me hizo recordar a un concepto que creo que es bastante novedoso en el Machine Learning y que consiste en “encadenar” diversos algoritmos como redes neuronales, o podrían ser árboles de decisión, regresión lineal, etc y que entre todos a su vez formen un “nuevo y más potente” algoritmo. Aún no lo estudié del todo, pero es un concepto super interesante que tengo entendido se está usando mucho en las competencias de Kaggle… para ganar 🙂
Intentaré conseguirte enlaces que te ayuden! y seguir escribiendo también !
También me encantaría conocer tu proyecto para niños, yo también tengo algo en mente relacionado con eso! Sigamos en contacto por el Blog, y si quieres, agrégame por Twitter y nos podemos enviar mensajes por privado
Hola Germán, aquí te dejo el enlace que te comentaba, sobre “encadenar” diversos algoritmos de ML (podrían ser diversas redes neuronales) Stacking Models for Improved Predictions
Hola, muy buena publicación! Quisiera saber como hacer las pruebas del modelos sin necesidad de volverlo a ejecutar dado a que de esta manera siempre se esta sobreescribiendo
Hola Melissa, gracias por escribir. Te cuento que sobre el final de artículo se explica esto bajo el título “Guardar la red y usarla”. Aqui verás que se guarda la red en formato json y luego “más tarde” (en otro archivo python u otra Notebook), puedes hacer read() del modelo y utilizarlo sin necesidad de repetir el entrenamiento cada vez.
Aprovecho a comentar que además de guardarlo en formato json puedes guardarlo en un formato llamado “.h5py” usando el método save(). Te dejo el enlace oficial de la web de Keras para que lo veas: Save and load Keras model
muy buen tutorial, he estado pensando aplicar keras un solucionador de video-laberintos, crees que me conviene trabajar con esto o no?
Hola gracias por escribir. Te soy sincero: no sé qué son los video-laberintos! Me explicas? Si hay enlaces con ejemplos tb acepto
Muchas gracias por el articulo!! Espero puedas seguir escribiendo msa..Saludos!! 🙂
Hola Manu, gracias por el apoyo! Mientras consiga ratitos libres… seguiré escribiendo jaja! Saludos!
Hola como estas? buen tutorial! Gracias!
Te encargo un tutorial de tensorflow con keras para poder hacer que la red de ordenes. Por ejemplo que aprenda hacer click para cerrar una ventana. Osea una red neuronal que aprenda a mover el mouse identifique las ventanas abiertas y haga click en la “x” de cada ventana. pls saludos
jaja. pues Pedro, parece algo divertido. Tomo nota para ver si se puede hacer en un futuro. ¿Vos no te animas a hacerlo y luego nos cuentas?
Saludos!
Hola, soy un enfermero aprendiendo programación y este tutorial me sirvió mucho para aprender las bases de un red neuronal. espero poder implementarlas en un futuro en mi ámbito laboral. Sigan así!!
Hola Hernán, gracias por escribir, espero que puedas implementarlo y ya nos contarás cómo va todo! Saludos
Super el ejemplo lo que queria pedirle es como lo implemento?? loaded_model.predict()
soy nueva en esto de python.
Hola Talia, pues usas la función de predict, como lo harías normalmente con el modelo que cargaste.
Para este ejemplo es algo trivial, pues sólo contamos con 4 entradas, pero si generalizas y extiendes lo aprendido, harías algo así:
valores_a_predecir = np.array([[1,1]])
print (loaded_model.predict(valores_a_predecir))
Saludos!
Perfecto tutorial!
Pero deberías añadir éstas dos líneas al tutorial para entenderlo todo perfectamente
Muchas gracias por tu publicación, vale oro!
Hola ronald, gracias por el comentario, saludos
amigo me ha servido de mucho tu artículo, espero poder adapatar la red a lo que necesito.
Muchas gracias por tu articulo, como siempre conciso y preciso como todos los demás
Excelente aporte. Gracias
Si queréis probarlo con Tensorflow 2.0, usad estos import:
import numpy as np
from tensorflow.keras.models import Sequential
from tensorflow.keras.layers import Dense
Excelente articulo, me ha ayudado mucho a entender que significan realmente las funciones para crear una RNA, llegue aquí porque no sabía como hacer para guardar la red… y ahora ya sé hasta como cargarla para no tener que volver a entrenar!!! Eres muy grande…. finalmente decirte que tenía la pregunta de por que guardas con lo de json en vez de con save() y en los comentarios ya vi que respondiste… de nuevo gracias y animarte a que continúes compartiendo lo que sabes de una forma fácil y sin parrafadas, que para eso están los libros y la documentación, una vez más… GRACIAS
Muy buena página, es de lo mejor que he podido encontrar. Muchas gracias. ¿Aún respondes dudas por algún medio?
muy buen aporte, tengo unas dudas con otro ejercicio, podrías ayudarme? gracias.
Hola, muchas gracias por explicar.
Soy nuevo en esto y tengo una gran duda. En este caso… los datos de entrada corresponderían a las 4 combinaciones de la puerta xor? [0,0],[0,1],[1,0],[1,1]. Si es a así, se consideraría como 1 dato de entrada, el cual consta de las 4 combinaciones? o serían 4 datos de entrada, los cuales corresponderían a cada combinación?
Por favor, agradecería una respuesta.
Hola. Excelentes todas tus publicaciones, muy bien explicadas todas.
¿Tienes trabajos de investigación al que hayan usado Deep Learning, que me puedas recomendar?
GRACIAS
Hola,
Gran artículo, te ayuda con un ejemplo práctico a entender el proceso completo y explicado línea a línea.
Respecto a las críticas iniciales, para flipar. Todos hemos intentado explicar algo alguna vez partiendo de un ejemplo lo más sencillo posible y que, en efecto, no tenía mucho sentido, pero a veces sólo así es posible explicar algo para que se entienda de la mejor forma posible. El autor ya pone sobre aviso. ¿Qué más quieren?
Imagino a esos críticos repasando millones y millones de libros de programación, molestos por esa primera linea de código “Hello world”, y refutándola con idioteces del estilo: “¿para que quieres hacer un programa para saludar?”, ” !! no se puede saludar al mundo !”, etc.
Gracias al autor por este y toda la web. Increible !
Saludos!
Enhorabuena Juan Ignacio,
este blog es un tesoro, estoy empezando casi desde cero pero estoy aprendiendo gracias a tus ejemplos y explicaciones.
Al hacer este ejemplo tan ilustrativo, me queda una duda ¿por que usar 16 neuronas en la capa oculta? “model.add(Dense(16, input_dim=2, activation=’relu’))” y no 4, una para cada posible entrada. ¿cual es el razonamiento para dimensionar capas si es que existe o procede?
Un saludo y muchas gracias por compartir y enseñarnos.
JGF
Hola pasaba por los comentarios para hacer esa misma pregunta… o parecida, quiero saber la trascendencia que tiene escoger 4, 16, o cualquiera sea el número. Claro que puedes cambiarla a 4 pero en el caso de mi algoritmo el que dio resultados mas óptimos fue 16.
Hola Eliana, gracias por escribir, te comento, hay que tener un equilibrio al escoger la cantidad de neuronas de cada capa. Si pones muy pocas, la red no será capaz de generalizar el conocimiento y por lo tanto dará malos resultados. Si pones demasiadas neuronas caerás en overfitting, es decir que la red realmente memorizará UNICAMENTE los casos del dataset con que la entrenas pero será incapaz de hacer predicciones ante nuevos inputs.
Saludos!
Hola Javier, gracias por escribir!.
Para que la red neuronal logre generalizar el conocimiento necesita una cantidad equilibrada de neuronas. Piensa que en momento de entrenar la red se estará haciendo el backpropagation que ajustará el peso final de las neuronas. Si tenemos muy pocas neuronas, no será capaz de dar una solución general, ante cualquier entrada. Si ponemos Muchisimas neuronas lo que ocurrirá sería overfitting donde en realidad las neuronas “memorizan” las entradas y sólo serán buenas con los mismos inputs, pero no con valores nuevos. Entonces debemos encontrar una cantidad de neuronas que ni sea demasiado ni muy poco.
Saludos!
Excelente tutorial , solo me queda una duda cada vez que realizo el entrenamiento de la Red neuronal y la cargo en el JSON y posteriormente la llamo, el nivel de precisión cae y no llega al 100% nose que estoy haciendo mal, es como si el entrenamiento no quedará guardado.
Hola Alejandro, gracias por comentar en el blog.
Asegurate de varias cosas:
Primero de hacer el save del modelo luego de haber hecho el fit().
Y fíjate que estamos guardando 2 ficheros: uno con el modelo y otro con los pesos.
Al momento de cargar, debes, primero recrear el modelo y luego asignarle los pesos (es decir, que hacer load de los 2 archivos)
Luego hacer el compile.
Y recién al final utilizarlo.
Si te sigue dando problemas vuelve a escribirme!
Saludos
Hola. Muy buenos tus posts. Lástima que no los vi antes. Recién estoy empezando y aún me quedan dudas de cómo utilizar las redes neuronales, que ya aprendieron, en otros programas. Tengo que revisar de nuevo la implementación en el robot arduino para entender un poco más. Te agradezco mucho por la información y ejemplos volcados. Saludos
Muchas gracias por el articulo, muy interesante e ilustrativo. Sin embargo, probar el modelo con:
valores_a_predecir = np.array([[1,0]])
print (loaded_model.predict(valores_a_predecir))
Imprime valores como 0.4462918 o 0.5566937, que si lo redondeamos seria un 0 y 1. Esto es correcto?
Hola! Me encanta esta página,te agradezco por todos los temas que desarrollas. Tambien, quiero preguntarte sobre las redes neuronales que de un vector de entrada resulta un vector de salida pero con valores que no son 0 o 1 , si no precios, propiedades químicas, etc. ¿Cómo las puedo buscar?
Actualmente quisiera ver como se realiza una RNA que no produce un valor 0 o 1 , si no una predicción de algun valor.
Gracias
Hola, gracias por escribir, es tan sencillo como usar un dataset donde tus etiquetas de salida sean númericas y pones como neurona de salida solo una.
Te dejó este enlace: https://www.tensorflow.org/tutorials/keras/regression?hl=es-419
Muchas gracias! 😀 Saludos cordiales
Hola soy nuevo en redes neuronales, he visto que has entrenado una red neuronal. En el ejemplo tenemos una entrada de 2 salidas, luego utilizas una red neuronal de 16 neuronas y salida 1 neurona.
Imagino q es xq le metes 2 numeros y te sale un numero o 0 o 1 . Explicame lo de las 16 neuronas. Pq ese numero??
Luego despues de entrenar como lo pruebas?
Yo quiero crear una secuencia de 5 numeros y q me saquee otros 5 numeros o sea q se retroalimente?? Como harias esto?
Gracias o sea seria una entrada de 5 una salida de 5 ?
Muchas gracias
Saludos
Me gusto los que hiciste. Me dio un pequeño error por que faltaba una instrucción :
import numpy as np
from keras.models import Sequential
from keras.layers.core import Dense
from keras.models import model_from_json
Luego de añadir esto todo corrió muy bien
Muchas gracias por el aporte!
Estuvo muy interesante! Te agradezco mucho. Recien comienzo con esto y el tutorial me parecio fantastico.
Mezclando este y otro tutorial me arme un ejemplo propio donde cargo 8 columnas de las cuales las primeras 7 son indicadores medicos y la ultima columna dice CERO/UNO e indica que ese paciente tuvo una determinada enfermedad.
Lo que no termino de entender, es como hacer el paso final que me convierte en util el modelo (ya leido, cargado, entrenado y evaluado): Es decir, ingresar un dataframe de por ejemplo 100 entradas con los 7 datos medicos y que me complete la columna de la enfermedad con cero/uno en un dataframe de output.
Hola Pablo, gracias por escribir! Lo que dices es la etapa luego de entrenar el modelo, para hacer “predict” justamente, que es el objetivo final de la red neuronal (ó de cualquier modelo de ML).
Si te fijas, se muestra un ejemplo al final que pone:
predicciones = model.predict(AQUI_NUEVO_DATAFRAME_SIN_COLUMNA_LABEL)
Eso te dejará las predicciones nuevas y sólo tienes que asignarlas a la columna de label de tu “nuevo dataset”
Saludos!
Buenas noches comunidad !
Saludo y agradezco a Juan Ignacio por compartir su conocimiento en éste blog.
En mi caso, estoy iniciando en redes neuronales, y me fue de gran ayuda el ejemplo y documentación.
Tomo el atrevimiento de realizar una consulta y solicitar una sugerencia a la comunidad, y es que en una problemática a resolver mi capa de entrada consta de una lista de listas de 11 elementos
ejemplo lista = [0, 1, 1, 1, 0, 1, 1, 0, 1, 1, 1]
si bien consta de ceros y unos, entiendo que usar el parámetro metrics=[«binary_accuracy»] de model.compile , es erróneo, ya que al intentar utilizar la red entrenada me arroja un error
raise ValueError(f’Input {input_index} of layer «{layer_name}» ‘
ValueError: Exception encountered when calling layer “sequential” (type Sequential).
Input 0 of layer “dense” is incompatible with the layer: expected min_ndim=2, found ndim=1. Full shape
received: (None,)
Call arguments received:
inputs=tf.Tensor(shape=(None,), dtype=int32)
training=False
mask=None
debería utilizar otro metrics ?
Agradecido desde ya
Saludos
Me encantó, gracias!!!!! 😀
Me ha servido para aprender mejor el concepto de la red, yo ya tenia cierto conocimiento porque soy ingeniero de telecos y llevaba un tiempo leyendo del tema y practicando. Cuando intentaba entenderlo me encontraba con redes enormes como las de clasificacion de imagenes, y acababa saturado al intentar entender el concepto de funcionamiento no me daba para más la cabeza.
Pero algo tan sencillo no me lo había encontrado, genial gracias la verdad 🙂
Hola Juan Ignacio, te felicito por tu trabajo, no soy informático, entonces agradezco el conocimiento que entregas, los críticos , que paguen un curso sin errores de sintaxis, muy desagradecidos.
El objetivo lo cumpliste. Te felicito y vamos por mas, Relacionado con el MKT y python?