static TestDomainData[] ReadTestDomainData(string path)
{
List <TestDomainData> data = new List <TestDomainData>();
CSVReader reader = new CSVReader(path, ',');
reader.Read(false);
for (int i = 0; i < reader.Output.Length; i++)
{
string[] outLine = reader.Output[i];
string[] splitInit = outLine[0].Split(' ');
byte[] init = new byte[splitInit.Length];
for (int j = 0; j < splitInit.Length; j++)
{
init[j] = byte.Parse(splitInit[j]);
}
int optimalCost = int.Parse(outLine[1]);
long generated = outLine[2] == string.Empty ? 0 : long.Parse(outLine[2]);
TestDomainData testDomainData = new TestDomainData(init, optimalCost, generated);
data.Add(testDomainData);
}
return(data.ToArray());
}
static TestDomainData[] GenTest(IHeuristic heuristic, int numTasks = 100, int numSteps = Global.MAXSTEPS, bool writeCSV = true, bool computeCost = true)
{
TestDomainData[] data = new TestDomainData[numTasks];
string csvWritePath = string.Format(Global.ROOTPATH, Global.TESTTASKFN);
CSVWriter csv = new CSVWriter(csvWritePath, ',');
for (int i = 0; i < numTasks; i++)
{
DomainContainer domainContainer = new DomainContainer(heuristic, numSteps);
ISearchDomain domain = domainContainer.Domain;
IState initState = domain.Initial();
string initStateStr = string.Join(" ", initState.Arr);
int cost = 0;
long generated = 0;
if (computeCost == true)
{
if (Global.DOMAINTYPE == typeof(BlocksWorld.BlocksWorld) && heuristic == null)
{
cost = PostBlocksWorld(initState, domain.Goal());
}
else
{
IDAStar <ISearchDomain> planner = new IDAStar <ISearchDomain>(domain);
List <IState> plan = planner.Search(initState);
cost = (plan.Count - 1);
generated = planner.Generated;
}
}
data[i] = new TestDomainData(initState.Arr, cost, generated);
csv.Add(initStateStr);
csv.Add(cost.ToString());
csv.Add(generated.ToString());
csv.EndLine();
}
if (writeCSV == true)
{
csv.Write();
}
return(data);
}
public static void TestAdmissibility(int run, string runType, int nnIndex, double?confLevel)
{
string nnFileName = string.Format(Global.NNFN, nnIndex);
string outputFileName = string.Format(Global.TESTADMISFN, confLevel == null ? "" : confLevel.ToString());
string nnLoadPath = string.Format(Global.RUNPATH, run, runType, nnFileName);
string csvWritePath = string.Format(Global.RUNPATH, run, runType, outputFileName);
CSVWriter csvWriter = new CSVWriter(csvWritePath, ',');
MyNN nnSolve = MyNN.Load(nnLoadPath);
TestDomainData[] data = ReadTestDomainData(Global.TESTTASKPATH);
IHeuristic heuristic = new NNPreTrainedHeuristic(nnSolve, representationSolve, confLevel, true);
SolveTestData(heuristic, data, csvWriter, null);
double sumExpanded = 0;
double sumGenerated = 0;
double sumOptimal = 0;
double sumCost = 0;
double sumSubOpt = 0;
for (int i = 0; i < data.Length; i++)
{
TestDomainData testDomainData = data[i];
sumExpanded += testDomainData.SolvedExpanded;
sumGenerated += testDomainData.SolvedGenerated;
sumOptimal += testDomainData.OptimalCost;
sumCost += testDomainData.SolvedCost;
sumSubOpt += testDomainData.SolvedCost / (double)testDomainData.OptimalCost;
}
Console.WriteLine("-----");
Console.WriteLine(sumExpanded / data.Length);
Console.WriteLine(sumGenerated / data.Length);
Console.WriteLine(sumOptimal / data.Length);
Console.WriteLine(sumCost / data.Length);
Console.WriteLine((sumSubOpt / data.Length) - 1);
csvWriter.Write();
}
static int SolveTestData(IHeuristic heuristic, TestDomainData[] data, CSVWriter csvWriter, int?timeout)
{
Stopwatch sw = new Stopwatch();
sw.Start();
int countSolved = 0;
for (int i = 0; i < data.Length; i++)
{
Console.WriteLine("iter: " + i.ToString());
if (timeout != null && sw.ElapsedMilliseconds > timeout)
{
break;
}
heuristic.ClearCache();
GC.Collect();
TestDomainData testDomainData = data[i];
DomainContainer domainContainer = new DomainContainer(heuristic, testDomainData.Init);
ISearchDomain domain = domainContainer.Domain;
IDAStar <ISearchDomain> planner = new IDAStar <ISearchDomain>(domain);
List <IState> plan = planner.Search(domain.Initial(), timeout);
testDomainData.SolvedCost = plan.Count - 1;
testDomainData.SolvedExpanded = planner.Expanded;
testDomainData.SolvedGenerated = planner.Generated;
if (testDomainData.SolvedCost > 0)
{
csvWriter.Add(planner.Expanded.ToString());
csvWriter.Add(planner.Generated.ToString());
csvWriter.Add(testDomainData.OptimalCost.ToString());
csvWriter.Add(testDomainData.SolvedCost.ToString());
csvWriter.Add(planner.SwopWatch.ElapsedMilliseconds.ToString());
csvWriter.EndLine();
csvWriter.Write();
csvWriter.Clear();
countSolved++;
}
Console.WriteLine("cost: " + (plan.Count - 1).ToString());
Console.WriteLine("generated: " + planner.Generated);
Console.WriteLine("elapsed: " + planner.SwopWatch.ElapsedMilliseconds);
}
return(countSolved);
}
static void Main(string[] args)
{
Control.UseNativeMKL();
Console.WriteLine("start1");
//PancakePuzzle.BuildPDBs.BuildPDBs24();
//GenTest(null, 50,Global.MAXSTEPS);
multHeuristic = null;
representationSolve = new SlidingPuzzle.Representations.TwoDim(new Func <double, double>(x => x / 10), new Func <double, double>(x => x * 10));
representationUncert = new SlidingPuzzle.Representations.TwoDim(null, null);
for (int r = 1; r <= 5; r++)
{
{
List <Tuple <int, bool, int> > paramaters = new List <Tuple <int, bool, int> >();
paramaters.Add(new Tuple <int, bool, int>(1, true, 1));
foreach (var p in paramaters)
{
Train(r, Global.NITER, p.Item1, p.Item2, p.Item3, false);
}
}
{
int nnIndex = Global.NITER - 1;
List <Tuple <string, int, double?> > paramaters = new List <Tuple <string, int, double?> >();
paramaters.Add(new Tuple <string, int, double?>("1", nnIndex, null));
foreach (var p in paramaters)
{
TestAdmissibility(r, p.Item1, p.Item2, p.Item3);
}
}
{
List <Tuple <int, bool, int> > paramaters = new List <Tuple <int, bool, int> >();
paramaters.Add(new Tuple <int, bool, int>(2, true, 1));
foreach (var p in paramaters)
{
Train(r, Global.NITER, p.Item1, p.Item2, p.Item3, false);
}
}
{
int nnIndex = Global.NITER - 1;
List <Tuple <string, int, double?> > paramaters = new List <Tuple <string, int, double?> >();
paramaters.Add(new Tuple <string, int, double?>("2", nnIndex, 0.5));
paramaters.Add(new Tuple <string, int, double?>("2", nnIndex, 0.95));
paramaters.Add(new Tuple <string, int, double?>("2", nnIndex, 0.9));
paramaters.Add(new Tuple <string, int, double?>("2", nnIndex, 0.75));
paramaters.Add(new Tuple <string, int, double?>("2", nnIndex, 0.25));
paramaters.Add(new Tuple <string, int, double?>("2", nnIndex, 0.1));
paramaters.Add(new Tuple <string, int, double?>("2", nnIndex, 0.05));
foreach (var p in paramaters)
{
TestAdmissibility(r, p.Item1, p.Item2, p.Item3);
}
}
{
List <Tuple <int, bool, int> > paramaters = new List <Tuple <int, bool, int> >();
paramaters.Add(new Tuple <int, bool, int>(1, true, 1));
paramaters.Add(new Tuple <int, bool, int>(1, false, 1));
paramaters.Add(new Tuple <int, bool, int>(1, false, 2));
paramaters.Add(new Tuple <int, bool, int>(1, false, 4));
paramaters.Add(new Tuple <int, bool, int>(1, false, 6));
paramaters.Add(new Tuple <int, bool, int>(1, false, 8));
paramaters.Add(new Tuple <int, bool, int>(1, false, 10));
foreach (var p in paramaters)
{
Train(r, Global.NITER, p.Item1, p.Item2, p.Item3, true);
}
}
{
int numTasks = 1000;
int numIter = 5;
int nnIndex = Global.NITER - 1;
TestDomainData[][] testData = new TestDomainData[numIter][];
for (int i = 0; i < numIter; i++)
{
TestDomainData[] data = new TestDomainData[numTasks];
for (int j = 0; j < numTasks; j++)
{
data[j] = GenTest(null, 1, j + 1, false, false)[0];
}
testData[i] = data;
}
List <Tuple <string, int> > paramaters = new List <Tuple <string, int> >();
paramaters.Add(new Tuple <string, int>("1e", nnIndex));
paramaters.Add(new Tuple <string, int>("k1", nnIndex));
paramaters.Add(new Tuple <string, int>("k2", nnIndex));
paramaters.Add(new Tuple <string, int>("k4", nnIndex));
paramaters.Add(new Tuple <string, int>("k6", nnIndex));
paramaters.Add(new Tuple <string, int>("k8", nnIndex));
paramaters.Add(new Tuple <string, int>("k10", nnIndex));
foreach (var p in paramaters)
{
TestEfficiency(r, p.Item1, p.Item2, testData);
}
}
}
Console.ReadLine();
}
