Genetische Algorithmen

Transkript

1 Genetische Algorithmen In dieser Ausarbeitung gemäss Aufgabenstellung auf der Kurshomepage des Moduls Knowledge- Based Systems wird die Funktionsweise und Nutzung von genetischen Algorithmen erläutert. Die Ausarbeitung stützt sich auf die im Kapitel Quellen angegebenen Webseiten und wurde daraus frei zusammengestellt und ergänzt. Inhaltsverzeichnis Was sind genetische Algorithmen?... 2 Biologische Evolution... 2 Aufbau... 2 Abbruchkriterium... 3 Zielfunktion... 3 Wo werden genetische Algorithmen verwendet?... 4 Beispiel... 4 Kommentar zum Beispiel... 8 Quellen... 10

2 Was sind genetische Algorithmen? Genetische Algorithmen zählen zu stochastischen Suchverfahren. Diese Verfahren arbeiten sich ausgehend von einer oder mehreren zulässigen Lösungen schrittweise zur optimalen Lösung vor. Beispielsweise werden mehrere Wege gefunden, die zum Ziel führen, und der kürzeste/effizienteste wird ermittelt. Es wird eine Menge an Lösungen zufällig erzeugt, die guten aussortiert. Diese Lösungen werden dann leicht mutiert und miteinander kombiniert und führen so irgendwann heuristisch zu einer möglichst guten Lösung Oftmals können auch genetische Algorithmen die optimale Lösung nicht in annehmbarer Zeit finden, und man gibt sich mit einer guten suboptimalen Lösung zufrieden. Biologische Evolution Genetische Algorithmen lehnen sich an die biologische Evolution und Genetik an. Lebewesen bestehen aus Zellen, in deren Chromosomen alle wichtigen Eigenschaften des Lebewesens verankert sind (z.b. Augenfarbe). Evolution wir nun die Veränderung dieser vererbbaren Gene genannt. Diese Veränderung geschieht bei jeder Generation (Kinder). Bei der Weitergabe der Gene gibt es drei wichtige Mechanismen: - Selektion: natürliche Auslesen von Individuen. Lebewesen die gut angepasst sind haben eine höhere Überlebenschance, d.h. sie haben eine höhere Chance sich fortzupflanzen und ihre Gene weiterleben zu lassen. Die Angepasstheit eines Individuums wird auch Fitness genannt. - Mutation: Ausprägung (=Wert) der Gene verändert sich, dies kann z.b. bei Radioaktivität geschehen. Mutationen können Lebewesen schädigen, aber auch stärken. - Rekombination (Crossover): Es entstehen neue Genkombinationen durch den Austausch der Werte zweier Chromosomen. Über viele Generationen hinweg sorgt dieser Prozess dafür, dass Lebewesen an die Umwelt angepasst sind und überleben können. Aufbau der Algorithmen Genetische Algorithmen werden nach den Grundsätzen der biologischen Evolution wie im vorhergehenden Kapitel erläutert, entwickelt.

3 Initialisierung: Erzeugen von n zufälligen Lösungskandidaten Lösungskandidat = Individuum Evaluation: Für jeden Kandidaten wird anhand div. Kriterien beurteilt wie gut er ist (Güte) Mit Hilfe sogenannter Fitnessfunktion gute Lösung = hoher Wert Selektion: Auswahl von Lösungskandidaten (Kandidaten mit höherer Güte werden zu einer höheren Wahrscheinlichkeit gewählt) Survival of the fittest Rekombination: Die ausgewählten Daten werden gemischt und daraus neue erzeugt Vermehrung Mutation: Die neuen Daten (ein od. mehrere Gene) werden zufällig verändert Neue Kandidaten: Je nach Verfahren werden aus neuen oder alten Daten Kandidaten der nächsten Generation ausgewählt Abbruchkriterium Es ist natürlich nicht garantiert, dass neue Lösungen immer besser sind, als ältere. Haben sich zum Beispiel schlechte Gene durchgesetzt oder wurde das Optimum bereits gefunden werden keine besseren Lösungen mehr gefunden. Algorithmus wiederholen bis zu einem definierten Abbruchskriterium. Diese könnten sein: - Algo hat bestimmte Anzahl Generationen durchlaufen (1 Durchlauf = 1 Generation) - Es ist keine Verbesserung zur vorherigen Generation aufgetreten - Es ist eine zu geringe Verbesserung zur vorherigen Generation aufgetreten Es wird die Lösung zurück gegeben, die die grösste Fitness zur Abbruchzeit besitzt. Zielfunktion Normalerweise gibt es mehrere Optimierungskriterien, und somit auch mehrere Zielfunktionen. Die Gewichtungsfunktion für eine Lösung wird dann als Summe der einzelnen Funktionen multipliziert mit einer Gewichtung des jeweiligen Kriteriums angesehen.

