J'avais besoin d'expliquer le code du réseau de neurones (ci-après, NN), j'ai donc décidé de profiter de l'occasion pour le résumer brièvement. Ci-dessous, nous procéderons en supposant que les connaissances de base sur NN sont connues.

Matériel de référence

[Learning and Neural Network (Electronic Information and Communication Engineering Series)](http://www.amazon.co.jp/gp/product/4627702914/ref=as_li_tf_tl?ie=UTF8&camp=247&creative=1211&creativeASIN=4627702914&linkCode=as2&tagao-shimash 22) <img src = "http://ir-jp.amazon-adsystem.com/e/ir?t=shimashimao06-22&l=as2&o=9&a=4627702914" width = "1" height = "1" border = " 0 "alt =" "style =" border: none! Important; margin: 0px! Important; "/>

Ce que j'ai fait

Théorie de la propagation arrière (BP)
Implémentation d'un réseau neuronal à 3 couches

Théorie BP

symbole

Entrée sur le réseau: $ (x_ {1}, x_ {2}, ..., x_ {N}) $ Sortie du réseau: $ (y_ {1}, y_ {2}, ..., y_ {M}) $ Relation réseau entrée / sortie: $ (y_ {1}, y_ {2}, ..., y_ {M}) = F (x_ {1}, x_ {2}, ..., x_ {N}) $ Poids de jointure: {$ w_ {ij} } Seuil: { {\ theta_ {i}} $}

Présentation de BP

Une des méthodes d'apprentissage pour feed-forward NN (extensible pour NN récurrent)
$ (y_ {1}, y_ {2}, ..., y_ {M}) = F (x_ {1}, x_ {2}, ..., x_ {N}) $ a été spécifié Une méthode pour donner une procédure pour déterminer les paramètres {$ w_ {ij}, \ theta_ {i} $} à l'intérieur du réseau afin de réaliser la relation entrée / sortie. (Cependant, à la suite de l'apprentissage, il n'est pas toujours possible de réaliser complètement la relation entrée / sortie cible.)
Pour la fonction F, la fonction sigmoïde etc. est utilisée
BP définit {$ w_ {ij}, \ theta_ {i} $} en fonction de la méthode du gradient
Dans la méthode du gradient, une échelle d'évaluation est utilisée pour mesurer le degré de réalisation de la cible (cette fois, l'erreur quadratique. Ci-après dénommée E).
Donner des valeurs initiales appropriées aux paramètres {$ w_ {ij}, \ theta_ {i} $} à l'intérieur du réseau, et répéter les corrections mineures des paramètres afin de réduire l'échelle d'évaluation des erreurs E.
En conséquence, l'ensemble des valeurs des paramètres converge vers l'un des points minimum de l'échelle d'évaluation.

Avantages de BP

Le livre de référence ci-dessus a la description suivante des raisons pour lesquelles BP est devenu largement utilisé.

Le calcul de la différenciation partielle de la fonction d'évaluation pour chaque paramètre a tendance à être compliqué dans un système non linéaire général, mais il existe une méthode de calcul systématique et systématique dans BP. De plus, les informations requises pour déterminer la quantité de correction de chaque paramètre peuvent être transmises à l'emplacement requis en utilisant la structure de connexion connue par le réseau. Cela signifie qu'il n'est pas nécessaire de fournir une ligne de communication spéciale pour l'apprentissage, ce qui est pratique pour simplifier l'algorithme et le matériel.

La capacité d'approximation fonctionnelle du réseau est théoriquement garantie. Si un nombre suffisant d'éléments de couche intermédiaire est utilisé, toute fonction peut être arbitrairement approximée avec une grande précision en déterminant de manière appropriée les valeurs de paramètres (poids de connexion, valeur de seuil). Il n'est pas toujours possible de trouver une valeur de paramètre qui donne l'approximation optimale par BP, mais la preuve d'une sorte de théorème d'existence donne un sentiment de sécurité.

