Examples with ElapsedCpuTimer tools.ElapsedCpuTimer used on opensource projects

Example 11 with ElapsedCpuTimer

use of tools.ElapsedCpuTimer in project SimpleAsteroids by ljialin.

the class SimpleGridTest method runOnce.

public static double runOnce() {
    // make an agent to test
    StateObservation gridGame = new GridModel();
    System.out.println(gridGame.getGameScore());
    System.out.println(gridGame.copy().getGameScore());
    // System.exit(0);
    ElapsedCpuTimer timer = new ElapsedCpuTimer();
    AbstractPlayer player;
    controllers.singlePlayer.sampleOLMCTS.Agent olmcts = new controllers.singlePlayer.sampleOLMCTS.Agent(gridGame, timer);
    controllers.singlePlayer.discountOLMCTS.Agent discountOlmcts = new controllers.singlePlayer.discountOLMCTS.Agent(gridGame, timer);
    controllers.singlePlayer.nestedMC.Agent nestedMC = new controllers.singlePlayer.nestedMC.Agent(gridGame, timer);
    player = olmcts;
    // player = discountOlmcts;
    // for the following we can pass the Evolutionary algorithm to use
    int nResamples = 2;
    EvoAlg evoAlg = new SimpleRMHC(nResamples);
    int nEvals = 2000;
    double kExplore = 10;
    int nNeighbours = 100;
    evoAlg = new NTupleBanditEA(kExplore, nNeighbours);
    evoAlg = new SlidingMeanEDA();
    // DefaultMutator.totalRandomChaosMutation = false;
    Agent.useShiftBuffer = true;
    Agent.SEQUENCE_LENGTH = 30;
    player = new Agent(gridGame, timer, evoAlg, nEvals);
    nestedMC.maxRolloutLength = 30;
    nestedMC.nestDepth = 3;
    // player = nestedMC;
    // in milliseconds
    int thinkingTime = 50;
    int delay = 30;
    // player = new controllers.singlePlayer.sampleRandom.Agent(stateObs, timer);
    // check that we can play the game
    Random random = new Random();
    // this is how many steps we'll take in the actual game ...
    int nSteps = 30;
    ElapsedTimer t = new ElapsedTimer();
    for (int i = 0; i < nSteps && !gridGame.isGameOver(); i++) {
        timer = new ElapsedCpuTimer();
        timer.setMaxTimeMillis(thinkingTime);
        Types.ACTIONS action = player.act(gridGame.copy(), timer);
        System.out.println();
        // + "\t " + action.ordinal());
        System.out.println("Selected: " + action);
        gridGame.advance(action);
        System.out.println("Game state: " + gridGame);
        System.out.println();
    }
    System.out.println(gridGame.getGameScore());
    return gridGame.getGameScore();
}

Example 12 with ElapsedCpuTimer

use of tools.ElapsedCpuTimer in project SimpleAsteroids by ljialin.

the class SpaceBattleLinkTestTwoPlayer method runTrial.

