Meßmethode

Methode

Nachdem in den letzten Punkten die Ergebnisse der Versuchsreihen protokolliert wurde, soll nun kurz die Methode beschrieben werden, mit der diese Ergebnisse erzielt worden sind. Die unterschiedlichen Parameter (Generation, Population, Mutationsw., Crossoverw.) wurden von vier ineinander verschachtelten Schleifen verändert. Eine fünfte (die innerste) Schleife sorgte für die Meßaufzeichnung mit gleichen Parametern. Die Ergebnisse jeder dieser Durchläufe wurde automatisch in eine Datei geschrieben:

----------------------------------------------------------------------------------    
Generationen: 10 Population: 10 Crossoverw.: 0.2 Mutationw.: 0.01 
----------------------------------------------------------------------------------    
Generation Tarifmodelle Kosten Fitness 
0 [2, 4, 7, 8] 29149.074218750007 0.8500099093405886    
1 [0, 7, 8] 31304.476562500004 0.8389190256123289 
2 [2, 4, 7] 29217.677734375004    0.8496569016446691 
3 [4, 6, 8] 28148.667968750007 0.8551576208256149 
4 [2, 4,    8] 28148.667968750007 0.8551576208256149 
5 [4, 6, 8] 28148.667968750007 0.8551576208256149    
6 [2, 4, 7] 29217.677734375004 0.8496569016446691 
7 [2, 3, 8] 29572.041015624993    0.8478334824759443 
8 [2, 3, 8] 29572.041015624993 0.8478334824759443 
9 [0, 1,    2, 6, 8] 32237.824218749996 0.8341163722406607 
----------------------------------------------------------------------------------    
Beste Fitness: 0.8551576208256149 Bestes Individuum: [4, 6, 8] 
----------------------------------------------------------------------------------    
----------------------------------------------------------------------------------    
Generationen: 10 Population: 10 Crossoverw.: 0.2 Mutationw.: 0.01 
----------------------------------------------------------------------------------    
Generation Tarifmodelle Kosten Fitness 
0 [0, 2, 3, 7] 31791.0859375 0.836415118156324    
1 [0, 2, 3, 7] 31791.0859375 0.836415118156324 
2 [0, 5, 7] 30348.226562500004    0.8438395257666975 
3 [0, 2, 5, 7] 30898.72070312499 0.8410068915142277 
4 [0,    2, 3, 5, 7] 31496.49218749999 0.8379309859653186 
5 [2, 3, 6, 7, 8] 31571.632812499993    0.8375443407816199 
6 [0, 4, 5] 30905.332031249993 0.8409728721248843 
7 [2, 3,    5, 6, 7] 31168.85546875 0.839616880370742 
8 [2, 3, 5, 6, 7] 31168.85546875 0.839616880370742    
9 [2, 3, 5, 6, 7] 31168.85546875 0.839616880370742 
----------------------------------------------------------------------------------    
Beste Fitness: 0.8438395257666975 Bestes Individuum: [0, 5, 7]
----------------------------------------------------------------------------------   
                                      . . .

Die Auswertung der aufgezeichneten Meßwerte erfolgte über ein eigens entwickeltes Java-Programm. Dabei wurde zuerst das Mittel jeder Generation, über die Anzahl der Messung mit gleichen Parametern, gebildet. Danach wurde für jeden "Parameter-Satz" die beste gemittelte Fitness bestimmt, und für eine konkrete Anzahl von Generation bzw. Populationen zusammengefaÿt. Die Ergebnisse wurden ebenfalls wieder in eine Datei geschrieben. Diese konnte leicht in eine Tabellenkalkulation (Excel) importiert und in leichter lesbare Diagramme umgewandelt werden.

