Eine Python-Probe zum Lernen von XOR mit einem genetischen Algorithmus in einem neuronalen Netz

Einführung

Ich habe die grundlegende Verarbeitung des genetischen Algorithmus und des neuronalen Netzes von Python geschrieben. Da der genetische Algorithmus kein Experte ist, handelt es sich um einen genetischen Algorithmus.

Was ist ein neuronales Netz?

Es ist eine Berechnungsmethode, die das Nervenzellnetz lebender Organismen nachahmt. [Link zu Wikipedia](https://ja.wikipedia.org/wiki/%E3%83%8B%E3%83%A5%E3%83%BC%E3%83%A9%E3%83%AB% E3% 83% 8D% E3% 83% 83% E3% 83% 88% E3% 83% AF% E3% 83% BC% E3% 82% AF)

Was ist XOR?

Es ist ein logischer Ausdruck, der 1 ausgibt, wenn die beiden Eingänge gleich sind, und 0, wenn sie unterschiedlich sind.

Was ist ein genetischer Algorithmus?

Was ich über genetische Algorithmen weiß ・ Wählen Sie Personen mit guten Eigenschaften aus -Erstellen Sie eine neue Person, die die Eigenschaften von einer Person mit guten Eigenschaften erbt. ・ Wiederholen Sie den Generationswechsel, um Personen mit besseren Eigenschaften zu finden und Antworten zu finden. darüber. Es scheint verschiedene Methoden zu geben, aber diesmal bin ich ein Amateur ・ Sortieren Sie die Populationen nach Klassen ・ Ersetzen Sie die unteren 10% durch neu generierte Personen ・ Generieren Sie + 50%, indem Sie die oberen 50% und andere Personen (später beschrieben) kreuzen. ・ Wiederholen Sie diesen Vorgang, um eine Person zu finden, die die am besten geeignete Antwort ableitet. Ich habe die Methode genommen.

Was ist eine Kreuzung?

Ich verstehe, dass es darum geht, die Eigenschaften von zwei Individuen herauszunehmen und eine neue zu schaffen. Es ahmt ein Kind nach, das das Gen der Eltern in der realen Welt der Lebewesen erbt. Die tatsächliche Vererbung ist ein Bild der digitalen Vererbung des Gens eines Elternteils Stück für Stück. Dieses Mal haben wir die synaptischen Gewichte (Float-Typ) des neuronalen Netzes angeordnet. Durch die interne Division jedes numerischen Wertes der beiden Sequenzen werden die synaptischen Gewichte der beiden Individuen angezeigt Ich ahmte nach, die Eigenschaften zweier Individuen zu erben. Beispiel

Da jedoch die Möglichkeit besteht, dass es zu einer lokalen Lösung konvergiert, haben wir uns entschlossen, den Wert der äußeren Teilung der beiden Gewichte zu verwenden.

Beispielprogramm

sample.py

from numpy.random import *
import numpy as np
import math
import sys

class Body:   #Jeder Einzelne
    #Anzahl der Eingabeebenen
    nn_input=2
    #Anzahl der mittleren Schichten
    nn_hidden=3
    nn_output=1
    #Bereich der anfänglichen Synapsengewichte
    w_range=10
    #Anzahl der Synapsen
    w_length=(nn_input+1)*(nn_hidden+1)+(nn_hidden+1)*(nn_output)
    #Mindestwert für die Eingabe in die Sigmoid-Funktion
    sigmoidinputmin=math.log(sys.float_info.min)
    #Maximaler Wert für die Eingabe in die Sigmoid-Funktion
    sigmoidinputmax=math.log(sys.float_info.max)

    #Wie viel die Vererbung zum Zeitpunkt der Überfahrt sollte in interne und externe aufgeteilt werden
    #0 ... Durchschnitt von zwei Gewichten
    #1 ... Eines der beiden Gewichte
    #1 oder mehr ... Externe Aufteilung (kein Wert zwischen zwei Gewichten) ist möglich
    crossRatio=2
    
    
    def __init__(self):
        self.w=None      #Synapsengewicht
        self.score=-1    #Resultate der Auswertung
        self.result=None #Berechnungsergebnis

    #Erstelle neu
    def createNewBodyAtInit():
        body=Body()
        body.w=np.random.uniform(-Body.w_range,Body.w_range,Body.w_length)
        body.calc()
        return body

    #Ergebnisse anzeigen
    def showResult(self):
        aaa= str(self.score) + ":" + str(self.result)
        print(aaa)

    #Kreuzung
    #Argument: Individuen kreuzen
    #Rückgabewert Generierte Person
    def cross(self,otherBody):
        w1=self.w
        w2=otherBody.w
        newW=[]
        for i in range(len(w1)):
            a=np.random.random()*Body.crossRatio
            newW.append(w1[i]*a+w2[i]*(1-a))
        newBody=Body()
        newBody.w=newW
        newBody.calc()
        
        return newBody

    #Bewertungsberechnung
    def calc(self):
        result=[]
        for _in in in_sample:
            result.append(self.nn(_in))
        _ = out_sample-result
        error = _*_
        self.result=result
        self.score=sum(error) 


    #Sigmaid-Funktion
    def sigmoid(self,x):
        #Gibt 1 zurück, da der Eingang zu klein ist, um überzulaufen
        if x<Body.sigmoidinputmin :
            return 1
        #Wenn es zu groß ist, gibt es keinen Überlauf,
        #Gleicher Vorgang wie oben (nicht erforderlich)
        if Body.sigmoidinputmax<x :
            return 0
        a=math.log(sys.float_info.max)
        return  1/(1+math.e**-x)




    #Berechnung des neuronalen Netzes
    def nn(self,inp):
        w=self.w
        w_num=0
        hidden_o=[]
        for i in range (Body.nn_hidden):
            o=0
            for j in range(Body.nn_input):
                o+=w[w_num]*inp[j]
                w_num+=1
            o+=w[w_num]
            w_num+=1

            hidden_o.append(self.sigmoid(o))
        o=0
        for i in range (Body.nn_hidden):
            o+=w[w_num]*hidden_o[i]
            w_num+=1
        o+=w[w_num]
        w_num+=1

        return self.sigmoid(o)



def main():
    #Eingegebener Wert
    global in_sample
    in_sample=np.array([[0,0],
                        [0,1],
                        [1,0],
                        [1,1]])
    #Zielwert ausgeben
    global out_sample
    out_sample=np.array([0,1,1,0]);


    #Anzahl der Personen
    body_counts=100

    #Anzahl der Generationen
    loop=1000
    

    #Population
    bodies=[]
    #Erstgeneration der Bevölkerung
    for i in range(body_counts):
        body=Body.createNewBodyAtInit()
        bodies.append(body)

    #Bewertung beim Generationenwechsel
    for i in range(loop):
        print("***")
        bodies=generate(bodies)
        bodies[0].showResult()
        

#Bevölkerungsregeneration
#Argument: Bevölkerung vor der Generation
#Rückgabewert: Bevölkerung nach Generationswechsel
def generate(bodies):
    bodies=sort(bodies)
    a1=0
    length=len(bodies)
    newgennum=length-1
    #Prozentsatz der mutierten Individuen
    mutationRatio=0.1
    stop=newgennum-int(length*mutationRatio)
    #Erzeugung mutierter Individuen
    while stop<newgennum :
        body = Body.createNewBodyAtInit()
        bodies[newgennum]=body
        newgennum += -1
    #Generationsrate gekreuzter Individuen
    crossRatio=0.5
    #Kreuzung
    stop=newgennum-int(length*crossRatio)
    while stop<newgennum :
        a2=int(length*np.random.random())
        body = bodies[a1].cross(bodies[a2])

        bodies[newgennum]=body
        a1 += 1
        a2 += -1
        newgennum += -1
    return bodies



#Sortieren Sie die Populationen nach Klassen.
#Argument: Vorsortierte Population
#Rückgabewert: Bevölkerung nach dem Sortieren
def sort(bodies):
    di = {}
    for body in bodies:
        di[body.score]=body
    keys = sorted(di.keys())
    li=[]
    for key in sorted(di.keys()):
        li.append(di[key])
    return li


if __name__ =="__main__":
    main()