Entrenamiento y análisis de resultados de tu red neuronal

Compañeros un gusto saludarlos.

Actualmente me encuentro desarrollando una librería de Machine Learning desde 0 utilizando Numpy Pandas y Matplotlib con el objetivo de interiorizar las conceptos y esto no se convierta una caja negra para nosotros.

También estaremos implementando y mejorando el modelo de red neuronal que nos acaba de presentar el profesor.

Por mi parte estaré encantado que puedan cooperar con esta aventura ya que aprenderemos mucho y además va a quedar genial en nuestro portafolio como Machine Learning Engineers.

Para revisar el repositorio pasen por los siguiente enlace:

• https://github.com/Mitchell-Mirano/Allison

Para contactar conmigo :
correo:
[email protected]
LinkedIn:
https://www.linkedin.com/feed/
Platzi:
https://platzi.com/p/MitchellMiranolnx/

Los espero!.

Logré obtener un error del 0.0106, osea el 1%
Corrigiendo la derivada de la función mse:

def mse(y, y_hat, derivate=False):
    if derivate:
        return 2*(y_hat - y)

Este módulo ha sido excelente, enseñó paso a paso a como construir una red neuronal.

• La verdad sí me emocioné. Este curso vale oro solo con esto que acabamos de hacer. Incluso si en la industria no se hace manualmente, haberlo hecho así te permite saber realmente como funciona, lo cual es más valioso.
• Les comparto mi resultado:
  
  

Que tal:
Noté que se tiene un desempeño superior si se añaden más neuronas a la segunda capa oculta en el Layers_dims, ejemplo:

layer_dims=[2,8,8,1]

Paso a paso, nos queda cada vez más claro cómo funciona realmente el cerebro humano para procesar todo tipo de datos y adaptarse a su medio

Esto nos lleva a una de las preguntas más importantes de la historia de la filosofía:
¿Los seres humanos tenemos libre albedrío y un alma o esencia en alguna parte?
¿O simplemente nuestros cerebros son máquinas que responden de manera increíblemente eficiente a su medio (tanto interno como externo), pero no son capaces de generar acciones espontáneas (generar acciones sin que estas sean reacciones)?.

¡Un saludo a todos los que llegaron hasta aquí! 😄

Al alterar los valores de learning rate y epoch hay que considerar que afectan

el epoch es cuantas iteraciones realiza la red para llegar a una conclusion y es posible que no tenga suficientes épocas para llegar a una conclusion optima como también es posible que tenga demasiadas y luego de llegar a una conclusion optima solo aumenta el error en las siguientes iteraciones

el learning rate es que tan amplios son los pasos que da la función tras cada iteración, si es muy pequeño es posible que tarde demasiado en alcanzar el punto mínimo de la función, pero si es muy grande es posible que pase sobre el punto óptimo y no logre llegar a un punto cercano

Este modulo es una joya de la escuela de Inteligencia Artificial! estas cosas son las que marcan la diferencia entre ser un ingeniero más a ser un “experto” en los temas que manejas.
Entender como funcionan las cosas por debajo es un gran bono a la hora de realizar tus productos

Entiendo que es solo un ejercicio para entender más o menos como funcionan las redes neuronales sin librerías. Sin embargo, cabe destacar que esta red neuronal resuelve un problema de clasificación, pero estamos usando una función de pérdida que no corresponde (MSE se aplica en regresiones). En este caso, se debería hacer con cross entropy.

Creo que esta mal el parametro b a la hora de modificarlo en el gradient descent, corregi la manera en la que se mueve el parametro b y tuve mucho mejores resultados, el learning rate es exageradamente bajo en el ejemplo de la clase ya que los numeros que se le estan dando a b cuando hacemos np.mean(params[‘dW3’]) no son los correctos y estos son muy grandes para corregirlo de la manera correcta, por lo que se necesitan pasos muchos mas chicos y muchas mas iteraciones para llegar a un resultado optimo, definiendo los diferentes valores de b de esta manera:

params[‘b3’] = params[‘b3’] - np.mean(params[‘dZ3’], axis=0, keepdims=True) * lr

params[‘b2’] = params[‘b2’] - np.mean(params[‘dZ2’], axis=0, keepdims=True) * lr

params[‘b1’] = params[‘b1’] - np.mean(params[‘dZ1’], axis=0, keepdims=True) * lr

Es decir, al bias actual, simplemente le resto el promedio de la derivada de la funcion de costo mutiplicada por la derivada de la funcion de activacion en la ultima capa, multiplicado por el learning rate.

Con un learning rate de 0.001, en 40000 iteraciones llegue aproximadamente a un 0.015 de error y al algoritmo le toma menos de 5000 iteraciones estar por debajo del 0.05, si me estoy equivocando corrijanme !

Les recomiendo ampliamente que vean mis notas de github en la siguiente liga:

notas

Ahí encontrarn el código completo adaptado para correr con n cantidad de layers, y explicado paso a paso 😄

No se muy bien por que, pero en mi caso la divergencia fue muy poca… el codigo sirvio muy bien desde las primeras condiciones. La grafica que he estado obteniendo ha sido muy parecida a esta:

