No tienes acceso a esta clase

¡Continúa aprendiendo! Únete y comienza a potenciar tu carrera

Entrenamiento y análisis de resultados de tu red neuronal

17/28
Recursos

Aportes 11

Preguntas 3

Ordenar por:

Los aportes, preguntas y respuestas son vitales para aprender en comunidad. Regístrate o inicia sesión para participar.

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:

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

Los espero!.

  • 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:

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

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í! 😄

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]

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)


Genial la implementación de la red.

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

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)

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

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