public SimpleClassifier(IClassificationAlgorithm classificationAlgorithm, ITextDocumentConverter textDocumentConverter, string targetTag, string[] featuredWords)
{
this.classificationAlgorithm = classificationAlgorithm;
this.textDocumentConverter = textDocumentConverter;
this.targetTag = targetTag;
this.featuredWords = featuredWords;
}
public static ClassificationAlgorithmBuildResult Create(IClassificationAlgorithm classificationAlgorithm, TrainingExample[] trainingSet)
{
var errorsCount = trainingSet.Count(x => classificationAlgorithm.Classify(x.Features).PredictedClass != x.ExpectedResult);
var error = errorsCount * 1.0 / trainingSet.Length;
return new ClassificationAlgorithmBuildResult
{
ClassificationAlgorithm = classificationAlgorithm,
Error = error
};
}
public static BayesianClusterMultinetClassifier CreateAntClustBMNClassifier_MB(int seed, Dataset dataset, int maxIterations, int colonySize, int convergence, int clustersNumber, ISimilarityMeasure similarityMeasure, IClassificationQualityMeasure classificationMeasure, IClassificationAlgorithm algorithm, bool fireEvents)
{
DataMining.Utilities.RandomUtility.Initialize(seed);
DefaultHeuristicCalculator <int> calculator = new DefaultHeuristicCalculator <int>();
ClusteringMBInvalidator invalidator = new ClusteringMBInvalidator();
ClusteringClassificationQualityEvaluator evaluator = new ClusteringClassificationQualityEvaluator(classificationMeasure, algorithm);
evaluator.Dataset = dataset;
KMeansLocalSearch localSearch = new KMeansLocalSearch(dataset, 1, similarityMeasure, evaluator);
Problem <int> problem = new Problem <int>(invalidator, calculator, evaluator, localSearch);
AntClustBMN_MB antClustBMN = new AntClustBMN_MB(maxIterations, colonySize, convergence, problem, clustersNumber, similarityMeasure, dataset, true, algorithm, classificationMeasure);
antClustBMN.OnPostColonyIteration += new EventHandler(antClustering_OnPostColonyIteration);
return(antClustBMN.CreateClassifier() as BayesianClusterMultinetClassifier);
}
public static BayesianClusterMultinetClassifier CreateClusteringBMNClassifier(int seed, int clusterNumber, Dataset dataset, ISimilarityMeasure similarityMeasure, IClassificationQualityMeasure accuracy, IClusteringAlgorithm algorithm, IClassificationAlgorithm naive, bool fireEvents)
{
DataMining.Utilities.RandomUtility.Initialize(seed);
if (fireEvents)
{
if (algorithm is ACOClustering_IB)
{
((ACOClustering_IB)algorithm).OnPostColonyIteration += new EventHandler(antClustering_OnPostColonyIteration);
}
if (algorithm is ACOClustering_MB)
{
((ACOClustering_MB)algorithm).OnPostColonyIteration += new EventHandler(antClustering_OnPostColonyIteration);
}
}
ClusterBMN cBMN = new ClusterBMN(dataset, clusterNumber, similarityMeasure, accuracy, algorithm, naive);
return(cBMN.CreateClassifier() as BayesianClusterMultinetClassifier);
}
public static IHierarchicalClassifier CreateLocalPerNodeHierarchicalClassifier(IClassificationAlgorithm algorithm, List <DataMining.Data.Dataset> dataRepresentations, IEnsembleClassificationStrategy ensembleStrategy, IClassificationQualityMeasure evaluator, bool serialize, bool fireEvents)
{
DataMining.Utilities.RandomUtility.Initialize();
LocalPerNodeClassificationAlgorithm hClassificatoinAlgorithm = new LocalPerNodeClassificationAlgorithm(dataRepresentations, algorithm, ensembleStrategy, evaluator, serialize, fireEvents);
if (fireEvents)
{
hClassificatoinAlgorithm.onPostClassifierConstruction += new EventHandler(hClassificatoinAlgorithm_onPostClassifierConstruction);
hClassificatoinAlgorithm.onPostNodeProcessing += new EventHandler(hClassificatoinAlgorithm_onPostNodeProcessing);
}
return(hClassificatoinAlgorithm.CreateClassifier());
}
public AntClustBMN_IB(int maxIterations, int colonySize, int convergenceIterations, Problem <ClusterExampleAssignment> problem, int clustersNumber, DataMining.ProximityMeasures.ISimilarityMeasure similarityMeasure, bool performLocalSearch, IClassificationAlgorithm algorithm, IClassificationQualityMeasure qualityMeasure)
: base(maxIterations, colonySize, convergenceIterations, problem, clustersNumber, similarityMeasure, performLocalSearch)
{
this._classificationAlgorithm = algorithm;
this._classificationQualityMeasure = qualityMeasure;
}
public ClusterBMN(int clustersNumber, ISimilarityMeasure similarityMeasure, IClassificationQualityMeasure classificationMeasure, IClusteringAlgorithm clusteringAlgorithm, IClassificationAlgorithm classificationAlgorithm)
{
this._similarityMeasure = similarityMeasure;
this._clustersNumber = clustersNumber;
this._classificationMeasure = classificationMeasure;
this._clusteringAlgorithm = clusteringAlgorithm;
this._classificationAlgorithm = classificationAlgorithm;
}
public ClusterBMN(DataMining.Data.Dataset trainingset, int clustersNumber, ISimilarityMeasure similarityMeasure, IClassificationQualityMeasure classificationMeasure, IClusteringAlgorithm clusteringAlgorithm, IClassificationAlgorithm classificationAlgorithm)
{
this._trainingset = trainingset;
this._similarityMeasure = similarityMeasure;
this._clustersNumber = clustersNumber;
this._classificationMeasure = classificationMeasure;
this._clusteringAlgorithm = clusteringAlgorithm;
this._classificationAlgorithm = classificationAlgorithm;
}
public void PerformIterationsClassifyEarlyStop(ILearningMethod train,
IClassificationAlgorithm model,
IList<BasicData> validationData,
int tolerate)
{
var iterationNumber = 0;
var done = false;
var bestError = double.PositiveInfinity;
var badIterations = 0;
do
{
iterationNumber++;
train.Iteration();
var validationError = DataUtil.CalculateClassificationError(validationData, model);
if (validationError < bestError)
{
badIterations = 0;
bestError = validationError;
}
else
{
badIterations++;
}
if (train.Done)
{
done = true;
}
else if (badIterations > tolerate)
{
done = true;
}
else if (double.IsNaN(train.LastError))
{
Console.WriteLine("Training failed.");
done = true;
}
Console.WriteLine("Iteration #" + iterationNumber
+ ", Iteration Score=" + train.LastError
+ ", Validation Incorrect= %" + validationError*100.0
+ ", " + train.Status);
} while (!done);
train.FinishTraining();
Console.WriteLine("Final score: " + bestError*100.0);
}
public ClusteringClassificationQualityEvaluator(DataMining.ClassificationMeasures.IClassificationQualityMeasure measure, IClassificationAlgorithm algorithm)
: base(null)
{
this._classificationAlgorithm = algorithm;
this._measure = measure;
}
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);
}
public void PerformIterationsClassifyEarlyStop(ILearningMethod train,
IClassificationAlgorithm model,
IList<BasicData> validationData,
int tolerate)
{
var iterationNumber = 0;
var done = false;
var bestError = double.PositiveInfinity;
var badIterations = 0;
var bestParams = new double[model.LongTermMemory.Length];
var bestTrainingError = 0.0;
do
{
iterationNumber++;
train.Iteration();
var validationError = DataUtil.CalculateClassificationError(validationData, model);
if (validationError < bestError)
{
badIterations = 0;
bestError = validationError;
bestTrainingError = train.LastError;
Array.Copy(model.LongTermMemory, bestParams, bestParams.Length);
}
else
{
badIterations++;
}
if (train.Done)
{
done = true;
}
else if (badIterations > tolerate)
{
done = true;
}
else if (double.IsNaN(train.LastError))
{
Console.WriteLine("Weights unstable, stopping training.");
done = true;
}
Console.WriteLine("Iteration #" + iterationNumber
+ ", training error=" + train.LastError
+ ", validation # Incorrect= %" + validationError*100.0
+ ", " + train.Status);
} while (!done);
train.FinishTraining();
Console.WriteLine("Best training error: " + bestTrainingError);
Console.WriteLine("Restoring weights to best iteration");
Array.Copy(bestParams, model.LongTermMemory, bestParams.Length);
}
public static BayesianClusterMultinetClassifier ConstructClusterBMNClassifier(ClusteringSolution clusteringSolution, IClassificationAlgorithm BayesianClassificationAlgorithms, DataMining.Data.Dataset trainingSet)
{
BayesianClusterMultinetClassifier BMNClassifier = new BayesianClusterMultinetClassifier(trainingSet.Metadata, clusteringSolution);
foreach (Cluster cluster in clusteringSolution.Clusters)
{
BayesianClassificationAlgorithms.Dataset = cluster.ConvertToDataset();
BayesianNetworkClassifier BNClassifier = BayesianClassificationAlgorithms.CreateClassifier() as BayesianNetworkClassifier;
BMNClassifier.AddBayesianNetworkClassifier(cluster.Label, BNClassifier);
}
return(BMNClassifier);
}
public override void Deserialize(MLSerializer ser)
{
m_SubAlgorithm = ser.ReadMLSerializable("SUB_ALGORITHM") as IClassificationAlgorithm <double[]>;
}