Hola, mi predicción todo el tiempo está en 15% y no baja casi nada, hago aproximadamente 60mil iteraciones y el lr es de 0.0001. No he conseguido bajar el error sino hasta que entrené como 500 mil veces:(

Genial la implementación de la red.

Es interesante saber que con NumPy también se pueden hacer redes neuronales.

Que pasó?

Excelente curso, para los compañeros que tengan dificultades, revisen el código en la sección de recursos ya que un mínimo error al momento de definir las funciones o en el proceso ** Forward / Gradient Descent / Backpropagation ** hace que el modelo no funcione*

No logre que me saliera la misma figura ???

Runtime / Change Runtime Type / GPU

import numpy as np
import matplotlib.pyplot as plt
from sklearn.datasets import make_gaussian_quantiles

#CREAR VALORES ALEATORIOS

N=1000

gaussian_quantiles=make_gaussian_quantiles(mean=None,
cov=0.1,
n_samples = N,
n_features = 2,
n_classes = 2,
shuffle = True,
random_state=None
)
X,Y = gaussian_quantiles

X.shape #(1000,2) 2 features
Y.shape #(1000,)

Y= Y[:,np.newaxis]

plt.scatter(X[:,0], X[:,1], c=Y[:,0], cmap=plt.cm.Spectral)

FUNCIONES
#FUNCION ACTIVACION SIGMOID, CON SU DERIVADA
def sigmoid(x, derivate = False):
if derivate:
return np.exp(-x)/(( np.exp(-x) +1)**2)
else:
return 1 / (1 + np.exp(-x))

#FUNCION ACTIVACION RELU, CON SU DERIVADA
def relu(x, derivate = False):
if derivate:
x[x <= 0] = 0
x[x > 0 ] = 1
return x
else:
return np.maximum(0, x)

#FUNCION DE PERDIDA MSE, CON SU DERIVADA
def mse(y, y_hat, derivate = False):
if derivate:
return (y_hat - y)
else:
return np.mean((y_hat - y)**2)

ESTRUCTURA DE RED, SUS PESOS Y BIAS

def initialize_parameters_deep(layers):

parameters = {}

L = len(layers)

for l in range(0,L-1):

    #np.random.rand(10,3) 10x3 numeros de 0-1
    Rand1 = np.random.rand( layers[l], layers[l+1])
    Rand2 = np.random.rand( 1, layers[l+1])

    #PESO W0 = Rand(Capas , 1)   W1 = Rand(Capas, 2)  ... W9 = Rand(Capas, 10)
    parameters['W' + str(l+1)] = (Rand1 * 2) -1

    # BIAS b0=Rand(1,1)  b1=Rand(1,2)... b9=Rand(1,10)
    parameters['b' + str(l+1)] = (Rand2 * 2) -1
return parameters

capas=[2,4,8,1]
params = initialize_parameters_deep(capas)
params

def trainData(X,params,lr,training=True):

#FORWARD
params['A0'] = X # entrada de los valores

#El producto punto de los parametros con el peso  mas el bias 
params['Z1']= np.matmul(params['A0'], params['W1']) + params['b1']  
params['A1'] =relu(params['Z1']) 


# Recibi el analisis de la anterior neurona
params['Z2']= np.matmul(params['A1'], params['W2']) + params['b2']  
params['A2'] =relu(params['Z2']) 


#El producto punto de los parametros con el peso  mas el vayas 
params['Z3']= np.matmul(params['A2'], params['W3']) + params['b3']  
params['A3'] = sigmoid(params['Z3']) 

output = params['A3']

#params['A0'].shape  #1000,2
#params['W1'].shape  #2,4
#params['b1'].shape  #1,4
#X.shape  #1000,2
#y.shape #1000,1

if training:

    #BACKPROPAGATION
    #producto de Y, derivada  X  parámetro con derivada de sigmoid
    params['dZ3'] = mse(Y,output,True) * sigmoid(params['A3'],True)
    params['dW3'] = np.matmul(params['A2'].T,params['dZ3'])

    params['dZ2'] = np.matmul(params['dZ3'], params['W3'].T) * relu(params['A2'],True)
    params['dW2'] = np.matmul(params['A1'].T,params['dZ2'])

    params['dZ1'] = np.matmul(params['dZ2'], params['W2'].T) * relu(params['A1'],True)
    params['dW1'] = np.matmul(params['A0'].T,params['dZ1'])

    #Gradiente descenso
    params['W3'] = params['W3'] - params['dW3'] * 0.0001
    params['b3'] = params['b3'] - (np.mean(params['dW3'],axis=0,keepdims=True)) * lr

    params['W2'] = params['W2'] - params['dW2'] * 0.0001
    params['b2'] = params['b2'] - (np.mean(params['dW2'],axis=0,keepdims=True)) * lr

    params['W1'] = params['W1'] - params['dW1'] * 0.0001
    params['b1'] = params['b1'] - (np.mean(params['dW1'],axis=0,keepdims=True)) * lr
    
return output

capas=[2,4,8,1]
params = initialize_parameters_deep(capas)
#params

errors=[]
for _ in range(60000):

output  = trainData(X, params, 0.0001)

if _ % 25 ==0:   #cada 25 iteraciones imprima y guarde
    #print(mse(Y,output))
    errors.append(mse(Y,output))

plt.plot(errors)

Me encanto la clase,
me quedo la duda de cómo se haría para poder distribuir una red neuronal, no sé cómo se hace en la industria así que hice mi propia solución manual

import pickle

def save_params_to_file(params_obj, filename):
  with open(filename, 'wb') as outfile:
    pickle.dump(params_obj, outfile)

def read_params_from_file(filename):
  with open(filename, 'rb') as dict_file:

    loaded_params = pickle.load(dict_file)

    return loaded_params

ya que entrenar la misma red multiples veces con los mismos learning rate y epoch da diferentes resultados de esta forma se pueden guardar los parámetros de los mejores resultados en un archivo para poder reutilizarlos, ya que los params son los pesos y bias de la red neuronal en ese momento