[cspoker] r1383 committed - Added Kullback-Leibler Divergence Listener and BucketSampler. Made som...

[codesite...@google.com]

Revision: 1383
Author: laurent.verbruggen
Date: Mon Jun 14 18:22:02 2010
Log: Added Kullback-Leibler Divergence Listener and BucketSampler. Made
some changes to online learning: (1) removed OpponentModelPool, (2) added
continuous learning.

http://code.google.com/p/cspoker/source/detail?r=1383

Added:

/trunk/ai/bots/src/main/java/org/cspoker/ai/bots/bot/gametree/search/expander/sampling/BucketSampler.java
/trunk/ai/bots/src/main/java/org/cspoker/ai/opponentmodels/listener

/trunk/ai/bots/src/main/java/org/cspoker/ai/opponentmodels/listener/OpponentModelListener.java

/trunk/ai/experiments/src/main/java/org/cspoker/ai/bots/listener/KullbackLeiblerListener.java

/trunk/ai/opponentmodels/weka/src/main/java/org/cspoker/ai/opponentmodels/weka/WekaLearningModel.java
Deleted:

/trunk/ai/bots/src/main/java/org/cspoker/ai/opponentmodels/OpponentModelPool.java
Modified:

/trunk/ai/bots/src/main/java/org/cspoker/ai/bots/bot/gametree/mcts/FixedSampleMCTSBot.java

/trunk/ai/bots/src/main/java/org/cspoker/ai/bots/bot/gametree/mcts/FixedSampleMCTSBotFactory.java

/trunk/ai/bots/src/main/java/org/cspoker/ai/bots/bot/gametree/mcts/MCTSBot.java

/trunk/ai/bots/src/main/java/org/cspoker/ai/bots/bot/gametree/mcts/MCTSBotFactory.java

/trunk/ai/bots/src/main/java/org/cspoker/ai/bots/bot/gametree/mcts/nodes/InnerNode.java

/trunk/ai/bots/src/main/java/org/cspoker/ai/bots/bot/gametree/search/SearchBotFactory.java

/trunk/ai/bots/src/main/java/org/cspoker/ai/bots/bot/gametree/search/expander/Expander.java

/trunk/ai/bots/src/main/java/org/cspoker/ai/bots/bot/gametree/search/expander/TokenExpander.java

/trunk/ai/bots/src/main/java/org/cspoker/ai/bots/bot/gametree/search/expander/sampling/RouletteWheelSampler.java

/trunk/ai/bots/src/main/java/org/cspoker/ai/bots/bot/gametree/search/expander/sampling/StochasticSampler.java

/trunk/ai/bots/src/main/java/org/cspoker/ai/bots/bot/gametree/search/expander/sampling/StochasticUniversalSampler.java

/trunk/ai/bots/src/main/java/org/cspoker/ai/opponentmodels/OpponentModel.java

/trunk/ai/bots/src/main/java/org/cspoker/ai/opponentmodels/simple/HistogramModel.java

/trunk/ai/bots/src/main/java/org/cspoker/ai/opponentmodels/simple/HistogramModelFactory.java
/trunk/ai/experiments/src/main/java/org/cspoker/ai/bots/BotRunner.java
/trunk/ai/experiments/src/main/java/org/cspoker/ai/bots/RunHumanVsBot.java

/trunk/ai/experiments/src/main/java/org/cspoker/ai/bots/bot/gametree/mcts/listeners/SWTTreeListener.java

/trunk/ai/experiments/src/main/java/org/cspoker/ai/bots/listener/CSVLogListener.java

/trunk/ai/experiments/src/main/java/org/cspoker/ai/bots/listener/GameLimitingBotListener.java

/trunk/ai/experiments/src/main/java/org/cspoker/ai/bots/listener/ReSitInBotListener.java

/trunk/ai/experiments/src/main/java/org/cspoker/ai/bots/listener/SpeedTestBotListener.java

/trunk/ai/experiments/src/main/java/org/cspoker/ai/experiments/RunExperimentB.java

/trunk/ai/experiments/src/main/java/org/cspoker/ai/experiments/RunExperimentC.java

/trunk/ai/experiments/src/main/java/org/cspoker/ai/experiments/RunExperimentD.java

/trunk/ai/experiments/src/main/java/org/cspoker/ai/experiments/RunExperimentF.java
/trunk/ai/lore/src/main/java/org/cspoker/ai/lore/Lore.java

/trunk/ai/opponentmodels/prolog/src/main/java/org/cspoker/ai/opponentmodels/prolog/TermListVisitor.java

/trunk/ai/opponentmodels/prolog/src/main/java/org/cspoker/ai/opponentmodels/prolog/cafe/PrologCafeModelFactory.java

/trunk/ai/opponentmodels/prolog/src/main/java/org/cspoker/ai/opponentmodels/prolog/redundant/RedundantModelFactory.java

/trunk/ai/opponentmodels/prolog/src/main/java/org/cspoker/ai/opponentmodels/prolog/tuprolog/TuPrologModelFactory.java

/trunk/ai/opponentmodels/weka/src/main/java/org/cspoker/ai/opponentmodels/weka/ARFFFile.java

/trunk/ai/opponentmodels/weka/src/main/java/org/cspoker/ai/opponentmodels/weka/ARFFPlayer.java

/trunk/ai/opponentmodels/weka/src/main/java/org/cspoker/ai/opponentmodels/weka/ARFFPropositionalizer.java

/trunk/ai/opponentmodels/weka/src/main/java/org/cspoker/ai/opponentmodels/weka/ActionTrackingVisitor.java

/trunk/ai/opponentmodels/weka/src/main/java/org/cspoker/ai/opponentmodels/weka/WekaModel.java

/trunk/ai/opponentmodels/weka/src/main/java/org/cspoker/ai/opponentmodels/weka/WekaOptions.java

/trunk/ai/opponentmodels/weka/src/main/java/org/cspoker/ai/opponentmodels/weka/WekaRegressionModel.java

/trunk/ai/opponentmodels/weka/src/main/java/org/cspoker/ai/opponentmodels/weka/WekaRegressionModelFactory.java

/trunk/ai/opponentmodels/weka/src/main/java/org/cspoker/ai/opponentmodels/weka/instances/PreFoldCallRaiseInstances.java

=======================================
--- /dev/null
+++
/trunk/ai/bots/src/main/java/org/cspoker/ai/bots/bot/gametree/search/expander/sampling/BucketSampler.java
Mon Jun 14 18:22:02 2010
@@ -0,0 +1,175 @@
+package org.cspoker.ai.bots.bot.gametree.search.expander.sampling;
+
+import java.util.ArrayList;
+import java.util.List;
+
+import org.cspoker.ai.bots.bot.gametree.action.CallAction;
+import org.cspoker.ai.bots.bot.gametree.action.CheckAction;
+import org.cspoker.ai.bots.bot.gametree.action.FoldAction;
+import org.cspoker.ai.bots.bot.gametree.action.ProbabilityAction;
+import org.cspoker.ai.opponentmodels.OpponentModel;
+import org.cspoker.client.common.gamestate.GameState;
+import org.cspoker.common.elements.player.PlayerId;
+import org.cspoker.common.util.Pair;
+import org.cspoker.common.util.Triple;
+
+import com.google.common.collect.ImmutableList;
+import com.google.common.collect.Lists;
+
+public class BucketSampler extends Sampler {
+
+ private double threshold;
+
+ public BucketSampler(double threshold) {
+ this.threshold = threshold;
+ }
+
+ class Bucket {
+ private double start;
+ private double end;
+ private double prob;
+ private double totalProb;
+ private double averageProb;
+
+ public Bucket(double start, double prob, double totalProb) {
+ this.start = start;
+ this.setProb(prob);
+ this.setTotalProb(totalProb);
+ }
+ public double getStart() {
+ return start;
+ }
+ public double getEnd() {
+ return end;
+ }
+ public void setEnd(double end) {
+ this.end = end;
+ }
+ public double getProb() {
+ return prob;
+ }
+ private void setProb(double prob) {
+ this.prob = prob;
+ }
+ public double getTotalProb() {
+ return totalProb;
+ }
+ public void setTotalProb(double totalProb) {
+ this.totalProb = totalProb;
+ }
+ public String toString() {
+ return "Start: " + start + ", \t end: " + end + ",\t prob: " +
+ prob + ", averageProb: " + averageProb + ", totalProb: " + totalProb;
+ }
+ public void setAverageProb(int length) {
+ if (end==start)
+ this.averageProb = totalProb;
+ else
+ this.averageProb = totalProb/((end-start)*(length-1));
+ }
+ public double getAverageProb() {
+ return averageProb;
+ }
+ }
+
+ protected List<Bucket> getBuckets() {
+ RelativeBetDistribution distr = new RelativeBetDistribution();
+ List<Bucket> buckets = new ArrayList<Bucket>();
+ // start of range bucket, prob of start, totalProb
+ Bucket bucket = new Bucket(0, distr.pdf(0), 0);
+ for (int i = 0; i < distr.length(); i++) {
+ double relBet = (double) i / (distr.length() - 1);
+ if (Math.abs(bucket.getProb() - distr.pdf(relBet)) > threshold) {
+ bucket.setEnd(relBet);
+ bucket.setAverageProb(distr.length());
+ buckets.add(bucket);
+ bucket = new Bucket(relBet, distr.pdf(relBet), 0);
+ }
+ bucket.setTotalProb(bucket.getTotalProb() + distr.pdf(relBet));
+ }
+ bucket.setEnd(1);
+ bucket.setAverageProb(distr.length());
+ buckets.add(bucket);
+ return buckets;
+ }
+
+ private static double[] samples = {};
+ private static double[] samplesProb = {};
+
+ public double[] getRelBetSizeSamples() {
+ if (samples.length>0)
+ return samples;
+
+ List<Bucket> buckets = getBuckets();
+ samples = new double[buckets.size()];
+ samplesProb = new double[buckets.size()];
+ for (int i = 0; i< samples.length; i++) {
+ samples[i] = (buckets.get(i).end + buckets.get(i).start) / 2.0;
+ samplesProb[i] = buckets.get(i).totalProb;
+ }
+ return samples;
+ }
+
+ public double[] getRelPBetSizeSamples() {
+ if (samplesProb.length>0)
+ return samplesProb;
+
+ getRelBetSizeSamples();
+ return samplesProb;
+ }
+
+ public static void main(String[] args) {
+ BucketSampler s = new BucketSampler(0.01);
+ List<Bucket> list = s.getBuckets();
+ double totalProb = 0;
+ for (int i = 0; i < list.size(); i++) {
+ totalProb += list.get(i).getTotalProb();
+ System.out.println(" - " + list.get(i));
+ }
+ System.out.println("\n => TotalProb: " + totalProb);
+ }
+
+ @Override
+ public ImmutableList<ProbabilityAction> getProbabilityActions(
+ GameState gameState, OpponentModel model, PlayerId actor,
+ PlayerId bot) {
+ List<ProbabilityAction> actions =
Lists.newArrayListWithExpectedSize(2+getRelBetSizeSamples().length);
+ if (gameState.getDeficit(actor)>0) {
+ // call, raise or fold
+ Triple<Double, Double, Double> probabilities =
+ model.getFoldCallRaiseProbabilities(gameState, actor);
+
+ double foldProbability = probabilities.getLeft();
+ actions.add(new ProbabilityAction(new FoldAction(gameState, actor),
foldProbability));
+
+ double callProbability = probabilities.getMiddle();
+ actions.add(new ProbabilityAction(new CallAction(gameState, actor),
callProbability));
+
+ if (!gameState.getPlayer(bot).isAllIn()
+ && gameState.isAllowedToRaise(actor)) {
+ double raiseProbability = probabilities.getRight();
+ addRaiseProbalities(gameState, actor, actions, raiseProbability,
+ true, getRelBetSizeSamples(), getRelPBetSizeSamples());
+ }
+ } else {
+ // check or bet
+ Pair<Double, Double> probabilities =
model.getCheckBetProbabilities(gameState, actor);
+
+ double checkProbability = probabilities.getLeft();
+ actions.add(new ProbabilityAction(new CheckAction(gameState, actor),
checkProbability));
+
+ if (!gameState.getPlayer(bot).isAllIn()
+ && gameState.isAllowedToRaise(actor)) {
+ double betProbability = probabilities.getRight();
+ addRaiseProbalities(gameState, actor, actions, betProbability,
+ false, getRelBetSizeSamples(), getRelPBetSizeSamples());
+ }
+ }
+ ImmutableList.Builder<ProbabilityAction> normalizedActionsBuilder =
ImmutableList.builder();
+ for (ProbabilityAction action : actions) {
+ normalizedActionsBuilder.add(new ProbabilityAction(action
+ .getActionWrapper(), action.getProbability()));
+ }
+ return normalizedActionsBuilder.build();
+ }
+}
=======================================
--- /dev/null
+++
/trunk/ai/bots/src/main/java/org/cspoker/ai/opponentmodels/listener/OpponentModelListener.java
Mon Jun 14 18:22:02 2010
@@ -0,0 +1,16 @@
+package org.cspoker.ai.opponentmodels.listener;
+
+import org.cspoker.ai.opponentmodels.OpponentModel;
+import org.cspoker.client.common.gamestate.GameState;
+import org.cspoker.common.elements.player.PlayerId;
+
+public interface OpponentModelListener {
+
+ public void onGetCheckProbabilities(GameState state, PlayerId actor);
+
+ public void onGetFoldCallRaiseProbabilities(GameState state, PlayerId
actor);
+
+ public void onGetShowdownProbilities(GameState state, PlayerId actor);
+
+ public void setOpponentModel(OpponentModel opponentModel);
+}
=======================================
--- /dev/null
+++
/trunk/ai/experiments/src/main/java/org/cspoker/ai/bots/listener/KullbackLeiblerListener.java
Mon Jun 14 18:22:02 2010
@@ -0,0 +1,165 @@
+package org.cspoker.ai.bots.listener;
+
+import java.util.ArrayList;
+import java.util.HashMap;
+import java.util.Map;
+
+import org.apache.log4j.Logger;
+import org.cspoker.ai.opponentmodels.OpponentModel;
+import org.cspoker.ai.opponentmodels.listener.OpponentModelListener;
+import org.cspoker.ai.opponentmodels.weka.WekaLearningModel;
+import org.cspoker.ai.opponentmodels.weka.WekaRegressionModel;
+import org.cspoker.client.common.gamestate.GameState;
+import org.cspoker.common.elements.player.PlayerId;
+import org.cspoker.common.util.Pair;
+import org.cspoker.common.util.Triple;
+
+public class KullbackLeiblerListener extends DealCountingListener
implements OpponentModelListener {
+
+ protected static final Logger logger =
Logger.getLogger(KullbackLeiblerListener.class);
+
+ private class KLState {
+ GameState gameState;
+ PlayerId actor;
+
+ public KLState(GameState gameState, PlayerId actor) {
+ this.gameState = gameState;
+ this.actor = actor;
+ }
+ }
+
+ private ArrayList<KLState> checkBetList = new ArrayList<KLState>();
+ private ArrayList<KLState> foldCallRaiseList = new ArrayList<KLState>();
+ private ArrayList<KLState> showdownList = new ArrayList<KLState>();
+
+ private final int max = 5000; // max gameSate per player
+
+ private final int reportInterval;
+
+
+ private WekaLearningModel learningModel;
+
+ public KullbackLeiblerListener() {
+ this(64);
+ }
+
+ public KullbackLeiblerListener(int reportInterval) {
+ this.reportInterval = reportInterval;
+ }
+
+ public int size() {
+ return checkBetList.size() + foldCallRaiseList.size() +
showdownList.size();
+ }
+
+
+ public double calculatePlayerKL(WekaRegressionModel base,
WekaRegressionModel model) {
+ double value = 0;
+ boolean print = false;
+ int index = 0;
+
+ for (KLState state : checkBetList) {
+ learningModel.assumeTemporarily(state.gameState);
+ Pair<Double, Double> pair = model.getCheckBetProbabilities(state.actor,
learningModel.getCurrentGamePropositionalizer());
+ Pair<Double, Double> basePair =
base.getCheckBetProbabilities(state.actor,
learningModel.getCurrentGamePropositionalizer());
+ if (print) {
+ System.out.println(index++ + " - (" + pair.getLeft() + "," +
pair.getRight() + ") => (" + basePair.getLeft() + "," + basePair.getRight()
+ ")");
+ }
+ learningModel.forgetLastAssumption();
+ value += pair.getLeft() *
(pair.getLeft()!=0?Math.log(pair.getLeft()/basePair.getLeft()):1);
+// value += pair.getRight() *
(pair.getRight()!=0?Math.log(pair.getRight()/basePair.getRight()):1);
+ }
+ index = 0;
+ for (KLState state : foldCallRaiseList) {
+ learningModel.assumeTemporarily(state.gameState);
+ Triple<Double,Double,Double> triple =
model.getFoldCallRaiseProbabilities(state.actor,
learningModel.getCurrentGamePropositionalizer());
+ Triple<Double,Double,Double> baseTriple =
base.getFoldCallRaiseProbabilities(state.actor,
learningModel.getCurrentGamePropositionalizer());
+ if (print) {
+ System.out.println(index++ + " - (" + triple.getLeft() + "," +
triple.getMiddle() + "," + triple.getRight()
+ + ") => (" + + baseTriple.getLeft() + "," + baseTriple.getMiddle()
+ "," + baseTriple.getRight() + ")");
+ }
+ learningModel.forgetLastAssumption();
+ value += triple.getLeft() *
(triple.getLeft()!=0?Math.log(triple.getLeft()/baseTriple.getLeft()):1);
+ value += triple.getMiddle() *
(triple.getMiddle()!=0?Math.log(triple.getMiddle()/baseTriple.getMiddle()):1);
+// value += triple.getRight() *
(triple.getRight()!=0?Math.log(triple.getRight()/baseTriple.getRight()):1);
+ }
+ index = 0;
+ for (KLState state : showdownList) {
+ learningModel.assumeTemporarily(state.gameState);
+ double[] arr = model.getShowdownProbabilities(state.actor,
learningModel.getCurrentGamePropositionalizer());
+ double[] baseArr = base.getShowdownProbabilities(state.actor,
learningModel.getCurrentGamePropositionalizer());
+ if (print) {
+ System.out.print(index++ + " - (");
+ for (int j = 0; j < arr.length; j++)
+ System.out.print(arr[j] + ",");
+ System.out.print(") => (");
+ for (int j = 0; j < arr.length; j++)
+ System.out.print(baseArr[j] + ",");
+ System.out.print(")");
+ }
+ learningModel.forgetLastAssumption();
+ for (int i = 1; i < arr.length; i++)
+ value += arr[i] * (arr[i]!=0?Math.log(arr[i]/baseArr[i]):1);
+ }
+ return value;
+ }
+
+ public HashMap<Object, Double> calculateAllKL() {
+ if (learningModel==null)
+ return new HashMap<Object, Double>();
+
+ HashMap<Object, Double> klMap = new HashMap<Object, Double>();
+ Map<PlayerId, WekaRegressionModel> map =
learningModel.getOpponentModels();
+ for (PlayerId actor : map.keySet()) {
+ klMap.put(actor, calculatePlayerKL(learningModel.getDefaultModel(),
map.get(actor)));
+ }
+ return klMap;
+ }
+
+ @Override
+ public void onGetCheckProbabilities(GameState state, PlayerId actor) {
+ if (size() < max)
+ checkBetList.add(new KLState(state, actor));
+ }
+
+ @Override
+ public void onGetFoldCallRaiseProbabilities(GameState state, PlayerId
actor) {
+ if (size() < max)
+ foldCallRaiseList.add(new KLState(state, actor));
+ }
+
+ @Override
+ public void onGetShowdownProbilities(GameState state, PlayerId actor) {
+ if (size() < max)
+ showdownList.add(new KLState(state, actor));
+ }
+
+ @Override
+ public void onNewDeal() {
+ int deals = getDeals();
+ if (deals % reportInterval == 0) {
+// logger.info("deal #" + deals);
+// logger.info("KL list size: " + size());
+ if (size() == max) {
+ HashMap<Object, Double> list = calculateAllKL();
+ for (Object actor : list.keySet()) {
+// logger.info("KL for player " + actor + " equals " +
list.get(actor));
+ System.out.println(deals + "\t" + list.get(actor));
+ }
+ } else {
+ logger.info("Not enough game states to calculate Kullback Leibler");
+ }
+ }
+
+ super.onNewDeal();
+ }
+
+ @Override
+ public void setOpponentModel(OpponentModel opponentModel) {
+ try {
+ this.learningModel = (WekaLearningModel) opponentModel;
+ } catch (Exception e) {
+ throw new IllegalStateException("Kullback Leibler Divergence can only
be used with WekaLearningModel!");
+ }
+ }
+
+}
=======================================
--- /dev/null
+++
/trunk/ai/opponentmodels/weka/src/main/java/org/cspoker/ai/opponentmodels/weka/WekaLearningModel.java
Mon Jun 14 18:22:02 2010
@@ -0,0 +1,157 @@
+package org.cspoker.ai.opponentmodels.weka;
+
+import java.util.ArrayDeque;
+import java.util.Deque;
+import java.util.HashMap;
+import java.util.Map;
+import java.util.Set;
+
+import org.apache.log4j.Logger;
+import org.cspoker.ai.opponentmodels.OpponentModel;
+import org.cspoker.ai.opponentmodels.listener.OpponentModelListener;
+import org.cspoker.client.common.gamestate.GameState;
+import org.cspoker.client.common.playerstate.PlayerState;
+import org.cspoker.common.elements.player.PlayerId;
+import org.cspoker.common.util.Pair;
+import org.cspoker.common.util.Triple;
+
+/**
+ * This OpponentModel delegates to a provided default {@link WekaModel}
for its opponent-model.
+ * In addition it observes the game and (configured by {@link
WekaOptions}) replaces
+ * the opponent-model for each villain after enough data has been
collected.
+ *
+ */
+public class WekaLearningModel implements OpponentModel {
+
+ protected static final Logger logger =
Logger.getLogger(WekaLearningModel.class);
+
+ private PlayerTrackingVisitor permanentVisitor;
+ private ActionTrackingVisitor actionTrackingVisitor;
+ private final Deque<PlayerTrackingVisitor> visitors = new
ArrayDeque<PlayerTrackingVisitor>();
+
+ Map<PlayerId, WekaRegressionModel> opponentModels = new HashMap<PlayerId,
WekaRegressionModel>();
+ private final WekaRegressionModel defaultModel;
+ private final WekaOptions config;
+
+ private final PlayerId bot;
+
+ private final OpponentModelListener[] listeners;
+
+ public WekaLearningModel(PlayerId botId, WekaRegressionModel
defaultModel, WekaOptions config,
+ OpponentModelListener... listeners) {
+ this.permanentVisitor = new PlayerTrackingVisitor();
+ this.visitors.add(permanentVisitor);
+ this.defaultModel = defaultModel;
+ this.config = config;
+ this.bot = botId;
+ this.listeners = listeners;
+ for (int i = 0; i < listeners.length; i++)
+ listeners[i].setOpponentModel(this);
+ if (config.useOnlineLearning()) {
+ this.actionTrackingVisitor = new ActionTrackingVisitor(bot);
+ }
+ }
+
+ public WekaOptions getConfig() {
+ return config;
+ }
+
+ // thse methods are used by KullbackLeiblerListener
+ // TODO: better design (this is messy)
+ public Map<PlayerId, WekaRegressionModel> getOpponentModels() {
+ return opponentModels;
+ }
+ public WekaRegressionModel getDefaultModel() {
+ return defaultModel;
+ }
+ public Propositionalizer getCurrentGamePropositionalizer() {
+ return visitors.peek().getPropz();
+ }
+ // *************************************************
+
+ @Override
+ public void assumePermanently(GameState gameState) {
+ // make sure we have created Models for all players
+ Set<PlayerState> seatedPlayers = gameState.getAllSeatedPlayers();
+ for (PlayerState playerState : seatedPlayers) {
+ getWekaModel(playerState.getPlayerId());
+ }
+ permanentVisitor.readHistory(gameState);
+ if (actionTrackingVisitor != null) {
+ actionTrackingVisitor.readHistory(gameState);
+ }
+ }
+
+ @Override
+ public void assumeTemporarily(GameState gameState) {
+ PlayerTrackingVisitor root = visitors.peek();
+ PlayerTrackingVisitor clonedTopVisitor = root.clone();
+ clonedTopVisitor.readHistory(gameState);
+ visitors.push(clonedTopVisitor);
+ }
+
+ @Override
+ public void forgetLastAssumption() {
+ visitors.pop();
+ // the permanentVisitor should never be popped
+ if (visitors.isEmpty()) {
+ throw new IllegalStateException("'forgetAssumption' was called more
often than 'assumeTemporarily'");
+ }
+ }
+
+ private WekaRegressionModel getWekaModel(PlayerId actor) {
+ WekaRegressionModel model = opponentModels.get(actor);
+ if (model == null) {
+ model = new WekaRegressionModel(defaultModel);
+ if (config.useOnlineLearning() && !actor.equals(bot)) {
+ opponentModels.put(actor, model);
+ actionTrackingVisitor.getPropz().addPlayer(actor, new
ARFFPlayer(actor, model, config));
+ }
+ }
+ return model;
+ }
+
+ @Override
+ public Pair<Double, Double> getCheckBetProbabilities(GameState gameState,
PlayerId actor) {
+ for (int i = 0; i < listeners.length; i++)
+ listeners[i].onGetCheckProbabilities(gameState, actor);
+// if (actor.equals(bot)) System.out.println("botAction - " +
getWekaModel(actor).toString().length());
+// else System.out.println("opponentAction - " +
getWekaModel(actor).toString().length());
+ Pair<Double, Double> pair =
getWekaModel(actor).getCheckBetProbabilities(actor,
getCurrentGamePropositionalizer());
+// if (actor.equals(bot)) System.out.println("botAction - (" +
pair.getLeft() + "," + pair.getRight() + ")");
+// else System.out.println("opponentAction - (" + pair.getLeft() + "," +
pair.getRight() + ")");
+ return pair;
+ }
+
+ @Override
+ public Triple<Double, Double, Double>
getFoldCallRaiseProbabilities(GameState gameState, PlayerId actor) {
+ for (int i = 0; i < listeners.length; i++)
+ listeners[i].onGetFoldCallRaiseProbabilities(gameState, actor);
+// if (actor.equals(bot)) System.out.println("botAction - " +
getWekaModel(actor).toString().length());
+// else System.out.println("opponentAction" +
getWekaModel(actor).toString().length());
+ Triple<Double, Double, Double> triple =
+ getWekaModel(actor).getFoldCallRaiseProbabilities(actor,
getCurrentGamePropositionalizer());
+// if (actor.equals(bot)) System.out.println("botAction - (" +
triple.getLeft() + "," + triple.getMiddle() + "," + triple.getRight()
+ ")");
+// else System.out.println("opponentAction - (" + triple.getLeft() + ","
+ triple.getMiddle() + "," + triple.getRight() + ")");
+ return triple;
+ }
+
+ @Override
+ public double[] getShowdownProbabilities(GameState gameState, PlayerId
actor) throws UnsupportedOperationException {
+ for (int i = 0; i < listeners.length; i++)
+ listeners[i].onGetShowdownProbilities(gameState, actor);
+// if (actor.equals(bot)) System.out.println("botAction - " +
getWekaModel(actor).toString().length());
+// else System.out.println("opponentAction" +
getWekaModel(actor).toString().length());
+ double[] list = getWekaModel(actor).getShowdownProbabilities(actor,
getCurrentGamePropositionalizer());
+// if (actor.equals(bot)) System.out.print("botAction - (");
+// else System.out.print("opponentAction - (");
+// for (int i = 0; i < list.length; i++) {
+// if (actor.equals(bot)) System.out.print(list[i] + ",");
+// else System.out.print(list[i] + ",");
+// }
+// if (actor.equals(bot)) System.out.println(")");
+// else System.out.println(")");
+ return list;
+ }
+
+}
=======================================
---
/trunk/ai/bots/src/main/java/org/cspoker/ai/opponentmodels/OpponentModelPool.java
Thu May 13 01:37:32 2010
+++ /dev/null
@@ -1,64 +0,0 @@
-package org.cspoker.ai.opponentmodels;
-
-import java.util.concurrent.ConcurrentHashMap;
-
-import org.cspoker.client.common.gamestate.GameState;
-
-public class OpponentModelPool {
-
- private ConcurrentHashMap<Object, OpponentModel> pool = new
ConcurrentHashMap<Object, OpponentModel>();
-
- private static OpponentModelPool instance;
-
- public static OpponentModelPool getInstance() {
- if (instance == null)
- instance = new OpponentModelPool();
- return instance;
- }
-
- public int size() {
- return pool.size();
- }
-
- public void addModel(Object player, OpponentModel model) {
- System.out.println("Adding model for player " + player + ":");
-// System.out.println(model);
- pool.put(player, model);
- System.out.println(pool.size() + " model(s) in pool!");
- }
-
- public OpponentModel getModel(Object player) {
- if (!pool.containsKey(player))
- return null;
- else {
- return pool.get(player);
- }
- }
-
- public Object getPlayer(OpponentModel model) {
- for(Object o:pool.keySet()){
- if(pool.get(o).equals(model)) {
- return o;
- }
- }
- return null;
- }
-
- public void assumePermanently(GameState gameState) {
- for (Object key : pool.keySet()) {
- pool.get(key).assumePermanently(gameState);
- }
- }
-
- public void assumeTemporarily(GameState gameState) {
- for (Object key : pool.keySet()) {
- pool.get(key).assumeTemporarily(gameState);
- }
- }
-
- public void forgetLastAssumption() {
- for (Object key : pool.keySet()) {
- pool.get(key).forgetLastAssumption();
- }
- }
-}
=======================================
---
/trunk/ai/bots/src/main/java/org/cspoker/ai/bots/bot/gametree/mcts/FixedSampleMCTSBot.java
Tue Mar 9 06:36:20 2010
+++
/trunk/ai/bots/src/main/java/org/cspoker/ai/bots/bot/gametree/mcts/FixedSampleMCTSBot.java
Mon Jun 14 18:22:02 2010
@@ -29,8 +29,8 @@
import org.cspoker.client.common.gamestate.GameState;
import org.cspoker.common.api.shared.exception.IllegalActionException;
import org.cspoker.common.elements.player.PlayerId;
-import org.cspoker.common.elements.table.Round;
import org.cspoker.common.elements.table.TableId;
+//import org.cspoker.common.elements.table.Round;

