public Model.Hierarchical.IHierarchicalClassifier CreateClassifier()
{
ClassHierarchy hierarchy = ((Data.HierarchicalAttribute) this._trainingSets[0].Metadata.Target).Hierarchy;
LocalPerNodeClassifier localClassifer = new LocalPerNodeClassifier(hierarchy, _ensembleStrategy);
Node current = hierarchy.Root;
Queue <Node> queue = new Queue <Node>();
foreach (Node node in hierarchy.GetNodes(current.Children))
{
queue.Enqueue(node);
}
int counter = 1;
while (queue.Count != 0)
{
current = queue.Dequeue();
if (localClassifer.Contains(current.Name))
{
continue;
}
List <ClassifierInfo> ensemble = CreateEnsemble(current);
if (_ensembleStrategy is EnsembleStrategy.EnsembleStackClassificationStrategy)
{
List <Dataset> localDatasets = new List <Dataset>();
foreach (Dataset trainingSet in this._trainingSets)
{
localDatasets.Add(GetLocalFlatDataset(current, trainingSet));
}
IClassifier metaClassifier = EnsembleStrategy.EnsembleStackClassificationStrategy.CreateMetaClassifier(this._algorithm, localDatasets, ensemble);
ClassifierInfo metaInfo = new ClassifierInfo()
{
Desc = "metaClassifier", Classifier = metaClassifier, Quality = -1
};
ensemble.Add(metaInfo);
}
if (_serialize)
{
IO.Serializer.SerializeEnsmeble(ensemble, current.Name);
localClassifer.PutEnsemble(current.Name, null);
}
else
{
localClassifer.PutEnsemble(current.Name, ensemble);
}
if (_fireEvents)
{
this.onPostNodeProcessing(current, new NodeCounterEventArgs()
{
Counter = counter
});
}
counter++;
if (current.Children != null)
{
foreach (string child in current.Children)
{
if (!queue.Contains(hierarchy[child]))
{
queue.Enqueue(hierarchy[child]);
}
}
}
}
if (_serialize)
{
foreach (Node node in hierarchy.GetDescendants(hierarchy.Root))
{
localClassifer.PutEnsemble(node.Name, IO.Serializer.DeserializeEnsemble(node.Name));
}
}
return(localClassifer);
}
public static EnsemblePerNodeTopDownClassifier CreateEnsembleDSPerNodeTopDownClassifier(List <Data.Dataset> trainingSets, IClassificationAlgorithm algorithm)
{
ClassHierarchy hierarchy = ((Data.HierarchicalAttribute)trainingSets[0].Metadata.Target).Hierarchy;
EnsemblePerNodeTopDownClassifier topDownClassifier = new EnsemblePerNodeTopDownClassifier(hierarchy);
Data.Attribute[] metaAttributes = new Data.Attribute[2];
string[] values = new string[trainingSets.Count];
for (int i = 0; i < metaAttributes.Length; i++)
{
values[i] = trainingSets[i].Metadata.DatasetName;
}
metaAttributes[0] = new Data.Attribute("Dataset", 0, values);
metaAttributes[1] = new Data.Attribute("Prediction", 1, new string[] { "yes", "no" });
Data.Attribute target = new Data.Attribute("class", metaAttributes.Length, new string[] { "yes", "no" });
Metadata meta = new Metadata("metaModel", metaAttributes, target);
Node current = hierarchy.Root;
Queue <Node> queue = new Queue <Node>();
foreach (Node node in hierarchy.GetNodes(current.Children))
{
queue.Enqueue(node);
}
while (queue.Count != 0)
{
current = queue.Dequeue();
Node[] siblings = hierarchy.GetSiblings(current);
List <string> negativeClassValues = new List <string>();
foreach (Node sibling in siblings)
{
negativeClassValues.Add(sibling.Name);
}
Dataset dsLocal = new Dataset(meta.Clone());
int i = 0;
foreach (Dataset trainingSet in trainingSets)
{
Dataset local = trainingSet.GetBinaryFlatLabelSubDataset(current.Name, negativeClassValues.ToArray());
algorithm.TrainingSet = local;
IClassifier classifier = algorithm.CreateClassifier();
topDownClassifier.AddClassifier(current.Name, local.Metadata.DatasetName, classifier);
//Example metaExample=new Example(dsLocal,i,
}
//algorithm.TrainingSet = local;
//IClassifier classifier = algorithm.CreateClassifier();
//topDownClassifier.PutClassifier(current.Name, trainingSet.Metadata.DatasetName, classifier);
//if (current.Children != null)
// foreach (string child in current.Children)
// queue.Enqueue(hierarchy[child]);
}
return(topDownClassifier);
}
