Python & maschinelles Lernen Lernnotiz Machine: Maschinelles Lernen durch Rückausbreitung

Einführung

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

• Referenzmaterial: Udemy jedermanns KI-Kurs Künstliche Intelligenz und maschinelles Lernen von Grund auf mit Python
• Ausgabeeinstellung: Erstellen Sie anhand des Breiten- und Längengrads ein Programm, das bestimmt, ob es zu Tokio oder Kanagawa gehört.
• Beurteilungsmethode: Die Beurteilung erfolgt durch ein neuronales Netzwerk mit zwei Eingangsschichten, zwei Zwischenschichten und einer Ausgangsschicht.

Maschinelles Lernen mit Rückenausbreitung

Das Gewicht der Neuronen in der Ausgabeschicht wird basierend auf dem Fehler zwischen der Ausgabe und der richtigen Antwort angepasst. Zusätzlich werden die Gewichte der Neuronen in der Zwischenschicht basierend auf den Gewichten der Neuronen in der Ausgangsschicht angepasst.

Zwischenebene - Anpassen des Gewichts der Ausgabeebene

Zwischenschicht - Die Gewichtsanpassung der Ausgangsschicht kann durch die folgende Formel erhalten werden.

\delta_{mo} = (Ausgabewert-Richtiger Antwortwert) \Differenzierung der Ausgabezeiten\\
Korrekturbetrag= \delta_{mo} \mal mittlerer Schichtwert\mal Lernkoeffizient

Differenzierung der Sigmoidfunktion

In Bezug auf die "Differenzierung der Ausgabe" in der obigen Formel ist die Differenzierung der Sigmoidfunktion $ f (x) = \ frac {1} {1 + e ^ x} $, die diesmal in der Aktivierungsfunktion des neuronalen Netzwerks verwendet wird, wie folgt. kann bekommen.

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

Referenz: https://qiita.com/yosshi4486/items/d111272edeba0984cef2

Quellcode

class NeuralNetwork:
    #Eingabegewicht
    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]
    #Erklärung jeder Schicht
    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):

        #Ausgabewert
        output_data = self.commit([input_data[0], input_data[1]])
        #Richtiger Antwortwert
        correct_value = input_data[2]
        #Lernkoeffizient
        k = 0.3

        #Ausgabeebene → Zwischenebene
        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

Eingabeebene - Anpassen der Zwischenschichtgewichte

Die Gewichtsanpassung der Eingangsschicht-Zwischenschicht wird durch die folgende Formel erhalten. Durch Einstellen des Gewichts des Neurons der ersten Stufe basierend auf dem Anpassungsergebnis des Neurons der zweiten Stufe ist es möglich, unabhängig von der Anzahl der Schichten einzustellen.

\delta_{im} = \delta_{mo} \mal Zwischenausgangsgewicht\Zeiten Differenzierung der Zwischenschichtausgabe\\
Korrekturbetrag= \delta_{im} \mal Eingabeebenenwert\mal Lernkoeffizient

Quellcode

class NeuralNetwork:
        ...
        #Zwischenebene → Eingabeebene
        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

Lernergebnis

Bereiten Sie Folgendes als Trainingsdaten vor

Wenn Sie die folgenden Daten in das oben trainierte neuronale Netzwerk werfen ...

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]]

Sie können sehen, dass es möglich ist, festzustellen, ob es als Tokio oder Kanagawa klassifiziert ist