Da wir hier mit der Praxis beginnen, lesen Sie bitte zuerst "Genetische Algorithmus-Theorie-".
Lassen Sie uns nun GA mit Python ausführen. Hier gehen wir davon aus, dass Sie bereits Grundkenntnisse in Python haben. Verwenden Sie Funktionen, aber keine Klassen, da die Erklärungen chaotisch sind.
Was genau machst Du?
Ein häufiges Beispiel ist das ONEMAX-Problem. das ist, ｛1，0，0，1，0，1，1，1，0，0｝ Aus einem Array bestehend aus "1" oder "0", wie z ｛1，1，1，1，1，1，1，1，1，1｝ Ich dachte darüber nach, wie man ein Array aller Einsen erstellt.
Dies wird mit GA gelöst. Der Ablauf besteht darin, zufällig eine Sequenz mit "1" oder "0" als Element zu erzeugen, diese als genetische Information zu verwenden und einen Algorithmus zu erstellen, der den Gesamtwert der Sequenz als Bewertungsstandard verwendet.
Zunächst wird der gesamte Code angezeigt.
GA.py
import random
from decimal import Decimal
GENOM_LENGTH = 20 #Länge der genetischen Information
MAX_GENOM_LIST = 200 #Die Größe der Genpopulation
SELECT_GENOM = 10 #Anzahl der Elite-Genselektionen
INDIVIDUAL_MUTATION = 0.01 #Individuelle Mutationswahrscheinlichkeit
GENOM_MUTATION = 0.01 #Wahrscheinlichkeit einer Genmutation
MAX_GENERATION = 20 #Anzahl der zu wiederholenden Generationen
def genom(length):
"""
Generieren Sie Gene nach dem Zufallsprinzip.
Der Rückgabewert ist die Gensequenz eines Individuums
"""
genom_list = []
for i in range(length):
a = random.randint(0,1)
genom_list.append(a)
return genom_list
def evaluation(ga):
"""
Bewertungsfunktion eines Individuums.
Aus der durch das Argument erhaltenen Gensequenz wird der Gesamtwert als Bewertungswert zurückgegeben.
"""
genom_total = sum(ga)
genom_num = len(ga)
return Decimal(genom_total) / Decimal(genom_num)
def select_elite(ga,elite_length):
"""
Eine Funktion, um hervorragende Individuen zu extrahieren.
"""
sort_result = sorted(ga, reverse=True, key=evaluation)
result = [sort_result.pop(0) for i in range(elite_length)]
return result
def crossover(ga_one,ga_second):
"""
Kreuzfunktion.
Zwei Nachkommen werden von den beiden durch das Argument angegebenen Eltern zurückgegeben.
Hier wird es durch Zweipunktkreuzung vererbt.
"""
genom_list = []
cross_one = random.randint(0,GENOM_LENGTH)
cross_second = random.randint(cross_one,GENOM_LENGTH)
one = ga_one
second = ga_second
progeny_one = one[:cross_one] + second[cross_one:cross_second] + one[cross_second:]
progeny_second = second[:cross_one] + one[cross_one:cross_second] + second[cross_second:]
genom_list.append(progeny_one)
genom_list.append(progeny_second)
return genom_list
def create_next_generation(ga,ga_elite,ga_progeny):
"""
Generieren Sie die Bevölkerung der nächsten Generation.
Holen Sie sich die vorherige Generationsgruppe mit dem ersten Argument,
Das zweite und dritte Argument Elite und Kinder werden hinzugefügt, und die weniger hervorragenden Personen werden entfernt.
"""
next_generation_geno = sorted(ga, reverse = False, key = evaluation)
for i in range(0, len(ga_elite) + len(ga_progeny)):
next_generation_geno.pop(0)
next_generation_geno.extend(ga_elite)
next_generation_geno.extend(ga_progeny)
return next_generation_geno
def mutation(ga, individual_mutation, genom_mutation):
"""
Mach eine Mutation.
Wählen Sie aus, ob das Individuum mit einer bestimmten Wahrscheinlichkeit mutiert.
Das Gensequenzelement des gefangenen Individuums wird ebenfalls mit Wahrscheinlichkeit ausgewählt,
Ändern Sie das eingeschlossene Element auf 1 oder 0.
"""
ga_list = []
for i in ga:
if individual_mutation > (random.randint(0,100) / Decimal(100)):
genom_list = []
for i_ in i:
if genom_mutation > (random.randint(0,100)/Decimal(100)):
genom_list.append(random.randint(0,1))
else:
genom_list.append(i_)
ga_list.append(genom_list)
else:
ga_list.append(i)
return ga_list
if __name__ == '__main__':
current_generation = []
for i in range(MAX_GENOM_LIST):
current_generation.append(genom(GENOM_LENGTH))
for count_ in range(1,MAX_GENERATION + 1):
current_evaluation = []
for i in range(MAX_GENOM_LIST):
evaluation_result = evaluation(current_generation[i])
current_evaluation.append(evaluation_result)
elite_genes = select_elite(current_generation,SELECT_GENOM)
progeny_gene = []
for i in range(0,SELECT_GENOM):
progeny_gene.extend(crossover(elite_genes[i-1],elite_genes[i]))
next_generation = create_next_generation(current_generation,elite_genes,progeny_gene)
next_generation = mutation(next_generation,INDIVIDUAL_MUTATION,GENOM_MUTATION)
fits = []
j = 0
for i in current_generation:
fits.append(current_evaluation[j])
j = j + 1
min_ = min(fits)
max_ = max(fits)
avg_ = sum(fits) / Decimal(len(fits))
print ("-----------Nein.{}Generation----------".format(count_))
print (" Min:{}".format(min_))
print (" Max:{}".format(max_))
print (" avg:{}".format(avg_))
print("\n")
current_generation = next_generation
print ("Das beste Individuum ist{}".format(elite_genes[0]))
Die Vorgehensweise ist wie im vorherigen Artikel Theorie gezeigt. In diesem Programm
** Die Anzahl der Individuen pro Generation beträgt 200, Die Länge der Gensequenz pro Individuum beträgt 20, Die Anzahl der sich wiederholenden Generationen beträgt 20, Die Mutationswahrscheinlichkeit beträgt für beide Arten 1%, 20 Elite-Möglichkeiten, **
Es bewegt sich mit dem Wert. Dieser Wert kann natürlich frei festgelegt werden. Grundsätzlich gilt: Je größer die Anzahl der Generationen ist, desto besser kommt das Individuum heraus und je länger die Gensequenz ist, desto langsamer ist die Konvergenzgeschwindigkeit zur optimalen Lösung, sodass die Anzahl der Generationen und die Größe des Satzes erhöht werden. Es besteht die Notwendigkeit. ** ** **
Und wenn Sie dies tun,
-----------20. Generation----------
Min:0.9
Max:1
avg:0.96875
Das beste Individuum ist[1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1]
Es wurde so ausgegeben und hat das ONEMAX-Problem hervorragend gelöst! !! (Nur die letzten Zeilen werden aufgelistet.)
Das ist die Kraft von GA! !!
Jetzt können Sie verstehen, was GA ist und welche Macht es hat. Daher möchte ich denjenigen, die mit diesem Artikel lernen, eine Aufgabe geben.
** ⑴ Erstellen Sie den obigen Code und führen Sie ihn aus, ohne die Verarbeitung der Mutation. Berücksichtigen Sie auch die Ergebnisse. ⑵ Optimale Lösung, ｛1,0,1,0,1,0,1,0,..........0,1｝ Als solches wird GA als Individuum zusammengesetzt, in dem "1" und "0" abwechselnd angeordnet sind. ** ** **
Das ist alles.
Es scheint, dass es ein Bild gibt, bei dem es äußerst schwierig ist, mit KI zu beginnen. Überraschenderweise ist die Stiftung interessant und leicht vorstellbar. In diesem Artikel konnten Sie einen Blick auf die KI werfen. Alles was Sie tun müssen, ist Ihre Ideen vorzustellen. Bis zum nächsten Mal. Danke fürs Lesen.
Recommended Posts