Approximation des fonctions

Effectuez les opérations suivantes.

Réglage de la valeur initiale du paramètre
Jugement de convergence
Saisie des données d'entraînement
Calcul du gradient
Correction des paramètres

Approximation de fonction dans un seul neurone

Puisque la méthode d'apprentissage de mise à jour séquentielle est dérivée, la méthode de gradient est appliquée dans le but de réduire l'échelle d'évaluation de l'équation suivante pour chaque donnée d'entraînement ($ x ^ {(l)}, y ^ {(l)} $). E(w_0, w_1, ..., w_N)=|y^{(l)}-\hat{y}^{(l)}|^2 s=\sum_{n=0}^{N}w_nx_n^{(l)} \hat{y}^{(l)}=sigmoid(s)

L'équation suivante est obtenue en différenciant l'échelle d'évaluation d'erreur $ E (w_0, w_1, ..., w_N) $ par $ w_n $. \frac{\partial E(w_0, w_1, ..., w_N)}{\partial w_n}=-2(y^{(l)}-\hat{y}^{(l)})sigmoid'(s)x_n^{(l)} ici, sigmoid(s)=\frac{1}{1+e^{-\alpha s}}

Lorsque cela est différencié, sigmoid'(s)=\frac{\alpha e^{-\alpha s}}{(1+e^{-\alpha s})^2}

Pour résumer cela davantage, \frac{\alpha e^{-\alpha s}}{(1+e^{-\alpha s})^2} =\alpha \frac{1}{1+e^{-\alpha s}}(1-\frac{1}{1+e^{-\alpha s}}) =\alpha sigmoid(s)(1-sigmoid(s)) =\alpha \hat{y}^{(l)}(1-\hat{y}^{(l)})

En utilisant la valeur de $ \ partial E (w_0, w_1, ..., w_N) / \ partial w_n $ obtenue à partir de ce qui précède, le poids de connexion est corrigé à plusieurs reprises par l'équation suivante. w_n=w_n-\epsilon \frac{\partial E(w_0, w_1, ..., w_N)}{\partial w_n}

Dérivation

Règles de chaîne

Le petit changement de x se propage au changement d'autres valeurs de variable dans une chaîne en fonction de la dépendance des variables dans la figure ci-dessus. Selon la règle de la chaîne, l'expression relationnelle suivante est valable entre les changements infimes de ces variables $ \ Delta x, \ Delta z_1, \ Delta x_2, \ Delta y $. \Delta z_1=\frac{\partial z_1}{\partial x}\Delta x \Delta z_2=\frac{\partial z_2}{\partial x}\Delta x \Delta y=\frac{\partial y}{\partial z_1}\Delta z_1 + \frac{\partial y}{\partial z_2}\Delta z_2

Pour résumer la formule ci-dessus, \frac{\partial y}{\partial x}=\frac{\partial y}{\partial z_1}\frac{\partial z_1}{\partial x} + \frac{\partial y}{\partial z_2}\frac{\partial z_2}{\partial x}

3 couches NN