public static double runTrial(boolean runVisible) {
    // make an agent to test
    // StateObservation stateObs = new SimpleMaxGame();
    // BattleGameSearchSpace.inject(BattleGameSearchSpace.getRandomPoint());
    // SampleEvolvedParams.solutions[1][2] = 5;
    // SampleEvolvedParams.solutions[5][4] = 0;
    // BattleGameSearchSpace.inject(SampleEvolvedParams.solutions[2]);
    // BattleGameSearchSpace.inject(SampleEvolvedParams.solutions[2]);
    // BattleGameSearchSpace.inject(SampleEvolvedParams.solutions[1]);
    System.out.println("Params are:");
    System.out.println(BattleGameParameters.params);
    // can also override parameters by setting them directly as follows:
    BattleGameParameters.loss = 0.996;
    BattleGameParameters.thrust = 3;
    // BattleGameParameters.shipSize *= 2;
    // BattleGameParameters.damageRadius *= 2;
    SpaceBattleLinkStateTwoPlayer linkState = new SpaceBattleLinkStateTwoPlayer();
    StateObservationMulti multi = linkState;
    GameActionSpaceAdapterMulti.useHeuristic = false;
    // DefaultMutator.totalRandomChaosMutation = false;
    // // supercl
    // StateObservation stateObs = linkState;
    ElapsedCpuTimer timer = new ElapsedCpuTimer();
    AbstractMultiPlayer player1, player2;
    // controllers.singlePlayer.sampleOLMCTS.Agent olmcts =
    // new controllers.singlePlayer.sampleOLMCTS.Agent(linkState, timer);
    int idPlayer1 = 0;
    int idPlayer2 = 1;
    player2 = new controllers.multiPlayer.discountOLMCTS.Agent(linkState, timer, idPlayer2);
    // try the evolutionary players
    int nResamples = 2;
    EvoAlg evoAlg = new SimpleRMHC(nResamples);
    double kExplore = 10;
    int nNeighbours = 100;
    int nEvals = 500;
    evoAlg = new NTupleBanditEA(kExplore, nNeighbours);
    // evoAlg = new CompactSlidingModelGA().setHistoryLength(20);
    evoAlg = new SlidingMeanEDA().setHistoryLength(20);
    EvoAlg evoAlg2 = new CompactSlidingModelGA().setHistoryLength(2);
    player1 = new controllers.multiPlayer.ea.Agent(linkState, timer, evoAlg, idPlayer1, nEvals);
    // player2 = new controllers.multiPlayer.ea.Agent(linkState, timer, evoAlg2, idPlayer2, nEvals);
    // player2 = new controllers.multiPlayer.ea.Agent(linkState, timer, new SimpleRMHC(nResamples), idPlayer2, nEvals);
    // player1  = new controllers.multiPlayer.smlrand.Agent();
    // EvoAlg evoAlg2 = new SimpleRMHC(2);
    // player1 = new controllers.multiPlayer.ea.Agent(linkState, timer, evoAlg2, idPlayer1, nEvals);
    // in milliseconds
    int thinkingTime = 50;
    int delay = 10;
    // player = new controllers.singlePlayer.sampleRandom.Agent(stateObs, timer);
    // check that we can play the game
    Random random = new Random();
    int nSteps = 500;
    ElapsedTimer t = new ElapsedTimer();
    BattleView view = new BattleView(linkState.state.copyState());
    // set view to null to run fast with no visuals
    if (!runVisible)
        view = null;
    if (view != null) {
        new JEasyFrame(view, "Simple Battle Game");
    }
    StatSummary sst1 = new StatSummary("Player 1 Elapsed Time");
    StatSummary sst2 = new StatSummary("Player 2 Elapsed Time");
    StatSummary ssTicks1 = new StatSummary("Player 1 nTicks");
    StatSummary ssTicks2 = new StatSummary("Player 2 nTicks");
    for (int i = 0; i < nSteps && !linkState.isGameOver(); i++) {
        linkState.state = linkState.state.copyState();
        timer = new ElapsedCpuTimer();
        timer.setMaxTimeMillis(thinkingTime);
        ElapsedTimer t1 = new ElapsedTimer();
        // keep track of the number of game ticks used by each algorithm
        int ticks;
        ticks = SpaceBattleLinkStateTwoPlayer.nTicks;
        Types.ACTIONS action1 = player1.act(multi.copy(), timer);
        sst1.add(t1.elapsed());
        ticks = SpaceBattleLinkStateTwoPlayer.nTicks - ticks;
        ssTicks1.add(ticks);
        // System.out.println("Player 1 Ticks = " + ticks);
        ElapsedTimer t2 = new ElapsedTimer();
        ticks = SpaceBattleLinkStateTwoPlayer.nTicks;
        Types.ACTIONS action2 = player2.act(multi.copy(), timer);
        sst2.add(t2.elapsed());
        ticks = SpaceBattleLinkStateTwoPlayer.nTicks - ticks;
        ssTicks2.add(ticks);
        // System.out.println("Player 2 Ticks = " + ticks);
        multi.advance(new Types.ACTIONS[] { action1, action2 });
        if (view != null) {
            view.game = linkState.state.copyState();
            view.setRolls(0, evoAlg);
            view.setRolls(1, evoAlg2);
            view.repaint();
            try {
                Thread.sleep(delay);
            } catch (Exception e) {
            }
        }
    // System.out.println(multi.getGameScore());
    }
    System.out.println(multi.getGameScore());
    System.out.println(multi.isGameOver());
    // System.out.println(SingleTreeNode.rollOutScores);
    System.out.println(sst1);
    System.out.println(sst2);
    System.out.println(ssTicks1);
    System.out.println(ssTicks2);
    return multi.getGameScore(0);
}

