Mémo d'étude Python & Machine Learning ④: Machine Learning par rétro-propagation

introduction

① https://qiita.com/yohiro/items/04984927d0b455700cd1 ② https://qiita.com/yohiro/items/5aab5d28aef57ccbb19c ③ https://qiita.com/yohiro/items/cc9bc2631c0306f813b5 A continué

• Matériel de référence: Cours d'IA d'Udemy Everyone sur l'intelligence artificielle et l'apprentissage automatique à partir de zéro avec Python --Réglage du problème: compte tenu de la latitude et de la longitude, créez un programme qui détermine s'il appartient à Tokyo ou Kanagawa.
• Méthode de jugement: le jugement est effectué par un réseau neuronal avec deux couches d'entrée, deux couches intermédiaires et une couche de sortie.

Apprentissage automatique avec rétro-propagation

Le poids des neurones dans la couche de sortie est ajusté en fonction de l'erreur entre la sortie et la bonne réponse. De plus, le poids des neurones dans la couche intermédiaire est ajusté en fonction des poids des neurones dans la couche de sortie.

Couche intermédiaire - Réglage du poids de la couche de sortie

Couche intermédiaire - L'ajustement du poids de la couche de sortie peut être obtenu par la formule suivante.

\delta_{mo} = (Valeur de sortie-Valeur de réponse correcte) \Différenciation des temps de sortie\\
Montant de la correction= \delta_{mo} \fois la valeur de la couche intermédiaire\coefficient d'apprentissage des temps

Différenciation de la fonction sigmoïde

En ce qui concerne la "différenciation de la sortie" dans la formule ci-dessus, la différenciation de la fonction sigmoïde $ f (x) = \ frac {1} {1 + e ^ x} $ utilisée dans la fonction d'activation du réseau de neurones cette fois est la suivante. peut obtenir.

f(x)' = f(x)\cdot(1-f(x))

Référence: https://qiita.com/yosshi4486/items/d111272edeba0984cef2

Code source

class NeuralNetwork:
    #Poids d'entrée
    w_im = [[1.0, 1.0], [1.0, 1.0], [1.0, 1.0]]  # [[i1-m1, i1-m2], [i2-m1, i2-m2], [bias1-m1, bias1-m2]]
    w_mo = [1.0, 1.0, 1.0]  # [m1-o, m2-o, bias2-0]
    #Déclaration de chaque couche
    input_layer = [0.0, 0.0, 1.0] # i1, i2, bias1
    middle_layer = [Neuron(), Neuron(), 1.0] # m1, m2, bias2
    ouput_layer = Neuron() # o

    def learn(self, input_data):

        #Valeur de sortie
        output_data = self.commit([input_data[0], input_data[1]])
        #Valeur de réponse correcte
        correct_value = input_data[2]
        #Coefficient d'apprentissage
        k = 0.3

        #Couche de sortie → Couche intermédiaire
        delta_w_mo = (correct_value - output_data) * output_data * (1.0 - output_data)
        old_w_mo = list(self.w_mo)
        self.w_mo[0] += self.middle_layer[0].output * delta_w_mo * k
        self.w_mo[1] += self.middle_layer[1].output * delta_w_mo * k
        self.w_mo[2] += self.middle_layer[2] * delta_w_mo * k

Couche d'entrée - Réglage des poids des couches intermédiaires

L'ajustement du poids de la couche d'entrée-couche intermédiaire est obtenu par la formule suivante. En ajustant le poids du neurone du premier étage en fonction du résultat de l'ajustement du neurone du deuxième étage, il est possible d'ajuster quel que soit le nombre de couches.

\delta_{im} = \delta_{mo} \fois Poids de sortie intermédiaire\fois Différenciation de la sortie de la couche intermédiaire\\
Montant de la correction= \delta_{im} \fois Valeur de la couche d'entrée\coefficient d'apprentissage des temps

Code source

class NeuralNetwork:
        ...
        #Couche intermédiaire → Couche d'entrée
        delta_w_im = [
            delta_w_mo * old_w_mo[0] * self.middle_layer[0].output * (1.0 - self.middle_layer[0].output),
            delta_w_mo * old_w_mo[1] * self.middle_layer[1].output * (1.0 - self.middle_layer[1].output)
        ]
        self.w_im[0][0] += self.input_layer[0] * delta_w_im[0] * k
        self.w_im[0][1] += self.input_layer[0] * delta_w_im[1] * k
        self.w_im[1][0] += self.input_layer[1] * delta_w_im[0] * k
        self.w_im[1][1] += self.input_layer[1] * delta_w_im[1] * k
        self.w_im[2][0] += self.input_layer[2] * delta_w_im[0] * k
        self.w_im[2][1] += self.input_layer[2] * delta_w_im[1] * k

Résultat d'apprentissage

Préparez les éléments suivants en tant que données d'entraînement

Si vous lancez les données suivantes dans le réseau neuronal formé ci-dessus ...

data_to_commit = [[34.6, 138.0], [34.6, 138.18], [35.4, 138.0], [34.98, 138.1], [35.0, 138.25], [35.4, 137.6], [34.98, 137.52], [34.5, 138.5], [35.4, 138.1]]

Vous pouvez voir qu'il est possible de déterminer s'il est classé comme Tokyo ou Kanagawa