public ChanceAbstractedGameDefParams(FictitiousPlay_Test test, string name, string gameDefFile,
IChanceAbstraction[] abstractions, double epsilon) :
base(test, gameDefFile, epsilon)
{
ChanceTree = CreateChanceTreeByAbstraction.CreateS(GameDef, abstractions);
Name = name;
}
public ChanceAbstractedGameDefParams(EqLp_Test test, string name, string gameDefFile, IChanceAbstraction[] abstractions,
double[] expectedResult, double epsilon) :
base(test, gameDefFile, expectedResult, epsilon)
{
ChanceTree = CreateChanceTreeByAbstraction.CreateS(GameDef, abstractions);
Name = name;
}
/// <summary>
/// This functions simulate a typical use case: create trees in many runs of MC sampling, write them, read again
/// and merge into the master tree. The master tree is than verified.
/// </summary>
private void GenerateAndVerifyCT(string name, GameDefinition gd, IChanceAbstraction[] chanceAbstractions, bool areAbstractionsEqual, int samplesCount, int runsCount, double avRelProbabEps, double avPotShareEps, double eqValEps, bool visualize)
{
CtMcGen.Tree masterTree = new CtMcGen.Tree();
int rngSeed = (int)DateTime.Now.Ticks;
for (int run = 0; run < runsCount; ++run)
{
CtMcGen.Tree runTree = CtMcGen.Generate(gd, chanceAbstractions, areAbstractionsEqual, samplesCount, rngSeed, null);
string fileName = Path.Combine(_outDir, String.Format("{0}-{1}-ct.dat", gd.Name, name));
runTree.Write(fileName);
masterTree.Read(fileName);
// Do not use the timer anymore because the tests are too fast.
rngSeed++;
}
ChanceTree actCt = masterTree.ConvertToChanceTree();
VisChanceTree.Show(actCt, Path.Combine(_outDir, String.Format("{0}-{1}-ct.gv", gd.Name, name)));
VerifyChanceTree.VerifyS(actCt);
ChanceTree expCt = CreateChanceTreeByAbstraction.CreateS(gd, chanceAbstractions);
Assert.AreEqual(expCt.PlayersCount, actCt.PlayersCount);
CompareChanceTrees cmp = new CompareChanceTrees();
cmp.IsVerbose = visualize;
cmp.Output = Console.Out;
cmp.Compare(expCt, actCt);
VisChanceTree.Show(expCt, Path.Combine(_outDir, String.Format("{0}-{1}-ct-exp.gv", gd.Name, name)));
Assert.Less(cmp.AverageRelProbabDiff, avRelProbabEps);
for (int p = 0; p < chanceAbstractions.Length; ++p)
{
Assert.Less(cmp.AveragePotShareDiff[p], avRelProbabEps);
}
ActionTree at = CreateActionTreeByGameDef.Create(gd);
double [] actEqValues, expEqValues;
EqLp.Solve(at, actCt, out actEqValues);
EqLp.Solve(at, expCt, out expEqValues);
for (int p = 0; p < chanceAbstractions.Length; ++p)
{
if (visualize)
{
Console.WriteLine("Eq pos: {0} exp: {1} act: {2}", p, expEqValues[p], actEqValues[p]);
}
Assert.AreEqual(expEqValues[p], actEqValues[p], eqValEps);
}
if (visualize)
{
Console.WriteLine();
}
}
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 OcfrParams(GameValue_Test test, string name, string gameDefFile, IChanceAbstraction[] abstractions, string[] ocfrFiles, double[] expectedResult, double epsilon)
{
Epsilon = epsilon;
ExpectedResult = expectedResult;
GameDef = XmlSerializerExt.Deserialize <GameDefinition>(
Props.Global.Expand("${bds.DataDir}ai.pkr.metastrategy/${0}",
gameDefFile));
Name = name;
OcfrFiles = new string[GameDef.MinPlayers].Fill(i => Path.Combine(test._testResDir, ocfrFiles[i]));
if (abstractions == null)
{
ChanceTree = CreateChanceTreeByGameDef.Create(GameDef);
}
else
{
ChanceTree = CreateChanceTreeByAbstraction.CreateS(GameDef, abstractions);
}
//VisChanceTree.Show(ChanceTree, Path.Combine(test._outDir, String.Format("{0}-c.gv", GameDef.Name)));
ActionTree = CreateActionTreeByGameDef.Create(GameDef);
StrategyTrees = new StrategyTree[GameDef.MinPlayers];
for (int p = 0; p < GameDef.MinPlayers; ++p)
{
ChanceTree pct = ExtractPlayerChanceTree.ExtractS(ChanceTree, p);
StrategyTrees[p] = CreateStrategyTreeByChanceAndActionTrees.CreateS(pct, ActionTree);
OpenCfrStrategyConverter conv = new OpenCfrStrategyConverter
{
GameDef = GameDef,
HeroPosition = p,
SourceFile = OcfrFiles[p],
Strategy = StrategyTrees[p],
ChanceAbstraction = abstractions == null ? null : abstractions[p]
};
conv.Convert();
//VisStrategyTree.Show(StrategyTrees[p], Path.Combine(test._outDir, String.Format("{0}-str-{1}.gv", GameDef.Name, p)));
}
}
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));
}
}
}
void SolveGame(string runDir, GameDefinition gd, IChanceAbstraction [] chanceAbstractions, double [] brValues)
{
ChanceTree ct = CreateChanceTreeByAbstraction.CreateS(gd, chanceAbstractions);
ActionTree at = CreateActionTreeByGameDef.Create(gd);
double[] eqValues;
StrategyTree[] eqStrategies = EqLp.Solve(at, ct, out eqValues);
string error;
for (int p = 0; p < gd.MinPlayers; ++p)
{
Assert.IsTrue(VerifyAbsStrategy.Verify(eqStrategies[p], p, 1e-7, out error), error);
}
// Verify eq
Assert.IsTrue(VerifyEq.Verify(at, ct, eqStrategies, 1e-7, out error), error);
StrategyTree[] brStrategies = new StrategyTree[gd.MinPlayers];
// Find BR for each position
for (int heroPos = 0; heroPos < gd.MinPlayers; ++heroPos)
{
Br br = new Br
{
HeroPosition = heroPos,
ActionTree = at,
ChanceTree = ct,
Strategies = (StrategyTree[])eqStrategies.Clone()
};
br.Solve();
brStrategies[heroPos] = br.Strategies[heroPos];
brValues[heroPos] = br.Value;
}
MergeAndSaveStrategies(runDir, "", eqStrategies, chanceAbstractions);
MergeAndSaveStrategies(runDir, "-br", brStrategies, chanceAbstractions);
}
