Changes between Version 15 and Version 16 of Documentation/Howto/OptimizeExternalApplications

Timestamp:

06/08/10 16:07:26 (14 years ago)

Author:

abeham

Comment:

update

Documentation/Howto/OptimizeExternalApplications

@@ -280 +280 @@
 What we want to do is add some operators for crossover and mutation of our real vector. So we click the yellow plus icon and open the !HeuristicLab.Encodings.!RealVectorEncoding namespace. We can select from the many crossover and manipulation (mutation) operators. For example add a !DiscreteCrossover, a !BlendAlphaBetaCrossover, and a !SimulatedBinaryCrossover. Click all of them to examine their parameters. Some operators have parameters that can configure their behavior. Make sure that each of their Child and Parents parameters has its Actual Name set to !RealVector. The parents are !RealVectors and the children are also again called !RealVector. If you look at the !BlendAlphaBetaCrossover you can see that you can also set the values for Alpha and Beta which determines to which extent the offspring should be closer to the better parent. If you double click the description of this crossover you can also see that in a new window and you see the publication that describes this crossover.
 
-Let's also add a manipulator and let's take a !UniformOnePositionManipulator, also examine its paremeters.
+Let's also add a manipulator and let's take a !UniformOnePositionManipulator. Don't forget to also examine its parameters. If an operator is new to you, always be sure to check what kind of parameters it requires and if the //Actual Name// points to the right parameter or variable.
 
 [[Image(Tutorial_ConfigureOperators.png)]]
