private Dataset GetLocalFlatDataset(Node current, Dataset dataset)
        {
            ClassHierarchy hierarchy = ((Data.HierarchicalAttribute)dataset.Metadata.Target).Hierarchy;

            Node[]        siblings            = hierarchy.GetSiblings(current);
            List <string> negativeClassValues = new List <string>();

            foreach (Node sibling in siblings)
            {
                negativeClassValues.Add(sibling.Name);
            }


            Dataset local = dataset.GetBinaryFlatLabelSubDataset(current.Name, negativeClassValues.ToArray());

            return(local);
        }
Esempio n. 2
0
        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);
        }