public TreeTrainingOperation(
Random randomNumberGenerator,
ITrainingContext <F, S> trainingContext,
TrainingParameters parameters,
IDataPointCollection data,
ProgressWriter progress)
{
data_ = data;
trainingContext_ = trainingContext;
parameters_ = parameters;
random_ = randomNumberGenerator;
progress_ = progress;
indices_ = new int[data.Count()];
for (int i = 0; i < indices_.Length; i++)
{
indices_[i] = i;
}
responses_ = new float[data.Count()];
parentStatistics_ = trainingContext_.GetStatisticsAggregator();
leftChildStatistics_ = trainingContext_.GetStatisticsAggregator();
rightChildStatistics_ = trainingContext_.GetStatisticsAggregator();
partitionStatistics_ = new S[parameters.NumberOfCandidateThresholdsPerFeature + 1];
for (int i = 0; i < parameters.NumberOfCandidateThresholdsPerFeature + 1; i++)
{
partitionStatistics_[i] = trainingContext_.GetStatisticsAggregator();
}
}
public void Aggregate(IDataPointCollection data, int index)
{
DataPointCollection concreteData = (DataPointCollection)(data);
bins_[concreteData.GetIntegerLabel((int)index)]++;
sampleCount_ += 1;
}
/// <summary>
/// Train a new decision forest given some training data and a training
/// problem described by an instance of the ITrainingContext interface.
/// </summary>
/// <param name="random">Random number generator.</param>
/// <param name="parameters">Training parameters.</param>
/// <param name="maxThreads">The maximum number of threads to use.</param>
/// <param name="context">An ITrainingContext instance describing
/// the training problem, e.g. classification, density estimation, etc. </param>
/// <param name="data">The training data.</param>
/// <returns>A new decision forest.</returns>
public static Forest <F, S> TrainForest(
Random random,
TrainingParameters parameters,
ITrainingContext <F, S> context,
int maxThreads,
IDataPointCollection data,
ProgressWriter progress = null)
{
if (progress == null)
{
progress = new ProgressWriter(parameters.Verbose?Verbosity.Verbose:Verbosity.Interest, Console.Out);
}
Forest <F, S> forest = new Forest <F, S>();
for (int t = 0; t < parameters.NumberOfTrees; t++)
{
progress.Write(Verbosity.Interest, "\rTraining tree {0}...", t);
Tree <F, S> tree = ParallelTreeTrainer <F, S> .TrainTree(random, context, parameters, maxThreads, data, progress);
forest.AddTree(tree);
}
progress.WriteLine(Verbosity.Interest, "\rTrained {0} trees. ", parameters.NumberOfTrees);
return(forest);
}
/// <summary>
/// Train a new decision tree given some training data and a training
/// problem described by an ITrainingContext instance.
/// </summary>
/// <param name="random">The single random number generator.</param>
/// <param name="progress">Progress reporting target.</param>
/// <param name="context">The ITrainingContext instance by which
/// the training framework interacts with the training data.
/// Implemented within client code.</param>
/// <param name="parameters">Training parameters.</param>
/// <param name="data">The training data.</param>
/// <returns>A new decision tree.</returns>
static public Tree <F, S> TrainTree(
Random random,
ITrainingContext <F, S> context,
TrainingParameters parameters,
IDataPointCollection data,
ProgressWriter progress = null)
{
if (progress == null)
{
progress = new ProgressWriter(Verbosity.Interest, Console.Out);
}
TreeTrainingOperation <F, S> trainingOperation = new TreeTrainingOperation <F, S>(
random, context, parameters, data, progress);
Tree <F, S> tree = new Tree <F, S>(parameters.MaxDecisionLevels);
progress.WriteLine(Verbosity.Verbose, "");
trainingOperation.TrainNodesRecurse(tree.nodes_, 0, 0, data.Count(), 0); // will recurse until termination criterion is met
progress.WriteLine(Verbosity.Verbose, "");
tree.CheckValid();
return(tree);
}
public AlertSystem()
{
dataPoints = new DataPointCollection();
analysts = new HashSet <IAnalyst>();
clients = new HashSet <IClient>();
rules = new List <IRule>();
}
public void Aggregate(IDataPointCollection data, int index, Object userData)
{
DataPointCollection concreteData = (DataPointCollection)(data);
HistogramData histogramData = (HistogramData)(userData);
histogramData.Increment(dataHandle_, concreteData.GetIntegerLabel((int)index));
// bins_[concreteData.GetIntegerLabel((int)index)]++;
sampleCount_ += 1;
}
public void Aggregate(IDataPointCollection data, int index)
{
DataPointCollection concreteData = (DataPointCollection)(data);
// Always aggregate density statistics
GaussianAggregator2d.Aggregate(data, index);
// Only aggregate histogram statistics for those data points that have class labels
if (concreteData.GetIntegerLabel((int)(index)) != DataPointCollection.UnknownClassLabel)
{
HistogramAggregator.Aggregate(data, index);
}
}
public void Aggregate(IDataPointCollection data, int index)
{
DataPointCollection concreteData = (DataPointCollection)(data);
sx_ += concreteData.GetDataPoint((int)index)[0];
sy_ += concreteData.GetDataPoint((int)index)[1];
sxx_ += Math.Pow(concreteData.GetDataPoint((int)index)[0], 2.0);
syy_ += Math.Pow(concreteData.GetDataPoint((int)index)[1], 2.0);
sxy_ += concreteData.GetDataPoint((int)index)[0] * concreteData.GetDataPoint((int)index)[1];
sampleCount_ += 1;
}
/// <summary>
/// Apply a forest of trees to a set of data points.
/// </summary>
/// <param name="data">The data points.</param>
public int[][] Apply(IDataPointCollection data, ProgressWriter progress = null)
{
if (progress == null)
{
progress = new ProgressWriter(Verbosity.Interest, Console.Out);
}
int[][] leafNodeIndices = new int[TreeCount][];
for (int t = 0; t < TreeCount; t++)
{
progress.Write(Verbosity.Interest, "\rApplying tree {0}...", t);
leafNodeIndices[t] = trees_[t].Apply(data);
}
progress.WriteLine(Verbosity.Interest, "\rApplied {0} trees. ", TreeCount);
return(leafNodeIndices);
}
public void Aggregate(IDataPointCollection data, int index)
{
DataPointCollection concreteData = (DataPointCollection)(data);
float[] datum = concreteData.GetDataPoint((int)index);
float target = concreteData.GetTarget((int)index);
XT_X_11_ += datum[0] * datum[0];
XT_X_12_ += datum[0];
XT_X_21_ += datum[0];
XT_X_22_ += 1.0;
XT_Y_1_ += datum[0] * target;
XT_Y_2_ += target;
Y2_ += target * target;
sampleCount_ += 1;
}
/// <summary>
/// Apply the decision tree to a collection of test data points.
/// </summary>
/// <param name="data">The test data.</param>
/// <returns>An array of leaf node indices per data point.</returns>
public int[] Apply(IDataPointCollection data)
{
CheckValid();
int[] leafNodeIndices = new int[data.Count()]; // of leaf node reached per data point
// Allocate temporary storage for data point indices and response values
int[] dataIndices_ = new int[data.Count()];
for (int i = 0; i < data.Count(); i++)
{
dataIndices_[i] = i;
}
float[] responses_ = new float[data.Count()];
ApplyNode(0, data, dataIndices_, 0, data.Count(), leafNodeIndices, responses_);
return(leafNodeIndices);
}
private void ApplyNode(
int nodeIndex,
IDataPointCollection data,
int[] dataIndices,
int i0,
int i1,
int[] leafNodeIndices,
float[] responses_)
{
System.Diagnostics.Debug.Assert(nodes_[nodeIndex].IsNull == false);
Node <F, S> node = nodes_[nodeIndex];
if (node.IsLeaf)
{
for (int i = i0; i < i1; i++)
{
leafNodeIndices[dataIndices[i]] = nodeIndex;
}
return;
}
if (i0 == i1) // No samples left
{
return;
}
for (int i = i0; i < i1; i++)
{
responses_[i] = node.Feature.GetResponse(data, dataIndices[i]);
}
int ii = Partition(responses_, dataIndices, i0, i1, node.Threshold);
// Recurse for child nodes.
ApplyNode(nodeIndex * 2 + 1, data, dataIndices, i0, ii, leafNodeIndices, responses_);
ApplyNode(nodeIndex * 2 + 2, data, dataIndices, ii, i1, leafNodeIndices, responses_);
}
public ParallelTreeTrainingOperation(
Random random,
ITrainingContext <F, S> trainingContext,
TrainingParameters parameters,
int maxThreads,
IDataPointCollection data,
ProgressWriter progress)
{
data_ = data;
trainingContext_ = trainingContext;
parameters_ = parameters;
maxThreads_ = maxThreads;
random_ = random;
progress_ = progress;
parentStatistics_ = trainingContext_.GetStatisticsAggregator();
leftChildStatistics_ = trainingContext_.GetStatisticsAggregator();
rightChildStatistics_ = trainingContext_.GetStatisticsAggregator();
responses_ = new float[data.Count()];
indices_ = new int[data.Count()];
for (int i = 0; i < indices_.Length; i++)
{
indices_[i] = i;
}
threadLocals_ = new ThreadLocalData[maxThreads_];
for (int threadIndex = 0; threadIndex < maxThreads_; threadIndex++)
{
threadLocals_[threadIndex] = new ThreadLocalData(random_, trainingContext_, parameters_, data_);
}
}
public ThreadLocalData(Random random, ITrainingContext <F, S> trainingContext_, TrainingParameters parameters, IDataPointCollection data)
{
parentStatistics_ = trainingContext_.GetStatisticsAggregator();
leftChildStatistics_ = trainingContext_.GetStatisticsAggregator();
rightChildStatistics_ = trainingContext_.GetStatisticsAggregator();
partitionStatistics_ = new S[parameters.NumberOfCandidateThresholdsPerFeature + 1];
for (int i = 0; i < parameters.NumberOfCandidateThresholdsPerFeature + 1; i++)
{
partitionStatistics_[i] = trainingContext_.GetStatisticsAggregator();
}
responses_ = new float[data.Count()];
random_ = new Random(random.Next());
}
public float GetResponse(IDataPointCollection data, int index)
{
DataPointCollection concreteData = (DataPointCollection)(data);
return(dx_ * concreteData.GetDataPoint((int)index)[0] + dy_ * concreteData.GetDataPoint((int)index)[1]);
}
public float GetResponse(IDataPointCollection data, int sampleIndex)
{
DataPointCollection concreteData = (DataPointCollection)(data);
return(concreteData.GetDataPoint((int)sampleIndex)[axis_]);
}
public float GetResponse(IDataPointCollection data, int sampleIndex)
{
DataPointCollection concreteData = (DataPointCollection)(data);
return concreteData.GetDataPoint((int)sampleIndex)[axis_];
}
public float GetResponse(IDataPointCollection data, int index)
{
DataPointCollection concreteData = (DataPointCollection)(data);
return dx_ * concreteData.GetDataPoint((int)index)[0] + dy_ * concreteData.GetDataPoint((int)index)[1];
}