Java-Programm für die Auswertung


   package com.fwilhelm.JImport;

   /**Classe für die Aufnahme der Meßwerte*/

   public class SumData
   {
      public int generation = 0;
      public int population = 0;
      public double crossover = 0.0;
      public double mutation = 0.0;
      public double bestFitness = 0.0;
      public SumData()
      {
      }
   }    

   package com.fwilhelm.JImport;
   import java.io.*;
   import java.util.*;

   public class JImporter
   {
   
   /**Variablen für das Öffnen und Lesen der Datei*/
      private FileInputStream file;  
      private BufferedInputStream bInputStream;           
      private DataInputStream input;
   
      private FileWriter fileWriter;
      private PrintWriter fileOut;
   
      private String fileInput;
      private String fileOutput;
   
      private StringTokenizer st;
   
      private SumData sumdata = new SumData();
      private Vector v = new Vector(1,1);	
   
   /**Daten einer Meßreihe*/
      public Data daten = new Data();
   /**Gemittelte Daten aus n Messungen*/
      public Data gemittelteDaten = new Data();
   
   /**
   /*Consturctor
   */
      public JImporter(String inputFile, String outputFile)
      {
         fileInput = inputFile;
         fileOutput = outputFile;
         this.init();
      }
   
   /*Abkürzung für System.out.println()*/
      private void p(String text)
      {
         System.out.println(text);
      }	
   
   /*Hier wird der FileReader initialisiert*/
      private void init()
      {
         try
         {
            file = new FileInputStream(fileInput);
            bInputStream = new BufferedInputStream(file);
            input = new DataInputStream(bInputStream);
         }
            catch(Exception e)
            {
               p("Fehler in init:JImporter \n" + e);
            }
      }
   
   /*Gibt die nächste Zeile aus; das File, das beim
   /*Erzeugen des Objektes geöffnet wurde*/
      private String nextLine()
      {
         try
         {
            String s = new String();
            if((s = input.readLine())!= null)
               return s;
            else
            {
               input.close();
               return null;
            }
         }
            catch(Exception e)
            {
               p("" + e);
               return null;
            }
      
      }
   
   
   /**
   /*Einlesen einer Messung; da auch die Anzahl der Generationen 
   /*eingelesen werden paßt sie sich automatisch an!
   */
      public boolean nextMeasure()
      {
         String line;
         String token = "";
         try
         {
            line = nextLine(); //Erste Zeile enthält keine Daten
         
            if(line == null)  //Wenn die erste Zeile einer Messung null
               return false;  //ist, gibt es nichts mehr zum Einlesen
         
            line = nextLine();
         /*zweite Zeile enthält Daten*/
            st = new StringTokenizer(line);
            token = st.nextToken(); //Enthält String "Generationen:"
            token = st.nextToken(); //Enthält den Wert Generationen
            daten.generation = Integer.parseInt(token);
         
            token = st.nextToken(); //Enthält den String "Population:"
            token = st.nextToken(); //Enthält den Wert population
            daten.population = Integer.parseInt(token);
         
            token = st.nextToken(); //Enthält den String "Crossoverw.:"
            token = st.nextToken(); //Enthält den Wert Crossoverw.
            daten.crossover = Double.parseDouble(token);
         
            token = st.nextToken(); //Enthält den String "Mutationw.:"
            token = st.nextToken(); //Enthält den Wert Mutation
            daten.mutation = Double.parseDouble(token);
         
            line = nextLine(); //Enthält keine Daten
            line = nextLine(); //Enthält keine Daten
         
         /*Einlesen der Kosten und der Fitness der einzelnen Generationen*/
            daten.kostsFitness = new double[daten.generation][2];
            for(int i = 0; i < daten.generation; i++)
            {
               line = nextLine(); //Zeile der 0-ten Generation
               st = new StringTokenizer(line);
               token = st.nextToken(); //Enthält die aktuelle Generation
            
               while(token.lastIndexOf(']') == -1) //Auslesen der aktuellen Generation
               {
                  token = token + st.nextToken();
               }	
               daten.bestIndividuum = token;
            
               token = st.nextToken(); //Enthält den Wert Kosten
               daten.kostsFitness[i][0] = Double.parseDouble(token);	
            
               token = st.nextToken(); //Enthält den Wert Fitness
               daten.kostsFitness[i][1] = Double.parseDouble(token);
            }
         
            line = nextLine(); //Enthält keine Daten
            line = nextLine();
         
            st = new StringTokenizer(line);
            token = st.nextToken(); //Enthält den String "Beste"
            token = st.nextToken(); //Enthält den String "Fitness:"
            token = st.nextToken(); //Enthält den Wert Beste Fitness
            daten.bestFitness = Double.parseDouble(token);
         
            line = nextLine(); //Letzte Zeile einer Messung einlesen 
         						    //Enhält keine Daten
            return true;					
         }
            catch(Exception e)
            {
               p("Fehler in nextMeasure bzw. keine Daten mehr! \n" + e);
               p("nextMeasure()");
               return false;
            }
      
      }	//nextMeasure()
   
   /**
   /*Faßt jeweils n Messungen mit gleiche
   /*Parametern zu einem Eintrag zusammen
   */	
      public boolean summarizeMeasure(int n)
      {
         Data[] sDaten = new Data[n];
         double sumKosten = 0.0;
         double sumFitness = 0.0;
         double varianzKosten = 0.0;
         double varianzFitness = 0.0;
      
         double bestFitness = 0.0;
      	//Einlesen der n Meßreihen
         for(int i = 0; i < n; i++)
         {
            if(nextMeasure())
            {
               sDaten[i] = new Data();
               sDaten[i].kostsFitness = new double[daten.generation][2];
            
               sDaten[i].generation = daten.generation; 
               sDaten[i].population = daten.population;
               sDaten[i].crossover = daten.crossover;
               sDaten[i].mutation = daten.mutation;
            }
            else
            {
               p("\nsummarizeMeasure()");
               p("Generation bis: " + daten.generation + " Population bis: " + daten.population);
               return false;
            }	
            for(int j = 0; j < daten.generation; j++)
            {
               sDaten[i].kostsFitness[j][0] = daten.kostsFitness[j][0];
               sDaten[i].kostsFitness[j][1] = daten.kostsFitness[j][1];
            }
         }
      
      	//Berechnen der Mittelwerte
         gemittelteDaten.kostsFitness = new double[sDaten[0].generation][2];
         gemittelteDaten.varianz = new double[sDaten[0].generation][2];
         for(int i = 0; i < sDaten[0].generation; i++)
         {
            for(int j = 0; j < n; j++)
            {
               sumKosten = sumKosten + sDaten[j].kostsFitness[i][0];
               sumFitness = sumFitness + sDaten[j].kostsFitness[i][1];
            }
            sumKosten = sumKosten / n;
            sumFitness = sumFitness / n;
            gemittelteDaten.kostsFitness[i][0] = sumKosten;
            gemittelteDaten.kostsFitness[i][1] = sumFitness;
         	//Berechnung der Varianz
            for(int j = 0; j < n; j++)
            {
               varianzKosten = (sumKosten - sDaten[j].kostsFitness[i][0])*
                     (sumKosten - sDaten[j].kostsFitness[i][0]);
               varianzFitness = (sumFitness - sDaten[j].kostsFitness[i][1]) *	
                     (sumFitness - sDaten[j].kostsFitness[i][1]);	
            }
            varianzKosten = varianzKosten / n-1;
            varianzFitness = varianzFitness / n-1;
            gemittelteDaten.varianz[i][0] = varianzKosten;
            gemittelteDaten.varianz[i][1] = varianzFitness;
         
            sumKosten = 0.0;
            sumFitness = 0.0;
            varianzKosten = 0.0;
            varianzFitness = 0.0;
         }
         gemittelteDaten.generation = sDaten[0].generation;
         gemittelteDaten.population = sDaten[0].population;
         gemittelteDaten.crossover = sDaten[0].crossover;
         gemittelteDaten.mutation = sDaten[0].mutation;
      
      	//Suchen der besten (gemittelten) Fitness aus gemittelteDaten
         for(int i = 0; i < gemittelteDaten.generation; i++)
         {
            if(bestFitness < gemittelteDaten.kostsFitness[i][1])
            {
               gemittelteDaten.bestFitness = gemittelteDaten.kostsFitness[i][1];
               bestFitness = gemittelteDaten.bestFitness;
            }
         }
         return true;
      }  //summarizeMeasure
   
   
   /**
   /*Hier werden die Daten zusammengefaßt und
   /*Excel-lesbar wieder gespeichert
   */
      public void writeSumData(int n)
      {
         SumData sumTemp = new SumData();
      
      	//Variablen für Zeitmessung
         long time1 = 0;
         long time2 = 0;
      
         String printString = "";
      
         p("Beginne mit dem Zusammenfassen der Daten: ");
         time1 = System.currentTimeMillis();
         int j = 0;
         while(summarizeMeasure(n))
         {
            sumTemp = new SumData();
            sumTemp.generation = gemittelteDaten.generation;
            sumTemp.population = gemittelteDaten.population;
            sumTemp.crossover = gemittelteDaten.crossover;
            sumTemp.mutation = gemittelteDaten.mutation;
            sumTemp.bestFitness = gemittelteDaten.bestFitness;
            v.addElement(sumTemp); //Sind die Daten geschrieben, werden sie an den Vector angehängt
            j++;
            if((j % 50) == 0)
               p("Generation: " + gemittelteDaten.generation + " Population: " + gemittelteDaten.population);
         
         }
         time2 = System.currentTimeMillis();
         p("Zusammenfassen der Daten beendet:");
         p("Zeit: " + (time2 - time1) + " Vektorlaenge: " + v.size() + "\n");
      
         try
         {
            p("Beginne mit dem Schreiben der Daten: ");
            time1 = System.currentTimeMillis();
         
            fileWriter = new FileWriter(fileOutput);
            fileOut = new PrintWriter(fileWriter);
         
            for(int i = 0; i < v.size(); )
            {
               sumTemp = (SumData)v.elementAt(i);
               printString = "Generationen: " + sumTemp.generation + " Population: " + sumTemp.population + "\n";
               System.out.print(printString); //zur Vortschrittskontrolle wird dieser String ausgegeben
               printString = printString + "	0,01	0,02	0,03	0,04	0,05	0,06	0,07	0,08	0,09	0,1\n";
            
            	/*Schreiben einer zusammengefaßten Messung*/
               //Crossover
               for(int k = 0; k < 5; k++)
               {
                  printString = printString + (0.2 + k * 0.1) + "	";
                  //Mutation
                  for(int m = 0; m < 10; m++)
                  {
                     sumTemp = (SumData)v.elementAt(i);
                     printString = printString + sumTemp.bestFitness + "	";
                     i++;
                  }
                  printString = printString + "\n";
               }
               fileOut.println(printString);
            }
         
            fileOut.close();
         
            time2 = System.currentTimeMillis();
            p("Schreibvorgang erfolgreich beendet ");
            p("Benoetigte Zeit: " + (time2 - time1));
         }
            catch(Exception e)
            {
               fileOut.close();
               time2 = System.currentTimeMillis();
               p("Schreibvorgang unvollstaendig beendet ");
               p("Benoetigte Zeit: " + (time2 - time1));
            }
      
      }
   
   /**
   /*Gibt die Datei aus, die bei der Instanziierung des
   /*Objectes angegeben wurde
   */
      public void printFile()
      {
         try
         {
            String s, s2 = new String();
            while((s = input.readLine())!= null)
               s2 += s + "\n";
            input.close();
            p(s2);
         }
            catch(Exception e)
            {
               p("" + e);
            }
      }
   }
    package com.fwilhelm.JImport;
   import java.io.*;
   import java.util.*;

   public class JMainBio
   {
      public static void main(String[] arg)
      {
         JImporter importer = new JImporter("d:/protokoll.txt","d:/output.txt");
         importer.writeSumData(20);
      }
   }