Example 13 with ElapsedCpuTimer

use of tools.ElapsedCpuTimer in project SimpleAsteroids by ljialin.

the class TestDiffGame method runTrial.

public static double runTrial(boolean runVisible) {
    // make an agent to test
    DiffGame.nValues = 21;
    DiffGame.minscore = 0;
    StateObservationMulti stateObs = new DiffGame();
    DefaultMutator.totalRandomChaosMutation = false;
    ElapsedCpuTimer timer = new ElapsedCpuTimer();
    AbstractMultiPlayer player1, player2;
    int idPlayer1 = 0;
    int idPlayer2 = 1;
    // try the evolutionary players
    int nResamples = 10;
    EvoAlg evoAlg = new SimpleRMHC(nResamples);
    EvoAlg evoAlg2 = new SimpleRMHC(nResamples);
    double kExplore = 2;
    int nNeighbours = 50;
    int nEvals = 1500;
    // evoAlg = new NTupleBanditEA(kExplore, nNeighbours);
    controllers.multiPlayer.ea.Agent agentEAShift = new controllers.multiPlayer.ea.Agent(stateObs, timer, evoAlg, idPlayer1, nEvals);
    agentEAShift.useShiftBuffer = true;
    agentEAShift.sequenceLength = 5;
    player1 = agentEAShift;
    controllers.multiPlayer.ea.Agent agentEANoShift = new controllers.multiPlayer.ea.Agent(stateObs, timer, evoAlg2, idPlayer2, nEvals);
    agentEANoShift.useShiftBuffer = true;
    agentEANoShift.sequenceLength = 25;
    player2 = agentEANoShift;
    // player2 = new controllers.multiPlayer.discountOLMCTS.Agent(stateObs, timer, idPlayer2);
    // player2 = new controllers.multiPlayer.doNothing.Agent(stateObs, timer, idPlayer2);
    // player2 = new controllers.multiPlayer.sampleRandom.Agent(stateObs, timer, idPlayer2);
    // player1  = new controllers.multiPlayer.smlrand.Agent();
    // EvoAlg evoAlg2 = new SimpleRMHC(1);
    // player1 = new controllers.multiPlayer.ea.Agent(linkState, timer, evoAlg2, idPlayer1, nEvals / 5);
    // in milliseconds
    int thinkingTime = 50;
    int delay = 10;
    // player = new controllers.singlePlayer.sampleRandom.Agent(stateObs, timer);
    // check that we can play the game
    Random random = new Random();
    int nSteps = 50;
    StatSummary sst1 = new StatSummary("Player 1 Elapsed Time");
    StatSummary sst2 = new StatSummary("Player 2 Elapsed Time");
    StatSummary ssTicks1 = new StatSummary("Player 1 nTicks");
    StatSummary ssTicks2 = new StatSummary("Player 2 nTicks");
    for (int i = 0; i < nSteps && !stateObs.isGameOver(); i++) {
        timer = new ElapsedCpuTimer();
        timer.setMaxTimeMillis(thinkingTime);
        ElapsedTimer t1 = new ElapsedTimer();
        // keep track of the number of game ticks used by each algorithm
        int ticks;
        ticks = DiffGame.nTicks;
        Types.ACTIONS action1 = player1.act(stateObs.copy(), timer);
        sst1.add(t1.elapsed());
        ticks = DiffGame.nTicks - ticks;
        ssTicks1.add(ticks);
        System.out.println("Player 1 Ticks = " + ticks);
        ElapsedTimer t2 = new ElapsedTimer();
        ticks = DiffGame.nTicks;
        Types.ACTIONS action2 = player2.act(stateObs.copy(), timer);
        sst2.add(t2.elapsed());
        ticks = DiffGame.nTicks - ticks;
        ssTicks2.add(ticks);
        stateObs.advance(new Types.ACTIONS[] { action1, action2 });
        // System.out.println(multi.getGameScore());
        System.out.println(stateObs);
    }
    System.out.println(stateObs.getGameScore());
    System.out.println(stateObs.isGameOver());
    // System.out.println(SingleTreeNode.rollOutScores);
    System.out.println(sst1);
    System.out.println(sst2);
    System.out.println(ssTicks1);
    System.out.println(ssTicks2);
    return stateObs.getGameScore(0);
}

