Réseau neuronal enseignant fonction Xor

Question

Je souhaite enseigner mon réseau de neurones x ou avec 3 couches: 1. Couche d'entrée avec 2 neurones entièrement connectés à la couche cachée suivante avec 2 neurones 3ème couche de sortie avec un seul neurone de sortie. Je vais utiliser la fonction d'activation sigmoïde et la descente en gradient. Mes questions sont: 1. Comment devrait être formulée la fonction d'arrêt: je sais que nous pouvons vérifier le nombre d'itérations ou vérifier si l'erreur est inférieure à une erreur acceptable mais comment cette erreur doit-elle être calculée? Quelle est la formule? Seule erreur calculée sur la couche de sortie? Au cours d'un seul passage d'enseignement d'un échantillon? 2. Peut-être une valeur de biais inférieure à 1 mais supérieure à 0? Certaines descriptions indiquent qu'il devrait toujours être 1 mais d'autres peuvent être des nombres aléatoires de cette gamme.

Answer 1

Voici un réseau de couche caché avec rétropropagation qui peut être personnalisé pour exécuter des expériences avec relu, sigmoïde et autres activations. Après plusieurs expériences, il a été conclu qu'avec relu, le réseau fonctionnait mieux et atteignait la convergence plus tôt, alors qu'avec le sigmoïde, la valeur de perte fluctuait. Cela arrive parce que "the gradient of sigmoids becomes increasingly small as the absolute value of x increases".

import numpy as np 
import matplotlib.pyplot as plt 
from operator import xor 

class neuralNetwork(): 
    def __init__(self): 
     # Define hyperparameters 
     self.noOfInputLayers = 2 
     self.noOfOutputLayers = 1 
     self.noOfHiddenLayerNeurons = 2 

     # Define weights 
     self.W1 = np.random.rand(self.noOfInputLayers,self.noOfHiddenLayerNeurons) 
     self.W2 = np.random.rand(self.noOfHiddenLayerNeurons,self.noOfOutputLayers) 

    def relu(self,z): 
     return np.maximum(0,z) 

    def sigmoid(self,z): 
     return 1/(1+np.exp(-z)) 

    def forward (self,X): 
     self.z2 = np.dot(X,self.W1) 
     self.a2 = self.relu(self.z2) 
     self.z3 = np.dot(self.a2,self.W2) 
     yHat = self.relu(self.z3) 
     return yHat 

    def costFunction(self, X, y): 
     #Compute cost for given X,y, use weights already stored in class. 
     self.yHat = self.forward(X) 
     J = 0.5*sum((y-self.yHat)**2) 
     return J 

    def costFunctionPrime(self,X,y): 
     # Compute derivative with respect to W1 and W2 
     delta3 = np.multiply(-(y-self.yHat),self.sigmoid(self.z3)) 
     djw2 = np.dot(self.a2.T, delta3) 
     delta2 = np.dot(delta3,self.W2.T)*self.sigmoid(self.z2) 
     djw1 = np.dot(X.T,delta2) 

     return djw1,djw2 


if __name__ == "__main__": 

    EPOCHS = 6000 
    SCALAR = 0.01 

    nn= neuralNetwork()  
    COST_LIST = [] 

    inputs = [ np.array([[0,0]]), np.array([[0,1]]), np.array([[1,0]]), np.array([[1,1]])] 

    for epoch in xrange(1,EPOCHS): 
     cost = 0 
     for i in inputs: 
      X = i #inputs 
      y = xor(X[0][0],X[0][1]) 
      cost += nn.costFunction(X,y)[0] 
      djw1,djw2 = nn.costFunctionPrime(X,y) 
      nn.W1 = nn.W1 - SCALAR*djw1 
      nn.W2 = nn.W2 - SCALAR*djw2 
     COST_LIST.append(cost) 

    plt.plot(np.arange(1,EPOCHS),COST_LIST) 
    plt.ylim(0,1) 
    plt.xlabel('Epochs') 
    plt.ylabel('Loss') 
    plt.title(str('Epochs: '+str(EPOCHS)+', Scalar: '+str(SCALAR))) 
    plt.show() 

    inputs = [ np.array([[0,0]]), np.array([[0,1]]), np.array([[1,0]]), np.array([[1,1]])] 
    print "X\ty\ty_hat" 
    for inp in inputs: 
     print (inp[0][0],inp[0][1]),"\t",xor(inp[0][0],inp[0][1]),"\t",round(nn.forward(inp)[0][0],4) 

Résultat final:

X  y  y_hat 
(0, 0) 0  0.0 
(0, 1) 1  0.9997 
(1, 0) 1  0.9997 
(1, 1) 0  0.0005 

Les poids obtenus après la formation étaient:

nn.w1

[ [-0.81781753 0.71323677] 
    [ 0.48803631 -0.71286155] ] 

nn.w2

[ [ 2.04849235] 
    [ 1.40170791] ] 

Je trouve la série youtube suivante extrêmement utile pour comprendre les réseaux de neurones: Neural networks demystified

Il n'y a que peu que je sais et que peut être expliqué dans cette réponse. Si vous voulez une meilleure compréhension des réseaux de neurones, alors je vous suggère de passer par le lien suivant: [cs231n: Modélisation d'un neurone] [4]