public static LabeledPoint MovePoint(LabeledPoint source,
double xDistance, double yDistance)
{
// return a default value:
if (source == null)
{
return(default);
private static int RecurseAndPredict(LabeledPoint point, DecisionTreeNode node, DecisionTreeOptions options)
{
if (node.IsLeaf)
{
return(node.Class);
}
else
{
SplitDirection direction = ComputeSplitDirection(point, node.Question, options);
if (direction == SplitDirection.Left)
{
return(RecurseAndPredict(point, node.LeftBranch, options));
}
else
{
return(RecurseAndPredict(point, node.RightBranch, options));
}
}
}
protected void Start()
{
Sort();
myItems.Clear();
int i = 0;
foreach (P3 item in items)
{
Debug.LogFormat("{0} at {1}", item.p, item.SortingValue);
myItems.Add(item);
LabeledPoint lp = gameObject.AddComponent <LabeledPoint> ();
lp.Point.transform.position = item.p;
lp.textMesh.text = string.Format("{0}", i.ToString());
lp.Point.localScale = Vector3.one * .2f;
i++;
}
}
private static SplitDirection ComputeSplitDirection(LabeledPoint point, SplittingQuestion question,
DecisionTreeOptions options)
{
int frameHeight = point.SourceTomogram.Height;
int frameWidth = point.SourceTomogram.Width;
int uY = point.Y + question.OffsetUY;
if (uY >= frameHeight)
{
uY = -1;
}
int uX = point.X + question.OffsetUX;
if (uX >= frameWidth)
{
uX = -1;
}
int vY = point.Y + question.OffsetVY;
if (vY >= frameHeight)
{
vY = -1;
}
int vX = point.X + question.OffsetVX;
if (vX >= frameWidth)
{
vX = -1;
}
int u = uY * frameWidth + uX;
int v = vY * frameWidth + vX;
int z = point.Y * frameWidth + point.X;
float uVal = 0f, vVal = 0f, zVal = point.SourceTomogram.Data[z];
if (u < 0 || v < 0)
{
uVal = vVal = options.OutOfRangeValue;
}
else
{
uVal = point.SourceTomogram.Data[u];
//if(Math.Abs(zVal - uVal) > options.DistanceThreshold)
//{
// uVal = options.OutOfRangeValue;
//}
vVal = point.SourceTomogram.Data[v];
//if(Math.Abs(zVal - vVal) > options.DistanceThreshold)
//{
// vVal = options.OutOfRangeValue;
//}
}
if ((uVal - vVal) < question.Threshold)
{
return(SplitDirection.Left);
}
else
{
return(SplitDirection.Right);
}
}
private static void RecurseAndPartition(List <LabeledPoint> trainingPoints, List <SplittingQuestion> splittingQuestions,
int currentRecursionLevel, DecisionTreeOptions options, DecisionTreeNode currentNode, Random random)
{
Console.WriteLine($"{new String('-', currentRecursionLevel)}{currentRecursionLevel}");
if (currentRecursionLevel >= options.MaximumNumberOfRecursionLevels)
{
// create leaf node
MakeLeafNode(currentNode, trainingPoints);
}
else
{
double currentShannonEntropy = ComputeShannonEntropy(trainingPoints);
double highestGain = double.MinValue;
SplittingQuestion bestSplittingQuestion = null;
//for (int s = 0; s < splittingQuestions.Count; s++)
Parallel.For(0, splittingQuestions.Count, s =>
{
//Console.Write(".");
//Interlocked.Increment(ref t);
//Console.WriteLine($"{t}/{splittingQuestions.Count}");
//List<LabeledPoint> leftBucket1 = new List<LabeledPoint>();
//List<LabeledPoint> rightBucket1 = new List<LabeledPoint>();
List <LabeledPointGroup> leftBucket = new List <LabeledPointGroup>();
leftBucket.Add(new LabeledPointGroup
{
Count = 0,
Class = 0
});
leftBucket.Add(new LabeledPointGroup
{
Count = 0,
Class = 1
});
List <LabeledPointGroup> rightBucket = new List <LabeledPointGroup>();
rightBucket.Add(new LabeledPointGroup
{
Count = 0,
Class = 0
});
rightBucket.Add(new LabeledPointGroup
{
Count = 0,
Class = 1
});
SplittingQuestion splittingQuestion = splittingQuestions[s];
for (int p = 0; p < trainingPoints.Count; p++)
{
//if (random.NextDouble() < .1 || trainingPoints.Count < 1000)
{
LabeledPoint trainingPoint = trainingPoints[p];
SplitDirection split = ComputeSplitDirection(trainingPoint, splittingQuestion, options);
if (split == SplitDirection.Left)
{
leftBucket[trainingPoint.Label].Count++;
//leftBucket1.Add(trainingPoint);
}
else
{
//rightBucket1.Add(trainingPoint);
rightBucket[trainingPoint.Label].Count++;
}
}
}
//double gain = ComputeGain(currentShannonEntropy, leftBucket1, rightBucket1);
double gain = ComputeGain(currentShannonEntropy, leftBucket, rightBucket);
lock (typeof(DecisionTreeBuilder))
{
if (gain > highestGain)
{
highestGain = gain;
bestSplittingQuestion = splittingQuestion;
}
}
});
if (highestGain > options.SufficientGainLevel)
{
List <LabeledPoint> bestLeftBucket = new List <LabeledPoint>();
List <LabeledPoint> bestRightBucket = new List <LabeledPoint>();
for (int p = 0; p < trainingPoints.Count; p++)
{
LabeledPoint trainingPoint = trainingPoints[p];
SplitDirection split = ComputeSplitDirection(trainingPoint, bestSplittingQuestion, options);
if (split == SplitDirection.Left)
{
bestLeftBucket.Add(trainingPoint);
}
else
{
bestRightBucket.Add(trainingPoint);
}
}
currentNode.Question = bestSplittingQuestion;
currentNode.LeftBranch = new DecisionTreeNode();
currentNode.RightBranch = new DecisionTreeNode();
currentNode.IsLeaf = false;
//System.Console.WriteLine("left: " + bestLeftBucket.Count.ToString());
//System.Console.WriteLine("right: " + bestRightBucket.Count.ToString());
//splittingQuestions =
// GenerateSplittingQuestions(random, options);
RecurseAndPartition(bestLeftBucket, splittingQuestions,
currentRecursionLevel + 1, options, currentNode.LeftBranch, random);
RecurseAndPartition(bestRightBucket, splittingQuestions,
currentRecursionLevel + 1, options, currentNode.RightBranch, random);
}
else
{
MakeLeafNode(currentNode, trainingPoints);
}
}
}