Sur la base de la règle de chaîne ci-dessus, nous dériverons le BP de NN constitué de la couche d'entrée, de la couche intermédiaire et de la couche de sortie. Le nombre d'unités pour les trois couches est de 3 (4 unités pour la couche d'entrée et la couche intermédiaire, compte tenu du terme de polarisation). À partir de l'unité de la couche de sortie, numérotez la couche de sortie: {1,2,3}, la couche intermédiaire: {4,5,6} et la couche d'entrée: {7,8,9}. Et

Lorsque le poids $ w_2 $ de la 4ème unité de la couche intermédiaire à la 2ème unité de la couche de sortie change légèrement
Lorsque le poids $ w_4 $ de la 5ème unité de la couche d'entrée à la 4ème unité de la couche intermédiaire change légèrement

BP est dérivée en utilisant ces deux cas comme exemples. Une image de chaque propagation est présentée ci-dessous.

Dans le cas de 1 ci-dessus

La relation entre le montant de la variation dans $ w_2 $ $ \ Delta w_2 $ et le montant de la variation dans $ s_2 $ $ \ Delta s_2 $ est illustrée par l'équation suivante. \Delta s_2=\Delta w_2y_4 Aussi, y_2=sigmoid(s_2) Que \Delta y_2=sigmoid'(s_2)\Delta s_2

Cette modification de $ y_2 $ modifie la valeur de l'échelle d'évaluation des erreurs, et l'expression relationnelle suivante est valable. \Delta E=2(y_2-t_2)\Delta y_2 Ici, $ t_2 $ fait référence aux données de réponse correctes de $ y_2 $. Si vous organisez la formule, \Delta E=2(y_2-t_2)sigmoid'(s_2)y_4\Delta w_2 \frac{\partial E}{\partial w_2}=2(y_2-t_2)sigmoid'(s_2)y_4

A partir de l'équation ci-dessus, le coefficient différentiel partiel $ \ partial E / \ partial w_2 $ requis pour corriger $ w_2 $ par la méthode du gradient a été obtenu.

Aussi, à partir de $ \ Delta s_2 = y_4 \ Delta w_2 $ \frac{\partial E}{\partial s_2}=2(y_2-t_2)sigmoid'(s_2) Est également recherché en même temps. Ces valeurs peuvent être utilisées telles quelles lors du calcul du coefficient différentiel partiel lorsque le poids une couche au-dessus change.

Dans le cas de 2 ci-dessus

La relation entre le montant du changement lorsque $ w_4 $ est modifié est calculée par la formule suivante. \Delta s_4=\Delta w_4 y_5 \Delta y_4=sigmoid'(s_4) \Delta s_4

Le changement de $ y_4 $ qui se produit de cette manière affecte $ s_1, s_2, s_3 $ à la destination de la connexion. Par conséquent, l'expression relationnelle suivante s'applique entre les quantités de changement. \Delta s_1=w_1 \Delta y_4 \Delta s_2=w_2 \Delta y_4 \Delta s_3=w_3 \Delta y_4

Le changement ci-dessus modifie également l'échelle d'évaluation des erreurs, comme indiqué dans l'équation suivante. \Delta E=\frac{\partial E}{\partial s_1} \Delta s_1+\frac{\partial E}{\partial s_2} \Delta s_2+\frac{\partial E}{\partial s_3} \Delta s_3

Organisez ceci et divisez les deux côtés par $ \ Delta s_4 $ en \frac{\partial E}{\partial s_4}=(\frac{\partial E}{\partial s_1}w_1+\frac{\partial E}{\partial w_2}s_2+\frac{\partial E}{\partial s_3}w_3)sigmoid'(s_4)

Est recherché. On peut voir que la formule ci-dessus est une sorte de formule graduelle dans laquelle $ \ partial E / \ partial s_i $ dans la couche intermédiaire est obtenu par $ \ partial E / \ partial s_j $ dans la couche de sortie. De même, on peut voir que l'erreur peut être propagée aux couches inférieures en trouvant $ \ partial E / \ partial s $ de la couche finale pour n'importe quel nombre de NN.

Finalement, \frac{\partial s_4}{\partial w_4}=y_5 À \frac{\partial E}{\partial w_4}=\frac{\partial E}{\partial s_4}\frac{\partial s_4}{\partial w_4} Remplacer dans \frac{\partial E}{\partial w_4}=\frac{\partial E}{\partial s_4}y_5 Obtenir. $ sigmoid '(s) $ simplifie le calcul en utilisant $ y = sigmoid (s) $ indiqué dans la partie neurone unique.

Code de référence

Désolé pour le code assez sale, mais je vais le coller ci-dessous. Le seuil (biais) est fixé pour tous les neurones par souci de simplicité. Lors de la création du code, ajoutez un élément avec une valeur de 1 au début du vecteur d'entrée, ajoutez un élément de biais au vecteur de pondération et ajustez les paramètres dans le cadre du poids.

`python`


# coding: utf-8

import numpy as np
Afrom numpy.random import randint
import sys


class NN:
    def __init__(self):
        self.alph = 0.04
        self.mu = 0.01
        self.theta = 0.1
        self.w = []
        self.output = []
        self.output_sigm = []
        self.T = 0

    def create_data(self, input_n_row, input_n_col, layer_sizes):
        self.x = randint(2, size=(input_n_row, input_n_col))
        self.y = randint(2, size=(input_n_row, layer_sizes[-1]))
        for i_layer, size in enumerate(layer_sizes):
            if i_layer == 0:
                self.w.append(np.random.randn(input_n_col, size))
                self.output.append(np.zeros((input_n_row, size)))
                self.output_sigm.append(np.zeros((input_n_row ,size)))
            else:
                self.w.append(np.random.randn(layer_sizes[i_layer-1], size))
                self.output.append(np.zeros((input_n_row, size)))
                self.output_sigm.append(np.zeros((input_n_row ,size)))

    def fit(self, eps=10e-6):
        error = sys.maxint
        self.forward()
        while error>eps:
            self.update( self.backword() )
            self.forward()
            error = self.calculate_error()
            self.T += 1
            print "T=", self.T
            print "error", error

    def calculate_error(self):
        return np.sum( np.power(self.y - self.output_sigm[-1], 2) )

    def forward(self):
        for i_layer in xrange(len(self.output)):
            if i_layer == 0:
                self.output[i_layer] = self.x.dot(self.w[i_layer])
                self.output_sigm[i_layer] = self.sigmoid(self.output[i_layer])
            else:
                self.output[i_layer] = self.output_sigm[i_layer-1].dot(self.w[i_layer])
                self.output_sigm[i_layer] = self.sigmoid(self.output[i_layer])

    def backword(self):
        result = []
        for i_layer in range(len(self.w))[::-1]:
            if i_layer==len(self.w)-1:
                result.insert(0, self.diff(self.output_sigm[i_layer], self.y) )
            else:
                result.insert(0, self.diff_mult( self.output_sigm[i_layer], result[0].dot(self.w[i_layer+1].T)) )
        return result

    def update(self, diff):
        for i_layer in range(len(self.w))[::-1]:
            if i_layer==0:
                for i_row in xrange(len(diff[i_layer])):
                    self.w[i_layer] -= self.get_incremental_update_value(
                                              self.x[i_row].reshape(len(self.w[i_layer]),1),
                                              diff[i_layer][i_row,:].reshape(1,self.w[i_layer].shape[1])
                                          )
            else:
                for i_row in xrange(len(diff[i_layer])):
                    self.w[i_layer] -= self.get_incremental_update_value(
                                              self.output_sigm[i_layer-1][i_row,:].reshape(len(self.w[i_layer]),1),
                                              diff[i_layer][i_row,:].reshape(1,self.w[i_layer].shape[1])
                                          )

    def get_incremental_update_value(self, input_data, diff):
        return np.kron(input_data, self.mu*diff)

    def diff(self, y, t):
        return self.alph * 2*(y - t) * self.dsigmoid(y)

    def diff_mult(self, y, prp_value):
        return self.alph * self.dsigmoid(y) * prp_value

    def sigmoid(self, s, alph=0.01):
        return 1/(1+np.exp(-self.alph*(s-self.theta)))

    def dsigmoid(self, y):
        return y * (1 - y)

if __name__=='__main__':
    layer_sizes = (4,3)
    input_layer_size = 3 
    input_data_size = 1000

    nn = NN()
    nn.create_data(input_data_size, input_layer_size, layer_sizes)
    nn.fit()

Nous vous prions de nous excuser pour la gêne occasionnée, mais nous vous serions reconnaissants de bien vouloir signaler toute erreur.

Théorie et implémentation simples des réseaux neuronaux