Genetischer Algorithmus

Transkript

1 Genetischer Algorithmus Roger Imbach KBS: Genetischer Algorithmus 1/12

2 Inhalsverzeichnis Einleitung...3 Was ist ein genetischer Algorithmus?...3 Was machen genetische Algorithmen?...3 Vorgehen...4 Crossover rate...4 Mutation...4 Vorteile...5 Nachteile...5 Anwendungsgebiete...5 Beispiel...6 Resultate...12 KBS: Genetischer Algorithmus 2/12

3 Einleitung Was ist ein genetischer Algorithmus? Genetische Algorithmen sind genau genommen heuristische Optimierungsverfahren, d.h. diese Algorithmen produzieren verschiedene Lösungsvorschläge (in mehreren Wiederholungszyklen) welche analysiert werden und anschliessend verschieden kombiniert, verändert und ausgelesen werden (durch bestimmte Heuristiken). Die genetischen Algorithmen gehören zu den evolutionären Algorithmen, wodurch ersichtlich ist dass sich diese, durch wiederholte Anpassung und Änderung, weiter entwickeln und sich verändern. Aufgrund dieser beschriebenen Eigenschaften eignen sich genetische Algorithmen für analytisch nicht lösbare Probleme oder auch für Probleme deren geschlossene Lösung nicht effizient berechnet werden kann (P=NP?). Was machen genetische Algorithmen? Genetische Algorithmen sind an die Biologie angelehnt und versuchen eigentlich nichts anderes zu machen als Mutter Natur selber. Aus einer Population von Individuen / Lösungen wird ein Paar (zufällig) ausgesucht was gut zu der Lösung des Problems passt. Diese beiden Individuen / Lösungen werden gepaart und solange verschieden kombiniert bis wiederum eine Population von Individuen / Lösungen entsteht und das Ganze von vorne beginnt, dabei wird sogar, wie auch in der Natur, Mutationen Sorge getragen. KBS: Genetischer Algorithmus 3/12

4 Vorgehen Initialisierung: Erzeugen einer ausreichend grossen Menge / Population unterschiedlicher Individuen (Lösungskandidaten). Dies ist die erste Generation. Evaluation: Für jeden Lösungskandidaten der aktuellen Generation wird anhand einer Funktion (auch Fitness-Funktion genannt) ein Wert bestimmt, der seine Güte angibt. Selektion: Zufällige Auswahl von Lösungskandidaten aus der aktuellen Generation. Dabei werden Lösungskandidaten mit besseren Zielfunktionswerten mit einer höheren Wahrscheinlichkeit ausgewählt. Rekombination: Die Daten der ausgewählten Individuen werden gemischt und daraus neue Individuen erzeugt. Mutation: Zufällige Veränderung der neuen Individuen (mit einer sehr kleinen Wahrscheinlichkeit werden Bitwerte einfach geswitcht). Auswahl der neuen Individuen für die nachfolgende Generation. Diese Individuen können je nach Implementation aus den neu gebildeten Individuen oder auch zusätzlich aus einem Bestandteil der alten Generation bestehen. Ist ein Abbruchkriterium erreicht wird das Individuum welches am besten der erwarteten Lösung entspricht ausgewählt und das Verfahren beendet, ansonsten wiederholen sich die jeweiligen Schritte. Crossover rate Mit der Crossover rate werden Rekombinationen erstellt. Diese rate gibt an mit welcher Wahrscheinlichkeit 2 Individuen ihre Bits swapen. Crossover funktioniert dabei so dass ein beliebiges Bit (Individuen sind von Vorteil binär codiert) ausgesucht wird und ab dieser Position die beiden Individuen ihre restlichen Bits tauschen. Mutation Wie oben schon beschrieben werden zufällig, mit einer sehr kleinen Wahrscheinlichkeit, einzelne Bits einfach von 0 auf 1 geswitcht und vis versa. Dabei ist anzumerken dass die Wahrscheinlichkeit von niederwärtigen Bits höher ist. KBS: Genetischer Algorithmus 4/12

