Cómo calcular la derivada parcial de un error en una RNA

Question

Esta es una pregunta de seguimiento de este post que hice, "Perceptrón multicapa (red neuronal) para la predicción de series temporales" hace unos meses.

Estoy construyendo una red neuronal artificial feed-forward, utilizando un entrenamiento de propagación resistente. Por el momento, estoy tratando de implementar un algoritmo de actualización del peso de la entrada de una neurona individual. No consigo encontrar una respuesta clara y directa sobre cómo calcular la derivada parcial del error para un peso determinado. Lo único que puedo encontrar en la web, es el hecho de que la actualización del peso de una neurona es una función de $\frac{dE}{dW}$ (véase el Papel original [p. 2 y 3], o este [p. 4]).

Sin embargo, ninguno de estos documentos describe realmente cómo calcularlo.

Entiendo el concepto de derivada parcial en un sentido matemático . Y asumo que el cálculo del cambio de peso de la entrada de la neurona actual es la operación en cuestión, mientras que todos los demás valores de entrada de la neurona se mantienen constantes.

Así que, para cada una de estas neuronas, calculo el error individual de cada entrada tomando el error total ( -0.3963277746392987 ), que se ha multiplicado por el peso de la entrada de esa neurona (cada :error calculado es la suma del error de las entradas individuales).

Para ambas neuronas, ¿cuál sería el cambio de peso para cada entrada?

Esta es mi estructura de datos:

    :input-layer                                                                                                                                                                                                     
     ({:calculated-error -1.0991814559154283,                                                                                                                                                                         
       :calculated-value 0.9908633780805893,                                                                                                                                                                            
       :inputs                                                                                                                                                                                                          
       ({:error -0.07709937922001887,                                                                                                                                                                                   
         :calculated 0.4377023624017325,                                                                                                                                                                                  
         :key :avolume,                                                                                                                                                                                                   
         :value 2.25,                                                                                                                                                                                                     
         :weight 0.19453438328965889,                                                                                                                                                                                     
         :bias 0}                                                                                                                                                                                                         
        {:error -0.19625185888745333,                                                                                                                                                                                    
         :calculated 1.4855269156904067,                                                                                                                                                                                  
         :key :bvolume,                                                                                                                                                                                                   
         :value 3.0,                                                                                                                                                                                                      
         :weight 0.4951756385634689,                                                                                                                                                                                      
         :bias 0}                                                                                                                                                                                                         
        {:error -0.3072203938672436,                                                                                                                                                                                     
         :calculated 1.0261589301119642,                                                                                                                                                                                  
         :key :ask,                                                                                                                                                                                                       
         :value 1.32379,                                                                                                                                                                                                  
         :weight 0.7751674586693994,                                                                                                                                                                                      
         :bias 0}                                                                                                                                                                                                         
        {:error -0.36920086975057054,                                                                                                                                                                                    
         :calculated 1.2332848282147972,                                                                                                                                                                                  
         :key :bid,                                                                                                                                                                                                       
         :value 1.3239,                                                                                                                                                                                                   
         :weight 0.9315543683169403,                                                                                                                                                                                      
         :bias 0}                                                                                                                                                                                                         
        {:error -0.14940895419014188,                                                                                                                                                                                    
         :calculated 0.5036129016361643,                                                                                                                                                                                  
         :key :time,                                                                                                                                                                                                      
         :value 1.335902400676,                                                                                                                                                                                           
         :weight 0.37698330460468044,                                                                                                                                                                                     
         :bias 0}),                                                                                                                                                                                                       
       :id "583c10bfdbd326ba525bda5d13a0a894b947ffc"},
      ...)

    :output-layer                                                                                                                                                                                                   
    ({:calculated-error -1.1139741279964241,                                                                                                                                                                        
      :calculated-value 0.9275622253607013,                                                                                                                                                                         
      :inputs                                                                                                                                                                                                       
      ({:error -0.2016795955938916,                                                                                                                                                                                 
        :calculated 0.48962608882549025,                                                                                                                                                                            
        :input-id "583c10bfdbd326ba525bda5d13a0a894b947ffb",                                                                                                                                                        
        :weight 0.5088707087900713,                                                                                                                                                                                 
        :bias 0}                                                                                                                                                                                                    
       {:error -0.15359996014735702,                                                                                                                                                                                
        :calculated 0.3095962076691644,                                                                                                                                                                             
        :input-id "583c10bfdbd326ba525bda5d13a0a894b947ffa",                                                                                                                                                        
        :weight 0.38755790024342773,                                                                                                                                                                                
        :bias 0}                                                                                                                                                                                                    
       {:error -0.11659507401745359

        :calculated 0.23938733624830652,                                                                                                                                                                            
        :input-id "583c10bfdbd326ba525bda5d13a0a894b947ff9",                                                                                                                                                        
        :weight 0.2941885012312543,                                                                                                                                                                                 
        :bias 0}                                                                                                                                                                                                    
       {:error -0.2784739949663631,                                                                                                                                                                                 
        :calculated 0.6681581686752845,                                                                                                                                                                             
        :input-id "583c10bfdbd326ba525bda5d13a0a894b947ff8",                                                                                                                                                        
        :weight 0.7026355778870271,                                                                                                                                                                                 
        :bias 0}                                                                                                                                                                                                    
       {:error -0.36362550327135884,                                                                                                                                                                                
        :calculated 0.8430641676611533,                                                                                                                                                                             
        :input-id "583c10bfdbd326ba525bda5d13a0a894b947ff7",                                                                                                                                                        
        :weight 0.9174868039523537,                                                                                                                                                                                 
        :bias 0}),                                                                                                                                                                                                  
      :id "583c10bfdbd326ba525bda5d13a0a894b947ff6"})

Gracias de antemano

Answer 1

No me queda muy claro lo que intentas hacer, y tal vez un mejor lugar para plantear tu pregunta sea Estadísticas.SE pero te animo a que vayas y eches un vistazo a esto clase en línea sobre aprendizaje automático que proporciona una implementación del algoritmo de retropropagación.

Puedes registrarte o darle a la vista previa e ir al capítulo NN:Learning, pero te recomendaría registrarte y hacer el ejercicio de programación en NN. Tal vez no sea exactamente lo que estás tratando de hacer, pero creo que podrías encontrar un ejemplo básico de cómo calcular la derivada parcial del término de error.

Answer 2

El cálculo del gradiente depende de las funciones de activación de sus neuronas (y, más concretamente, de sus derivadas). Además, el gradiente de cualquier peso individual depende de los pesos y las activaciones que aparecen más adelante en la red -- esa es la idea clave detrás del algoritmo de retropropagación, que aprovecha ese hecho para calcular los gradientes. Puede encontrar una descripción muy detallada de la retropropagación en este documento . Nótese que los ejemplos utilizan funciones de activación sigmoideas, pero el método es aplicable a cualquier activación diferenciable.

Tenga en cuenta también que la principal diferencia entre backprop y rprop es que backprop requiere el valor del gradiente del peso y rprop sólo requiere su signo. Aunque el rprop puede parecer más sencillo en ese sentido, te aconsejo que te asegures primero de entender completamente el backprop.