public void Test_Merge()
{
IChanceAbstraction[] chanceAbstractions = new IChanceAbstraction[]
{
new LeducHeChanceAbstraction(LeducHeChanceAbstraction.FractionalResult),
new LeducHeChanceAbstraction(LeducHeChanceAbstraction.FractionalResult)
};
CtMcGen.Tree tree1 = CtMcGen.Generate(_leducHeGd, chanceAbstractions, false, 10000, 333, null);
CtMcGen.Tree tree2 = CtMcGen.Generate(_leducHeGd, chanceAbstractions, false, 10000, 333, null);
UInt64 expSamplesCount = tree1.SamplesCount + tree2.SamplesCount;
string fileName = Path.Combine(_outDir, "ctmcgen-tree2.dat");
tree2.Write(fileName);
tree1.Read(fileName);
Assert.AreEqual(expSamplesCount, tree1.SamplesCount);
ChanceTree ct1 = tree1.ConvertToChanceTree();
ChanceTree ct2 = tree2.ConvertToChanceTree();
// Compare two chance trees, they must be exactly the same.
CompareChanceTrees cmp = new CompareChanceTrees();
cmp.Compare(ct1, ct2);
Assert.AreEqual(0, cmp.SumProbabDiff);
for (int p = 0; p < chanceAbstractions.Length; ++p)
{
Assert.AreEqual(0, cmp.SumPotShareDiff[p]);
}
}
static int Main(string[] args)
{
if (!Parser.ParseArgumentsWithUsage(args, _cmdLine))
{
return(1);
}
if (_cmdLine.DebuggerLaunch)
{
Debugger.Launch();
}
foreach (string propsFile in _cmdLine.PropsFiles)
{
Console.WriteLine("Input file: {0}", propsFile);
IChanceAbstraction ca = ChanceAbstractionHelper.CreateFromPropsFile(propsFile);
if (_cmdLine.PreflopRanges)
{
AnalyzeHeChanceAbstraction.PrintPreflopRanges(ca);
}
ShowHands(ca);
Console.WriteLine();
}
return(0);
}
public void Test_ReadWrite()
{
IChanceAbstraction[] chanceAbstractions = new IChanceAbstraction[]
{
new LeducHeChanceAbstraction(LeducHeChanceAbstraction.FractionalResult),
new LeducHeChanceAbstraction(LeducHeChanceAbstraction.FractionalResult)
};
CtMcGen.Tree tree1 = CtMcGen.Generate(_leducHeGd, chanceAbstractions, false, 10000, (int)DateTime.Now.Ticks, null);
ChanceTree ct1 = tree1.ConvertToChanceTree();
string fileName = Path.Combine(_outDir, "ctmcgen-tree.dat");
tree1.Write(fileName);
CtMcGen.Tree tree2 = new CtMcGen.Tree();
tree2.Read(fileName);
// Compare public data
Assert.AreEqual(tree1.CalculateLeavesCount(), tree2.CalculateLeavesCount());
Assert.AreEqual(tree1.SamplesCount, tree2.SamplesCount);
Assert.AreEqual(tree1.Version, tree2.Version);
ChanceTree ct2 = tree2.ConvertToChanceTree();
// Compare two chance trees, they must be exactly the same.
CompareChanceTrees cmp = new CompareChanceTrees();
cmp.Compare(ct1, ct2);
Assert.AreEqual(0, cmp.SumProbabDiff);
for (int p = 0; p < chanceAbstractions.Length; ++p)
{
Assert.AreEqual(0, cmp.SumPotShareDiff[p]);
}
}
public static IChanceAbstraction[] CreateFromPropsFiles(string[] fileNames)
{
IChanceAbstraction[] result = new IChanceAbstraction[fileNames.Length];
for (int i = 0; i < result.Length; ++i)
{
result[i] = CreateFromPropsFile(fileNames[i]);
}
return(result);
}
public TestParams(FictitiousPlayMc_Test test, string gameDefFile,
IChanceAbstraction chanceAbstr, int [] cardCount, double epsilon)
{
Epsilon = epsilon;
GameDef = XmlSerializerExt.Deserialize <GameDefinition>(Props.Global.Expand("${bds.DataDir}ai.pkr.metastrategy/${0}", gameDefFile));
Name = chanceAbstr.Name;
ChanceAbstraction = chanceAbstr;
ActionTree = CreateActionTreeByGameDef.Create(GameDef);
Debug.Assert(GameDef.MinPlayers == 2);
ChanceTree = CreateChanceTreeByAbstraction.CreateS(GameDef, new IChanceAbstraction[] { chanceAbstr, chanceAbstr });
CardCount = cardCount;
}
public void Test_Leduc__FullGame_FractionalResult()
{
IChanceAbstraction[] chanceAbstractions = new IChanceAbstraction[]
{
new LeducHeChanceAbstraction(LeducHeChanceAbstraction.FullGame),
new LeducHeChanceAbstraction(LeducHeChanceAbstraction.FractionalResult)
};
// Typical situation - many runs
GenerateAndVerifyCT("fgfr", _leducHeGd, chanceAbstractions, false, 100000, 10, 0.01, 0, 0.01, true);
// Do one run only
GenerateAndVerifyCT("fgfr", _leducHeGd, chanceAbstractions, false, 1000000, 1, 0.01, 0, 0.01, true);
// Extreme case - very short runs (skip read/write).
GenerateAndVerifyCT("fgfr", _leducHeGd, chanceAbstractions, false, 10, 10000, 0.05, 0, 0.05, true);
}
static int Main(string[] args)
{
if (!Parser.ParseArgumentsWithUsage(args, _cmdLine))
{
return(1);
}
if (_cmdLine.DebuggerLaunch)
{
Debugger.Launch();
}
Props caProps = XmlSerializerExt.Deserialize <Props>(_cmdLine.ChanceAbstractionFile);
caProps.Set("IsCreatingClusterTree", "true");
IChanceAbstraction ca = ChanceAbstractionHelper.CreateFromProps(caProps);
Console.WriteLine("CA: {0}", ca.Name);
List <int> samplesCount = new List <int>();
foreach (string sc in _cmdLine.SamplesCount.Split(new char[] { ',' }, StringSplitOptions.RemoveEmptyEntries))
{
samplesCount.Add(int.Parse(sc));
}
int rngSeed = _cmdLine.RngSeed == 0 ? (int)DateTime.Now.Ticks : _cmdLine.RngSeed;
Console.WriteLine("RNG seed: {0}", rngSeed);
CaMcGen gen = new CaMcGen
{
Clusterizer = (IClusterizer)ca,
IsVerbose = true,
// IsVerboseSamples = true,
RngSeed = rngSeed,
SamplesCount = samplesCount.ToArray()
};
ClusterTree rt = new ClusterTree();
rt.Root = gen.Generate();
string dir = Path.GetDirectoryName(_cmdLine.ChanceAbstractionFile);
string file = Path.GetFileNameWithoutExtension(_cmdLine.ChanceAbstractionFile) + ".dat";
string fileName = Path.Combine(dir, file);
Console.WriteLine("Writing range tree to {0}", fileName);
rt.Write(fileName);
return(0);
}
public void Benchmark_Generate()
{
IChanceAbstraction[] chanceAbstractions = new IChanceAbstraction[]
{
new LeducHeChanceAbstraction(LeducHeChanceAbstraction.FullGame),
new LeducHeChanceAbstraction(LeducHeChanceAbstraction.FullGame)
};
int repCount = 5000000;
DateTime startTime = DateTime.Now;
CtMcGen.Generate(_leducHeGd, chanceAbstractions, false, repCount, 1, null);
double time = (DateTime.Now - startTime).TotalSeconds;
Console.WriteLine("Repetitions: {0:0,0}, time: {1:0.0} s, {2:0,0} r/s", repCount, time, repCount / time);
}
private static void ShowHands(IChanceAbstraction ca)
{
if (_cmdLine.Hands == null)
{
return;
}
foreach (string handS in _cmdLine.Hands)
{
handS.Trim();
if (handS.Length % 2 != 0)
{
Console.WriteLine("Wrong HE hand: {0}", handS);
continue;
}
string cards = "";
for (int i = 0; i < handS.Length; i += 2)
{
cards += handS.Substring(i, 2) + " ";
}
int[] hand = null;
try
{
hand = StdDeck.Descriptor.GetIndexes(cards);
}
catch (Exception e)
{
Console.WriteLine("Wrong HE hand: {0}, {1}", cards, e.ToString());
continue;
}
int round = HeHelper.HandSizeToRound[hand.Length];
if (round == -1)
{
Console.WriteLine("Wrong HE hand size: {0}", handS);
continue;
}
Console.Write("Abstract cards for hand {0}:", StdDeck.Descriptor.GetCardNames(hand));
for (int r = 0; r <= round; ++r)
{
int abstrCard = ca.GetAbstractCard(hand, HeHelper.RoundToHandSize[r]);
Console.Write(" {0}", abstrCard);
}
Console.WriteLine();
}
}
public static IChanceAbstraction CreateFromProps(Props props)
{
ClassFactoryParams cfp = new ClassFactoryParams
{
TypeName = props.Get("TypeName"),
AssemblyFile = props.Get("AssemblyFileName"),
Arguments = new object[] { props }
};
if (string.IsNullOrEmpty(cfp.TypeName))
{
throw new ApplicationException("Missing required property 'TypeName'");
}
IChanceAbstraction ca = ClassFactory.CreateInstance <IChanceAbstraction>(cfp);
return(ca);
}
/// <summary>
/// Creates files for each chance abstraction based on the template file.
/// Tries to reuse the same chance abstration if buckets strings are the same
/// to test Patience in this mode.
/// </summary>
/// <param name="runDir"></param>
/// <param name="bucketizerStrings"></param>
/// <returns></returns>
private IChanceAbstraction[] PrepareConfigsAndChanceAbstractions(string runDir, string[] bucketizerStrings)
{
string botPropsFile = Path.Combine(runDir, "props.xml");
Props botProps = XmlSerializerExt.Deserialize <Props>(botPropsFile);
IChanceAbstraction[] chanceAbstractions = new IChanceAbstraction[bucketizerStrings.Length];
string caPropsTemplateFile = Path.Combine(runDir, "chance-abstraction-props-template.xml");
for (int p = 0; p < bucketizerStrings.Length; ++p)
{
for (int p1 = 0; p1 < p; ++p1)
{
// Try to reuse the same chance abstraction.
if (bucketizerStrings[p1] == bucketizerStrings[p])
{
botProps.Set(string.Format("ChanceAbstraction-{0}", p),
string.Format("chance-abstraction-props-{0}.xml", p1));
botProps.Set(string.Format("Strategy-{0}", p), string.Format("strategy-{0}.dat", p1));
chanceAbstractions[p] = chanceAbstractions[p1];
goto next;
}
}
Props caProps = XmlSerializerExt.Deserialize <Props>(caPropsTemplateFile);
caProps.Set("BucketsString", bucketizerStrings[p]);
botProps.Set(string.Format("ChanceAbstraction-{0}", p),
string.Format("chance-abstraction-props-{0}.xml", p));
string caPropsFileRel = string.Format("chance-abstraction-props-{0}.xml", p);
string caPropsFileAbs = Path.Combine(runDir, caPropsFileRel);
XmlSerializerExt.Serialize(caProps, caPropsFileAbs);
botProps.Set(string.Format("ChanceAbstraction-{0}", p), caPropsFileRel);
botProps.Set(string.Format("Strategy-{0}", p), string.Format("strategy-{0}.dat", p));
chanceAbstractions[p] = ChanceAbstractionHelper.CreateFromProps(caProps);
next :;
}
XmlSerializerExt.Serialize(botProps, botPropsFile);
File.Delete(caPropsTemplateFile);
return(chanceAbstractions);
}
public static void PrintPreflopRanges(IChanceAbstraction ca)
{
List <HePocketKind>[] abstrRanges = new List <HePocketKind> [0];
int[] abstrRangesSizes = new int[0];
for (int p = 0; p < (int)HePocketKind.__Count; ++p)
{
HePocketKind kind = (HePocketKind)p;
CardSet pocketCS = HePocket.KindToCardSet(kind);
int [] pocketArr = StdDeck.Descriptor.GetIndexesAscending(pocketCS).ToArray();
int abstrCard = ca.GetAbstractCard(pocketArr, pocketArr.Length);
if (abstrCard >= abstrRanges.Length)
{
Array.Resize(ref abstrRanges, abstrCard + 1);
Array.Resize(ref abstrRangesSizes, abstrCard + 1);
}
if (abstrRanges[abstrCard] == null)
{
abstrRanges[abstrCard] = new List <HePocketKind>();
}
abstrRanges[abstrCard].Add(kind);
abstrRangesSizes[abstrCard] += HePocket.KindToRange(kind).Length;
}
Console.WriteLine("Preflop ranges of CA: {0}", ca.Name);
int total = 0;
for (int i = abstrRanges.Length - 1; i >= 0; --i)
{
Console.Write("{0,2} ({1,4}):", i, abstrRangesSizes[i]);
foreach (HePocketKind k in abstrRanges[i])
{
Console.Write(" {0}", HePocket.KindToString(k));
}
Console.WriteLine();
total += abstrRangesSizes[i];
}
Console.WriteLine("Total: {0}", total);
}
public TestParams(Breb_Test test, string gameDefFile,
IChanceAbstraction chanceAbstr, double epsilon)
{
Epsilon = epsilon;
GameDef = XmlSerializerExt.Deserialize <GameDefinition>(Props.Global.Expand("${bds.DataDir}ai.pkr.metastrategy/${0}", gameDefFile));
Name = chanceAbstr == null ? GameDef.Name : chanceAbstr.Name;
ChanceAbstraction = chanceAbstr;
ActionTree = CreateActionTreeByGameDef.Create(GameDef);
Debug.Assert(GameDef.MinPlayers == 2);
if (chanceAbstr == null)
{
ChanceTree = CreateChanceTreeByGameDef.Create(GameDef);
}
else
{
ChanceTree = CreateChanceTreeByAbstraction.CreateS(GameDef,
new IChanceAbstraction[]
{ chanceAbstr, chanceAbstr });
}
}
public void Test_Kuhn()
{
GameDefinition gd = XmlSerializerExt.Deserialize <GameDefinition>(
Props.Global.Expand("${bds.DataDir}ai.pkr.metastrategy/kuhn.gamedef.xml"));
IChanceAbstraction[] abstractions = new IChanceAbstraction [] { new KuhnChanceAbstraction(), new KuhnChanceAbstraction() };
ChanceTree ct = CreateChanceTreeByGameDef.Create(gd);
ChanceTree act = CreateChanceTreeByAbstraction.CreateS(gd, abstractions);
VerifyChanceTree.VerifyS(act);
VisChanceTree.Show(act, Path.Combine(_outDir, gd.Name + "-abct.gv"));
UInt16[] activePlayersOne = ActivePlayers.Get(gd.MinPlayers, 1, 1);
UInt16[] activePlayersAll = ActivePlayers.Get(gd.MinPlayers, 1, gd.MinPlayers);
int maxDepth = gd.RoundsCount * gd.MinPlayers;
Assert.AreEqual(act.PlayersCount, gd.MinPlayers);
Assert.AreEqual(ct.NodesCount, act.NodesCount);
double[] expPotShares = new double[gd.MinPlayers];
double[] actPotShares = new double[gd.MinPlayers];
for (int i = 0; i < ct.NodesCount; ++i)
{
Assert.AreEqual(ct.Nodes[i].Position, act.Nodes[i].Position);
Assert.AreEqual(ct.Nodes[i].Card, act.Nodes[i].Card); // Kuhn abstraction has the same card
Assert.AreEqual(ct.Nodes[i].Probab, act.Nodes[i].Probab);
if (i == 0)
{
continue;
}
UInt16[] activePlayers = ct.GetDepth(i) == maxDepth ? activePlayersAll : activePlayersOne;
foreach (UInt16 ap in activePlayers)
{
ct.Nodes[i].GetPotShare(ap, expPotShares);
act.Nodes[i].GetPotShare(ap, actPotShares);
Assert.AreEqual(expPotShares, actPotShares, String.Format("Node: {0}, ap: {1}", i, ap));
}
}
}
static int Main(string[] args)
{
if (!Parser.ParseArgumentsWithUsage(args, _cmdLine))
{
return(1);
}
if (_cmdLine.DebuggerLaunch)
{
Debugger.Launch();
}
GameDefinition gd = XmlSerializerExt.Deserialize <GameDefinition>(_cmdLine.GameDef.Get(Props.Global));
if (gd.MinPlayers != _cmdLine.ChanceAbstractionFiles.Length)
{
Console.WriteLine("Number of chance abstractions ({0}) does not match to the minimal number of players in game definition ({1})",
_cmdLine.ChanceAbstractionFiles.Length, gd.MinPlayers);
return(1);
}
IChanceAbstraction[] chanceAbstractions = new IChanceAbstraction[_cmdLine.ChanceAbstractionFiles.Length];
bool areAbstractionsEqual = true;
string fileName0 = _cmdLine.ChanceAbstractionFiles[0].Get().ToUpperInvariant();
for (int p = 0; p < chanceAbstractions.Length; ++p)
{
string fileName = _cmdLine.ChanceAbstractionFiles[p];
if (fileName.ToUpperInvariant() != fileName0)
{
areAbstractionsEqual = false;
}
chanceAbstractions[p] = ChanceAbstractionHelper.CreateFromPropsFile(fileName);
Console.WriteLine("CA pos {0}: {1}", p, chanceAbstractions[p].Name);
}
Console.WriteLine("Abstractions are {0}.", areAbstractionsEqual ? "equal" : "unequal");
Console.Write("Samples: {0:#,#}. ", _cmdLine.SamplesCount);
if (_cmdLine.RunsCount > 0)
{
Console.Write("Runs: {0:#,#}", _cmdLine.RunsCount);
}
else
{
Console.WriteLine("Runs: unlimited");
Console.Write("Press 'q' to quit asap, 'f' to finish run.");
}
Console.WriteLine();
for (int run = 0; ;)
{
int rngSeed = (int)DateTime.Now.Ticks;
Console.Write("Run:{0}, seed:{1}. ", run, rngSeed);
DateTime startTime = DateTime.Now;
CtMcGen.Tree tree = CtMcGen.Generate(gd, chanceAbstractions, areAbstractionsEqual, _cmdLine.SamplesCount, rngSeed, Feedback);
double genTime = (DateTime.Now - startTime).TotalSeconds;
string fileName = SaveFile(tree, gd, chanceAbstractions);
Int64 samplesDone = (Int64)tree.SamplesCount;
Console.WriteLine("Samples: {0:#,#}, time: {1:0.0} s, {2:#,#} sm/s, file: {3}",
samplesDone,
genTime,
samplesDone / genTime,
fileName);
++run;
if (_cmdLine.RunsCount > 0)
{
if (run >= _cmdLine.RunsCount)
{
break;
}
}
else
{
ProcessKeys();
if (_quitAsap || _finishRun)
{
Console.WriteLine("Exiting on user request");
break;
}
}
}
return(0);
}
void Initialize()
{
_playerInfoProps = new Props();
string strDir = _creationParams.Get("StrategyDir");
_playerInfoProps.Set("StrategyDir", strDir);
string propsFile = Path.Combine(strDir, "props.xml");
Props props = XmlSerializerExt.Deserialize <Props>(propsFile);
int rngSeed = int.Parse(_creationParams.GetDefault("RngSeed", "0"));
if (rngSeed == 0)
{
rngSeed = (int)DateTime.Now.Ticks;
}
_checkBlinds = bool.Parse(_creationParams.GetDefault("CheckBlinds", "true"));
string amountCompareMethodText = _creationParams.GetDefault("AmountSearchMethod", "Equal");
if (amountCompareMethodText == "Equal")
{
_amountSearchMethod = AmountSearchMethod.Equal;
}
else if (amountCompareMethodText == "Closest")
{
_amountSearchMethod = AmountSearchMethod.Closest;
}
else
{
throw new ApplicationException(string.Format("Unknown amount compare method {0}", amountCompareMethodText));
}
_relProbabIgnoreLevel = double.Parse(_creationParams.GetDefault("RelProbabIgnoreLevel", "0.0"), CultureInfo.InvariantCulture);
_playerInfoProps.Set("RelProbabIgnoreLevel", _relProbabIgnoreLevel.ToString());
// Use MersenneTwister because it is under our control on all platforms and
// is probably better than System.Random.
Random underlyingRng = new MersenneTwister(rngSeed);
_moveSelector = new DiscreteProbabilityRng(underlyingRng);
_playerInfoProps.Set("RngSeed", rngSeed.ToString());
_deckDescr = XmlSerializerExt.Deserialize <DeckDescriptor>(props.Get("DeckDescriptor"));
_chanceAbsrtractions = new IChanceAbstraction[0];
// Create chance abstractions
for (int pos = 0; ; pos++)
{
string caPropName = String.Format("ChanceAbstraction-{0}", pos);
string relFileName = props.Get(caPropName);
if (string.IsNullOrEmpty(relFileName))
{
break;
}
Array.Resize(ref _chanceAbsrtractions, _chanceAbsrtractions.Length + 1);
string absFileName = Path.Combine(strDir, relFileName);
_chanceAbsrtractions[pos] = ChanceAbstractionHelper.CreateFromPropsFile(absFileName);
_playerInfoProps.Set(caPropName + ".Name", _chanceAbsrtractions[pos].Name);
}
Dictionary <string, int> fileToPos = new Dictionary <string, int>();
_strategies = new StrategyTree[0];
_strIndexes = new UFTreeChildrenIndex[0];
// Load strategies, reuse if file is the same
for (int pos = 0; ; pos++)
{
string strPropName = String.Format("Strategy-{0}", pos);
string relFileName = props.Get(strPropName);
if (string.IsNullOrEmpty(relFileName))
{
break;
}
Array.Resize(ref _strategies, _strategies.Length + 1);
Array.Resize(ref _strIndexes, _strIndexes.Length + 1);
string absFileName = Path.Combine(strDir, relFileName);
int existingPos;
if (fileToPos.TryGetValue(absFileName, out existingPos))
{
_strategies[pos] = _strategies[existingPos];
_strIndexes[pos] = _strIndexes[existingPos];
}
else
{
fileToPos.Add(absFileName, pos);
_strategies[pos] = StrategyTree.ReadFDA <StrategyTree>(absFileName);
_strIndexes[pos] = new UFTreeChildrenIndex(_strategies[pos], Path.Combine(strDir, "strategy-idx.dat"), false);
}
_playerInfoProps.Set(strPropName + ".Version", _strategies[pos].Version.ToString());
}
// Read blinds
for (int strPos = 0; strPos < _strategies.Length; ++strPos)
{
StringBuilder sb = new StringBuilder();
for (int playerPos = 0; playerPos < _strategies.Length; ++playerPos)
{
StrategyTreeNode stNode = new StrategyTreeNode();
_strategies[strPos].GetNode(playerPos + 1, &stNode);
sb.AppendFormat("{0:0.000000 }", stNode.Amount);
}
_playerInfoProps.Set("Blinds." + strPos.ToString(), sb.ToString());
}
}