5 Vorteile Roger Imbach Schnellsten Optimierungsverfahren. Binäre Darstellung der Individuen -> Perfekte Anpassung an aktuelle Rechner. Verwendung mehrerer Individuen -> Parallelisierung. Nachteile Optimalitätsproblem (Ist die Lösung optimal?). Es ist schwer geeignete Mutations und Rekombinationsverfahren zu finden. Anwendungsgebiete Optimierungsverfahren Genetische Programmierung -> Automatische Generierung von Computerprogrammen Robotik -> Bewegungsabläufe -> Wegfindungsalgorithmen Konstruktion von komplexen Bauteilen Brückenbau Lösung (-sansätze) für Probleme im NP-Raum (N=NP?). -> Optimalitätsprinzip bleibt weiterhin bestehen. KBS: Genetischer Algorithmus 5/12

6 Beispiel Roger Imbach Das Beispiel wurde von der Seite ai-junkies entnommen ( ) und beschäftigt sich damit eine Formel zu finden welche einen Eingabewert berechnet, dabei sind die Operationen *, /, +, - möglich inklusive den Zahlen 0-9. Hier ist der Code: import java.util.*; public class GA { public static void main(string[] args) { new GA().doIt(Integer.parseInt("77")); // Static info static char[] ltable = {'0','1','2','3','4','5','6','7','8','9','+','-','*','/'; static int chromolen = 5; static double crossrate =.7; static double mutrate =.001; static Random rand = new Random(); static int poolsize = 40; // Must be even private void doit(int target) { int gen=0; // Create the pool ArrayList pool = new ArrayList(poolSize); ArrayList newpool = new ArrayList(pool.size()); // Generate unique cromosomes in the pool for (int x=0;x<poolsize;x++) pool.add(new Chomosone(target)); // Loop until solution is found while(true) { // Clear the new pool newpool.clear(); // Add to the generations gen++; // Loop until the pool has been processed for(int x=pool.size()-1;x>=0;x-=2) { // Select two members Chomosone n1 = selectmember(pool); KBS: Genetischer Algorithmus 6/12

7 Chomosone n2 = selectmember(pool); // Cross over and mutate n1.crossover(n2); n1.mutate(); n2.mutate(); // Rescore the nodes n1.scorechromo(target); n2.scorechromo(target); Roger Imbach // Check to see if either is the solution if (n1.total == target && n1.isvalid()) { System.out.println("Generations: " + gen + " Solution: " + n1.decodechromo()); return; if (n2.total == target && n2.isvalid()) { System.out.println("Generations: " + gen + " Solution: " + n2.decodechromo()); return; // Add to the new pool newpool.add(n1); newpool.add(n2); // Add the newpool back to the old pool pool.addall(newpool); //---- Chomosone Class private Chomosone selectmember(arraylist l) { // Get the total fitness double tot=0.0; for (int x=l.size()-1;x>=0;x--) { double score = ((Chomosone)l.get(x)).score; tot+=score; double slice = tot*rand.nextdouble(); // Loop to find the node double ttot=0.0; for (int x=l.size()-1;x>=0;x--) { Chomosone node = (Chomosone)l.get(x); ttot+=node.score; if (ttot>=slice) { l.remove(x); return node; return (Chomosone)l.remove(l.size()-1); KBS: Genetischer Algorithmus 7/12

8 // Genetic Algorithm Node private static class Chomosone { // The chromo StringBuffer chromo = new StringBuffer(chromoLen * 4); public StringBuffer decodechromo = new StringBuffer(chromoLen * 4); public double score; public int total; // Constructor that generates a random public Chomosone(int target) { // Create the full buffer for(int y=0;y<chromolen;y++) { // What's the current length int pos = chromo.length(); // Generate a random binary integer String binstring = Integer.toBinaryString(rand.nextInt(ltable.length)); int filllen = 4 - binstring.length(); // Fill to 4 for (int x=0;x<filllen;x++) chromo.append('0'); // Append the chromo chromo.append(binstring); // Score the new cromo scorechromo(target); public Chomosone(StringBuffer chromo) { this.chromo = chromo; // Decode the string public final String decodechromo() { // Create a buffer decodechromo.setlength(0); // Loop throught the chromo for (int x=0;x<chromo.length();x+=4) { // Get the int idx = Integer.parseInt(chromo.substring(x,x+4), 2); if (idx<ltable.length) decodechromo.append(ltable[idx]); // Return the string return decodechromo.tostring(); // Scores this chromo KBS: Genetischer Algorithmus 8/12

9 public final void scorechromo(int target) { total = addup(); if (total == target) score = 0; score = (double)1 / (target - total); // Crossover bits public final void crossover(chomosone other) { // Should we cross over? if (rand.nextdouble() > crossrate) return; // Generate a random position int pos = rand.nextint(chromo.length()); // Swap all chars after that position for (int x=pos;x<chromo.length();x++) { // Get our character char tmp = chromo.charat(x); // Swap the chars chromo.setcharat(x, other.chromo.charat(x)); other.chromo.setcharat(x, tmp); '0')); // Mutation public final void mutate() { for (int x=0;x<chromo.length();x++) { if (rand.nextdouble()<=mutrate) chromo.setcharat(x, (chromo.charat(x)=='0'? '1' : // Add up the contents of the decoded chromo public final int addup() { // Decode our chromo String decodedstring = decodechromo(); // Total int tot = 0; // Find the first number int ptr = 0; while (ptr<decodedstring.length()) { char ch = decodedstring.charat(ptr); if (Character.isDigit(ch)) { tot=ch-'0'; ptr++; KBS: Genetischer Algorithmus 9/12

10 break; else { ptr++; // If no numbers found, return if (ptr==decodedstring.length()) return 0; // Loop processing the rest boolean num = false; char oper=' '; while (ptr<decodedstring.length()) { // Get the character char ch = decodedstring.charat(ptr); // Is it what we expect, if not - skip if (num &&!Character.isDigit(ch)) {ptr++;continue; if (!num && Character.isDigit(ch)) {ptr++;continue; break; // Is it a number if (num) { switch (oper) { case '+' : { tot+=(ch-'0'); break; case '-' : { tot-=(ch-'0'); break; case '*' : { tot*=(ch-'0'); break; case '/' : { if (ch!='0') tot/=(ch-'0'); else { oper = ch; // Go to next character ptr++; num=!num; return tot; public final boolean isvalid() { // Decode our chromo String decodedstring = decodechromo(); boolean num = true; for (int x=0;x<decodedstring.length();x++) { char ch = decodedstring.charat(x); // Did we follow the num-oper-num-oper-num patter if (num ==!Character.isDigit(ch)) return false; KBS: Genetischer Algorithmus 10/12

11 return false; // Don't allow divide by zero if (x>0 && ch=='0' && decodedstring.charat(x-1)=='/') num =!num; // Can't end in an operator if (! Character.isDigit(decodedString.charAt(decodedString.length()-1))) return false; return true; Wir sehen dass ich den Eingabewert 77 gewählt habe und die Länge der Chromosomen auf 5 gesetzt wurde (sprich die Lösung hat 5 Bestandteile (Operationen + Zahlen)), wie auch die Mutationsrate und Crossoverrate. Wir sehen dass der Algorithmus nichts anderes macht als wir bereits besprochen haben. 1. Generation erstellen 2. Chromosomen aussuchen 3. Chromosomen paaren (Crossover) 4. Chromosomen mutieren 5. Chromosomen neu bewerten(fitting) 6. Schauen ob wir einen korrekten Wert gefunden haben 7. Ansonsten wiederholen bis Lösung gefunden wurde Wie die ganzen Operationen auf den Chromosomen durchgeführt werden ist wirklich gut im Code ersichtlich, die Prinzipien erfolgen auch den in der Einleitung beschriebenen Ideen. KBS: Genetischer Algorithmus 11/12

12 Resultate Ich habe die Zahl 77 gewählt. Hier einige Lösungen: Generations: 543 Solution: 9*8+5 Generations: 3872 Solution: 9*8+5 Generations: 6710 Solution: 7+4*7 Generations: 2270 Solution: 9*9-4 Generations: 2274 Solution: 9*9-4 Generations: 2090 Solution: 7+4*7 Auffällig daran ist dass die Anzahl der Generationen ziemlich hoch ist, das Ganze jedoch ziemlich schnell abläuft. Die Resultate ähneln sich auch ziemlich, was aufgrund der Beschränkung der Chromosomenlänge auf 5 und der Wahl der Zahl einleuchtend ist, denn 77 besitzt in der Primzahlenzerlegung die Primzahlen 7 und 11, welche in einigen der Lösungen vorkommen (7+4 = 11 * 7 = 77) und diese sich auf wenige verschiedene Arten bilden lassen (zumindest im Vergleich mit nicht Primzahlen). Wie es zu der Berechnung der Zahl kommt ist in den Beschreibungen ganz gut ersichtlich. Quellen KBS: Genetischer Algorithmus 12/12