public class FixedSampleMCTSBot extends AbstractBot {

@@ -62,6 +62,7 @@

@Override
public void doNextAction() throws RemoteException, IllegalActionException
{
+// long startTime = System.currentTimeMillis();
GameState gameState = tableContext.getGameState();
RootNode root = new RootNode(gameState,botId,config);
switch (gameState.getRound()) {
@@ -107,9 +108,12 @@
iterate(root);
iterate(root);
iterate(root);
- }while(root.getNbSamples()<nbSamples);
- if (printed && tableContext.getGameState().getRound() == r)
- printed = false;
+ }while(root.getNbSamples()<nbSamples);
+
+ // to calculate efficiency of sampling algorithms
+// if (tableContext.getGameState().getRound() == Round.FINAL)
+// System.out.println(System.currentTimeMillis()-startTime);
+
if(logger.isDebugEnabled()){
logger.debug("Stopped MCTS.");
}
@@ -121,24 +125,9 @@
}
}

- public static boolean printed = false;
long nbSamples;
- long currentCount = 0;
- long lastCount = 0;
- private final static Round r = Round.PREFLOP;

private void iterate(RootNode root) {
- Round round = tableContext.getGameState().getRound();
- if (printed && round == r){
- currentCount = root.getNbSamples();
- if (currentCount-lastCount!=1) {
- for (long i = lastCount+1; i <= currentCount; i++)
- System.out.println(i + " - " + root.getEV() + " - " +
root.getEVStdDev());
- } else {
- System.out.println(currentCount + " - " + root.getEV() + " - " +
root.getEVStdDev());
- }
- lastCount = currentCount;
- }
INode selectedLeaf = root.selectRecursively();
selectedLeaf.expand();
double value = selectedLeaf.simulate();
=======================================
---
/trunk/ai/bots/src/main/java/org/cspoker/ai/bots/bot/gametree/mcts/FixedSampleMCTSBotFactory.java
Thu May 13 01:37:32 2010
+++
/trunk/ai/bots/src/main/java/org/cspoker/ai/bots/bot/gametree/mcts/FixedSampleMCTSBotFactory.java
Mon Jun 14 18:22:02 2010
@@ -28,7 +28,6 @@
import org.cspoker.ai.bots.bot.gametree.search.expander.sampling.Sampler;
import org.cspoker.ai.bots.listener.BotListener;
import org.cspoker.ai.opponentmodels.OpponentModel;
-import org.cspoker.ai.opponentmodels.OpponentModelPool;
import org.cspoker.client.common.SmartLobbyContext;
import org.cspoker.common.elements.player.PlayerId;
import org.cspoker.common.elements.table.TableId;
@@ -86,11 +85,7 @@
SmartLobbyContext lobby, int buyIn, ExecutorService executor,
BotListener... botListeners) {
copies++;
- OpponentModel opponentModel =
OpponentModelPool.getInstance().getModel(botId);
- if(opponentModel==null){
- opponentModel = opponentModelFactory.create();
- OpponentModelPool.getInstance().addModel(botId, opponentModel);
- }
+ OpponentModel opponentModel = opponentModelFactory.create(botId);
Config config = new Config(opponentModel, showdownNodeFactory,
decisionNodeSelectionStrategy, opponentNodeSelectionStrategy,
moveSelectionStrategy, backPropStratFactory, sampler);
=======================================
---
/trunk/ai/bots/src/main/java/org/cspoker/ai/bots/bot/gametree/mcts/MCTSBot.java
Thu May 13 01:37:32 2010
+++
/trunk/ai/bots/src/main/java/org/cspoker/ai/bots/bot/gametree/mcts/MCTSBot.java
Mon Jun 14 18:22:02 2010
@@ -22,19 +22,17 @@
import org.cspoker.ai.bots.bot.AbstractBot;
import org.cspoker.ai.bots.bot.gametree.action.SearchBotAction;
import org.cspoker.ai.bots.bot.gametree.mcts.listeners.MCTSListener;
-import org.cspoker.ai.bots.bot.gametree.mcts.listeners.SWTTreeListener;
-import org.cspoker.ai.bots.bot.gametree.mcts.listeners.TextTreeListener;
import org.cspoker.ai.bots.bot.gametree.mcts.nodes.Config;
import org.cspoker.ai.bots.bot.gametree.mcts.nodes.INode;
import org.cspoker.ai.bots.bot.gametree.mcts.nodes.RootNode;
import org.cspoker.ai.bots.listener.BotListener;
-import org.cspoker.ai.opponentmodels.OpponentModelPool;
import org.cspoker.client.common.SmartLobbyContext;
import org.cspoker.client.common.gamestate.GameState;
import org.cspoker.common.api.shared.exception.IllegalActionException;
import org.cspoker.common.elements.player.PlayerId;
import org.cspoker.common.elements.table.TableId;
-import org.eclipse.swt.widgets.Display;
+
+//import org.cspoker.common.elements.table.Round;

public class MCTSBot extends AbstractBot {

@@ -101,40 +99,32 @@
iterate(root);
iterate(root);
}while(System.currentTimeMillis()<endTime);
-// if (printed && tableContext.getGameState().getRound() == r)
-// printed = false;
SearchBotAction action =
root.selectChild(config.getMoveSelectionStrategy()).getLastAction().getAction();
- if(logger.isInfoEnabled()) logger.info("Stopped MCTS
after "+root.getNbSamples()+" samples and choosing "+action);
+ if(logger.isInfoEnabled())
+ logger.info("Stopped MCTS after "+root.getNbSamples()+" samples and
choosing "+action);
+
+ // to calculate efficiency of sampling algorithms
+// if (tableContext.getGameState().getRound() == Round.PREFLOP)
+// System.out.print(root.getNbSamples());
+// System.out.print("\t");
+// if (tableContext.getGameState().getRound() == Round.FLOP)
+// System.out.print(root.getNbSamples());
+// System.out.print("\t");
+// if (tableContext.getGameState().getRound() == Round.TURN)
+// System.out.print(root.getNbSamples());
+// System.out.print("\t");
+// if (tableContext.getGameState().getRound() == Round.FINAL)
+// System.out.print(root.getNbSamples());
+// System.out.println("");
+
action.perform(playerContext);
MCTSListener[] listeners = createListeners(gameState, botId);
for (MCTSListener listener : listeners) {
listener.onMCTS(root);
}
-// if (OpponentModelPool.getInstance().size() > 1) {
-// TextTreeListener.Factory factory = new TextTreeListener.Factory();
-//// SWTTreeListener.Factory factory = new
SWTTreeListener.Factory(Display.getDefault());
-// MCTSListener listener = factory.create(gameState, botId);
-// listener.onMCTS(root);
-// System.out.println("Tree printed");
-// }
}

-// long currentCount = 0;
-// private final static Round r = Round.FLOP;
-// public static boolean printed = false;
-
private void iterate(RootNode root) {
-// long currentTime = (System.currentTimeMillis()-startTime);
-// Round round = tableContext.getGameState().getRound();
-// if (printed && currentCount<currentTime && round == r){
-// if (currentTime-currentCount!=1) {
-// for (long i = currentCount+1; i <= currentTime; i++)
-// System.out.println(i + " - " + root.getEV() + " - " +
root.getEVStdDev());
-// } else {
-// System.out.println(currentTime + " - " + root.getEV() + " - " +
root.getEVStdDev());
-// }
-// currentCount = currentTime;
-// }
INode selectedLeaf = root.selectRecursively();
selectedLeaf.expand();
double value = selectedLeaf.simulate();
@@ -144,7 +134,6 @@
private MCTSListener[] createListeners(GameState gameState, PlayerId
actor) {
MCTSListener[] listeners = new
MCTSListener[MCTSlistenerFactories.length];
for (int i=0;i<MCTSlistenerFactories.length;i++) {
- System.out.println((i+1) + " listener");
listeners[i] = MCTSlistenerFactories[i].create(gameState, actor);
}
return listeners;
=======================================
---
/trunk/ai/bots/src/main/java/org/cspoker/ai/bots/bot/gametree/mcts/MCTSBotFactory.java
Thu May 13 01:37:32 2010
+++
/trunk/ai/bots/src/main/java/org/cspoker/ai/bots/bot/gametree/mcts/MCTSBotFactory.java
Mon Jun 14 18:22:02 2010
@@ -28,7 +28,6 @@
import org.cspoker.ai.bots.bot.gametree.search.expander.sampling.Sampler;
import org.cspoker.ai.bots.listener.BotListener;
import org.cspoker.ai.opponentmodels.OpponentModel;
-import org.cspoker.ai.opponentmodels.OpponentModelPool;
import org.cspoker.client.common.SmartLobbyContext;
import org.cspoker.common.elements.player.PlayerId;
import org.cspoker.common.elements.table.TableId;
@@ -74,11 +73,8 @@
public Bot createBot(final PlayerId botId, TableId tableId,
SmartLobbyContext lobby, int buyIn, ExecutorService executor,
BotListener... botListeners) {
- OpponentModel opponentModel =
OpponentModelPool.getInstance().getModel(botId);
- if(opponentModel==null){
- opponentModel = opponentModelFactory.create();
- OpponentModelPool.getInstance().addModel(botId, opponentModel);
- }
+ OpponentModel opponentModel = opponentModelFactory.create(botId);
+
Config config = new Config(opponentModel, showdownNodeFactory,
decisionNodeSelectionStrategy, opponentNodeSelectionStrategy,
moveSelectionStrategy, backPropStratFactory, sampler);
=======================================
---
/trunk/ai/bots/src/main/java/org/cspoker/ai/bots/bot/gametree/mcts/nodes/InnerNode.java
Thu May 13 01:37:32 2010
+++
/trunk/ai/bots/src/main/java/org/cspoker/ai/bots/bot/gametree/mcts/nodes/InnerNode.java
Mon Jun 14 18:22:02 2010
@@ -25,7 +25,6 @@
import
org.cspoker.ai.bots.bot.gametree.mcts.strategies.backpropagation.BackPropagationStrategy;
import
org.cspoker.ai.bots.bot.gametree.mcts.strategies.selection.SelectionStrategy;
import org.cspoker.ai.bots.bot.gametree.search.expander.Expander;
-import org.cspoker.ai.opponentmodels.OpponentModelPool;
import org.cspoker.client.common.gamestate.GameState;
import org.cspoker.common.elements.player.PlayerId;

@@ -63,19 +62,14 @@

public INode selectRecursively(){
//if(!inTree) return this;
-// long size = config.getModel().getVisitorSize();
boolean needsChildExpansion = (children==null);
if(needsChildExpansion){
- OpponentModelPool.getInstance().assumeTemporarily(gameState);
-// config.getModel().assumeTemporarily(gameState);
+ config.getModel().assumeTemporarily(gameState);
expandChildren();
}
INode selectedChild = selectChild().selectRecursively();
- if(needsChildExpansion){
-// config.getModel().forgetLastAssumption();
- OpponentModelPool.getInstance().forgetLastAssumption();
- }
-// if (size != config.getModel().getVisitorSize()) throw new
IllegalStateException("Model didn't forget last assumption");
+ if(needsChildExpansion)
+ config.getModel().forgetLastAssumption();
return selectedChild;
}

@@ -160,7 +154,7 @@

protected void expandChildren(){
if(children == null){
- Expander expander = new Expander(gameState, gameState.getNextToAct(),
bot, config.getSampler());
+ Expander expander = new Expander(gameState, config.getModel(),
gameState.getNextToAct(), bot, config.getSampler());
List<ProbabilityAction> actions = expander.getProbabilityActions();
ImmutableList.Builder<INode> childrenBuilder = ImmutableList.builder();
probabilities = new double[actions.size()];
=======================================
---
/trunk/ai/bots/src/main/java/org/cspoker/ai/bots/bot/gametree/search/SearchBotFactory.java
Tue Mar 9 06:36:20 2010
+++
/trunk/ai/bots/src/main/java/org/cspoker/ai/bots/bot/gametree/search/SearchBotFactory.java
Mon Jun 14 18:22:02 2010
@@ -83,7 +83,7 @@

OpponentModel opponentModel = opponentModels.get(botId);
if(opponentModel==null){
- opponentModel = modelFactory.create();
+ opponentModel = modelFactory.create(botId);
opponentModels.put(botId, opponentModel);
}
SearchConfiguration config = new SearchConfiguration(opponentModel,
showdownNodeFactory,
=======================================
---
/trunk/ai/bots/src/main/java/org/cspoker/ai/bots/bot/gametree/search/expander/Expander.java
Thu May 13 01:37:32 2010
+++
/trunk/ai/bots/src/main/java/org/cspoker/ai/bots/bot/gametree/search/expander/Expander.java
Mon Jun 14 18:22:02 2010
@@ -19,7 +19,6 @@
import org.cspoker.ai.bots.bot.gametree.search.InnerGameTreeNode;
import org.cspoker.ai.bots.bot.gametree.search.expander.sampling.Sampler;
import org.cspoker.ai.opponentmodels.OpponentModel;
-import org.cspoker.ai.opponentmodels.OpponentModelPool;
import org.cspoker.client.common.gamestate.GameState;
import org.cspoker.common.elements.player.PlayerId;
import com.google.common.collect.ImmutableList;
@@ -32,19 +31,19 @@
private final PlayerId actor;
private final PlayerId bot;
private final Sampler sampler;
-
- public Expander(GameState gameState,
+ private final OpponentModel model;
+
+ public Expander(GameState gameState, OpponentModel model,
PlayerId actor, PlayerId bot, Sampler sampler) {
this.gameState = gameState;
this.actor = actor;
this.bot = bot;
this.sampler = sampler;
+ this.model = model;
}

public ImmutableList<ProbabilityAction> getProbabilityActions() {
- OpponentModel actorModel =
OpponentModelPool.getInstance().getModel(actor);
- if (actorModel == null) actorModel =
OpponentModelPool.getInstance().getModel(bot);
- return sampler.getProbabilityActions(gameState, actorModel, actor, bot);
+ return sampler.getProbabilityActions(gameState, model, actor, bot);
}

public static interface Factory {
=======================================
---
/trunk/ai/bots/src/main/java/org/cspoker/ai/bots/bot/gametree/search/expander/TokenExpander.java
Thu May 13 01:37:32 2010
+++
/trunk/ai/bots/src/main/java/org/cspoker/ai/bots/bot/gametree/search/expander/TokenExpander.java
Mon Jun 14 18:22:02 2010
@@ -29,7 +29,7 @@
protected final InnerGameTreeNode node;

public TokenExpander(InnerGameTreeNode node, int tokens, Sampler sampler)
{
- super(node.getGameState(), node.getPlayerId(), node.getBotId(), sampler);
+ super(node.getGameState(), node.getOpponentModel(), node.getPlayerId(),
node.getBotId(), sampler);
this.tokens = tokens;
this.node = node;
}
=======================================
---
/trunk/ai/bots/src/main/java/org/cspoker/ai/bots/bot/gametree/search/expander/sampling/RouletteWheelSampler.java
Thu May 13 01:37:32 2010
+++
/trunk/ai/bots/src/main/java/org/cspoker/ai/bots/bot/gametree/search/expander/sampling/RouletteWheelSampler.java
Mon Jun 14 18:22:02 2010
@@ -1,8 +1,6 @@
package org.cspoker.ai.bots.bot.gametree.search.expander.sampling;

-import java.util.ArrayList;
import java.util.Arrays;
-import java.util.List;

public class RouletteWheelSampler extends StochasticSampler {

@@ -13,54 +11,6 @@
public RouletteWheelSampler(int nbBetSizeSamples) {
super(nbBetSizeSamples);
}
-
- class Bucket {
- private double start;
- private double end;
- private double prob;
- private double totalProb;
- private double averageProb;
-
- public Bucket(double start, double prob, double totalProb) {
- this.start = start;
- this.setProb(prob);
- this.setTotalProb(totalProb);
- }
- public double getStart() {
- return start;
- }
- public double getEnd() {
- return end;
- }
- public void setEnd(double end) {
- this.end = end;
- }
- public double getProb() {
- return prob;
- }
- private void setProb(double prob) {
- this.prob = prob;
- }
- public double getTotalProb() {
- return totalProb;
- }
- public void setTotalProb(double totalProb) {
- this.totalProb = totalProb;
- }
- public String toString() {
- return "Start: " + start + ", \t end: " + end + ",\t prob: " +
- prob + ", averageProb: " + averageProb + ", totalProb: " + totalProb;
- }
- public void setAverageProb(int length) {
- if (end==start)
- this.averageProb = totalProb;
- else
- this.averageProb = totalProb/((end-start)*(length-1));
- }
- public double getAverageProb() {
- return averageProb;
- }
- }

@Override
protected double[] getStochasticSamples(int n) {
@@ -71,40 +21,12 @@
Arrays.sort(samples);
return samples;
}
-
- protected List<Bucket> getStochasticSamples(double threshold) {
- RelativeBetDistribution distr = new RelativeBetDistribution();
- List<Bucket> buckets = new ArrayList<Bucket>();
- // start of range bucket, prob of start, totalProb
- Bucket bucket = new Bucket(0, distr.pdf(0), 0);
- for (int i = 0; i < distr.length(); i++) {
- double relBet = (double) i / (distr.length() - 1);
- if (Math.abs(bucket.getProb() - distr.pdf(relBet)) > threshold) {
- bucket.setEnd(relBet);
- bucket.setAverageProb(distr.length());
- buckets.add(bucket);
- bucket = new Bucket(relBet, distr.pdf(relBet), 0);
- }
- bucket.setTotalProb(bucket.getTotalProb() + distr.pdf(relBet));
- }
- bucket.setEnd(1);
- bucket.setAverageProb(distr.length());
- buckets.add(bucket);
- return buckets;
- }

public static void main(String[] args) {
RouletteWheelSampler s = new RouletteWheelSampler();
-// double[] list = s.getStochasticSamples(8);
-// for (int i = 0; i < list.length; i++) {
-// System.out.println(" - " + list[i]);
-// }
- List<Bucket> list = s.getStochasticSamples(0.01);
- double totalProb = 0;
- for (int i = 0; i < list.size(); i++) {
- totalProb += list.get(i).getTotalProb();
- System.out.println(" - " + list.get(i));
- }
- System.out.println("\n => TotalProb: " + totalProb);
+ double[] list = s.getStochasticSamples(8);
+ for (int i = 0; i < list.length; i++) {
+ System.out.println(" - " + list[i]);
+ }
}
}
=======================================
---
/trunk/ai/bots/src/main/java/org/cspoker/ai/bots/bot/gametree/search/expander/sampling/StochasticSampler.java
Thu May 13 01:37:32 2010
+++
/trunk/ai/bots/src/main/java/org/cspoker/ai/bots/bot/gametree/search/expander/sampling/StochasticSampler.java
Mon Jun 14 18:22:02 2010
@@ -91,10 +91,8 @@
double totalProbability = 0;
if (gameState.getDeficit(actor)>0) {
// call, raise or fold
-// model.assumeTemporarily(gameState);
Triple<Double, Double, Double> probabilities =
model.getFoldCallRaiseProbabilities(gameState, actor);
-// model.forgetLastAssumption();

double foldProbability = probabilities.getLeft();
totalProbability += foldProbability;
@@ -121,9 +119,7 @@
}
} else {
// check or bet
-// model.assumeTemporarily(gameState);
Pair<Double, Double> probabilities =
model.getCheckBetProbabilities(gameState, actor);
-// model.forgetLastAssumption();
double checkProbability = probabilities.getLeft();
totalProbability += checkProbability;
actions.add(new ProbabilityAction(new CheckAction(gameState, actor),
checkProbability));
=======================================
---
/trunk/ai/bots/src/main/java/org/cspoker/ai/bots/bot/gametree/search/expander/sampling/StochasticUniversalSampler.java
Tue Mar 9 06:36:20 2010
+++
/trunk/ai/bots/src/main/java/org/cspoker/ai/bots/bot/gametree/search/expander/sampling/StochasticUniversalSampler.java
Mon Jun 14 18:22:02 2010
@@ -16,8 +16,9 @@
RelativeBetDistribution distr = new RelativeBetDistribution();
double[] samples = new double[n];
double sample = r.nextDouble() / n;
- for (int i = 0; i < n; i++)
+ for (int i = 0; i < n; i++) {
samples[i] = distr.inverseCdf(sample + (double) i/n);
+ }
Arrays.sort(samples);
return samples;
}
=======================================
---
/trunk/ai/bots/src/main/java/org/cspoker/ai/opponentmodels/OpponentModel.java
Thu Sep 17 15:34:17 2009
+++
/trunk/ai/bots/src/main/java/org/cspoker/ai/opponentmodels/OpponentModel.java
Mon Jun 14 18:22:02 2010
@@ -50,10 +50,15 @@
* Forget the last assumption.
*/
void forgetLastAssumption();
+
+// /**
+// * Return a clone of opponentmodel
+// */
+// OpponentModel clone();

static interface Factory {

- OpponentModel create();
+ OpponentModel create(PlayerId bot);

}
}
=======================================
---
/trunk/ai/bots/src/main/java/org/cspoker/ai/opponentmodels/simple/HistogramModel.java
Thu Sep 17 15:34:17 2009
+++
/trunk/ai/bots/src/main/java/org/cspoker/ai/opponentmodels/simple/HistogramModel.java
Mon Jun 14 18:22:02 2010
@@ -150,6 +150,16 @@
lastKnownState = gameState;
}

+ @Override
+ public OpponentModel clone() {
+ HistogramModel hist = new HistogramModel();
+ hist.opponentModels.putAll(this.opponentModels);
+ hist.lastKnownState = this.lastKnownState;
+ hist.round = this.round;
+ hist.started = this.started;
+ return hist;
+ }
+
@Override
public void visitAllInState(AllInState allInState) {
if (started) {
=======================================
---
/trunk/ai/bots/src/main/java/org/cspoker/ai/opponentmodels/simple/HistogramModelFactory.java
Tue Aug 18 10:58:09 2009
+++
/trunk/ai/bots/src/main/java/org/cspoker/ai/opponentmodels/simple/HistogramModelFactory.java
Mon Jun 14 18:22:02 2010
@@ -16,12 +16,12 @@
package org.cspoker.ai.opponentmodels.simple;

import org.cspoker.ai.opponentmodels.OpponentModel;
+import org.cspoker.common.elements.player.PlayerId;

public class HistogramModelFactory implements OpponentModel.Factory{

@Override
- public OpponentModel create() {
+ public OpponentModel create(PlayerId botId) {
return new HistogramModel();
}
-
-}
+}
=======================================
--- /trunk/ai/experiments/src/main/java/org/cspoker/ai/bots/BotRunner.java
Thu May 13 01:37:32 2010
+++ /trunk/ai/experiments/src/main/java/org/cspoker/ai/bots/BotRunner.java
Mon Jun 14 18:22:02 2010
@@ -39,6 +39,7 @@
import org.cspoker.ai.bots.listener.BotListener;
import org.cspoker.ai.bots.listener.CSVLogListener;
import org.cspoker.ai.bots.listener.GameLimitingBotListener;
+import org.cspoker.ai.bots.listener.KullbackLeiblerListener;
import org.cspoker.ai.bots.listener.ReSitInBotListener;
import org.cspoker.ai.bots.listener.SpeedTestBotListener;
import org.cspoker.ai.experiments.util.CombinationGenerator;
@@ -67,14 +68,12 @@
private static final TableConfiguration config = new
TableConfiguration(100,
0, false, true, true,0);

- public static final int nbGamesPerConfrontation = 2000;
- public final int nbPlayersPerGame;
-
- public static final int reportInterval = 50;
-
- public final String expName;
- public final int nbExperiments = 3;
+ public static final int nbGamesPerConfrontation = 300;
+ public static final int reportInterval = 1;
+ public final int nbExperiments = 1;
+
public static int currentExperiment = 1;
+ public int nbPlayersPerGame;

static {
Log4JPropertiesLoader
@@ -83,14 +82,14 @@

private final static Logger logger = Logger.getLogger(BotRunner.class);

- private final BotFactory[] botFactories;
-
- private final SmartLobbyContext[] botLobbies;
- private final PlayerId[] botIDs;
-
- protected final SmartLobbyContext directorLobby;
-
- private final ExecutorService executor;
+ private BotFactory[] botFactories;
+
+ private SmartLobbyContext[] botLobbies;
+ private PlayerId[] botIDs;
+
+ protected SmartLobbyContext directorLobby;
+
+ private ExecutorService executor;

private volatile Bot[] bot;

@@ -99,10 +98,18 @@
private BotListener speedMonitor;
private CSVLogListener csvLogger;
private volatile BotListener gameLimiter;
-
- private final CombinationGenerator combinationgenerator;
-
- public static BotRunner create(RemoteCSPokerServer cspokerServer) {
+ private static KullbackLeiblerListener kullbackLeibler;
+
+ private CombinationGenerator combinationgenerator;
+ private final String expName;
+ private final RemoteCSPokerServer cspokerServer;
+
+ public static void create(RemoteCSPokerServer cspokerServer) {
+// new BotRunner(cspokerServer, "bucketSampler0.01VsRulebots");
+ new BotRunner(cspokerServer, "testBucket", getBots());
+ }
+
+ public static BotFactory[] getBots() {
try {
// if(false){
// //hide compiler warnings
@@ -111,127 +118,154 @@
// if(false){
// throw new ClassNotFoundException();
// }
-// WekaOptions.setArffPersistency(false);
- Sampler s = new StochasticUniversalSampler(5);
- return new BotRunner(cspokerServer, "testLearning",
- new BotFactory[] {
- new CallBotFactory("CallBot"),
-// new CardBotFactory("CardBot"),
-// new HandBotFactory("HandBot"),
-// new FixedSampleMCTSBotFactory("MCTSBot",
-//
WekaRegressionModelFactory.createForZip(overwrite, "org/cspoker/ai/opponentmodels/weka/models/model1.zip"),
-// new SamplingToFunctionSelector(50,new UCTSelector(40000)),
-// new SamplingToFunctionSelector(50,new UCTPlusPlusSelector()),
-// new MaxValueSelector(),
-// new MCTSBucketShowdownNode.Factory(),
-// new MixedBackPropStrategy.Factory(
-// 50,
-// new SampleWeightedBackPropStrategy.Factory(),
-// new MaxDistributionPlusBackPropStrategy.Factory()
-// ),s,
-// 1000,1000,1000,1000),
- new MCTSBotFactory("MCTSBot",
-
WekaRegressionModelFactory.createForZip("org/cspoker/ai/opponentmodels/weka/models/model1.zip"),
- new SamplingToFunctionSelector(50,new UCTSelector(2000)),
- new SamplingSelector(),
- new MaxValueSelector(),
- new MCTSShowdownRollOutNode.Factory(),
- new SampleWeightedBackPropStrategy.Factory(),
- s,
- 250
- ),
-// new SearchBotFactory(
-//
WekaRegressionModelFactory.createForZip(overwrite, "org/cspoker/ai/opponentmodels/weka/models/model1.zip"),
-// new ShowdownRolloutNode.Factory(new
DistributionRollout4.Factory()), s,
-// 200, 600, 1000, 3000, 0.0, false, true
-// )
- // new MCTSBotFactory(
- // "MCTS Bot",
- // new
WekaRegressionModelFactory("/home/guy/Werk/thesis/weka-3-6-0/model1"),
- // new SamplingToFunctionSelector(20,new UCTSelector(40000)),
- // new SamplingSelector(),
- // new MaxValueSelector(),
- // new MCTSBucketShowdownNode.Factory(),
- // new SampleWeightedBackPropStrategy.Factory(),
- // 2000
- // ),
- // new MCTSBotFactory(
- // "Bot 2",
- // new
WekaRegressionModelFactory("/home/guy/Werk/thesis/weka-3-6-0/model1"),
- // new SamplingToFunctionSelector(10,new
UCTPlusSelector(2000,0.5)),
- // new MixedSelectionStrategy(new SamplingSelector(), new
MinValueSelector(),0.95),
- // new MaxUnderValueSelector(2),
- // new MCTSBucketShowdownNode.Factory(),
- // new MixtureBackPropStrategy.Factory(new
MaxUnderValueSelector(2)),
- // 250
- // ),
- // new MCTSBotFactory(
- // "Bot 3",
- // new
WekaRegressionModelFactory("/home/guy/Werk/thesis/weka-3-6-0/model1"),
- // new SamplingToFunctionSelector(10,new UCTSelector(20000)),
- // new MixedSelectionStrategy(new SamplingSelector(), new
MinValueSelector(),0.95),
- // new MaxUnderValueSelector(2),
- // new MCTSBucketShowdownNode.Factory(),
- // new MixtureBackPropStrategy.Factory(new
MaxUnderValueSelector(2)),
- // 250
- // ),
- // new MCTSBotFactory(
- // "Bot 4",
- // new
WekaRegressionModelFactory("/home/guy/Werk/thesis/weka-3-6-0/model1"),
- // new SamplingToFunctionSelector(10,new
UCTPlusSelector(20000,0.5)),
- // new MixedSelectionStrategy(new SamplingSelector(), new
MinValueSelector(),0.95),
- // new MaxUnderValueSelector(2),
- // new MCTSBucketShowdownNode.Factory(),
- // new MixtureBackPropStrategy.Factory(new
MaxUnderValueSelector(2)),
- // 250
- // ),
- // new MCTSBotFactory(
- // "Bot B",
- // new
WekaRegressionModelFactory("/home/guy/Werk/thesis/weka-3-6-0/model1"),
- // new SamplingToFunctionSelector(new UCTSelector(5000)),
- // new SampleProportionateSelector(),
- // new MCTSBucketShowdownNode.Factory(),
- // 50),
- });
+ WekaOptions configNoPersist = new WekaOptions();
+ configNoPersist.setUseOnlineLearning(false);
+ WekaOptions configPersist = new WekaOptions();
+ configPersist.setContinuousLearning(true);
+ configPersist.setModelCreationTreshold(1000);
+// configPersist.setContinueAfterCreation(true);
+ Sampler s = new BucketSampler(0.01);
+// Sampler s = new StochasticUniversalSampler(9);
+// Sampler s = new RouletteWheelSampler(9);
+// Sampler s = new RandomSampler(9);
+ kullbackLeibler = new KullbackLeiblerListener(reportInterval);
+
+ return new BotFactory[] {
+// new CallBotFactory("CallBot"),
+ new CardBotFactory("CardBot"),
+// new HandBotFactory("HandBot"),
+// new FixedSampleMCTSBotFactory("MCTSBot",
+//
WekaRegressionModelFactory.createForZip("org/cspoker/ai/opponentmodels/weka/models/model1.zip",
+// configNoPersist),
+// new SamplingToFunctionSelector(50,new UCTSelector(40000)),
+// new SamplingToFunctionSelector(50,new UCTPlusPlusSelector()),
+// new MaxValueSelector(),
+// new MCTSBucketShowdownNode.Factory(),
+// new MixedBackPropStrategy.Factory(
+// 50,
+// new SampleWeightedBackPropStrategy.Factory(),
+// new MaxDistributionPlusBackPropStrategy.Factory()
+// ),s,
+// 200,500,1000,3000),
+// new MCTSBotFactory("MCTSBot",
+// WekaRegressionModelFactory.createForZip(
+// "org/cspoker/ai/opponentmodels/weka/models/model1.zip",
configNoPersist),
+// new SamplingToFunctionSelector(50,new UCTSelector(2000)),
+// new SamplingSelector(),
+// new MaxValueSelector(),
+// new MCTSShowdownRollOutNode.Factory(),
+// new SampleWeightedBackPropStrategy.Factory(),
+// s,
+// 500
+// ),
+ new MCTSBotFactory("MCTSBot",
+ WekaRegressionModelFactory.createForZip(
+ "org/cspoker/ai/opponentmodels/weka/models/model1.zip",
configPersist, kullbackLeibler),
+ new SamplingToFunctionSelector(50,new UCTSelector(2000)),
+ new SamplingSelector(),
+ new MaxValueSelector(),
+ new MCTSShowdownRollOutNode.Factory(),
+ new SampleWeightedBackPropStrategy.Factory(),
+ s,
+ 250
+ ),
+// new SearchBotFactory(
+//
WekaRegressionModelFactory.createForZip("org/cspoker/ai/opponentmodels/weka/models/model1.zip",
configNoPersist),
+// new ShowdownRolloutNode.Factory(new
DistributionRollout4.Factory()), s,
+// 200, 600, 1000, 3000, 0.0, false, true
+// )
+ // new MCTSBotFactory(
+ // "MCTS Bot",
+ // new
WekaRegressionModelFactory("/home/guy/Werk/thesis/weka-3-6-0/model1"),
+ // new SamplingToFunctionSelector(20,new UCTSelector(40000)),
+ // new SamplingSelector(),
+ // new MaxValueSelector(),
+ // new MCTSBucketShowdownNode.Factory(),
+ // new SampleWeightedBackPropStrategy.Factory(),
+ // 2000
+ // ),
+ // new MCTSBotFactory(
+ // "Bot 2",
+ // new
WekaRegressionModelFactory("/home/guy/Werk/thesis/weka-3-6-0/model1"),
+ // new SamplingToFunctionSelector(10,new
UCTPlusSelector(2000,0.5)),
+ // new MixedSelectionStrategy(new SamplingSelector(), new
MinValueSelector(),0.95),
+ // new MaxUnderValueSelector(2),
+ // new MCTSBucketShowdownNode.Factory(),
+ // new MixtureBackPropStrategy.Factory(new
MaxUnderValueSelector(2)),
+ // 250
+ // ),
+ // new MCTSBotFactory(
+ // "Bot 3",
+ // new
WekaRegressionModelFactory("/home/guy/Werk/thesis/weka-3-6-0/model1"),
+ // new SamplingToFunctionSelector(10,new UCTSelector(20000)),
+ // new MixedSelectionStrategy(new SamplingSelector(), new
MinValueSelector(),0.95),
+ // new MaxUnderValueSelector(2),
+ // new MCTSBucketShowdownNode.Factory(),
+ // new MixtureBackPropStrategy.Factory(new
MaxUnderValueSelector(2)),
+ // 250
+ // ),
+ // new MCTSBotFactory(
+ // "Bot 4",
+ // new
WekaRegressionModelFactory("/home/guy/Werk/thesis/weka-3-6-0/model1"),
+ // new SamplingToFunctionSelector(10,new
UCTPlusSelector(20000,0.5)),
+ // new MixedSelectionStrategy(new SamplingSelector(), new
MinValueSelector(),0.95),
+ // new MaxUnderValueSelector(2),
+ // new MCTSBucketShowdownNode.Factory(),
+ // new MixtureBackPropStrategy.Factory(new
MaxUnderValueSelector(2)),
+ // 250
+ // ),
+ // new MCTSBotFactory(
+ // "Bot B",
+ // new
WekaRegressionModelFactory("/home/guy/Werk/thesis/weka-3-6-0/model1"),
+ // new SamplingToFunctionSelector(new UCTSelector(5000)),
+ // new SampleProportionateSelector(),
+ // new MCTSBucketShowdownNode.Factory(),
+ // 50),
+ };
+
} catch (IOException e) {
throw new IllegalStateException(e);
} catch (ClassNotFoundException e) {
throw new IllegalStateException(e);
}
}
-
+
public BotRunner(RemoteCSPokerServer cspokerServer, BotFactory[] bots) {
this(cspokerServer, "bots", bots);
}

