static void Main(string[] args)
{
DecisionTreeModel model = new DecisionTreeModel();
model.TrainModel();
model.Predict(model.GetTrainingData());
Train(model);
}
public LearningHelper(string modelToLoadPath = null)
{
data = new List <ScreenData>();
if (modelToLoadPath != null)
{
model = (DecisionTreeModel)numl.Utils.Xml.Load(modelToLoadPath, typeof(DecisionTreeModel));
}
}
public TurnManager(Direction direction, Board board, IUpdater updater, TileAdder adder, GameOverChecker gameOverChecker, Tracker tracker, DecisionTreeModel model)
{
this.GameBoard = board;
this.Swiper = direction;
this.Updater = updater;
this.Adder = adder;
this.GameOverChecker = gameOverChecker;
this.Tracker = tracker;
this.Model = model;
}
public double LearnFromData(int iterations)
{
var d = Descriptor.Create <ScreenData>();
var g = new DecisionTreeGenerator(d);
g.SetHint(false);
var mdl = Learner.Learn(data, 0.80, iterations, g);
model = (DecisionTreeModel)mdl.Model;
return(mdl.Accuracy);
}
static void Train(DecisionTreeModel model = null)
{
for (int i = 0; i <= 100; i++)
{
Board board = new Board();
Direction direction = new Direction();
TileAdder adder = new TileAdder(board);
IUpdater updater = new Updater(board, direction, adder);
GameOverChecker checker = new GameOverChecker(board, direction, updater);
Tracker tracker = new Tracker(15);
TurnManager manager = new TurnManager(direction, board, updater, adder, checker, tracker, model);
manager.Play();
Uploader uploader = new Uploader();
uploader.Upload(manager.GetTracker().GetTrainData());
}
}
public void TestDecisionTree(DecisionTreeModel decisionTreeModel, string[] sample)
{
if (decisionTreeModel.DecisionTreeModels == null)
{
//Console.WriteLine(decisionTreeModel.Attribute.Equals(sample.Last())
// ? $"true {sample.Last()} -> {decisionTreeModel.Attribute}"
// : $"false {sample.Last()} -> {decisionTreeModel.Attribute}");
if (decisionTreeModel.Attribute.Equals(sample.Last()))
{
Node++;
}
var nstr = decisionTreeModel.Attribute.Equals(sample.Last())
? $"{sample.Last()} -> {decisionTreeModel.Attribute}"
: $"{sample.Last()} -> {decisionTreeModel.Attribute}";
ResultTest.Add(nstr);
return;
}
var str = sample[int.Parse(decisionTreeModel.Attribute)];
var index = 0;
decisionTreeModel.Predicates.ForEach(x =>
{
if (x(str))
{
TestDecisionTree(decisionTreeModel.DecisionTreeModels[index], sample);
}
index++;
});
}
public void TestDecisionTrees(DecisionTreeModel decisionTreeModel, params string[][] sample)
{
ResultTest.Clear();
Node = 0;
sample.ToList().ForEach(x => TestDecisionTree(decisionTreeModel, x));
}
public void BuildDecisionTree(DecisionTreeModel decisionTreeModel, List <List <string> > samples)
{
var q = samples.GroupBy(x => x.Last()).Select(y => y.Count());
if (q.Count() == 1)
{
decisionTreeModel.Attribute = samples[0].Last();
Console.WriteLine($"bulid result {samples[0].Last()}");
return;
}
var entropy = measureController.CalculEntropy(q, samples.Count());
var index = 0;
var max = 0d;
var attributesMax = 0;
dataController.Attributes.ForEach(x =>
{
var informationGain = measureController.CalculInformationGain(entropy, int.Parse(x), samples);
if (informationGain > max)
{
max = informationGain;
attributesMax = index;
}
index++;
});
decisionTreeModel.Attribute = attributesMax.ToString();
var samplesGroupBy = samples.GroupBy(x => x[attributesMax]);
Enumerable.Range(0, samplesGroupBy.Count());
List <Predicate <string> > predicates = samplesGroupBy.Select(x =>
{
Predicate <string> w2 = (string attribute) => attribute.Equals(x.Key);
return(w2);
}).ToList();
decisionTreeModel.Predicates = predicates;
var r = samplesGroupBy.Select(x =>
{
return(x.ToList());
}).ToList();
var decisionTreeModels = new List <DecisionTreeModel>();
samplesGroupBy.ToList().ForEach(x =>
{
var asdasd = x.ToList();
var subDecisionTreeModel = new DecisionTreeModel();
decisionTreeModels.Add(subDecisionTreeModel);
BuildDecisionTree(subDecisionTreeModel, x.ToList());
});
decisionTreeModel.DecisionTreeModels = decisionTreeModels;
}