4 Wo werden genetische Algorithmen verwendet? Genetische Algorithmen werden vor allem für Probleme verwendet, für die eine exakte Lösung nur sehr aufwändig berechnet werden kann. Das Profil eines Flügels und die Form eines Rumpfes von Flugzeugen werden mit Hilfe von genetischen Algorithmen berechnet und simuliert. Auch im Brückenbau können mit Hilfe von Genetischen Algorithmen Teile in Lage, Form und Gewicht optimiert werden. Nützlich sind genetische Algorithmen auch in der Logistik (siehe z.b. nachfolgendes Codebeispiel) Beispiel Beispiel entnommen von: Mit diesem genetischen Algorithmus wird das Rundreise Problem eines Paketdienstes gelöst. Von einem Warenlager aus, sollen alle Stationen einmal angefahren werden, natürlich auf dem kürzesten Weg und ohne eine zweimal zu besuchen. Es handelt sich hierbei um die klassische Travelling Salesman Problematik. Dieses Problem kann mit einem normalen Algorithmus nur mit polynomialem Aufwand gelöst werden. public class GeneticAlgorithm { public static void main(string[] args) { GeneticAlgorithm app = new GeneticAlgorithm(); app.berechneroute(); /* Implementierung des genetischen Algorithmus */ private Random rnd = new Random(); private Point lager = new Point(221, 106); private Point[] stationen = new Point[] { new Point(98, 154), new Point(98, 192), new Point(23, 154), new Point(42, 59), new Point(155, 21), new Point(325, 77), new Point(345, 170), ; private float p_m = 0.05f; // Mutationswahrscheinlichkeit private float p_c = 0.1f; // Crossover-Wahrscheinlichkeit

5 private void berechneroute() { List<int[]> population = new ArrayList<int[]>(); int populationsgroesse = 40; // Anfangspopulation erzeugen for(int i = 0; i < populationsgroesse; i++ ) { population.add(generierechromosom()); // solange Abbruchbedingung nicht erfã¼llt int anz_generationen = 1; while(anz_generationen <= 100) { // Selektion population = selektiere(population); // Mutation mutiere(population); // Crossover crossover(population); // Anzeigen des besten Chromsoms in der Tabelle (Ausgabe) zeigebesteschromosoman(anz_generationen, population); // ZÃ hler fã¼r Generationen erhã hen anz_generationen++; // Ergebnis ist der letzte Eintrag in der Tabelle private void zeigebesteschromosoman(int generation, List<int[]> population) { float beste_fitness = Float.MAX_VALUE; int beste_fitness_index = -1; // kleinste Fitness finden for(int i = 0; i < population.size(); i++) { float f = berechnefitness(population.get(i)); if(f < beste_fitness) { beste_fitness = f; beste_fitness_index = i; // Chromosom als Zeichenkette darstellen String bestes_chromosom = ""; int[] chromosom = population.get(beste_fitness_index); for(int i = 0; i < chromosom.length; i++) { bestes_chromosom += ((i == 0)? "" : ", ") + (chromosom[i]+1); // neue Zeile in Auswertungstabelle schreiben System.out.println(Integer.toString(generation) + "\t\t(" + bestes_chromosom + ")\t\t" + Float.toString(beste_fitness)); private void crossover(list<int[]> population) {

6 // - jedes Chromosom soll genau einmal in den Vorgang involviert sein // - immer zwei Chromosomen zufã llig wã hlen List<int[]> verbleibend = new ArrayList<int[]>(population); while(verbleibend.size() >= 2) { // Auswahl zweier Chromosomen int[] c1 = verbleibend.get(rnd.nextint(verbleibend.size())); verbleibend.remove(c1); int[] c2 = verbleibend.get(rnd.nextint(verbleibend.size())); verbleibend.remove(c2); // fã¼hre Crossover mit Wahrscheinlichkeit p_c aus if(rnd.nextfloat() <= p_c) { // Austauschstelle zufã llig bestimmen int z = rnd.nextint(c1.length-1) + 1; int[] c1_getauscht = c1.clone(), c2_getauscht = c2.clone(); for(int i = z; i < c1_getauscht.length; i++) { int tmp = c1_getauscht[i]; c1_getauscht[i] = c2_getauscht[i]; c2_getauscht[i] = tmp; c1.length); c2.length); // nur dann verwenden, wenn Chromosom immer noch // gã¼ltige LÃ sung reprã sentiert if(istgueltig(c1_getauscht)) { System.arraycopy(c1_getauscht, 0, c1, 0, System.arraycopy(c2_getauscht, 0, c2, 0, private boolean istgueltig(int[] chromosom) { Set<Integer> enthaltene_stationen = new HashSet<Integer>(); for(int i = 0; i < chromosom.length; i++ ) { if(enthaltene_stationen.contains(chromosom[i]) chromosom[i] < 0 chromosom[i] >= stationen.length) { return false; enthaltene_stationen.add(chromosom[i]); return true; private void mutiere(list<int[]> population) { for(int[] chromosom : population) { for(int i = 0; i < chromosom.length; i++) { // mutiere mit Wahrscheinlichkeit p_m if(rnd.nextfloat() <= p_m) { // Ã ndere die Station int vorherige = chromosom[i];

7 1); 1 : 0; bereits wegchromosom[i]) { chromosom[i] = rnd.nextint(stationen.length- chromosom[i] += (chromosom[i] >= vorherige)? // die zufã llig gewã hlte Station taucht // irgendwo im Chromosom auf, daher sollte sie // durch die Station, die durch das mutieren // gefallen ist, ersetzt werden for(int k = 0; k < chromosom.length; k++) { if(k!= i && chromosom[k] == chromosom[k] = vorherige; break; private List<int[]> selektiere(list<int[]> population) { List<int[]> neue_population = new ArrayList<int[]>(); // Fitness der Chromosomen berechnen float gesamt_fitness = 0.0f, maximale_fitness = 0.0f; float[] fitness = new float[population.size()]; for(int i = 0; i < population.size(); i++) { fitness[i] = berechnefitness(population.get(i)); maximale_fitness = Math.max(maximale_fitness, fitness[i]); // Da wir minimieren wollen, bedienen wir uns dem Trick, dass // wir jede berechnete Fitness ersetzen durch: // Maximale Fitness - Fitness for(int i = 0; i < fitness.length; i++) { fitness[i] = (float)math.pow(1.2f, (maximale_fitness - fitness[i]) / 100.0f); gesamt_fitness += fitness[i]; // nun kã nnen wir entsprechend oft auswã hlen for(int i = 0; i < population.size(); i++) { float z = rnd.nextfloat() * gesamt_fitness; float hilfswert = 0.0f; for(int k = 0; k < fitness.length; k++) { // auszuwã hlendes Chromosom gefunden? if(z <= hilfswert + fitness[k]) { neue_population.add(population.get(k).clone()); break; // sonst weitersuchen hilfswert += fitness[k]; return neue_population;

8 private float berechnefitness(int[] chromosom) { float strecken_laenge = 0.0f; // Strecken zwischen den Stationen einbeziehen for(int i = 0; i < chromosom.length-1; i++) { int k1 = chromosom[i]; int k2 = chromosom[i+1]; strecken_laenge += Math.sqrt(Math.pow(stationen[k2].xstationen[k1].x, 2) + Math.pow(stationen[k2].y-stationen[k1].y, 2)); // Strecke zwischen Lager-erste Station und zwischen Lagerletzte Station einbeziehen int n = stationen.length - 1; strecken_laenge += Math.sqrt(Math.pow(stationen[0].x-lager.x, 2) + Math.pow(stationen[0].y-lager.y, 2)); strecken_laenge += Math.sqrt(Math.pow(stationen[n].x-lager.x, 2) + Math.pow(stationen[n].y-lager.y, 2)); return strecken_laenge; private int[] generierechromosom() { // ein Chromosom/Lösung wird als Reihenfolge der Stationen // kodiert; die Reihenfolge wird durch ein Array festgelegt int[] chromosom = new int[stationen.length]; // Variable fã¼r verbleibende Stationen zum Auswà hlen ArrayList<Integer> stationen_verbl = new ArrayList<Integer>(); for(int i = 0; i < stationen.length; i++) { stationen_verbl.add(i); // Stationen nach zufã lliger Reihenfolge auswã hlen for(int i = 0; i < stationen.length; i++) { int zufallsindex = rnd.nextint(stationen_verbl.size()); chromosom[i] = stationen_verbl.get(zufallsindex); stationen_verbl.remove(zufallsindex); return chromosom; Kommentar zum Beispiel 1. Es werden anfänglich 40 verschiedene Standort Kombinationen (=Chromosome) als Startpopulation generiert. Die Standort Reihenfolge die abgefahren wird wird dabei zufällig gewählt. Natürlich muss stets darauf geachtet werden, dass bei jedem Chromosom, jeder Standort nur einmal vorhanden ist. 2. Es wird definiert, dass der Algorithmus nach 100 Generationen abbrechen soll. Die Startpopulation ist Generation Als erstes wird nun eine Selektion vorgenommen. a. Für jedes Chromosom der Population die Fitness berechnen. Es wir die Länge der Strecke vom Lager, über alle Stationen (in gegebener Reihenfolge) bis zurück zum Lager berechnet.

9 b. Da wir die minimale Weglänge wollen, berechnen wir die Maximale Fitness Fitness des Chromosoms, so dass trotzdem gilt, je Grösser die Fitness, desto besser. c. Nun wiederum 40 Chromosome aus den bereits vorhandenen ausgewählt. 4. Mutation a. Ein Gen wird zu einer zuvor festgelegten Wahrscheinlichkeit (0.05) mutiert. b. Der Standort der aktuellen Gens wird dafür einfach geändert. Natürlich muss bedacht werden, dass der neue Standort im Chromosom schon irgendwo vorhanden ist. Man ersetzt also diesen mit dem alten Standort des aktuellen Gens. 5. Crossover a. Jedes Chromosom soll einmal involviert sein. b. Immer zwei Chromosome werden dafür zufällig aus einer Liste unbehandelter Chromosome ausgewählt. c. Mit der Wahrscheinlichkeit 0.1 wird ein Crossover durchgeführt. d. Die Austauschstelle wird zufällig gewählt. Und der Teil nach dieser Stelle zwischen den beiden Chromosomen ausgetauscht e. Natürlich kann es nun vorkommen, dass Chromosome mit doppelten Standorten entstehen. Dies muss überprüft werden, und gegebenenfalls der Crossover rückgängig gemacht werden. 6. Bestes Chromosom anzeigen a. Gibt das Chromosom mit der besten Fitness nach der gegebenen Generation aus. Und schreibt dieses in eine Tabelle. Im Screenshot der Java Console sieht man nun von jeder Generation das beste Chromosom (=Kürzester Weg). Gut ersichtlich ist, dass das beste Resultat nicht in Generation 100 gefunden wurde, das Resultat z.b. bei Generation 80 ist besser. Das Problem konnte von rund 1100 auf rund 880 optimiert werden.

10 Quellen 19.Mai Mai 2009