public BotRunner(RemoteCSPokerServer cspokerServer, String expName,
BotFactory[] bots) {
+ this.expName = expName;
+ this.cspokerServer = cspokerServer;
+ this.botFactories = bots;
+
+ prepareBots();
+ iterateBots();
+ }
+
+ private void prepareBots() {
try {
- this.botFactories = bots;
- nbPlayersPerGame = bots.length;//or a constant
+ nbPlayersPerGame = botFactories.length;//or a constant
bot = new Bot[nbPlayersPerGame];
botIndex = new int[nbPlayersPerGame];
-
- botLobbies = new SmartLobbyContext[bots.length];
- botIDs = new PlayerId[bots.length];
-
- this.expName = expName;
-
+
+ botLobbies = new SmartLobbyContext[botFactories.length];
+ botIDs = new PlayerId[botFactories.length];
+
SmartClientContext director = new SmartClientContext(cspokerServer
.login("director", "test"));
directorLobby = director.getLobbyContext(BotRunner.this);
-
- for (int i = 0; i < bots.length; i++) {
+
+ for (int i = 0; i < botFactories.length; i++) {
SmartClientContext clientContext = new SmartClientContext(
- cspokerServer.login(bots[i].toString(), "test"));
+ cspokerServer.login(botFactories[i].toString(), "test"));
botLobbies[i] = clientContext.getLobbyContext(new
DefaultLobbyListener());
botIDs[i] = clientContext.getAccountContext().getPlayerID();
}
-
+
executor = SingleThreadRequestExecutor.getInstance();
-
- combinationgenerator = new CombinationGenerator(bots.length,
nbPlayersPerGame);
- iterateBots();
-
+
+ combinationgenerator = new CombinationGenerator(botFactories.length,
nbPlayersPerGame);
} catch (LoginException e) {
throw new IllegalStateException("Login Failed", e);
} catch (RemoteException e) {
@@ -241,7 +275,6 @@
logger.error(e);
throw new IllegalStateException("Server setup failed.", e);
}
-
}

