Una Introducción Completa A Redes Neuronales Con Python y Tensorflow 2.0

Source: Deep Learning on Medium


Go to the profile of Harpie Crispi

Hola a todos, en este primer documento, quiero hacer una introducción completa y detallada a las famosas “Redes Neuronales Profundas”. En este documento pretendo abordar tanto la teoría, como la parte practica para desplegar nuestro primer modelo con Tensorflow 2.0. Sin nada mas que decir vamos con la teoría.


1. La Neurona

Neuronas (Fuente: https://es.wikipedia.org/wiki/Neurona)

Los puntos teñidos de rojo son neuronas humanas, es una curiosidad ver una imagen real de las neuronas antes de estudiar redes neuronales. Pero la pregunta aquí es, ¿Como podemos recrear esto en una maquina?, porque, es algo que la naturaleza creó y pareciera que todo el propósito del “deep learning” es intentar imitar el funcionamiento del cerebro humano. Y el propósito de hacer eso posible es increíble, crear una infraestructura para que las maquinas puedan “aprender”. ¿Y para que hacer eso?, bueno como sabemos el cerebro humano es uno de los mecanismos de aprendizaje mas complejos actualmente en el planeta, e imagina lo increíble que seria poder recrear algo como eso.

Entonces nuestro desafió actual se basa en como recreamos una neurona, primero, vamos a echar un vistazo mas de cerca al concepto de neurona humana

(Fuente: https://es.wikipedia.org/wiki/Neurona)

Esta imagen fue creada por un neurocientífico Santiago Ramón y Cajal en 1899, y lo que hizo fue teñir neuronas para mirarlas bajo el microscopio y la imagen fue lo que el dibujo posteriormente a su observación.

(Fuente: https://es.wikipedia.org/wiki/Neurona)

Años después pudimos observar mejor la estructura de la neurona, y es así como se ve, y es muy similar al dibujo de Santiago, aquí quiero que observemos que tenemos un cuerpo neuronal, y también fijémonos bien en las dendritas, y en el axón.

El concepto clave aquí, es que las neuronas por si solas son inutiles, son como las hormigas, tienen que vivir en colonia, millones de hormigas pueden armar una colonia, y lo mismo pasa con las neuronas, si trabajan juntas, pueden lograr cosas fantásticas.

¿Como trabajan juntas?. Para eso tienen las dendritas y los axones, las dendritas reciben información, y el axón transmite esta información.

(Fuente: https://gl.wikipedia.org/wiki/Sinapse)

Básicamente transmiten impulsos eléctricos a través del axón a las dendritas de la otra neurona, a esta transmisión de información se le llama sinapsis, entonces muchas millones de neuronas forman la red neuronal humana.

Ahora vamos a ir a como nosotros encontramos la manera de representar esto en las maquinas, y es similar.

Neurona Artificial

Esta seria una representación gráfica de una neurona artificial, imagina las flechas como dendritas, y las X como información que le pasan otras neuronas, entonces nuestras flechas serian la sinapsis, en este caso la señal que le pasamos es básicamente un valor de entrada. Entonces a partir de estos valores generara un valor de salida, estas entradas pueden ser cualquier cosa, pero por ahora las llamaremos, variables independientes y a la salida la llamaremos variable dependiente. Y ya que estamos nombrando cosas, a las sinapsis las llamaremos pesos.

Estos “pesos” son los componentes cruciales dentro de una red neuronal artificial, porque las redes neuronales artificiales aprenden ajustando estos valores, y estos valores deciden en cada caso que señal es importante, o cual no, que señal pasa o que señal no. Los pesos son cruciales, de hecho lo único que hacemos durante el proceso de entrenamiento es ajustar sus valores para obtener los resultados que esperamos. Pero, ¿ por que ?

El entrenamiento tiene dos pasos, uno es hacer una suma ponderada de nuestras variables y nuestros pesos, una suma ponderada es multiplicar y sumar.

Y luego se aplica sobre el resultado una “función de activación”.

Que es de lo que hablaremos ahora.


2. Función de activación

La función de activación, va a ser quien determine el comportamiento de mis salidas de cada capa, es decir, quien escoge que valor pasa o cual se queda, saber escoger una función de activación es fundamental en el proceso de “deep learning”, y ahora vamos a hablar de 4 de ellas.

La primera que te quiero presentar se llama Threshold Function, y se ve así

fuente (https://www.saedsayad.com/artificial_neural_network.htm)

En esencia la función Threshold es bastante simple, solo devuelve 1 cuando x ≥ 0 y 0 de otro modo, es decir que nuestras salidas serán todas binarias, si o no, encendido o apagado, una vez vista esta función vamos a movernos a una un poco mas compleja.

Función Sigmoide

En este caso tenemos una curva mas suave que va de 0 a casi 1 pasando por sus valores intermedios, esta función es muy bueno tenerla en la capa de salida cuando queremos calcular alguna probabilidad.

Función Rectificadora

Es una de las funciones de activación mas popular para las redes neuronales artificiales, que simplemente devuelve el numero si es mayor a cero o si no devuelve cero.

Tangente Hiperbólica

y por ultimo tenemos las función tahn, probablemente ya hayas oído hablar de ella, es similar a la sigmoide pero los valores van de casi -1 a casi 1, no quiero ir muy en profundidad en como ocupar cada una de estas funciones porque las iremos viendo a lo largo de esta serie de artículos, pero si me gustaria que supieras que existen, y como se ven mas o menos.

Y si tienes curiosidad por saber porque la función rectificadora es tan popular checa el siguiente link:

Deep Sparse Rectifier

Pero solo es opcional, de hecho te recomiendo leerlo cuando ya tengas practica con esta función de activación.

Basado en lo que vimos, si yo tengo que predecir un resultado binario, es decir, tengo mis datos y la variable independiente es Si o No, ¿que función de activación aplicarías en la ultima capa?. Comenta


3. Como funcionan las Redes Neuronales Artificiales

Ahora vamos a imaginar que estamos haciendo nuestra primera clasificación, de un dataset, en este caso, escogimos el dataset del Titanic, que trae la lista de pasajeros información sobre ellos y si sobrevivieron o no, ya escogimos nuestras variables y serán las siguientes

Las X se llaman Variables Independientes, porque no dependen de ni un factor para ser calculadas, y las Y se llaman variables dependientes porque dependen de X para set calculadas.

En este caso el resultado sera muy pero muy fácil de calcular, solo sera la suma ponderada con la activación, pero si agregamos otra capa, todas las neuronas de la capa anterior irán conectadas a todas las neuronas de la capa siguiente y si agrego otra, todas la de la capa anterior irán conectadas con la de la capa siguiente, lo que aumenta la capacidad de predecir un valor, mejora mucho el modelo, pero eso no quiere decir que mientras mas capas intermedias tenga mejores resultados obtendré. Se vería tal que así

Y mientras mas capaz intermedias agreguemos mas nivel de abstracción tendrá nuestra red, algo que hay que notar es que no todas las neuronas analizan los mismos valores de X, recordemos que por las funciones de activación algunos de los valores podrían ser descartados, porque no son significantes para el rendimiento de la red neuronal. Y de esta forma todas estas neuronas se dividen la información cada una encargándose de una tarea distinta, pero esto es solo una analogía, no siempre es así


4. Como aprenden las redes neuronales

Hay dos formas de solucionar un problema en la programación, la primera es escribir muchas reglas y mucho código, programando cada caso con el que el programa va a lidiar, no es una mala manera, pero aveces hay problemas que no se pueden solucionar de esa manera, y ahí es donde entran las redes neuronales.

Las redes neuronales son una herramienta que tiene la ventaja de que puede “entender” los datos que uno le presenta, y hacer una función, que se ajuste a nuestro X, imagina que tenemos imágenes de perros y gatos, en ves de hacer un programa gigante de “Computer Vision” de cierto modo yo le puedo decir a mi red neuronal, “Ve y aprende que es un gato” y la red neuronal va a extraer todos los patrones de la imagen que diferencian a un perro y un gato, así cuando le des una imagen de un perro que no le enseñaste en las pruebas, de cierto modo con todas las reglas que aprendió podrá “entender” de que animal se trata.

Volvamos a mi red neuronal anterior, y lo que tengo que predecir es el valor de y, por cada época, lo que haré es predecir todos los datos a partir de nuestros datos a esto le llamaremos, “Predicción de Y” y a su ves le pase los valores reales, ¿Pero si predice Y en cada época, de que me sirve haberle pasado valores reales?.

La razón es simple, porque al final de cada época, nuestro modelo va a comparar sus “Predicciones de Y” con “Los valores reales de Y” y esta comparación se hace a través de la función de perdida.

Hay muchas funciones de perdida, pero esta es la mas común se llama “Mean Squared Error” (La media de los errores al cuadrado).

Esta función nos dirá, cuanto es el margen de error en nuestra red, y nuestro objetivo es minimizar esa función, que este lo mas cercano a cero posible, porque eso significa que en nuestro modelo no existe distancia entre la predicción y el error, es decir, es preciso.

Y básicamente, esta función de error va hacia atrás, directamente y se ajustan nuestros pesos con el fin de minimizar la perdida.

Para saber todas las funciones de perdida que existen te recomiendo visitar el siguiente link:

A List Of Cost Functions Used In Neural Networks Alongside The Applications


5. Descenso de gradiente

¿Como es que minimizo mi función de perdida?, una manera es a fuerza bruta, literalmente cambiando todos los valores de mis pesos para obtener algo parecido a una parábola. Y después de eso revisas tus resultados y ves el resultado mas bajo. Esto puede funcionar, de hecho es muy viable, pero en redes neuronales existe, “La maldición de la dimensionalidad”, para 1000 pesos “que es un valor bajo”, no podemos hacer eso, estaríamos toda la vida encontrando los mínimos, de la función literalmente tenemos exp(10, 75) combinaciones, y no tenemos tiempo de probar todas y cada una de ellas. para que veas que no estoy exagerando, Sunway Taihulight: La super computadora mas rápida del mundo, tardaría exp(10, 50) años en hacer eso.

Sunway Taihulght

Entonces, la fuerza bruta, no es una opción.

Aquí es donde entra el descenso de gradiente.

Imagen relacionada
Descenso de gradiente

Este método nos permite empezar en cualquier punto de nuestra función y calcula la pendiente del punto en el que esta, si la pendiente es negativa, ajusta los pesos después de cada época, para ir hacia abajo, si se pasa ajusta los pesos para ir hacia el otro lado, hasta que encuentra los mínimos locales.


6. Descenso de gradiente estocástico

Nuestro método de descenso de gradiente funciona, pero que pasa si tengo varios mínimos, ¿como?, así:

Fuente: https://machinelearningmastery.com/why-training-a-neural-network-is-hard/

Si situamos mal nuestro algoritmo de descenso de gradiente, quedara atascado en el mínimo local, por lo que nuestra función no sera optima, porque no estamos encontrando el mínimo real (Mínimo Global), nos quedamos atascado en un mínimo, que en realidad no nos sirve para predecir nuestros resultados.

Entonces, como dijimos, el método de descenso de gradiente ajusta los pesos, después de cada época, en cambio el Descenso de gradiente estocástico, lo hace cada vez que se pasa un dato por ejemplo, los pasos que sigue el descenso de gradiente son los siguientes:

  • Paso el dato 1
  • Paso el dato 2
  • Paso el dato 3
  • Ajusto los pesos

Y el método de descenso de gradiente estocástico hace lo siguiente:

  • Paso el dato 1
  • Ajusto los pesos
  • Paso el dato 2
  • Ajusto los pesos
  • Paso el dato 3
  • Ajusto los pesos

De esta manera localiza los mínimos globales ajustándose cada vez en ubicaciones distintas por decirlo de algún modo, entonces la fluctuación sobre la función sera mucho mas alta, por esta razón el algoritmo encontrara el mínimo global a base de estar en movimiento constante sobre la misma función.

Lo otro importante de este método es que es rápido, por la manera en que funciona se tiende a pensar que no, porque se ajusta por cada dato, pero en realidad como no tiene que cargar todos los datos en memoria, para ajustar los pesos y esperar hasta recorrer todas las filas de nuestros datos, va uno por uno, por lo que es un algoritmo mas liviano y mas rápido.


7. Backpropagation

Hasta el momento todo el proceso que vimos fue el Forward Propagation, donde un valor de entrada, pasa por toda la red hasta la salida, y se calcula la función de perdida, luego de este proceso, la perdida se debe Propagar Hacia Atrás, ajustando los valores de los pesos, lo que tenemos que tener en cuenta, es que el Backpropagation es un algoritmo avanzado, basado en matemáticas muy interesantes y sofisticadas, y nos permite ajustar todos los pesos a la vez, todos los pesos son ajustados de forma simultanea.

En el caso de que quieras experimentar este proceso sin librerías, como lo haré en el siguiente modulo, debes tener en cuenta que todos los pesos de la red se deben ajustar al mismo tiempo, para que los valores sean consistentes, esta es la clave para que el algoritmo funcione.


8. Implementación de una red neuronal muy simple sin librerías de deep learning

Vamos a codificar un ejemplo de red neuronal solo con numpy, para entender mucho mejor el proceso que se lleva a cabo en cada uno de los pasos anteriormente descritos.

Voy a pasar a explicar el código de imatrask, sobre como implementar una red neuronal solo con numpy en muy pocas lineas de código.

Primero si no tienes numpy debes instalarlo con el siguiente comando

  • Jupyter:
  • !pip install numpy
  • Console:
  • pip install numpy
  • o
  • pip3 install numpy

Una vez hecho esto primero importaremos numpy en nuestro proyecto

Lo siguiente es definir nuestra función de perdida, que en este caso sera una variante de la función sigmoide

Hay que notar que tenemos dos formas de usar esta función, usar la función en si, o su derivada, tenlo en mente para mas adelante

Definimos un dataset pequeño para entrenar nuestra red

Como paso opcional, definimos una seed, para tener los mismo resultados, y inicializamos de forma aleatoria nuestros pesos.

  • La primera matriz de pesos tiene que ser de un tamaño fijo, en este caso (3,4) porque tenemos 3 valores de entrada y la siguiente capa tiene 4, entonces la salida tiene que tener la misma cantidad de entradas que tiene la siguiente capa

El primer paso es la Forward Propagation, para efectuarlo sacamos el producto punto de nuestros datos nuestros pesos (Suma Ponderada) y lo pasamos por nuestra función de activación.

Y para la siguiente capa multiplicamos los valores de la capa anterior y nuestra capa de pesos de la segunda capa. Es a esto cuando nos referimos a que están cada una de las neuronas de la capa anterior conectadas con las neuronas de la capa siguiente.

Ahora lo que haremos es calcular el error entre nuestras predicciones actuales, y las reales, para determinar la función de perdida, restare nuestras predicciones reales, con nuestras predicciones actuales.

Recuerdan que habíamos hablado sobre el algoritmo de Descenso de Gradiente, bueno esa pendiente se calcula multiplicando nuestra perdida actual con la derivada de nuestras predicciones actuales, de esta manera vamos a saber para que dirección ajustar los pesos.

Una vez calculada esa pendiente, vamos a multiplicarla por la transpuesta de los pesos de la capa siguiente, de este modo propagaremos el error hacia atrás, es decir, lo que estoy haciendo para calcular la perdida de la capa siguiente, es la dirección hacia donde moveré los pesos de la ultima capa, y de esta manera el error de la capa anterior sera mas el cambio formaran parte activa para que la capa siguiente calcule la dirección hacia donde debe mover los pesos.

Y finalmente ajustamos el valor de nuestros pesos, multiplicando la transpuesta de la capa por sus respectivas optimizaciones, o direcciones hacia donde actualizar los pesos, y esto se suma a nuestros pesos actuales, actualizando las dos capas a la vez.

Código Completo

Una vez entrenada la red, nos lanzara un resultado como el siguiente.

Predicción -> Valor Real

[[0.00260572] ->[0]
 [0.99672209] -> [1]
 [0.99701711] -> [1]
 [0.00386759]]->[0]

Como vemos la clasificación, se ha hecho correctamente, dando como resultado valores cercanos a los de entrada.


9. Titanic dataset con Tensorflow 2.0 Keras API

Ahora vamos a implementar un modelo de “Deep Learning” básico en Tensorflow con la API de Keras.

Primero vamos a correr los siguientes comandos en nuestra consola

  • pip install scikit-learn
  • pip install pandas
  • pip install numpy
  • pip install tensorflow==2.0.0-beta0

Hay que recalcar que esta versión de Tensorflow, es inestable, por lo que si tienes un error te recomiendo abrir un issue en github, siempre asegúrate que no sea un error cometido por ti.

El dataset que estaré usando se puede descargar del siguiente enlace:

Dataset Kaggle: Titanic

Una vez descargado, descomprime el archivo “train.csv”, dentro de la carpeta donde tengas tu código.

Ahora vamos a codificar paso a paso.

Vamos a empezar importando todos las librerías que usaremos.

Lo siguiente, es importar nuestro dataset y observar e inferir que variables no son importantes.

Para cargar el dataset, usaremos la función read_dataset de pandas y para observar el dataset tenemos que usar la función head() de los dataframes de pandas que nos mostrara las primeras 5 filas de nuestro dataset, esto es mas que nada para hacernos a la idea de nuestros datos.

Aquí solo con la vista podemos descartar muchas variables que son las siguientes

  • Nombre: No nos sirve porque no aporta información al resultado
  • Ticket: Tampoco nos aporta Información
  • Cabin: Podría aportarnos información pero tiene valores perdidos
  • PassangerID: Es el indice, eso no aporta ni una información relevante
  • Parch: Lo eliminaremos para tener una peor rendimiento para saber como optimizar el modelo en la siguiente sección

Entonces nuestros datos de entrada “X” tendrá los siguientes valores.

  • Sex: Genero de la persona
  • Age: Edad de la persona
  • SibSp: Que es la cantidad de hermanos o esposa
  • Fare: El impuesto que pagaron para embarcarse
  • Embarked: Es la clase en donde se embarco la persona

Con esto ya podemos empezar, para separar nuestra variable dependiente de la independiente, haremos lo siguiente

Tomamos todos nuestros valores anteriormente mencionados en X en forma de “Dataframe” luego veremos por que, y nuestra variable dependiente que era obvio, ¿Sobrevivió?, pero de ella tomamos solo el array.

Ahora pasaremos a pre-procesar los datos, me recuerdo que cuando empece, este era el paso que mas me costaba, pero todo va en leer, la documentación de las librerías, y leer tips en Internet, ahora les daré un tip, para hacer un pre-procesado rápido, primero debemos definir, que tenemos que hacer con las variables, por ejemplo. Fare, Sibsp, Age, son variables numéricas, representan un valor “cuantitativo” es decir que mientras mas alto sea, o mas bajo sea, representa un posible cambio en el resultado.

Generalmente cuando entrenamos modelos de “Deep Learning” antes de pasar los datos, todos los valores numéricos hay que normalizarlos, porque si tengo valores muy altos y muy bajos en la misma tabla, al pasar por mi función de activación, dependiendo cual sea no lanzara resultados óptimos, por lo que se que a esos valores tengo que hacerle un escalado, para que los valores queden a la misma escala, usare el StandarScaler, que es para valores, que tienen mucha diferencia entre ambos.

Embarked, Sex, y PClass, son valores categóricos, es decir, son valores que pertenecen a categorías, por ejemplo, PClass representa la clase en que estaban embarcados los pasajeros, un pasajero de primera clase no representa mas que uno de segunda, a efectos prácticos, a nivel matemático, si lo tratamos como un numero no suma ni resta, pero sin embargo, podemos tratarlo como una categoría, porque tenemos una cantidad fija de clases a lo largo de los datos lo mismo pasa con Embarked.

Pero no podemos darle las categorías directamente, tenemos que pasarla en formato (one_hot) que consiste en poner tantos ceros como categorías tengo y para representar un valor, vamos a poner un uno en la posición del valor, esto hará que la maquina reconozca que todas las categorías tienen el mismo valor que la forma de analizar el patrón, es analizando por grupos, un ejemplo podría ser.

Tengo 3 ingredientes: Pollo, Arroz, Carne

y quiero representar mi valor “carne” en el formato one_hot, entonces pongo tantos ceros como categorías tengo en total en este caso 3:

[0,0,0]

La carne es el tercero, por lo que para representar ese valor pondre un uno en esa posición

carne = [0,0,1]

Una vez decidido esto, vamos a hacer un pipeline de pre procesamiento con sk_learn, para ello, usaremos la función, make_column_transformer que importamos anteriormente.

Entonces así de simple, aplicamos todo lo que decidimos anteriormente.

Ahora lo que falto es aplicarlo sobre los datos, y es tan fácil como decir:

Esta función primero ajustara el pipeline a los datos que le pasaremos, y luego va a devolvernos nuestros datos ya listos.

Ahora armare mi perceptron. Para ello importare las neuronas simples y el modelo secuencial

Modelo secuencial quiere decir que empezare a agregar capas y se conectaran de manera automática, y Dense es la neurona simple, de la que hablamos.

Ahora vamos a construir el modelo inicial.

La primera capa Dense recibe el numero de datos por fila, que es la segunda dimensión de la matriz X.

Porque la forma de la matriz aquí nos indica en este caso (Cantidad de datos X Numero de parámetros por dato).

Y como activación usaremos la función rectificadora, mi capa de salida tiene que tener la misma dimensión como de cantidad de salidas quiero, por ejemplo en este caso solo tengo 0 y 1 por lo que 0 o 1 ocupan solo un valor dentro de cada dato y le pasamos como función de activación sigmoide para clasificación por probabilidad.

Finalmente compilamos, como tenemos dos posibles salidas, vamos a escoger que el error lo trate como una clasificación binaria, el optimizador sera nuestra función derivada que nos ayudara a determinar hacia donde mover mis pesos.

Por ultimo lo entrenaremos por 100 épocas, el batch_size es un argumento importante, porque representa cada cuantos datos va a actualizar los pesos.

Como resultado al proceso de entrenamiento tengo un accuracy de:

0.4148

Esta bien para ser nuestra primera vez, vamos a ver como predecir valores, para ello definiré una función simple, que tomara los datos que pase, los va a integrar a una dataframe, y los va a preprocesar, y me entregara una predicción.

de esta manera si evaluamos los siguientes datos

  • Pclass = 1
  • Sex = ’male’,
  • Age = 60,
  • Fare = 0,
  • Embarked = ‘C’.

Nos entrega como resultado:

array([[1]], dtype=int32)

Que significa que no sobrevivió.

Código Completo:

10. Optimizacion y fine tuning

Primero antes de empezar necesitamos darnos mejor a la idea de cuanto es nuestro error, para eso vamos a realizar un proceso llamado cross_validation, lo que hace este proceso, es entrenar una cantidad de veces que tu definas y devuelve la métrica que le indiques para todos los pasos, esto es mas que nada porque en cada época la perdida suele variar, entonces esto nos permitirá hacernos a la idea de en este caso la precisión calculando la media de todas estas precisiones, para implementarlo haremos lo siguiente

Primero importaremos lo que necesitemos, en este caso nuestro algoritmo de cross validator, y un wrapper que permitira usar modelos de keras con scikit learn, asique hagamoslo:

Ahora vamos a pasar nuestro modelo a una función.

Esto lo hacemos porque el “KerasClasifier” recibe como parámetro una función para compilar el modelo

Hay que notar que tenemos que entregarle la epocas y el tamaño del mini batch de datos, ya que como la función cross_validation_score no es nativa de esta librería, no podemos pesarla los parámetros a esa función, y le pasamos el modelo como función

Ahora para hacer el proceso, tenemos que invocar a nuestra función, que recibe como el primer parámetro el modelo, y los otros dos son los datos de entrenamiento, y luego cv, que es la cantidad de veces que entrenare el modelo, y n_jobs es para ocupar mas de un procesador y le paso el parámetro -1 para indicarle que quiero utilizar todos los disponibles

Luego calculamos nuestro promedio que resulto en mi caso:

0.5272869631648064

Entonces haremos la primera mejora, que sera agregar una cantidad de Dropout, que basicamente lo que hace es apagar neuronas al azar con el fin de que las neuronas no se vuelvan tan dependientes de los datos, es decir que se entrenen mejor para evitar el overfitting, para ello importaremos nuestra capa de dropout.

La capa dropout recibe como parámetro un numero entre 0 y 1 que representa el porcentaje de neuronas que va a desactivar en esa capa, yo le pondré 0.1 porque me ocupare de ello luego.

Ahora comenzaremos el proceso de Fine Tunning, donde buscaremos posibles errores, y combinaciones de parámetros que puedan mejorar nuestro modelo.

Este proceso ocupa mucha ram (hasta 16 gb) por lo que te recomiendo hacerlo en esta pagina:

Google Colab

dropouts, el plan de optimizacion que tengo es el siguiente:

  • Compilación
  • Densidad de las capas de neuronas
  • Dropout

así que vamos a importar las librerías que necesito.

Con este modelo podre optimizar todos mis parámetros, ahora vamos a actualizar mi modelo, con las capaz dropout

Ahora voy a definir los parámetros que quiero modificar, y los valores que les pasare.

Voy a probar jugando con mi batch_size, epocas, y optimizador, con el fin de encontrar la mejor combinación entre estos tres parámetros.

Ahora no le paso los parámetros al KerasClasifier, porque se los pasare a través, de mi GridSearchCV, el argumento verbose=0 es para que no me muestre salida, si lo dejo en cero no me mostrara la barra de progreso del entrenamiento.

Este recibe como parámetros el nuestro modelo, nuestros parámetros, la medida sobre la que queremos comparar, y la cantidad de veces que lo entrenara para sacar la media de accuracy.

Por ultimo le pasamos nuestros datos para que nos de un resultado, es hora de ir a comprar o lo que quieras porque se demorara bastante.

Una vez terminado el proceso revisaremos los resultados

A mi me dio como salida lo siguiente

{‘batch_size’: 16, ‘epochs’: 100, ‘optimizer’: ‘rmsprop’}

Y queda en evidencia un error fatal de nuestro modelo, y es que a propósito, puse un optimizador que no sirve para este tipo de problemas, por lo que nos dará una precisión muy baja.

Ahora vamos a la capas.

Tenemos que notar es que ahora tenemos que incluir el batch_size y las epocas

{‘l1’: 32, ‘l2’: 16}

Ese es el resultado que me dio a mi, por lo que salta otro error de la red, las capas van desde la mas densa, a la menos densa, que también lo hice con intención.

Por ultimo vamos a repetir el proceso con nuestros dropouts

Vamos a ver los resultados

{‘d1’:0.2, ‘d2’:0.3}

Por ultimo vamos a ver como mejoro nuestro modelo, vamos a repetir el proceso de la validación cruzada.

Y el resultado es !

Precision media: 0.801409775018692

Pasamos de un 50% precisión a un 80% de precisión, por lo que recomiendo si son nuevos dentro de esta disciplina, siempre hacer el proceso de fine tunning, porque los ayudara a luego hacer modelos correctos en la mayoría de los casos.

Codigo Completo

11. Gracias

Bueno hoy aprendimos mucho, te agradezco si llegaste hasta aquí, si conoces mas gente que le guste este tema, comparte este articulo con ellos, de esa manera me estas ayudando, sin mas que decir, hasta la próxima :D