Example 14 with ElapsedCpuTimer

use of tools.ElapsedCpuTimer in project SimpleAsteroids by ljialin.

the class DiffGameViewTest method main.

public static void main(String[] args) throws Exception {
    // stop the game ending
    DiffGame.maxTick = 1000000;
    DiffGame dg = new DiffGame();
    AbstractMultiPlayer player1, player2;
    ElapsedCpuTimer timer = new ElapsedCpuTimer();
    player1 = new controllers.multiPlayer.sampleRandom.Agent(dg, timer, 0);
    player2 = new controllers.multiPlayer.sampleRandom.Agent(dg, timer, 1);
    int idPlayer1 = 0;
    int idPlayer2 = 1;
    // try the evolutionary players
    int nResamples = 3;
    EvoAlg evoAlg = new SimpleRMHC(nResamples);
    EvoAlg evoAlg2 = new SimpleRMHC(nResamples);
    double kExplore = 2;
    int nNeighbours = 50;
    int nEvals = 15000;
    // evoAlg = new NTupleBanditEA(kExplore, nNeighbours);
    controllers.multiPlayer.ea.Agent agentEAShift = new controllers.multiPlayer.ea.Agent(dg, timer, evoAlg, idPlayer1, nEvals);
    agentEAShift.useShiftBuffer = true;
    agentEAShift.sequenceLength = 10;
    player1 = agentEAShift;
    // player2 = new controllers.multiPlayer.discountOLMCTS.Agent(dg, timer, idPlayer2);
    // player2 = new controllers.multiPlayer.sampleOLMCTS.Agent(dg, timer, idPlayer2);
    controllers.multiPlayer.ea.Agent agentEANoShift = new controllers.multiPlayer.ea.Agent(dg, timer, evoAlg2, idPlayer1, nEvals);
    agentEANoShift.useShiftBuffer = true;
    agentEANoShift.sequenceLength = 10;
    player1 = agentEANoShift;
    int nTicks = 250;
    int delay = 100;
    int updateTick = 1;
    DiffGameView view = new DiffGameView(dg);
    JEasyFrame frame = new JEasyFrame(view, "Diff Game");
    KeyPlayer keyPlayer = new KeyPlayer(view);
    frame.addKeyListener(keyPlayer.controller);
    // player1 = keyPlayer;
    player2 = new ConstantPlayer(2);
    Types.ACTIONS[] actions = new Types.ACTIONS[2];
    for (int i = 0; i < nTicks; i++) {
        // update the chosen actions every so often
        if (i % updateTick == 0) {
            actions[0] = player1.act(dg.copy(), timer);
            actions[1] = player2.act(dg.copy(), timer);
        }
        // advance anyway
        dg.advance(actions);
        view.update(dg);
        Thread.sleep(delay);
    }
    System.out.println(dg.getGameScore());
}

Example 15 with ElapsedCpuTimer

use of tools.ElapsedCpuTimer in project SimpleAsteroids by ljialin.

the class SingleTreeNode method mctsSearch.

public void mctsSearch(ElapsedCpuTimer elapsedTimer) {
    double avgTimeTaken = 0;
    double acumTimeTaken = 0;
    long remaining = elapsedTimer.remainingTimeMillis();
    int numIters = 0;
    int remainingLimit = 10;
    // while(remaining > 2*avgTimeTaken && remaining > remainingLimit){
    while (numIters < Agent.MCTS_ITERATIONS) {
        StateObservation state = rootState.copy();
        ElapsedCpuTimer elapsedTimerIteration = new ElapsedCpuTimer();
        SingleTreeNode selected = treePolicy(state);
        double delta = selected.rollOut(state);
        backUp(selected, delta);
        numIters++;
        acumTimeTaken += (elapsedTimerIteration.elapsedMillis());
        // System.out.println(elapsedTimerIteration.elapsedMillis() + " --> " + acumTimeTaken + " (" + remaining + ")");
        avgTimeTaken = acumTimeTaken / numIters;
        remaining = elapsedTimer.remainingTimeMillis();
    }
// System.out.println("Iterations: " + numIters);
}