private void iterateBots() {
@@ -273,8 +306,7 @@

bot[0] = botFactories[botIndex[0]].createBot(botIDs[botIndex[0]],
tableId,
botLobbies[botIndex[0]], buyIn, executor,
- new ReSitInBotListener(this), csvLogger, speedMonitor, gameLimiter);
-// new ReSitInBotListener(this), csvLogger, gameLimiter);
+ new ReSitInBotListener(this), /*csvLogger, speedMonitor,*/
gameLimiter, kullbackLeibler);
bot[0].start();
for (int i = 1; i < nbPlayersPerGame; i++) {
bot[i] = botFactories[botIndex[i]].createBot(botIDs[botIndex[i]],
@@ -295,7 +327,8 @@
logger.info("Experiment " + expName + "-" + (currentExperiment - 1)
+ " successfully ended!");
if (currentExperiment <= nbExperiments) {
- resetStateAndStartPlay();
+ prepareBots();
+ iterateBots();
} else {
executor.shutdownNow();
GlobalThreadPool.getInstance().shutdownNow();
@@ -336,7 +369,7 @@
return bot[i];
}

- public static TableConfiguration getConfig() {
+ public TableConfiguration getConfig() {
return config;
}

=======================================
---
/trunk/ai/experiments/src/main/java/org/cspoker/ai/bots/RunHumanVsBot.java
Thu May 13 01:37:32 2010
+++
/trunk/ai/experiments/src/main/java/org/cspoker/ai/bots/RunHumanVsBot.java
Mon Jun 14 18:22:02 2010
@@ -21,18 +21,23 @@
import org.cspoker.ai.bots.bot.Bot;
import org.cspoker.ai.bots.bot.BotFactory;
import org.cspoker.ai.bots.bot.gametree.mcts.FixedSampleMCTSBotFactory;
+import org.cspoker.ai.bots.bot.gametree.mcts.MCTSBotFactory;
import org.cspoker.ai.bots.bot.gametree.mcts.listeners.SWTTreeListener;
import org.cspoker.ai.bots.bot.gametree.mcts.nodes.MCTSBucketShowdownNode;
+import org.cspoker.ai.bots.bot.gametree.mcts.nodes.MCTSShowdownRollOutNode;
import
org.cspoker.ai.bots.bot.gametree.mcts.strategies.backpropagation.MaxDistributionPlusBackPropStrategy;
import
org.cspoker.ai.bots.bot.gametree.mcts.strategies.backpropagation.MixedBackPropStrategy;
import
org.cspoker.ai.bots.bot.gametree.mcts.strategies.backpropagation.SampleWeightedBackPropStrategy;
import
org.cspoker.ai.bots.bot.gametree.mcts.strategies.selection.MaxValueSelector;
+import
org.cspoker.ai.bots.bot.gametree.mcts.strategies.selection.SamplingSelector;
import
org.cspoker.ai.bots.bot.gametree.mcts.strategies.selection.SamplingToFunctionSelector;
import
org.cspoker.ai.bots.bot.gametree.mcts.strategies.selection.UCTPlusPlusSelector;
import
org.cspoker.ai.bots.bot.gametree.mcts.strategies.selection.UCTSelector;
+import
org.cspoker.ai.bots.bot.gametree.search.expander.sampling.BucketSampler;
import
org.cspoker.ai.bots.bot.gametree.search.expander.sampling.SmartSampler;
import
org.cspoker.ai.bots.bot.gametree.search.nodevisitor.StatisticsVisitor;
import org.cspoker.ai.bots.listener.DefaultBotListener;
+import org.cspoker.ai.opponentmodels.weka.WekaOptions;
import org.cspoker.ai.opponentmodels.weka.WekaRegressionModelFactory;
import org.cspoker.client.User;
import org.cspoker.client.common.SmartClientContext;
@@ -69,7 +74,7 @@
}

private ClientCore client;
- private ClientCore client2;
+// private ClientCore client2;
protected CSPokerServer server;
private final DisplayExecutor displayexecutor;
private StatisticsVisitor.Factory stats;
@@ -90,16 +95,16 @@
User u = new User("Human", "test");
client = new ClientCore(u);
client.login(server);
- User u2 = new User("Human2", "test");
- client2 = new ClientCore(u2);
- client2.login(server);
+// User u2 = new User("Human2", "test");
+// client2 = new ClientCore(u2);
+// client2.login(server);

final LobbyWindow lobby = new LobbyWindow(client);
lobby.setLobbyContext(client.getCommunication());
client.getGui().setLobby(lobby);
- final LobbyWindow lobby2 = new LobbyWindow(client2);
- lobby2.setLobbyContext(client2.getCommunication());
- client2.getGui().setLobby(lobby2);
+// final LobbyWindow lobby2 = new LobbyWindow(client2);
+// lobby2.setLobbyContext(client2.getCommunication());
+// client2.getGui().setLobby(lobby2);

tConfig = new TableConfiguration(smallBet, delay, false, false, true,0);
lobby.getContext().createHoldemTable(u.getUserName() + "'s test table",
tConfig);
@@ -109,51 +114,68 @@
public void run() {
lobby.show();

- }
- });displayexecutor.execute(new Runnable() {
-
- public void run() {
- lobby2.show();
-
}
});
+// displayexecutor.execute(new Runnable() {
+//
+// public void run() {
+// lobby2.show();
+//
+// }
+// });
final GameWindow w = client.getGui().getGameWindow(tableId, true);
w.getUser().sitIn(new SeatId(0), 0);
- final GameWindow w2 = client2.getGui().getGameWindow(tableId, true);
- w2.getUser().sitIn(new SeatId(2), 0);
+// final GameWindow w2 = client2.getGui().getGameWindow(tableId, true);
+// w2.getUser().sitIn(new SeatId(2), 0);
// Run blocking calls in extra thread
displayexecutor.execute(new Runnable() {

public void run() {
w.show();

- }
- });displayexecutor.execute(new Runnable() {
-
- public void run() {
- w2.show();
-
}
});
+// displayexecutor.execute(new Runnable() {
+//
+// public void run() {
+// w2.show();
+//
+// }
+// });
stats = new StatisticsVisitor.Factory();