+
+It's a good idea to save the problem so far. You can do that by selecting the tab with the problem, then go to the Edit menu and select "Copy to Clipboard". This will place a clone of that item in the clipboard. So when you continue editing in the current window these changes will not be synced with the clipboard! Thus close the problem tab and open again the problem from the clipboard by double clicking it. That way we are directly modifying the problem in the clipboard. Press the disk icon in the clipboard window (not the one in the toolbar) to save the clipboard to the disk.
+
+[[Image(Tutorial_SaveToClipboard.png)]]
+
+The clipboard will be loaded every time the HeuristicLab optimizer is started. It is not saved automatically though, you have to manually save it after making the changes.
+
+=== Configuring the client ===
+
+Finally, the last task is to configure the !EvaluationServiceClient in the problem, but we don't yet have an endpoint for that client. So we should start with the example client from the competition's website. Go to [http://cig.dei.polimi.it/?page_id=103 the competition's website] and download the "Java Client" if you don't have already. Unpack that into a folder and open it using your favorite Java IDE - which is [http://www.eclipse.org/ Eclipse] in my case. Get an overview of the software, it has two packages: evaluator and ga. The !SimpleGA should give us a good overview of what we need to do to communicate to the TORCS driver. Create a new package "heuristiclab" and add a client there to connect our optimization environment. Be sure to include the java service library that you find under attachments and which was described in more detail above.
+
+Here is the code that I have written using the framework.
+
+{{{#!java
+public class HLEvaluator {
+        private ServerCommunication simulation;
+        private double bestQuality;
+
+        public static void main(String[] args) {
+                HLEvaluator main = new HLEvaluator();
+                main.run();
+        }
+        
+        private void run() {
+                ServerSocketChannelFactory factory = new ServerSocketChannelFactory(8844);
+                PollService service = new PollService(factory, 1);
+                service.start();
+                
+                initializeSimulation();
+                bestQuality = Double.MIN_VALUE;
+                
+                while (true) {
+                        SolutionMessage solution = service.getSolution();
+                        
+                        double[] params = getParameters(solution);
+                        int time = getTime(solution);
+                        
+                        try {
+                                Double quality = (Double)simulation.launchSimulation(params, time);
+                                updateBestParams(quality, params);
+                                service.sendQuality(solution, quality);
+                        } catch (Exception e) {
+                                break;
+                        }
+                }
+                simulation.close();
+                service.stop();
+        }
+
+        private double[] getParameters(SolutionMessage solution) {
+                SolutionMessage.DoubleArrayVariable paramVar = solution.getDoubleArrayVars(0);
+                List<Double> params = paramVar.getDataList();
+                double[] arr = new double[params.size()];
+                for (int i = 0; i < arr.length; i++) arr[i] = params.get(i).doubleValue();
+                return arr;
+        }
+        
+        private int getTime(SolutionMessage solution) {
+                SolutionMessage.IntegerVariable timeVar = solution.getIntegerVars(0);
+                return timeVar.getData();
+        }
+        
+        private void initializeSimulation() {
+                simulation = new ServerCommunication("localhost", 3001);
+                simulation.setFitnessFunction(new Fitness());
+        }
+        
+        private void updateBestParams(double quality, double[] params) throws Exception {
+                if (quality > bestQuality) simulation.saveBest(params);
+        }
+
+        private class Fitness implements FitnessFunction {
+                public Object getFitness(double bestlap, double topspeed, double distraced, double damage) {
+                        return new Double(distraced);
+                }
+        }
+}
+}}}
+
+This means that by executing the client we open the port 8844 on this computer and listen for connections to HeuristicLab there. All solution messages are unpacked and the parameters passed on to the simulator. We receive a quality which our client again forwards to HeuristicLab, so it basically sits in between HeuristicLab and the TORCS simulator forwarding the messages and translating them from one format into another. This client will run as long as it receives an exception in which case it stops. That means when the simulator says that enough simulation runs have been performed we cut the connection to HeuristicLab which will again inform the user of an exception and that the algorithm has terminated. This is probably not the most convenient approach, but we are probably eager to get the optimization going and can improve this later on.
+
+By writing that client we learned that we can also pass the time variable that defines the length of the solution evaluation to the simulator. We don't yet include that in our problem, but since that affects our algorithms and the amount of time they can calculate we should better include this as well.
+
+==== Include additional information in the evaluator ====
+
+So we go back to our problem, stored in the clipboard. We'll open it from the clipboard and add another parameter to it. It is a !ValueParameter<!IntValue> and we call it "SimulationTime".
+
+[[Image(Tutorial_AddSimulationTimeParameter.png)]]
+
+The value of that parameter is null initially so let's assign it a value. Click the pencil icon, confirm the !IntValue and input 600 as value. This is the default setting of the !SimpleGA and probably a good base to start from. We also need to transmit that parameter to the forwarding java client.  Open the Evaluator parameter, add a new !LookupParameter<!IntValue> and also call it !SimulationTime.
+
+==== Configure the client in the HeuristicLab problem ====
+
+Finally visit the Client parameter in our problem, you can see that it has a Channel parameter that is still null. We need to define the channel here. Because our java client listens for connections on a socket will be using an '''!EvaluationTCPChannel'''. Click the Channel, create a new value using the pencil icon and select the TCP channel. Configure the TCP channel according to our java forwarding client.
+
+[[Image(Tutorial_NewTCPChannel.png)]]
+
+If you start the java client now and press "Connect" you should be able to establish a connection. Be aware though that the client currently serves just a single connections. So if you disconnect, you have to restart the client.
+
+=== Optimize the problem ===
+
+So now we have the problem configured, we have saved it so that we don't have to do that again, we have written the forwarding client and if the setup with the TORCS simulator was done right we have everything to start optimizing.
+
+This is so simple it's just a few steps:
+ 1. Create a GA by selecting File>New and select the "Genetic Algorithm".
+ 2. Drag the problem from the clipboard into the empty Problem tab (note that this again creates a clone!)
+ 3. Go to the Parameters tab and configure the GA as you like. Select among the crossovers and manipulators that you have added. Choose the Selection scheme (Proportional, Tournament, Linear Rank,...). Choose the number of Elites, the mutation probability and population size.
+ 4. Start the TORCS simulator and select the race that you want to evaluate on (look in the manual to see how this is done)
+ 5. Start the java forwarding client
+ 6. Click the green arrow button at the bottom of the Genetic Algorithm and watch the optimization run.