source: java/ecj/cecj/app/othello/OthelloTDL.java @ 57

package cecj.app.othello;

import ec.EvolutionState;
import ec.Individual;
import ec.Population;
import ec.Statistics;
import ec.Subpopulation;
import ec.simple.SimpleEvolutionState;
import ec.simple.SimpleFitness;
import ec.util.MersenneTwisterFast;
import ec.util.Output;
import ec.util.Parameter;
import ec.util.ParameterDatabase;
import ec.vector.DoubleVectorIndividual;
import games.BoardGame;
import games.scenarios.SelfPlayTDLScenario;

public class OthelloTDL {

        private static final String P_TDL = "tdl";

        private static final String P_STAT = "stat";
        private static final String P_SEED = "seed";
        private static final String P_VERBOSITY = "verbosity";

        private static final String P_RANDOMNESS = "randomness";
        private static final String P_LEARNING_RATE = "learning-rate";

        private static final String P_GAMES = "games";

        public static void main(String[] args) {
                ParameterDatabase parameters = ec.Evolve.loadParameterDatabase(args);

                Parameter verbosityParam = new Parameter(P_VERBOSITY);
                int verbosity = parameters.getInt(verbosityParam, null, 0);
                if (verbosity < 0) {
                        Output.initialError("Verbosity should be an integer >= 0.\n", verbosityParam);
                }

                Output output = new Output(true, verbosity);
                output.addLog(ec.util.Log.D_STDOUT, Output.V_VERBOSE, false);
                output.addLog(ec.util.Log.D_STDERR, Output.V_VERBOSE, true);

                int time = (int) (System.currentTimeMillis());
                Parameter seedParam = new Parameter(P_SEED);
                int seed = ec.Evolve.determineSeed(output, parameters, seedParam, time, 0, false);
                MersenneTwisterFast random = new MersenneTwisterFast(seed);

                EvolutionState state = new SimpleEvolutionState();
                state.parameters = parameters;
                state.random = new MersenneTwisterFast[] { random };
                state.output = output;
                
                state.generation = 0;
                state.population = new Population();
                state.population.subpops = new Subpopulation[1];
                state.population.subpops[0] = new Subpopulation();
                state.population.subpops[0].individuals = new Individual[1];

                OthelloPlayer player = new OthelloPlayer();
                DoubleVectorIndividual ind = new DoubleVectorIndividual();
                ind.genome = player.getWPC();
                ind.fitness = new SimpleFitness();
                state.population.subpops[0].individuals[0] = ind;
        
                new OthelloTDL(state).run(player);
        }

        private Statistics stat;
        private EvolutionState state;
        private MersenneTwisterFast random;

        private int numGames;
        private double randomness;
        private double learningRate;

        public OthelloTDL(EvolutionState state) {
                this.state = state;
                this.random = state.random[0];

                Parameter base = new Parameter(P_TDL);
                Parameter randomnessParam = base.push(P_RANDOMNESS);
                randomness = state.parameters.getDoubleWithDefault(randomnessParam, null, 0.1);

                Parameter learningRateParam = base.push(P_LEARNING_RATE);
                learningRate = state.parameters.getDoubleWithDefault(learningRateParam, null, 0.01);

                Parameter numGamesParam = base.push(P_GAMES);
                numGames = state.parameters.getIntWithDefault(numGamesParam, null, 1000000);
                state.numGenerations = numGames;
                
                Parameter statParam = base.push(P_STAT);
                stat = (Statistics) state.parameters.getInstanceForParameterEq(statParam, null,
                                                                                                                                                Statistics.class);
                stat.setup(state, statParam);
        }

        public void run(OthelloPlayer player) {
                BoardGame othelloGame = new OthelloGame(new OthelloBoard());
                SelfPlayTDLScenario scenario = new SelfPlayTDLScenario(random, player, randomness,
                        learningRate);
                
                for (int game = 0; game < numGames; game++) {
                        stat.postEvaluationStatistics(state);
                        othelloGame.reset();
                        scenario.play(othelloGame);
                        state.generation++;
                }
        }
}