BotFactory botFactory;
try {
- botFactory = new FixedSampleMCTSBotFactory(
- "Plus Bot",
-
WekaRegressionModelFactory.createForZip("org/cspoker/ai/opponentmodels/weka/models/model1.zip"),
- new SamplingToFunctionSelector(50,new UCTSelector(40000)),
- new SamplingToFunctionSelector(50,new UCTPlusPlusSelector()),
+ WekaOptions configPersist = new WekaOptions();
+ configPersist.setContinuousLearning(true);
+ configPersist.setModelCreationTreshold(1);
+ botFactory = new MCTSBotFactory("MCTSBot",
+ WekaRegressionModelFactory.createForZip(
+ "org/cspoker/ai/opponentmodels/weka/models/model1.zip",
configPersist/*, kullbackLeibler*/),
+ new SamplingToFunctionSelector(50,new UCTSelector(2000)),
+ new SamplingSelector(),
new MaxValueSelector(),
- new MCTSBucketShowdownNode.Factory(),
- new MixedBackPropStrategy.Factory(
- 50,
- new SampleWeightedBackPropStrategy.Factory(),
- new MaxDistributionPlusBackPropStrategy.Factory()
- ),
- new SmartSampler(),
- 20000,40000,80000,100000,
- new SWTTreeListener.Factory(client.getGui().getDisplay()));
+ new MCTSShowdownRollOutNode.Factory(),
+ new SampleWeightedBackPropStrategy.Factory(),
+ new BucketSampler(0.01),
+ 250,
+ new SWTTreeListener.Factory(client.getGui().getDisplay())
+ );
+// botFactory = new FixedSampleMCTSBotFactory(
+// "Plus Bot",
+//
WekaRegressionModelFactory.createForZip("org/cspoker/ai/opponentmodels/weka/models/model1.zip",
configPersist),
+// new SamplingToFunctionSelector(50,new UCTSelector(40000)),
+// new SamplingToFunctionSelector(50,new UCTPlusPlusSelector()),
+// new MaxValueSelector(),
+// new MCTSBucketShowdownNode.Factory(),
+// new MixedBackPropStrategy.Factory(
+// 50,
+// new SampleWeightedBackPropStrategy.Factory(),
+// new MaxDistributionPlusBackPropStrategy.Factory()
+// ),
+// new BucketSampler(0.01),
+// 250,500,1000,2000,
+// new SWTTreeListener.Factory(client.getGui().getDisplay()));

// botFactory = new SearchBotFactory(
// new
WekaRegressionModelFactory("/home/guy/Werk/thesis/weka-3-6-0/model1"),
=======================================
---
/trunk/ai/experiments/src/main/java/org/cspoker/ai/bots/bot/gametree/mcts/listeners/SWTTreeListener.java
Fri Aug 14 07:58:03 2009
+++
/trunk/ai/experiments/src/main/java/org/cspoker/ai/bots/bot/gametree/mcts/listeners/SWTTreeListener.java
Mon Jun 14 18:22:02 2010
@@ -15,7 +15,6 @@
*/
package org.cspoker.ai.bots.bot.gametree.mcts.listeners;

-import org.apache.log4j.Logger;
import org.cspoker.ai.bots.bot.gametree.action.ProbabilityAction;
import org.cspoker.ai.bots.bot.gametree.mcts.nodes.INode;
import org.cspoker.ai.bots.bot.gametree.mcts.nodes.InnerNode;
@@ -40,7 +39,6 @@

public class SWTTreeListener implements MCTSListener {

- private final static Logger logger =
Logger.getLogger(SWTTreeListener.class);
private final Display display;
private final Tree tree;
private final int relStackSize;
=======================================
---
/trunk/ai/experiments/src/main/java/org/cspoker/ai/bots/listener/CSVLogListener.java
Tue Mar 9 06:36:20 2010
+++
/trunk/ai/experiments/src/main/java/org/cspoker/ai/bots/listener/CSVLogListener.java
Mon Jun 14 18:22:02 2010
@@ -20,8 +20,6 @@

import org.apache.log4j.Logger;
import org.cspoker.ai.bots.BotRunner;
-import org.cspoker.ai.bots.bot.gametree.mcts.FixedSampleMCTSBot;
-import org.cspoker.ai.bots.bot.gametree.mcts.MCTSBot;
import org.cspoker.ai.bots.util.RunningStats;

public class CSVLogListener extends DealCountingListener {
@@ -37,6 +35,8 @@

private final FileWriter file;

+ private long overallStartTime;
+
public CSVLogListener(BotRunner runner) {
this(64, runner, "bots");
}
@@ -56,12 +56,9 @@
int deals = getDeals();
if (deals % reportInterval == 0) {
long nowTime = System.currentTimeMillis();
+ if (deals == 1)
+ overallStartTime = startTime;
if (startTime > 0) {
-// for testing convergence EV
-// if (deals==100) {
-// MCTSBot.printed = true;
-// FixedSampleMCTSBot.printed = true;
-// }
logger.info("deal #" + deals + " at " + reportInterval * 1000.0
/ (nowTime - startTime) + " games/s");
try {
@@ -71,7 +68,7 @@
}
for (int i = 0; i < runner.nbPlayersPerGame; i++) {
RunningStats profit = runner.getBot(i).getProfit();
- int smallBet = BotRunner.getConfig().getSmallBet();
+ int smallBet = runner.getConfig().getSmallBet();
double mean = profit.getMean() / smallBet;
double stdDevMean = profit.getEVStdDev()/ smallBet;
try {
@@ -82,6 +79,7 @@
}

try {
+ file.write("," + deals * 1000.0/ (nowTime - overallStartTime));
file.write("\n");
file.flush();
} catch (IOException e) {
=======================================
---
/trunk/ai/experiments/src/main/java/org/cspoker/ai/bots/listener/GameLimitingBotListener.java
Fri Aug 14 07:58:03 2009
+++
/trunk/ai/experiments/src/main/java/org/cspoker/ai/bots/listener/GameLimitingBotListener.java
Mon Jun 14 18:22:02 2010
@@ -15,14 +15,10 @@
*/
package org.cspoker.ai.bots.listener;

-import org.apache.log4j.Logger;
import org.cspoker.ai.bots.BotRunner;

public class GameLimitingBotListener extends DealCountingListener {

- private final static Logger logger = Logger
- .getLogger(GameLimitingBotListener.class);
-
private final int maxNbGames;

private final BotRunner botRunner;
=======================================
---
/trunk/ai/experiments/src/main/java/org/cspoker/ai/bots/listener/ReSitInBotListener.java
Fri Aug 14 07:58:03 2009
+++
/trunk/ai/experiments/src/main/java/org/cspoker/ai/bots/listener/ReSitInBotListener.java
Mon Jun 14 18:22:02 2010
@@ -15,14 +15,11 @@
*/
package org.cspoker.ai.bots.listener;

-import org.apache.log4j.Logger;
import org.cspoker.ai.bots.BotRunner;
import org.cspoker.common.api.lobby.holdemtable.event.SitOutEvent;

public class ReSitInBotListener extends DefaultBotListener {

- private final static Logger logger = Logger
- .getLogger(ReSitInBotListener.class);
private final BotRunner runner;

public ReSitInBotListener(BotRunner runner) {
=======================================
---
/trunk/ai/experiments/src/main/java/org/cspoker/ai/bots/listener/SpeedTestBotListener.java
Wed Sep 16 07:58:09 2009
+++
/trunk/ai/experiments/src/main/java/org/cspoker/ai/bots/listener/SpeedTestBotListener.java
Mon Jun 14 18:22:02 2010
@@ -31,6 +31,8 @@

private final BotRunner runner;

+ private long overallStartTime;
+
public SpeedTestBotListener(BotRunner runner) {
this(64, runner);
}
@@ -45,9 +47,12 @@
int deals = getDeals();
if (deals % reportInterval == 0) {
long nowTime = System.currentTimeMillis();
+ if (deals == 1)
+ overallStartTime = startTime;
if (startTime > 0) {
logger.info("deal #" + deals + " at " + reportInterval * 1000.0
- / (nowTime - startTime) + " games/s");
+ / (nowTime - startTime) + " games/s (overall speed: " +
+ deals * 1000.0/ (nowTime - overallStartTime)+ " games/s)");
for (int i = 0; i < runner.nbPlayersPerGame; i++) {
RunningStats profit = runner.getBot(i).getProfit();
int smallBet = runner.getConfig().getSmallBet();
=======================================
---
/trunk/ai/experiments/src/main/java/org/cspoker/ai/experiments/RunExperimentB.java
Thu May 13 01:37:32 2010
+++
/trunk/ai/experiments/src/main/java/org/cspoker/ai/experiments/RunExperimentB.java
Mon Jun 14 18:22:02 2010
@@ -30,6 +30,7 @@
import
org.cspoker.ai.bots.bot.gametree.mcts.strategies.selection.SamplingToFunctionSelector;
import
org.cspoker.ai.bots.bot.gametree.mcts.strategies.selection.UCTSelector;
import org.cspoker.ai.bots.bot.gametree.search.expander.sampling.*;
+import org.cspoker.ai.opponentmodels.weka.WekaOptions;
import org.cspoker.ai.opponentmodels.weka.WekaRegressionModelFactory;
import org.cspoker.server.embedded.EmbeddedCSPokerServer;

@@ -38,6 +39,9 @@

public static void main(String[] args) throws IOException,
ClassNotFoundException {

+ WekaOptions config = new WekaOptions();
+ config.setUseOnlineLearning(false);
+
if(args[0].equals("time")){

int time = Integer.parseInt(args[1]);
@@ -46,13 +50,13 @@
int treshold1 = Integer.parseInt(args[3]);

int treshold2 = Integer.parseInt(args[4]);
-
+
new BotRunner(
new EmbeddedCSPokerServer(),
new BotFactory[] {
new MCTSBotFactory(
"Standard Bot",
-
WekaRegressionModelFactory.createForZip("org/cspoker/ai/opponentmodels/weka/models/model1.zip"),
+
WekaRegressionModelFactory.createForZip("org/cspoker/ai/opponentmodels/weka/models/model1.zip",
config),
new SamplingToFunctionSelector(treshold1,new UCTSelector(C)),
new SamplingSelector(),
new MaxValueSelector(),
@@ -63,7 +67,7 @@
),
new MCTSBotFactory(
"MaxDistribution Bot",
-
WekaRegressionModelFactory.createForZip("org/cspoker/client/bots/bot/search/opponentmodel/weka/models/model1.zip"),
+
WekaRegressionModelFactory.createForZip("org/cspoker/client/bots/bot/search/opponentmodel/weka/models/model1.zip",
config),
new SamplingToFunctionSelector(treshold1,new UCTSelector(C)),
new SamplingSelector(),
new MaxValueSelector(),
@@ -96,7 +100,7 @@
new BotFactory[] {
new FixedSampleMCTSBotFactory(
"Standard Bot",
-
WekaRegressionModelFactory.createForZip("org/cspoker/client/bots/bot/search/opponentmodel/weka/models/model1.zip"),
+
WekaRegressionModelFactory.createForZip("org/cspoker/client/bots/bot/search/opponentmodel/weka/models/model1.zip",
config),
new SamplingToFunctionSelector(treshold1,new UCTSelector(C)),
new SamplingSelector(),
new MaxValueSelector(),
@@ -107,7 +111,7 @@
),
new FixedSampleMCTSBotFactory(
"MaxDistribution Bot",
-
WekaRegressionModelFactory.createForZip("org/cspoker/client/bots/bot/search/opponentmodel/weka/models/model1.zip"),
+
WekaRegressionModelFactory.createForZip("org/cspoker/client/bots/bot/search/opponentmodel/weka/models/model1.zip",
config),
new SamplingToFunctionSelector(treshold1,new UCTSelector(C)),
new SamplingSelector(),
new MaxValueSelector(),
=======================================
---
/trunk/ai/experiments/src/main/java/org/cspoker/ai/experiments/RunExperimentC.java
Thu May 13 01:37:32 2010
+++
/trunk/ai/experiments/src/main/java/org/cspoker/ai/experiments/RunExperimentC.java
Mon Jun 14 18:22:02 2010
@@ -31,6 +31,7 @@
import
org.cspoker.ai.bots.bot.gametree.mcts.strategies.selection.UCTPlusSelector;
import
org.cspoker.ai.bots.bot.gametree.mcts.strategies.selection.UCTSelector;
import org.cspoker.ai.bots.bot.gametree.search.expander.sampling.*;
+import org.cspoker.ai.opponentmodels.weka.WekaOptions;
import org.cspoker.ai.opponentmodels.weka.WekaRegressionModelFactory;
import org.cspoker.server.embedded.EmbeddedCSPokerServer;

@@ -39,6 +40,9 @@

public static void main(String[] args) throws IOException,
ClassNotFoundException {

+ WekaOptions config = new WekaOptions();
+ config.setUseOnlineLearning(false);
+
if(args[0].equals("time")){

int time = Integer.parseInt(args[1]);
@@ -54,7 +58,7 @@
new BotFactory[] {
new MCTSBotFactory(
"Standard Bot",
-
WekaRegressionModelFactory.createForZip("org/cspoker/client/bots/bot/search/opponentmodel/weka/models/model1.zip"),
+
WekaRegressionModelFactory.createForZip("org/cspoker/client/bots/bot/search/opponentmodel/weka/models/model1.zip",
config),
new SamplingToFunctionSelector(treshold1,new UCTSelector(C)),
new SamplingSelector(),
new MaxValueSelector(),
@@ -65,7 +69,7 @@
),
new MCTSBotFactory(
"MaxDistribution Bot",
-
WekaRegressionModelFactory.createForZip("org/cspoker/client/bots/bot/search/opponentmodel/weka/models/model1.zip"),
+
WekaRegressionModelFactory.createForZip("org/cspoker/client/bots/bot/search/opponentmodel/weka/models/model1.zip",
config),
new SamplingToFunctionSelector(treshold1,new UCTPlusSelector(C,
C2)),
new SamplingSelector(),
new MaxValueSelector(),
@@ -97,7 +101,7 @@
new BotFactory[] {
new FixedSampleMCTSBotFactory(
"Standard Bot",
-
WekaRegressionModelFactory.createForZip("org/cspoker/client/bots/bot/search/opponentmodel/weka/models/model1.zip"),
+
WekaRegressionModelFactory.createForZip("org/cspoker/client/bots/bot/search/opponentmodel/weka/models/model1.zip",
config),
new SamplingToFunctionSelector(treshold1,new UCTSelector(C)),
new SamplingSelector(),
new MaxValueSelector(),
@@ -108,7 +112,7 @@
),
new FixedSampleMCTSBotFactory(
"MaxDistribution Bot",
-
WekaRegressionModelFactory.createForZip("org/cspoker/client/bots/bot/search/opponentmodel/weka/models/model1.zip"),
+
WekaRegressionModelFactory.createForZip("org/cspoker/client/bots/bot/search/opponentmodel/weka/models/model1.zip",
config),
new SamplingToFunctionSelector(treshold1,new UCTPlusSelector(C,
C2)),
new SamplingSelector(),
new MaxValueSelector(),
=======================================
---
/trunk/ai/experiments/src/main/java/org/cspoker/ai/experiments/RunExperimentD.java
Thu May 13 01:37:32 2010
+++
/trunk/ai/experiments/src/main/java/org/cspoker/ai/experiments/RunExperimentD.java
Mon Jun 14 18:22:02 2010
@@ -31,6 +31,7 @@
import
org.cspoker.ai.bots.bot.gametree.mcts.strategies.selection.UCTPlusSelector;
import
org.cspoker.ai.bots.bot.gametree.mcts.strategies.selection.UCTSelector;
import org.cspoker.ai.bots.bot.gametree.search.expander.sampling.*;
+import org.cspoker.ai.opponentmodels.weka.WekaOptions;
import org.cspoker.ai.opponentmodels.weka.WekaRegressionModelFactory;
import org.cspoker.server.embedded.EmbeddedCSPokerServer;

@@ -38,6 +39,9 @@
public class RunExperimentD {

public static void main(String[] args) throws IOException,
ClassNotFoundException {
+
+ WekaOptions config = new WekaOptions();
+ config.setUseOnlineLearning(false);

if(args[0].equals("time")){

@@ -54,7 +58,7 @@
new BotFactory[] {
new MCTSBotFactory(
"Standard Bot",
-
WekaRegressionModelFactory.createForZip("org/cspoker/client/bots/bot/search/opponentmodel/weka/models/model1.zip"),
+
WekaRegressionModelFactory.createForZip("org/cspoker/client/bots/bot/search/opponentmodel/weka/models/model1.zip",
config),
new SamplingToFunctionSelector(treshold1,new UCTSelector(C)),
new SamplingSelector(),
new MaxValueSelector(),
@@ -69,7 +73,7 @@
),
new MCTSBotFactory(
"MaxDistribution Bot",
-
WekaRegressionModelFactory.createForZip("org/cspoker/client/bots/bot/search/opponentmodel/weka/models/model1.zip"),
+
WekaRegressionModelFactory.createForZip("org/cspoker/client/bots/bot/search/opponentmodel/weka/models/model1.zip",
config),
new SamplingToFunctionSelector(treshold1,new UCTPlusSelector(C,
C2)),
new SamplingSelector(),
new MaxValueSelector(),
@@ -101,7 +105,7 @@
new BotFactory[] {
new FixedSampleMCTSBotFactory(
"Standard Bot",
-
WekaRegressionModelFactory.createForZip("org/cspoker/client/bots/bot/search/opponentmodel/weka/models/model1.zip"),
+
WekaRegressionModelFactory.createForZip("org/cspoker/client/bots/bot/search/opponentmodel/weka/models/model1.zip",
config),
new SamplingToFunctionSelector(treshold1,new UCTSelector(C)),
new SamplingSelector(),
new MaxValueSelector(),
@@ -116,7 +120,7 @@
),
new FixedSampleMCTSBotFactory(
"MaxDistribution Bot",
-
WekaRegressionModelFactory.createForZip("org/cspoker/client/bots/bot/search/opponentmodel/weka/models/model1.zip"),
+
WekaRegressionModelFactory.createForZip("org/cspoker/client/bots/bot/search/opponentmodel/weka/models/model1.zip",
config),
new SamplingToFunctionSelector(treshold1,new UCTPlusSelector(C,
C2)),
new SamplingSelector(),
new MaxValueSelector(),
=======================================
---
/trunk/ai/experiments/src/main/java/org/cspoker/ai/experiments/RunExperimentF.java
Thu May 13 01:37:32 2010
+++
/trunk/ai/experiments/src/main/java/org/cspoker/ai/experiments/RunExperimentF.java
Mon Jun 14 18:22:02 2010
@@ -32,6 +32,7 @@
import org.cspoker.ai.bots.bot.gametree.search.expander.sampling.*;
import org.cspoker.ai.bots.bot.rule.CardBotFactory;
import org.cspoker.ai.bots.bot.rule.HandBotFactory;
+import org.cspoker.ai.opponentmodels.weka.WekaOptions;
import org.cspoker.ai.opponentmodels.weka.WekaRegressionModelFactory;
import org.cspoker.server.embedded.EmbeddedCSPokerServer;

@@ -40,6 +41,9 @@

public static void main(String[] args) throws IOException,
ClassNotFoundException {

+ WekaOptions config = new WekaOptions();
+ config.setUseOnlineLearning(false);
+
if(args[0].equals("time")){

int time = Integer.parseInt(args[1]);
@@ -55,7 +59,7 @@
new HandBotFactory("HandBot"),
new MCTSBotFactory(
"MaxDistribution Bot",
-
WekaRegressionModelFactory.createForZip("org/cspoker/client/bots/bot/search/opponentmodel/weka/models/model1.zip"),
+
WekaRegressionModelFactory.createForZip("org/cspoker/client/bots/bot/search/opponentmodel/weka/models/model1.zip",
config),
new SamplingToFunctionSelector(treshold1,new UCTSelector(C)),
new SamplingSelector(),
new MaxValueSelector(),
@@ -88,7 +92,7 @@
new HandBotFactory("HandBot"),
new FixedSampleMCTSBotFactory(
"MaxDistribution Bot",
-
WekaRegressionModelFactory.createForZip("org/cspoker/client/bots/bot/search/opponentmodel/weka/models/model1.zip"),
+
WekaRegressionModelFactory.createForZip("org/cspoker/client/bots/bot/search/opponentmodel/weka/models/model1.zip",
config),
new SamplingToFunctionSelector(treshold1,new UCTSelector(C)),
new SamplingSelector(),
new MaxValueSelector(),
=======================================
--- /trunk/ai/lore/src/main/java/org/cspoker/ai/lore/Lore.java Thu May 13
01:37:32 2010
+++ /trunk/ai/lore/src/main/java/org/cspoker/ai/lore/Lore.java Mon Jun 14
18:22:02 2010
@@ -35,6 +35,7 @@
import org.cspoker.ai.bots.listener.ProfitInfo;
import org.cspoker.ai.bots.listener.ProfitListener;
import org.cspoker.ai.bots.util.RunningStats;
+import org.cspoker.ai.opponentmodels.weka.WekaOptions;
import org.cspoker.ai.opponentmodels.weka.WekaRegressionModelFactory;
import org.cspoker.client.common.SmartClientContext;
import org.cspoker.client.common.SmartLobbyContext;
@@ -68,12 +69,14 @@
private Bot bot;

public Lore(RemoteCSPokerServer server) throws Exception {
+ WekaOptions config = new WekaOptions();
+ config.setUseOnlineLearning(false);
this.server = server;
this.botFactory =
// new CallBotFactory();
new MCTSBotFactory(
"CSPoker Bot",
-
WekaRegressionModelFactory.createForZip("org/cspoker/ai/opponentmodels/weka/models/model1.zip"),
+
WekaRegressionModelFactory.createForZip("org/cspoker/ai/opponentmodels/weka/models/model1.zip",
config),
new SamplingToFunctionSelector(50,new UCTSelector(2000000)),
new SamplingSelector(),
new MaxValueSelector(),
=======================================
---
/trunk/ai/opponentmodels/prolog/src/main/java/org/cspoker/ai/opponentmodels/prolog/TermListVisitor.java
Fri Aug 14 07:58:03 2009
+++
/trunk/ai/opponentmodels/prolog/src/main/java/org/cspoker/ai/opponentmodels/prolog/TermListVisitor.java
Mon Jun 14 18:22:02 2010
@@ -21,13 +21,8 @@

import jp.ac.kobe_u.cs.prolog.lang.StructureTerm;

-import org.apache.log4j.Logger;
-
public class TermListVisitor extends ToPrologTermVisitor {

- private final static Logger logger = Logger
- .getLogger(TermListVisitor.class);
-
private final List<StructureTerm> terms = new ArrayList<StructureTerm>();

public TermListVisitor() {
=======================================
---
/trunk/ai/opponentmodels/prolog/src/main/java/org/cspoker/ai/opponentmodels/prolog/cafe/PrologCafeModelFactory.java
Fri Aug 14 07:58:03 2009
+++
/trunk/ai/opponentmodels/prolog/src/main/java/org/cspoker/ai/opponentmodels/prolog/cafe/PrologCafeModelFactory.java
Mon Jun 14 18:22:02 2010
@@ -20,12 +20,13 @@
import net.jcip.annotations.ThreadSafe;

import org.cspoker.ai.opponentmodels.OpponentModel;
+import org.cspoker.common.elements.player.PlayerId;

@ThreadSafe
public class PrologCafeModelFactory implements OpponentModel.Factory {

@Override
- public OpponentModel create() {
+ public OpponentModel create(PlayerId actor) {
PrologControl prolog = new PrologControl();
return new PrologCafeModel(prolog);
}
=======================================
---
/trunk/ai/opponentmodels/prolog/src/main/java/org/cspoker/ai/opponentmodels/prolog/redundant/RedundantModelFactory.java
Tue Aug 18 10:58:09 2009
+++
/trunk/ai/opponentmodels/prolog/src/main/java/org/cspoker/ai/opponentmodels/prolog/redundant/RedundantModelFactory.java
Mon Jun 14 18:22:02 2010
@@ -25,6 +25,7 @@
import org.cspoker.ai.opponentmodels.OpponentModel;
import org.cspoker.ai.opponentmodels.prolog.cafe.PrologCafeModel;
import org.cspoker.ai.opponentmodels.prolog.tuprolog.TuPrologModel;
+import org.cspoker.common.elements.player.PlayerId;

import alice.tuprolog.InvalidTheoryException;
import alice.tuprolog.Prolog;
@@ -35,7 +36,7 @@
public class RedundantModelFactory implements OpponentModel.Factory {

@Override
- public OpponentModel create() {
+ public OpponentModel create(PlayerId actor) {
PrologControl prolog = new PrologControl();
PrologCafeModel model1 = new PrologCafeModel(prolog);

=======================================
---
/trunk/ai/opponentmodels/prolog/src/main/java/org/cspoker/ai/opponentmodels/prolog/tuprolog/TuPrologModelFactory.java
Fri Aug 14 07:58:03 2009
+++
/trunk/ai/opponentmodels/prolog/src/main/java/org/cspoker/ai/opponentmodels/prolog/tuprolog/TuPrologModelFactory.java
Mon Jun 14 18:22:02 2010
@@ -21,6 +21,7 @@
import net.jcip.annotations.ThreadSafe;

import org.cspoker.ai.opponentmodels.OpponentModel;
+import org.cspoker.common.elements.player.PlayerId;

import alice.tuprolog.InvalidTheoryException;
import alice.tuprolog.Prolog;
@@ -30,7 +31,7 @@
public class TuPrologModelFactory implements OpponentModel.Factory {

@Override
- public OpponentModel create() {
+ public OpponentModel create(PlayerId actor) {
Prolog engine = new Prolog();
try {
Theory theory1 = new Theory(
=======================================
---
/trunk/ai/opponentmodels/weka/src/main/java/org/cspoker/ai/opponentmodels/weka/ARFFFile.java
Thu May 13 01:37:32 2010
+++
/trunk/ai/opponentmodels/weka/src/main/java/org/cspoker/ai/opponentmodels/weka/ARFFFile.java
Mon Jun 14 18:22:02 2010
@@ -21,80 +21,75 @@
private final String name;

private Writer file;
- private double count;
-
- private boolean modelReady;
+ private long count = 0;
+ private WekaOptions config;

public ARFFFile(String path, Object player, String name, String
attributes,
- boolean overwrite) throws IOException {
+ WekaOptions config) throws IOException {
this.path = path;
this.player = player;
this.name = name;
-
- boolean fileExists = fileExists();
- file = new BufferedWriter(new FileWriter(path + player +
name, !overwrite));
-
- if (overwrite || !fileExists) {
- file.write(attributes);
- file.flush();
- }
-
- count = countDataLines();
- if (count >= WekaOptions.getModelCreationTreshold())
- modelReady = true;
+ this.config = config;
+
+ // TODO: false => !config.arffOverwrite()
+ file = new BufferedWriter(new FileWriter(path + player + name, false));
+ file.write(attributes);
+ file.flush();
}

- private double countDataLines() throws IOException {
- InputStream is = new BufferedInputStream(new FileInputStream(path +
player + name));
- byte[] c = new byte[1024];
- int count = 0;
- int readChars = 0;
- boolean startReading = false;
- while ((readChars = is.read(c)) != -1) {
- for (int i = 0; i < readChars; ++i) {
- if (c[i] == '\n' && startReading)
- ++count;
- else if (!startReading && i >= 4 && c[i - 4] == '@'
- && c[i - 3] == 'd' && c[i - 2] == 'a'
- && c[i - 1] == 't' && c[i] == 'a')
- startReading = true;
- }
- }
- is.close();
- return count + (count > 0 ? -1 : 0);
- }
-
- private boolean fileExists() throws FileNotFoundException {
- return new File(path + player + name).exists();
- }
+// private double countDataLines() {
+// InputStream is;
+// try {
+// is = new BufferedInputStream(new FileInputStream(path + player +
name));
+// byte[] c = new byte[1024];
+// int count = 0;
+// int readChars = 0;
+// boolean startReading = false;
+// while ((readChars = is.read(c)) != -1) {
+// for (int i = 0; i < readChars; ++i) {
+// if (c[i] == '\n' && startReading)
+// ++count;
+// else if (!startReading && i >= 4 && c[i - 4] == '@'
+// && c[i - 3] == 'd' && c[i - 2] == 'a'
+// && c[i - 1] == 't' && c[i] == 'a')
+// startReading = true;
+// }
+// }
+// is.close();
+// return count + (count > 0 ? -1 : 0);
+// } catch (FileNotFoundException e) {
+// e.printStackTrace();
+// } catch (IOException e) {
+// e.printStackTrace();
+// }
+// return 0;
+// }
+//
+// private boolean fileExists() throws FileNotFoundException {
+// return new File(path + player + name).exists();
+// }

public void close() throws IOException {
file.close();
}

public void write(Instance instance) {
+// System.out.println("Writing instance " + (count +1) + " in file " +
player + name);
try {
+ count++;
file.write(instance.toString() + nl);
file.flush();
- count++;
- if (count >= WekaOptions.getModelCreationTreshold())
- modelReady = true;
} catch (IOException e) {
- e.printStackTrace();
throw new IllegalStateException(e);
- } catch (ArrayIndexOutOfBoundsException e) {
- e.printStackTrace();
- throw new IllegalStateException(e);
- }
+ }
}

public boolean isModelReady() {
- return modelReady;
+ return count > config.getMinimalLearnExamples();
}

public Classifier createModel(String fileName, String attribute, String[]
rmAttributes) throws Exception {
- if (!modelReady) throw new IllegalStateException("Model didn't reach
threshold for creation!");
-
+// System.out.println("Creating model for " + player + name);
DataSource source = new DataSource(path + player + name);
Instances data = source.getDataSet();
if (rmAttributes.length > 0) {
@@ -122,7 +117,7 @@
cl.buildClassifier(data);

// save model + header
- if (WekaOptions.isModelPersistency())
+ if (config.modelPersistency())
SerializationHelper.write(path + "../" + player + fileName
+ ".model", cl);

return cl;
=======================================
---
/trunk/ai/opponentmodels/weka/src/main/java/org/cspoker/ai/opponentmodels/weka/ARFFPlayer.java
Thu May 13 01:37:32 2010
+++
/trunk/ai/opponentmodels/weka/src/main/java/org/cspoker/ai/opponentmodels/weka/ARFFPlayer.java
Mon Jun 14 18:22:02 2010
@@ -3,7 +3,6 @@
import java.io.*;

import org.apache.log4j.Logger;
-import org.cspoker.ai.opponentmodels.OpponentModelPool;

import weka.core.Instance;

@@ -21,44 +20,37 @@
private ARFFFile postFoldCallRaiseFile;
private ARFFFile showdownFile;

- private boolean preCheckBetCreated = false;
- private boolean postCheckBetCreated = false;
- private boolean preFoldCallRaiseCreated = false;
- private boolean postFoldCallRaiseCreated = false;
- private boolean showdownCreated = false;
-
private boolean modelCreated = false;

private WekaRegressionModel model = null;
-
- public ARFFPlayer(Object player, WekaRegressionModel baseModel) throws
IOException {
+ private WekaOptions config = new WekaOptions();
+
+ private long writeCounter = 0;
+
+ public ARFFPlayer(Object player, WekaRegressionModel baseModel,
WekaOptions config) {
+ if (!config.useOnlineLearning())
+ throw new IllegalStateException("ARFFPlayer can only be used with
online learning!");
+
this.player = player;
-
- if (OpponentModelPool.getInstance().getModel(player) != null) {
- modelCreated = true;
- preCheckBetCreated = true;
- postCheckBetCreated = true;
- preFoldCallRaiseCreated = true;
- postFoldCallRaiseCreated = true;
- showdownCreated = true;
- }
-
- if (!modelCreated || (modelCreated &&
WekaOptions.isContinueAfterCreation())){
+ this.config = config;
+ this.model = baseModel;
+
+ try {
String path = (getClass().getProtectionDomain().getCodeSource()
- .getLocation().getPath() + folder).replace("%20", " ");
- this.model = new WekaRegressionModel(baseModel);
-
- boolean overwrite = WekaOptions.isArffOverwrite();
+ .getLocation().getPath() + folder).replace("%20", " ");
+
preCheckBetFile = new ARFFFile(path, player, "PreCheckBet.arff",
- ARFFPropositionalizer.getPreCheckBetInstance().toString(), overwrite);
+ ARFFPropositionalizer.getPreCheckBetInstance().toString(), config);
postCheckBetFile = new ARFFFile(path, player, "PostCheckBet.arff",
- ARFFPropositionalizer.getPostCheckBetInstance().toString(),
overwrite);
+ ARFFPropositionalizer.getPostCheckBetInstance().toString(), config);
preFoldCallRaiseFile = new ARFFFile(path,
player, "PreFoldCallRaise.arff",
- ARFFPropositionalizer.getPreFoldCallRaiseInstance().toString(),
overwrite);
+ ARFFPropositionalizer.getPreFoldCallRaiseInstance().toString(),
config);
postFoldCallRaiseFile = new ARFFFile(path,
player, "PostFoldCallRaise.arff",
- ARFFPropositionalizer.getPostFoldCallRaiseInstance().toString(),
overwrite);
+ ARFFPropositionalizer.getPostFoldCallRaiseInstance().toString(),
config);
showdownFile = new ARFFFile(path, player, "Showdown.arff",
- ARFFPropositionalizer.getShowdownInstance().toString(), overwrite);
+ ARFFPropositionalizer.getShowdownInstance().toString(), config);
+ } catch (IOException io) {
+ throw new RuntimeException(io);
}
}

@@ -71,102 +63,167 @@
showdownFile.close();
}
}
+
+ public void learnNewModel() {
+ if (!(preCheckBetFile.isModelReady() && postCheckBetFile.isModelReady()
&& preFoldCallRaiseFile.isModelReady()
+ && postFoldCallRaiseFile.isModelReady() &&
showdownFile.isModelReady()))
+ return;
+ System.out.println("");
+ logger.info("Learning new opponentModel for player " + player);
+ System.out.println("");
+ modelCreated = true;
+
+ // learning preCheckBetModel
+ learnPreCheckBet();
+ // learning postCheckBetModel
+ learnPostCheckBet();
+ // learning preFoldCallRaiseModel
+ learnPreFoldCallRaise();
+ // learning postFoldCallRaiseModel
+ learnPostFoldCallRaise();
+ // learning showdownModel
+ learnShowdown();
+ }
+
+ public boolean writeAllowed() {
+ return config.continuousLearning() || !modelCreated || (modelCreated &&
config.continueAfterCreation());
+ }
+
+ public boolean learningAllowed() {
+ return config.continuousLearning() || (!modelCreated && (writeCounter >=
config.modelCreationTreshold()));
+ }

public void writePreCheckBet(Instance instance) {
- if (preCheckBetCreated && !WekaOptions.isContinueAfterCreation()) return;
- preCheckBetFile.write(instance);
- if (!preCheckBetCreated && preCheckBetFile.isModelReady()) {
- try {
- logger.info("Learning preBetModel for player " + player);
- model.setPreBetModel(preCheckBetFile.createModel("preBet", "betProb",
new String[]{"action"}));
- // add it to pool
- OpponentModelPool.getInstance().addModel(player, model);
- preCheckBetCreated = true;
- } catch (Exception e) {
- e.printStackTrace();
+ if (writeAllowed()) {
+ preCheckBetFile.write(instance);
+ incrementWriteCounter();
+ if (learningAllowed()) {
+ if (config.continuousLearning())
+ learnPreCheckBet();
+ else
+ learnNewModel();
}
}
}
-
+
+ public void learnPreCheckBet() {
+ try {
+ logger.trace("Learning preBetModel for player " + player);
+ model.setPreBetModel(preCheckBetFile.createModel("preBet", "betProb",
new String[]{"action"}));
+ } catch (Exception e) {
+ e.printStackTrace();
+ }
+ }
+
public void writePostCheckBet(Instance instance) {
- if (postCheckBetCreated && !WekaOptions.isContinueAfterCreation())
return;
- postCheckBetFile.write(instance);
- if (!postCheckBetCreated && postCheckBetFile.isModelReady()) {
- try {
- logger.info("Learning postBetModel for player " + player);
-
model.setPostBetModel(postCheckBetFile.createModel("postBet", "betProb",
new String[]{"action"}));
- // add it to pool
- OpponentModelPool.getInstance().addModel(player, model);
- postCheckBetCreated = true;
- } catch (Exception e) {
- e.printStackTrace();
+ if (writeAllowed()) {
+ postCheckBetFile.write(instance);
+ incrementWriteCounter();
+ if (learningAllowed()) {
+ if (config.continuousLearning())
+ learnPostCheckBet();
+ else
+ learnNewModel();
}
}
}
+
+ public void learnPostCheckBet() {
+ try {
+ logger.trace("Learning postBetModel for player " + player);
+
model.setPostBetModel(postCheckBetFile.createModel("postBet", "betProb",
new String[]{"action"}));
+ } catch (Exception e) {
+ e.printStackTrace();
+ }
+ }

public void writePreFoldCallRaise(Instance instance) {
- if (preFoldCallRaiseCreated && !WekaOptions.isContinueAfterCreation())
return;
- preFoldCallRaiseFile.write(instance);
- if (!preFoldCallRaiseCreated && preFoldCallRaiseFile.isModelReady()) {
- try {
- logger.info("Learning preFoldModel for player " + player);
-
model.setPreFoldModel(preFoldCallRaiseFile.createModel("preFold", "foldProb",
new String[]{"callProb", "raiseProb", "action"}));
- logger.info("Learning preCallModel for player " + player);
-
model.setPreCallModel(preFoldCallRaiseFile.createModel("preCall", "callProb",
new String[]{"foldProb", "raiseProb", "action"}));
- logger.info("Learning preRaiseModel for player " + player);
-
model.setPreRaiseModel(preFoldCallRaiseFile.createModel("preRaise", "raiseProb",
new String[]{"callProb", "foldProb", "action"}));
- // add it to pool
- OpponentModelPool.getInstance().addModel(player, model);
- preFoldCallRaiseCreated = true;
- } catch (Exception e) {
- e.printStackTrace();
+ if (writeAllowed()) {
+ preFoldCallRaiseFile.write(instance);
+ incrementWriteCounter();
+ if (learningAllowed()) {
+ if (config.continuousLearning())
+ learnPreFoldCallRaise();
+ else
+ learnNewModel();
}
}
}
+
+ public void learnPreFoldCallRaise() {
+ try {
+ logger.trace("Learning preFoldModel for player " + player);
+
model.setPreFoldModel(preFoldCallRaiseFile.createModel("preFold", "foldProb",
new String[]{"callProb", "raiseProb", "action"}));
+ logger.trace("Learning preCallModel for player " + player);
+
model.setPreCallModel(preFoldCallRaiseFile.createModel("preCall", "callProb",
new String[]{"foldProb", "raiseProb", "action"}));
+ logger.trace("Learning preRaiseModel for player " + player);
+
model.setPreRaiseModel(preFoldCallRaiseFile.createModel("preRaise", "raiseProb",
new String[]{"callProb", "foldProb", "action"}));
+ } catch (Exception e) {
+ e.printStackTrace();
+ }
+ }

public void writePostFoldCallRaise(Instance instance) {
- if (postFoldCallRaiseCreated && !WekaOptions.isContinueAfterCreation())
return;
- postFoldCallRaiseFile.write(instance);
- if (!postFoldCallRaiseCreated && postFoldCallRaiseFile.isModelReady()) {
- try {
- logger.info("Learning postFoldModel for player " + player);
-
model.setPostFoldModel(postFoldCallRaiseFile.createModel("postFold", "foldProb",
new String[]{"callProb", "raiseProb", "action"}));
- logger.info("Learning postCallModel for player " + player);
-
model.setPostCallModel(postFoldCallRaiseFile.createModel("postCall", "callProb",
new String[]{"foldProb", "raiseProb", "action"}));
- logger.info("Learning postRaiseModel for player " + player);
-
model.setPostRaiseModel(postFoldCallRaiseFile.createModel("postRaise", "raiseProb",
new String[]{"callProb", "foldProb", "action"}));
- // add it to pool
- OpponentModelPool.getInstance().addModel(player, model);
- postFoldCallRaiseCreated = true;
- } catch (Exception e) {
- e.printStackTrace();
+ if (writeAllowed()) {
+ postFoldCallRaiseFile.write(instance);
+ incrementWriteCounter();
+ if (learningAllowed()) {
+ if (config.continuousLearning())
+ learnPostFoldCallRaise();
+ else
+ learnNewModel();
}
}
}
+
+ public void learnPostFoldCallRaise() {
+ try {
+ logger.trace("Learning postFoldModel for player " + player);
+
model.setPostFoldModel(postFoldCallRaiseFile.createModel("postFold", "foldProb",
new String[]{"callProb", "raiseProb", "action"}));
+ logger.trace("Learning postCallModel for player " + player);
+
model.setPostCallModel(postFoldCallRaiseFile.createModel("postCall", "callProb",
new String[]{"foldProb", "raiseProb", "action"}));
+ logger.trace("Learning postRaiseModel for player " + player);
+
model.setPostRaiseModel(postFoldCallRaiseFile.createModel("postRaise", "raiseProb",
new String[]{"callProb", "foldProb", "action"}));
+ } catch (Exception e) {
+ e.printStackTrace();
+ }
+
+ }

public void writeShowdown(Instance instance) {
- if (showdownCreated && !WekaOptions.isContinueAfterCreation()) return;
- showdownFile.write(instance);
- if (!showdownCreated && showdownFile.isModelReady()) {
- try {
- logger.info("Learning showdown0Model for player " + player);
-
model.setShowdown0Model(showdownFile.createModel("showdown0", "part0Prob",
new
String[]{"part1Prob", "part2Prob", "part3Prob", "part4Prob", "part5Prob", "avgPartition"}));
- logger.info("Learning showdown1Model for player " + player);
-
model.setShowdown1Model(showdownFile.createModel("showdown1", "part1Prob",
new
String[]{"part0Prob", "part2Prob", "part3Prob", "part4Prob", "part5Prob", "avgPartition"}));
- logger.info("Learning showdown2Model for player " + player);
-
model.setShowdown2Model(showdownFile.createModel("showdown5", "part2Prob",
new
String[]{"part0Prob", "part1Prob", "part3Prob", "part4Prob", "part5Prob", "avgPartition"}));
- logger.info("Learning showdown3Model for player " + player);
-
model.setShowdown3Model(showdownFile.createModel("showdown3", "part3Prob",
new
String[]{"part0Prob", "part1Prob", "part2Prob", "part4Prob", "part5Prob", "avgPartition"}));
- logger.info("Learning showdown4Model for player " + player);
-
model.setShowdown4Model(showdownFile.createModel("showdown4", "part4Prob",
new
String[]{"part0Prob", "part1Prob", "part2Prob", "part3Prob", "part5Prob", "avgPartition"}));
- logger.info("Learning showdown5Model for player " + player);
-
model.setShowdown5Model(showdownFile.createModel("showdown5", "part5Prob",
new
String[]{"part0Prob", "part1Prob", "part2Prob", "part3Prob", "part4Prob", "avgPartition"}));
- // add it to pool
- OpponentModelPool.getInstance().addModel(player, model);
- showdownCreated = true;
- } catch (Exception e) {
- e.printStackTrace();
+ if (writeAllowed()) {
+ showdownFile.write(instance);
+ incrementWriteCounter();
+ if (learningAllowed()) {
+ if (config.continuousLearning())
+ learnShowdown();
+ else
+ learnNewModel();
}
}
}
-}
+
+ public void learnShowdown() {
+ try {
+ logger.trace("Learning showdown0Model for player " + player);
+
model.setShowdown0Model(showdownFile.createModel("showdown0", "part0Prob",
new
String[]{"part1Prob", "part2Prob", "part3Prob", "part4Prob", "part5Prob", "avgPartition"}));
+ logger.trace("Learning showdown1Model for player " + player);
+
model.setShowdown1Model(showdownFile.createModel("showdown1", "part1Prob",
new
String[]{"part0Prob", "part2Prob", "part3Prob", "part4Prob", "part5Prob", "avgPartition"}));
+ logger.trace("Learning showdown2Model for player " + player);
+
model.setShowdown2Model(showdownFile.createModel("showdown5", "part2Prob",
new
String[]{"part0Prob", "part1Prob", "part3Prob", "part4Prob", "part5Prob", "avgPartition"}));
+ logger.trace("Learning showdown3Model for player " + player);
+
model.setShowdown3Model(showdownFile.createModel("showdown3", "part3Prob",
new
String[]{"part0Prob", "part1Prob", "part2Prob", "part4Prob", "part5Prob", "avgPartition"}));
+ logger.trace("Learning showdown4Model for player " + player);
+
model.setShowdown4Model(showdownFile.createModel("showdown4", "part4Prob",
new
String[]{"part0Prob", "part1Prob", "part2Prob", "part3Prob", "part5Prob", "avgPartition"}));
+ logger.trace("Learning showdown5Model for player " + player);
+
model.setShowdown5Model(showdownFile.createModel("showdown5", "part5Prob",
new
String[]{"part0Prob", "part1Prob", "part2Prob", "part3Prob", "part4Prob", "avgPartition"}));
+ } catch (Exception e) {
+ e.printStackTrace();
+ }
+ }
+
+ private void incrementWriteCounter() {
+ writeCounter++;
+// System.out.println("=" + writeCounter + "=");
+ }
+}
=======================================
---
/trunk/ai/opponentmodels/weka/src/main/java/org/cspoker/ai/opponentmodels/weka/ARFFPropositionalizer.java
Thu May 13 01:37:32 2010
+++
/trunk/ai/opponentmodels/weka/src/main/java/org/cspoker/ai/opponentmodels/weka/ARFFPropositionalizer.java
Mon Jun 14 18:22:02 2010
@@ -3,46 +3,46 @@
import java.io.IOException;
import java.util.HashMap;

-//import org.apache.log4j.Logger;
import org.cspoker.ai.opponentmodels.weka.instances.InstancesBuilder;
import org.cspoker.ai.opponentmodels.weka.instances.PostCheckBetInstances;
import
org.cspoker.ai.opponentmodels.weka.instances.PostFoldCallRaiseInstances;
import org.cspoker.ai.opponentmodels.weka.instances.PreCheckBetInstances;
import
org.cspoker.ai.opponentmodels.weka.instances.PreFoldCallRaiseInstances;
import org.cspoker.ai.opponentmodels.weka.instances.ShowdownInstances;
-import org.cspoker.common.elements.cards.Card;
-
+import org.cspoker.common.elements.player.PlayerId;
+
+/**
+ * This ARFFPropositionalizer will be called on important GameEvents.
+ * It manages the {@link ARFFPlayer}-instances for each villain, creates
+ * classified Weka-Instances and delegates to the corresponding {@link
ARFFPlayer}
+ *
+ */
public class ARFFPropositionalizer extends Propositionalizer {

// private final static Logger logger =
Logger.getLogger(ARFFPropositionalizer.class);

- private static final String nl = InstancesBuilder.nl;
- private static HashMap<Object, ARFFPlayer> arffFiles = new
HashMap<Object, ARFFPlayer>();
-
- private final HashMap<String, Card> cards = new HashMap<String, Card>();
-
+ private static final String nl = InstancesBuilder.nl;
+
+ private HashMap<Object, ARFFPlayer> arffFiles = new HashMap<Object,
ARFFPlayer>();
+
+
private final PreCheckBetInstances preCheckBetInstance;
private final PostCheckBetInstances postCheckBetInstance;
private final PreFoldCallRaiseInstances preFoldCallRaiseInstance;
private final PostFoldCallRaiseInstances postFoldCallRaiseInstance;
private final ShowdownInstances showdownInstance;

- private boolean newDeal = false;
- private final WekaRegressionModel baseModel;
-
- public ARFFPropositionalizer(WekaRegressionModel baseModel) throws
IOException {
- this.baseModel = baseModel;
+ private final PlayerId bot;
+
+ public ARFFPropositionalizer(PlayerId bot) throws IOException {
this.preCheckBetInstance = getPreCheckBetInstance();
this.postCheckBetInstance = getPostCheckBetInstance();
this.preFoldCallRaiseInstance = getPreFoldCallRaiseInstance();
this.postFoldCallRaiseInstance = getPostFoldCallRaiseInstance();
this.showdownInstance = getShowdownInstance();
-
- for(Card c:Card.values()){
- cards.put(c.getShortDescription(), c);
- }
- }
-
+ this.bot = bot;
+ }
+
public static PreCheckBetInstances getPreCheckBetInstance() {
return new PreCheckBetInstances("PreCheckBet",
"@attribute betProb real" + nl
@@ -85,28 +85,21 @@
if (arffFiles.containsKey(actorId))
return arffFiles.get(actorId);
else {
- try {
- ARFFPlayer f = new ARFFPlayer(actorId, baseModel);
- arffFiles.put(actorId, f);
- return f;
- } catch (IOException e) {
- e.printStackTrace();
- }
- }
- return null;
+ throw new IllegalStateException("no arff-player for " + actorId + "
registered yet");
+ }
}

- public void setNewDeal(boolean deal) {
- newDeal = deal;
- }
-
- public boolean isNewDeal() {
- return newDeal;
- }
-
+ public void addPlayer(Object actorID, ARFFPlayer arffPlayer) {
+ if (arffFiles.containsKey(actorID)) {
+ throw new IllegalStateException("arffPlayer for actor " + actorID + "
registered twice");
+ } else {
+ arffFiles.put(actorID, arffPlayer);
+ }
+ }
+
@Override
protected void logFold(Object actorId) {
- if (!newDeal) return;
+ if (actorId.equals(bot)) return;
if (getRound().equals("preflop")) {
getARFF(actorId).writePreFoldCallRaise(
preFoldCallRaiseInstance.getClassifiedInstance(this,
@@ -121,7 +114,7 @@

@Override
protected void logCall(Object actorId) {
- if (!newDeal) return;
+ if (actorId.equals(bot)) return;
if (getRound().equals("preflop")) {
getARFF(actorId).writePreFoldCallRaise(
preFoldCallRaiseInstance.getClassifiedInstance(this,
@@ -135,7 +128,7 @@

@Override
protected void logRaise(Object actorId, double raiseAmount) {
- if (!newDeal) return;
+ if (actorId.equals(bot)) return;
if (getRound().equals("preflop")) {
getARFF(actorId).writePreFoldCallRaise(
preFoldCallRaiseInstance.getClassifiedInstance(this,
@@ -149,7 +142,7 @@

@Override
protected void logCheck(Object actorId) {
- if (!newDeal) return;
+ if (actorId.equals(bot)) return;
if (getRound().equals("preflop")) {
getARFF(actorId).writePreCheckBet(
preCheckBetInstance.getClassifiedInstance(this, actorId,
@@ -163,7 +156,7 @@

@Override
protected void logBet(Object actorId, double raiseAmount) {
- if (!newDeal) return;
+ if (actorId.equals(bot)) return;
if (getRound().equals("preflop")) {
getARFF(actorId).writePreCheckBet(
preCheckBetInstance.getClassifiedInstance(this, actorId,
@@ -177,7 +170,7 @@

@Override
protected void logShowdown(Object actorId, double[] partitionDistr) {
- if (!newDeal) return;
+ if (actorId.equals(bot)) return;
Object[] targets = new Object[partitionDistr.length + 1];
double avgBucket = 0;
for (int i = 0; i < partitionDistr.length; i++) {
=======================================
---
/trunk/ai/opponentmodels/weka/src/main/java/org/cspoker/ai/opponentmodels/weka/ActionTrackingVisitor.java
Thu May 13 01:37:32 2010
+++
/trunk/ai/opponentmodels/weka/src/main/java/org/cspoker/ai/opponentmodels/weka/ActionTrackingVisitor.java
Mon Jun 14 18:22:02 2010
@@ -25,63 +25,71 @@
import org.cspoker.client.common.gamestate.modifiers.WinnerState;
import org.cspoker.client.common.playerstate.PlayerState;
import org.cspoker.common.elements.cards.Card;
+import org.cspoker.common.elements.player.PlayerId;
import org.cspoker.common.elements.table.Round;

+import org.cspoker.ai.opponentmodels.weka.ARFFPropositionalizer;
+import org.cspoker.ai.opponentmodels.weka.PlayerTrackingVisitor;
+
+
+/**
+ * The ActionTrackingVisitor currently is used to observe the game
+ * and delegate important states to an {@link ARFFPropositionalizer}<br>
+ * <br>
+ * TODO: this classes extend {@link PlayerTrackingVisitor} though I think
it doesn't
+ * really uses much of its functions (anymore). We should directly
+ * implement GameVisitor ?
+ *
+ */
public class ActionTrackingVisitor extends PlayerTrackingVisitor {
-
+
private final static Logger logger =
Logger.getLogger(ARFFPropositionalizer.class);
-
- public ActionTrackingVisitor(WekaRegressionModel baseModel) {
+
+ public ActionTrackingVisitor(PlayerId bot) {
try {
- this.propz = new ARFFPropositionalizer(baseModel);
+ this.propz = new ARFFPropositionalizer(bot);
} catch (IOException e) {
e.printStackTrace();
}
}
-
+
public ARFFPropositionalizer getPropz() {
return (ARFFPropositionalizer) this.propz;
}
-
- @Override
- public void setPropz(Propositionalizer propz) {
- this.propz = propz;
- getPropz().setNewDeal(false);
- }
-
+
@Override
public void visitAllInState(AllInState allInState) {
- if(getPropz().isNewDeal()) logger.trace("(" +
allInState.getPlayer(allInState.getNextToAct()).getName() + ")
AllInState: " + allInState.getRound());
+ logger.trace("(" +
allInState.getPlayer(allInState.getNextToAct()).getName() + ")
AllInState: " + allInState.getRound());
propz.signalAllIn(allInState.getEvent().getPlayerId(),
allInState.getEvent().getMovedAmount());
}

@Override
public void visitBetState(BetState betState) {
- if(getPropz().isNewDeal()) logger.trace("(" +
betState.getPlayer(betState.getNextToAct()).getName() + ") BetState: " +
betState.getEvent().getAmount());
+ logger.trace("(" + betState.getPlayer(betState.getNextToAct()).getName()
+ ") BetState: " + betState.getEvent().getAmount());
propz.signalBet(false, betState.getEvent().getPlayerId(),
betState.getEvent().getAmount());
}

@Override
public void visitCallState(CallState callState) {
- if(getPropz().isNewDeal()) logger.trace("(" +
callState.getPlayer(callState.getNextToAct()).getName() + ") CallState");
+ logger.trace("(" +
callState.getPlayer(callState.getNextToAct()).getName() + ") CallState");
propz.signalCall(false, callState.getEvent().getPlayerId());
}

@Override
public void visitCheckState(CheckState checkState) {
- if(getPropz().isNewDeal()) logger.trace("(" +
checkState.getPlayer(checkState.getNextToAct()).getName() + ") CheckState");
+ logger.trace("(" +
checkState.getPlayer(checkState.getNextToAct()).getName() + ") CheckState");
propz.signalCheck(checkState.getEvent().getPlayerId());
}

@Override
public void visitFoldState(FoldState foldState) {
- if(getPropz().isNewDeal()) logger.trace("(" +
foldState.getPlayer(foldState.getNextToAct()).getName() + ") FoldState");
+ logger.trace("(" +
foldState.getPlayer(foldState.getNextToAct()).getName() + ") FoldState");
propz.signalFold(foldState.getEvent().getPlayerId());
}

@Override
public void visitInitialGameState(DetailedHoldemTableState
initialGameState) {
-
+
}

@Override
@@ -95,24 +103,19 @@
}

@Override
- public void visitNewCommunityCardsState(
- NewCommunityCardsState newCommunityCardsState) {
- if(getPropz().isNewDeal()) {
- logger.trace("NewCommunityCardsState: " +
newCommunityCardsState.getRound() + " ");
- for(Card c : newCommunityCardsState.getCommunityCards())
- logger.trace(" ("+ c +")");
- }
+ public void visitNewCommunityCardsState(NewCommunityCardsState
newCommunityCardsState) {
+ logger.trace("NewCommunityCardsState: " +
newCommunityCardsState.getRound() + " ");
+
+ logger.trace(" " + newCommunityCardsState.getCommunityCards());
propz.signalCommunityCards(newCommunityCardsState.getCommunityCards());
}

@Override
public void visitNewDealState(NewDealState newDealState) {
logger.trace("(" +
newDealState.getPlayer(newDealState.getDealer()).getName() + ")
NewDealState");
-// setPropz(ARFFPropositionalizerFactory.getPropz(player))
- getPropz().setNewDeal(true);
propz.signalBBAmount(newDealState.getTableConfiguration().getBigBlind());
propz.signalNewGame();
- for(PlayerState player: newDealState.getAllSeatedPlayers()){
+ for (PlayerState player : newDealState.getAllSeatedPlayers()) {
propz.signalSeatedPlayer(player.getStack(), player.getPlayerId());
}
}
@@ -124,12 +127,12 @@

@Override
public void visitNewRoundState(NewRoundState newRoundState) {
- if(getPropz().isNewDeal()) logger.trace("NewRoundState: " +
newRoundState.getRound());
- if(newRoundState.getRound()==Round.FLOP){
+ logger.trace("NewRoundState: " + newRoundState.getRound());
+ if (newRoundState.getRound() == Round.FLOP) {
propz.signalFlop();
- }else if(newRoundState.getRound()==Round.TURN){
+ } else if (newRoundState.getRound() == Round.TURN) {
propz.signalTurn();
- }else if(newRoundState.getRound()==Round.FINAL){
+ } else if (newRoundState.getRound() == Round.FINAL) {
propz.signalRiver();
}
}
@@ -141,7 +144,7 @@

@Override
public void visitRaiseState(RaiseState raiseState) {
- if(getPropz().isNewDeal()) logger.trace("(" +
raiseState.getPlayer(raiseState.getNextToAct()).getName() + ")
RaiseState: " + raiseState.getLargestBet());
+ logger.trace("(" +
raiseState.getPlayer(raiseState.getNextToAct()).getName() + ")
RaiseState: " + raiseState.getLargestBet());
propz.signalRaise(false, raiseState.getLastEvent().getPlayerId(),
raiseState.getLargestBet());
}

@@ -150,7 +153,7 @@
Card[] cardset = new Card[]{};
cardset = showHandState.getLastEvent().getShowdownPlayer()
.getHandCards().toArray(cardset);
- if(getPropz().isNewDeal()) logger.trace("("
+ logger.trace("("
+ showHandState.getPlayer(
showHandState.getLastEvent().getShowdownPlayer()
.getPlayerId()).getName() + ") ShowHandState: "
@@ -170,13 +173,13 @@

@Override
public void visitBlindState(BlindState blindState) {
- if(getPropz().isNewDeal()) logger.trace("(" +
blindState.getPlayer(blindState.getLastEvent().getPlayerId()).getName()
+ ") BlindState: " + blindState.getRound());
+ logger.trace("(" +
blindState.getPlayer(blindState.getLastEvent().getPlayerId()).getName()
+ ") BlindState: " + blindState.getRound());
propz.signalBlind(false, blindState.getLastEvent().getPlayerId(),
blindState.getLastEvent().getAmount());
}

@Override
public void visitWinnerState(WinnerState winnerState) {
- if(getPropz().isNewDeal()) logger.trace("(" +
winnerState.getLastEvent().getWinners().toArray()[0] + ") WinnerState: " +
winnerState.getRound());
+ logger.trace("(" + winnerState.getLastEvent().getWinners().toArray()[0]
+ ") WinnerState: " + winnerState.getRound());
}

@Override
=======================================
---
/trunk/ai/opponentmodels/weka/src/main/java/org/cspoker/ai/opponentmodels/weka/WekaModel.java
Thu May 13 01:37:32 2010
+++
/trunk/ai/opponentmodels/weka/src/main/java/org/cspoker/ai/opponentmodels/weka/WekaModel.java
Mon Jun 14 18:22:02 2010
@@ -15,94 +15,61 @@
*/
package org.cspoker.ai.opponentmodels.weka;

-import java.util.ArrayDeque;
-import java.util.Deque;
-
import org.apache.log4j.Logger;
-import org.cspoker.ai.opponentmodels.OpponentModel;
import org.cspoker.ai.opponentmodels.weka.instances.InstancesBuilder;
import org.cspoker.ai.opponentmodels.weka.instances.PostCheckBetInstances;
import
org.cspoker.ai.opponentmodels.weka.instances.PostFoldCallRaiseInstances;
import org.cspoker.ai.opponentmodels.weka.instances.PreCheckBetInstances;
import
org.cspoker.ai.opponentmodels.weka.instances.PreFoldCallRaiseInstances;
import org.cspoker.ai.opponentmodels.weka.instances.ShowdownInstances;
-import org.cspoker.client.common.gamestate.GameState;
import org.cspoker.common.elements.player.PlayerId;

+import org.cspoker.ai.opponentmodels.weka.Propositionalizer;
+import org.cspoker.ai.opponentmodels.weka.WekaRegressionModel;
+
import weka.core.Instance;

-public abstract class WekaModel implements OpponentModel{
+public abstract class WekaModel {

protected static final Logger logger =
Logger.getLogger(WekaRegressionModel.class);
-
- protected PlayerTrackingVisitor visitor;
- private final Deque<PlayerTrackingVisitor> visitors = new
ArrayDeque<PlayerTrackingVisitor>();
-
+
private final PostCheckBetInstances postCheckBetInstance;
private final PreCheckBetInstances preCheckBetInstance;
private final PreFoldCallRaiseInstances preFoldCallRaiseInstance;
private final PostFoldCallRaiseInstances postFoldCallRaiseInstance;
private final ShowdownInstances showdownInstance;
-
+
public WekaModel() {
- this.visitor = new PlayerTrackingVisitor();
-
- this.preCheckBetInstance = new
PreCheckBetInstances("PreCheckBet", "@attribute prob
real"+InstancesBuilder.nl);
- this.postCheckBetInstance = new
PostCheckBetInstances("PostCheckBet", "@attribute prob
real"+InstancesBuilder.nl);
- this.preFoldCallRaiseInstance = new
PreFoldCallRaiseInstances("PreFoldCallRaise", "@attribute prob
real"+InstancesBuilder.nl);
- this.postFoldCallRaiseInstance = new
PostFoldCallRaiseInstances("PostFoldCallRaise", "@attribute prob
real"+InstancesBuilder.nl);
- this.showdownInstance = new ShowdownInstances("Showdown", "@attribute
prob real"+InstancesBuilder.nl);
+ this.preCheckBetInstance = new
PreCheckBetInstances("PreCheckBet", "@attribute prob real" +
InstancesBuilder.nl);
+ this.postCheckBetInstance = new
PostCheckBetInstances("PostCheckBet", "@attribute prob real" +
InstancesBuilder.nl);
+ this.preFoldCallRaiseInstance = new
PreFoldCallRaiseInstances("PreFoldCallRaise", "@attribute prob real" +
InstancesBuilder.nl);
+ this.postFoldCallRaiseInstance = new
PostFoldCallRaiseInstances("PostFoldCallRaise", "@attribute prob real" +
InstancesBuilder.nl);
+ this.showdownInstance = new ShowdownInstances("Showdown", "@attribute
prob real" + InstancesBuilder.nl);
}

-// public long getVisitorSize() {
-// System.out.print("<" + visitors.size() + ">");
-// return visitors.size();
-// }
-
- @Override
- public void assumePermanently(GameState gameState) {
- visitor.readHistory(gameState);
- }
-
- @Override
- public void assumeTemporarily(GameState gameState) {
- PlayerTrackingVisitor root = getTopVisitor();
- PlayerTrackingVisitor clonedTopVisitor = root.clone();
- clonedTopVisitor.readHistory(gameState);
- visitors.push(clonedTopVisitor);
+ // public long getVisitorSize() {
+ // System.out.print("<" + visitors.size() + ">");
+ // return visitors.size();
+ // }
+
+ protected Instance getPreCheckBetInstance(PlayerId actor,
Propositionalizer props) {
+ return preCheckBetInstance.getUnclassifiedInstance(props, actor);
}

- @Override
- public void forgetLastAssumption() {
- if(!visitors.isEmpty())
- visitors.pop();
+ protected Instance getPostCheckBetInstance(PlayerId actor,
Propositionalizer props) {
+ return postCheckBetInstance.getUnclassifiedInstance(props, actor);
}

- protected PlayerTrackingVisitor getTopVisitor() {
- if(visitors.isEmpty()){
- return visitor;
- }
- return visitors.peek();
- }
-
- protected Instance getPreCheckBetInstance(PlayerId actor) {
- return
preCheckBetInstance.getUnclassifiedInstance(getTopVisitor().getPropz(),
actor);
+ protected Instance getPostFoldCallRaiseInstance(PlayerId actor,
Propositionalizer props) {
+ return postFoldCallRaiseInstance.getUnclassifiedInstance(props, actor);
}

- protected Instance getPostCheckBetInstance(PlayerId actor) {
- return
postCheckBetInstance.getUnclassifiedInstance(getTopVisitor().getPropz(),
actor);
+ protected Instance getPreFoldCallRaiseInstance(PlayerId actor,
Propositionalizer props) {
+ return preFoldCallRaiseInstance.getUnclassifiedInstance(props, actor);
}

- protected Instance getPostFoldCallRaiseInstance(PlayerId actor) {
- return
postFoldCallRaiseInstance.getUnclassifiedInstance(getTopVisitor().getPropz(),
actor);
- }
-
- protected Instance getPreFoldCallRaiseInstance(PlayerId actor) {
- return
preFoldCallRaiseInstance.getUnclassifiedInstance(getTopVisitor().getPropz(),
actor);
- }
-
- protected Instance getShowdownInstance(PlayerId actor) {
- return
showdownInstance.getUnclassifiedInstance(getTopVisitor().getPropz(), actor);
+ protected Instance getShowdownInstance(PlayerId actor, Propositionalizer
props) {
+ return showdownInstance.getUnclassifiedInstance(props, actor);
}

}
=======================================
---
/trunk/ai/opponentmodels/weka/src/main/java/org/cspoker/ai/opponentmodels/weka/WekaOptions.java
Thu May 13 01:37:32 2010
+++
/trunk/ai/opponentmodels/weka/src/main/java/org/cspoker/ai/opponentmodels/weka/WekaOptions.java
Mon Jun 14 18:22:02 2010
@@ -2,49 +2,99 @@

public class WekaOptions {

- private static boolean arffPersistency = true;
- private static boolean arffOverwrite = true;
- private static long modelCreationTreshold = 500;
- private static boolean continueAfterCreation = false;
- private static boolean modelPersistency = true;
-
- public static boolean isArffPersistency() {
- return arffPersistency;
+ private boolean useOnlineLearning = true;
+ private boolean continuousLearning = true; // if false, we need a
treshold value => modelCreationTreshold
+
+ /** if continuousLearning is false, a new model will be learned
+ * after X actions by an opponent, where X is modelCreationTreshold */
+ private long modelCreationTreshold = 500;
+ private long minimalLearnExamples = 1;
+
+ /** continuousLearning must be true for using solveConceptDrift */
+ private boolean solveConceptDrift = true; //
+ /** if solveConceptDrift is false, a new model must be learned at
intervals
+ * based on the number of reported actions */
+ private long learningInterval = 1;
+
+ // TODO: keep files of previous online learning
+ private boolean arffOverwrite = true;
+ /** only available when continuousLearning if false */
+ private boolean continueAfterCreation = true;
+
+ private boolean modelPersistency = true;
+
+ public boolean useOnlineLearning() {
+ return useOnlineLearning;
}

- public static void setArffPersistency(boolean arffPersistency) {
- WekaOptions.arffPersistency = arffPersistency;
+ public void setUseOnlineLearning(boolean useOnlineLearning) {
+ this.useOnlineLearning = useOnlineLearning;
}

- public static boolean isArffOverwrite() {
- return arffOverwrite;
+ public boolean continuousLearning() {
+ return continuousLearning;
}

- public static void setArffOverwrite(boolean arffOverwrite) {
- WekaOptions.arffOverwrite = arffOverwrite;
+ public void setContinuousLearning(boolean continuousLearning) {
+ this.continuousLearning = continuousLearning;
}

- public static long getModelCreationTreshold() {
+ public long modelCreationTreshold() {
return modelCreationTreshold;
}

- public static void setModelCreationTreshold(long modelCreationTreshold) {
- WekaOptions.modelCreationTreshold = modelCreationTreshold;
+ public void setModelCreationTreshold(long modelCreationTreshold) {
+ this.modelCreationTreshold = modelCreationTreshold;
}

- public static boolean isContinueAfterCreation() {
+ public long getMinimalLearnExamples() {
+ return minimalLearnExamples;
+ }
+
+ public void setMinimalLearnExamples(long minimalLearnExamples) {
+ this.minimalLearnExamples = minimalLearnExamples;
+ }
+
+ public boolean solveConceptDrift() {
+ return solveConceptDrift;
+ }
+
+ public void setSolveConceptDrift(boolean solveConceptDrift) {
+ if (!continuousLearning && solveConceptDrift)
+ throw new IllegalStateException("Cannot use concept drift solver
without continuous learning!");
+ this.solveConceptDrift = solveConceptDrift;
+ }
+
+
+ public long getLearningInterval() {
+ return learningInterval;
+ }
+
+ public void setLearningInterval(long learningInterval) {
+ this.learningInterval = learningInterval;
+ }
+
+ public boolean arffOverwrite() {
+ return arffOverwrite;
+ }
+
+ public void setArffOverwrite(boolean arffOverwrite) {
+ this.arffOverwrite = arffOverwrite;
+ }
+
+ public boolean continueAfterCreation() {
return continueAfterCreation;
}

- public static void setContinueAfterCreation(boolean
continueAfterCreation) {
- WekaOptions.continueAfterCreation = continueAfterCreation;
+ public void setContinueAfterCreation(boolean continueAfterCreation) {
+ this.continueAfterCreation = continueAfterCreation;
}

- public static boolean isModelPersistency() {
+ public boolean modelPersistency() {
return modelPersistency;
}

- public static void setModelPersistency(boolean modelPersistency) {
- WekaOptions.modelPersistency = modelPersistency;
- }
-}
+ public void setModelPersistency(boolean modelPersistency) {
+ this.modelPersistency = modelPersistency;
+ }
+}
=======================================
---
/trunk/ai/opponentmodels/weka/src/main/java/org/cspoker/ai/opponentmodels/weka/WekaRegressionModel.java
Thu May 13 01:37:32 2010
+++
/trunk/ai/opponentmodels/weka/src/main/java/org/cspoker/ai/opponentmodels/weka/WekaRegressionModel.java
Mon Jun 14 18:22:02 2010
@@ -15,12 +15,14 @@
*/
package org.cspoker.ai.opponentmodels.weka;

-import org.cspoker.client.common.gamestate.GameState;
import org.cspoker.common.elements.player.PlayerId;
-import org.cspoker.common.elements.table.Round;
import org.cspoker.common.util.Pair;
import org.cspoker.common.util.Triple;

+import org.cspoker.ai.opponentmodels.weka.Propositionalizer;
+import org.cspoker.ai.opponentmodels.weka.WekaModel;
+import org.cspoker.ai.opponentmodels.weka.WekaRegressionModel;
+
import weka.classifiers.Classifier;
import weka.core.Instance;

@@ -41,11 +43,9 @@
protected Classifier showdown4Model;
protected Classifier showdown5Model;

- public WekaRegressionModel(
- Classifier preBetModel, Classifier preFoldModel, Classifier
preCallModel, Classifier preRaiseModel,
- Classifier postBetModel, Classifier postFoldModel, Classifier
postCallModel, Classifier postRaiseModel,
- Classifier showdown0Model, Classifier showdown1Model, Classifier
showdown2Model, Classifier showdown3Model,
- Classifier showdown4Model, Classifier showdown5Model) {
+ public WekaRegressionModel(Classifier preBetModel, Classifier
preFoldModel, Classifier preCallModel, Classifier preRaiseModel, Classifier
postBetModel,
+ Classifier postFoldModel, Classifier postCallModel, Classifier
postRaiseModel, Classifier showdown0Model, Classifier showdown1Model,
+ Classifier showdown2Model, Classifier showdown3Model, Classifier
showdown4Model, Classifier showdown5Model) {
this.preBetModel = preBetModel;
this.preFoldModel = preFoldModel;
this.preCallModel = preCallModel;
@@ -60,10 +60,8 @@
this.showdown3Model = showdown3Model;
this.showdown4Model = showdown4Model;
this.showdown5Model = showdown5Model;
- if (WekaOptions.isArffPersistency())
- this.visitor = new ActionTrackingVisitor(this);
- }
-
+ }
+
public WekaRegressionModel(WekaRegressionModel model) {
this.preBetModel = model.preBetModel;
this.preFoldModel = model.preFoldModel;
@@ -80,17 +78,17 @@
this.showdown4Model = model.showdown4Model;
this.showdown5Model = model.showdown5Model;
}
-
+
@Override
public String toString() {
String str = "";
- str += "preBetModel " + preBetModel.toString().length(); // (preBetModel
== null?"NULL":"OK");
- str += "\npreFoldModel " + preFoldModel.toString().length(); //
(preFoldModel == null?"NULL":"OK");
- str += "\npreCallModel " + preCallModel.toString().length(); //
(preCallModel == null?"NULL":"OK");
- str += "\npreRaiseModel " + preRaiseModel.toString().length(); //
(preRaiseModel == null?"NULL":"OK");
- str += "\npostBetModel " + postBetModel.toString().length(); //
(postBetModel == null?"NULL":"OK");
- str += "\npostFoldModel " + postFoldModel.toString().length(); //
(postFoldModel == null?"NULL":"OK");
- str += "\npostCallModel " + postCallModel.toString().length(); //
(postCallModel == null?"NULL":"OK");
+ str += "preBetModel " + preBetModel.toString(); // (preBetModel ==
null?"NULL":"OK");
+ str += "\npreFoldModel " + preFoldModel.toString(); // (preFoldModel ==
null?"NULL":"OK");
+ str += "\npreCallModel " + preCallModel.toString(); // (preCallModel ==
null?"NULL":"OK");
+ str += "\npreRaiseModel " + preRaiseModel.toString(); // (preRaiseModel
== null?"NULL":"OK");
+ str += "\npostBetModel " + postBetModel.toString(); // (postBetModel ==
null?"NULL":"OK");
+ str += "\npostFoldModel " + postFoldModel.toString(); // (postFoldModel
== null?"NULL":"OK");
+ str += "\npostCallModel " + postCallModel.toString(); // (postCallModel
== null?"NULL":"OK");
str += "\npostRaiseModel " + postRaiseModel.toString().length(); //
(postRaiseModel == null?"NULL":"OK");
str += "\nshowdown0Model " + showdown0Model.toString().length(); //
(showdown0Model == null?"NULL":"OK");
str += "\nshowdown1Model " + showdown1Model.toString().length(); //
(showdown1Model == null?"NULL":"OK");
@@ -100,97 +98,101 @@
str += "\nshowdown5Model " + showdown5Model.toString().length(); //
(showdown5Model == null?"NULL":"OK");
return str;
}
-
- @Override
- public Pair<Double, Double> getCheckBetProbabilities(GameState gameState,
- PlayerId actor) {
+
+ public Pair<Double, Double> getCheckBetProbabilities(PlayerId actor,
Propositionalizer props) {
Instance instance;
- if(Round.PREFLOP.equals(gameState.getRound())){
- instance = getPreCheckBetInstance(actor);
- }else{
- instance = getPostCheckBetInstance(actor);
+ if ("preflop".equals(props.getRound())) {
+ instance = getPreCheckBetInstance(actor, props);
+ } else {
+ instance = getPostCheckBetInstance(actor, props);
}
try {
double prediction;
- if(Round.PREFLOP.equals(gameState.getRound())){
- if (preBetModel == null) System.out.println(this);
+ if ("preflop".equals(props.getRound())) {
+ if (preBetModel == null)
+ System.out.println(this);
prediction = preBetModel.classifyInstance(instance);
- }else{
- if (postBetModel == null) System.out.println(this);
+ } else {
+ if (postBetModel == null)
+ System.out.println(this);
prediction = postBetModel.classifyInstance(instance);
}
- double prob = Math.min(1,Math.max(0, prediction));
-
- if(Double.isNaN(prob) || Double.isInfinite(prob)){
- throw new IllegalStateException("Bad probability: "+prob);
- }
- Pair<Double, Double> result = new Pair<Double, Double>(1-prob,prob);
- if(logger.isTraceEnabled()){
- logger.trace(instance+": "+result);
+ double prob = Math.min(1, Math.max(0, prediction));
+
+ if (Double.isNaN(prob) || Double.isInfinite(prob)) {
+ throw new IllegalStateException("Bad probability: " + prob);
+ }
+ Pair<Double, Double> result = new Pair<Double, Double>(1 - prob, prob);
+ if (logger.isTraceEnabled()) {
+ logger.trace(instance + ": " + result);
}
return result;
} catch (Exception e) {
- throw new IllegalStateException(e.toString() + "\n" + actor + " " +
gameState.getRound() + ": " + instance.toString(), e);
+ throw new IllegalStateException(e.toString() + "\n" + actor + " " +
props.getRound() + ": " + instance.toString(), e);
}
}

- @Override
- public Triple<Double, Double, Double> getFoldCallRaiseProbabilities(
- GameState gameState, PlayerId actor) {
+ public Triple<Double, Double, Double>
getFoldCallRaiseProbabilities(PlayerId actor, Propositionalizer props) {
Instance instance;
- boolean preshowdown = Round.PREFLOP.equals(gameState.getRound());
- if(preshowdown){
- instance = getPreFoldCallRaiseInstance(actor);
- }else{
- instance = getPostFoldCallRaiseInstance(actor);
+ boolean preflop = "preflop".equals(props.getRound());
+ if (preflop) {
+ instance = getPreFoldCallRaiseInstance(actor, props);
+ } else {
+ instance = getPostFoldCallRaiseInstance(actor, props);
}
try {
double probFold;
- if(preshowdown){
- if (preFoldModel == null) System.out.println(this);
+ if (preflop) {
+ if (preFoldModel == null)
+ System.out.println(this);
probFold = preFoldModel.classifyInstance(instance);
- }else{
- if (postFoldModel == null) System.out.println(this);
+ } else {
+ if (postFoldModel == null)
+ System.out.println(this);
probFold = postFoldModel.classifyInstance(instance);
}
- probFold = Math.min(1,Math.max(0, probFold));
+ probFold = Math.min(1, Math.max(0, probFold));

double probCall;
- if(preshowdown){
- if (preCallModel == null) System.out.println(this);
+ if (preflop) {
+ if (preCallModel == null)
+ System.out.println(this);
probCall = preCallModel.classifyInstance(instance);
- }else{
- if (postCallModel == null) System.out.println(this);
+ } else {
+ if (postCallModel == null)
+ System.out.println(this);
probCall = postCallModel.classifyInstance(instance);
}
- probCall = Math.min(1,Math.max(0, probCall));
+ probCall = Math.min(1, Math.max(0, probCall));

double probRaise;
- if(preshowdown){
- if (preRaiseModel == null) System.out.println(this);
+ if (preflop) {
+ if (preRaiseModel == null)
+ System.out.println(this);
probRaise = preRaiseModel.classifyInstance(instance);
- }else{
- if (postRaiseModel == null) System.out.println(this);
+ } else {
+ if (postRaiseModel == null)
+ System.out.println(this);
probRaise = postRaiseModel.classifyInstance(instance);
}
- probRaise = Math.min(1,Math.max(0, probRaise));
+ probRaise = Math.min(1, Math.max(0, probRaise));

double sum = probFold + probCall + probRaise;
- if(Double.isNaN(sum) || sum==0 || Double.isInfinite(sum)){
- throw new IllegalStateException("Bad probabilities: "+probFold+"
(probFold), "+probCall+" (probCall), "+probRaise+" (probRaise)");
- }
- Triple<Double, Double, Double> result = new Triple<Double, Double,
Double>(probFold/sum,probCall/sum,probRaise/sum);
- if(logger.isTraceEnabled()){
- logger.trace(instance+": "+result);
+ if (Double.isNaN(sum) || sum == 0 || Double.isInfinite(sum)) {
+ throw new IllegalStateException("Bad probabilities: " + probFold + "
(probFold), " + probCall + " (probCall), " + probRaise + " (probRaise)");
+ }
+ Triple<Double, Double, Double> result = new Triple<Double, Double,
Double>(probFold / sum, probCall / sum, probRaise / sum);
+ if (logger.isTraceEnabled()) {
+ logger.trace(instance + ": " + result);
}
return result;
} catch (Exception e) {
- throw new IllegalStateException(e.toString() + "\n" + actor + " " +
gameState.getRound() + ": " + instance.toString(), e);
+ throw new IllegalStateException(e.toString() + "\n" + actor + " " +
props.getRound() + ": " + instance.toString(), e);
}
}

- public double[] getShowdownProbabilities(GameState gameState, PlayerId
actor) {
- Instance instance = getShowdownInstance(actor);
+ public double[] getShowdownProbabilities(PlayerId actor,
Propositionalizer props) {
+ Instance instance = getShowdownInstance(actor, props);
try {
double[] prob = {
Math.min(1,Math.max(0, showdown0Model.classifyInstance(instance))),
@@ -200,8 +202,8 @@
Math.min(1,Math.max(0, showdown4Model.classifyInstance(instance))),
Math.min(1,Math.max(0, showdown5Model.classifyInstance(instance))),
};
- if(logger.isTraceEnabled()){
- logger.trace(instance+": "+prob);
+ if (logger.isTraceEnabled()) {
+ logger.trace(instance + ": " + prob);
}
return prob;
} catch (Exception e) {
=======================================
---
/trunk/ai/opponentmodels/weka/src/main/java/org/cspoker/ai/opponentmodels/weka/WekaRegressionModelFactory.java
Thu May 13 01:37:32 2010
+++
/trunk/ai/opponentmodels/weka/src/main/java/org/cspoker/ai/opponentmodels/weka/WekaRegressionModelFactory.java
Mon Jun 14 18:22:02 2010
@@ -28,13 +28,21 @@

import org.apache.log4j.Logger;
import org.cspoker.ai.opponentmodels.OpponentModel;
+import org.cspoker.ai.opponentmodels.listener.OpponentModelListener;
+
+import org.cspoker.ai.opponentmodels.weka.WekaLearningModel;
+import org.cspoker.ai.opponentmodels.weka.WekaRegressionModel;
+import org.cspoker.common.elements.player.PlayerId;

import weka.classifiers.Classifier;

@ThreadSafe
public class WekaRegressionModelFactory implements OpponentModel.Factory {

- public static WekaRegressionModelFactory createForZip(String zippedModel)
throws IOException, ClassNotFoundException {
+ private OpponentModelListener[] listeners = {};
+ private WekaOptions config;
+
+ public static WekaRegressionModelFactory createForZip(String zippedModel,
WekaOptions config, OpponentModelListener... listeners) throws IOException,
ClassNotFoundException {
ZipInputStream zis = null;
ClassLoader classLoader =
WekaRegressionModelFactory.class.getClassLoader();

@@ -54,14 +62,14 @@
zis.close();
fis.close();

- return new WekaRegressionModelFactory(classifiers.get("preBet.model"),
classifiers.get("preFold.model"), classifiers.get("preCall.model"),
classifiers.get("preRaise.model"), classifiers.get("postBet.model"),
classifiers.get("postFold.model"), classifiers.get("postCall.model"),
classifiers.get("postRaise.model"),
+ return new WekaRegressionModelFactory(config, listeners,
classifiers.get("preBet.model"), classifiers.get("preFold.model"),
classifiers.get("preCall.model"), classifiers.get("preRaise.model"),
classifiers.get("postBet.model"), classifiers.get("postFold.model"),
classifiers.get("postCall.model"), classifiers.get("postRaise.model"),
classifiers.get("showdown0.model"),
classifiers.get("showdown1.model"), classifiers.get("showdown2.model"),
classifiers.get("showdown3.model"), classifiers.get("showdown4.model"),
classifiers.get("showdown5.model"));
}

private final static Logger logger = Logger
.getLogger(WekaRegressionModelFactory.class);

- public static WekaRegressionModelFactory createForDir(String models)
throws IOException, ClassNotFoundException {
+ public static WekaRegressionModelFactory createForDir(String models,
WekaOptions config, OpponentModelListener... listeners) throws IOException,
ClassNotFoundException {
Classifier preBetModel, preFoldModel, preCallModel, preRaiseModel,
postBetModel, postFoldModel, postCallModel, postRaiseModel,
showdown0Model, showdown1Model, showdown2Model, showdown3Model,
showdown4Model, showdown5Model;
ClassLoader classLoader =
WekaRegressionModelFactory.class.getClassLoader();
@@ -107,15 +115,16 @@
in = new
ObjectInputStream(classLoader.getResourceAsStream(models+"showdown5.model"));
showdown5Model = (Classifier)in.readObject();
in.close();
- return new WekaRegressionModelFactory(preBetModel, preFoldModel,
preCallModel, preRaiseModel, postBetModel, postFoldModel, postCallModel,
postRaiseModel,
+ return new WekaRegressionModelFactory(config, listeners, preBetModel,
preFoldModel, preCallModel, preRaiseModel, postBetModel, postFoldModel,
postCallModel, postRaiseModel,
showdown0Model, showdown1Model, showdown2Model, showdown3Model,
showdown4Model, showdown5Model);
}
-
- public WekaRegressionModelFactory(
+
+ public WekaRegressionModelFactory(WekaOptions config,
OpponentModelListener[] listeners,
Classifier preBetModel, Classifier preFoldModel, Classifier
preCallModel, Classifier preRaiseModel,
Classifier postBetModel, Classifier postFoldModel, Classifier
postCallModel, Classifier postRaiseModel,
Classifier showdown0Model, Classifier showdown1Model, Classifier
showdown2Model, Classifier showdown3Model,
Classifier showdown4Model, Classifier showdown5Model) {
+ this.listeners = listeners;
this.preBetModel = preBetModel;
this.preFoldModel = preFoldModel;
this.preCallModel = preCallModel;
@@ -130,6 +139,7 @@
this.showdown3Model = showdown3Model;
this.showdown4Model = showdown4Model;
this.showdown5Model = showdown5Model;
+ this.config = config;
}

private final Classifier preBetModel, preFoldModel, preCallModel,
preRaiseModel, postBetModel, postFoldModel, postCallModel, postRaiseModel,
@@ -137,9 +147,9 @@

@Override
- public OpponentModel create() {
- return new WekaRegressionModel(preBetModel, preFoldModel, preCallModel,
preRaiseModel, postBetModel, postFoldModel, postCallModel, postRaiseModel,
- showdown0Model, showdown1Model, showdown2Model, showdown3Model,
showdown4Model, showdown5Model);
+ public OpponentModel create(PlayerId bot) {
+ return new WekaLearningModel(bot, new WekaRegressionModel(preBetModel,
preFoldModel, preCallModel, preRaiseModel, postBetModel, postFoldModel,
postCallModel, postRaiseModel,
+ showdown0Model, showdown1Model, showdown2Model, showdown3Model,
showdown4Model, showdown5Model), config, listeners);
}

@Override
=======================================
---
/trunk/ai/opponentmodels/weka/src/main/java/org/cspoker/ai/opponentmodels/weka/instances/PreFoldCallRaiseInstances.java
Mon Mar 15 05:15:17 2010
+++
/trunk/ai/opponentmodels/weka/src/main/java/org/cspoker/ai/opponentmodels/weka/instances/PreFoldCallRaiseInstances.java
Mon Jun 14 18:22:02 2010
@@ -74,7 +74,7 @@
public Instance getUnclassifiedInstance(Propositionalizer prop, Object
actor) {
PlayerData p = prop.getPlayers().get(actor);
Instance instance = new Instance(length);
-
+ if (p==null) p = new PlayerData(actor);
instance.setDataset(dataset);

instance.setValue(0, prop.getRoundCompletion());