public static BayesianNetworkClassifier CreateABCMinerPlusIClassifier(int seed, int iterations, int colonySize, int localColonySize, int convergence, int maxParents, Dataset trainingSet, DataMining.ClassificationMeasures.IClassificationQualityMeasure measure, bool performLocalSearch, bool fireEvents)
{
DataMining.Utilities.RandomUtility.Initialize(seed);
VariableTypeAssigmentInvalidator invalidator1 = new VariableTypeAssigmentInvalidator();
BayesianClassificationQualityEvaluator evaluator = new BayesianClassificationQualityEvaluator(measure);
SimpleVariableTypeAssignmentLocalSearch localSearch1 = new SimpleVariableTypeAssignmentLocalSearch(evaluator);
DefaultHeuristicCalculator <VariableTypeAssignment> calculator1 = new DefaultHeuristicCalculator <VariableTypeAssignment>();
Problem <VariableTypeAssignment> problem1 = new Problem <VariableTypeAssignment>(invalidator1, calculator1, evaluator, localSearch1);
CyclicRelationInvalidator invalidator2 = new CyclicRelationInvalidator();
BackwardRemovalLocalSearch localSearch2 = new BackwardRemovalLocalSearch(evaluator);
CMICalculator calculator = new CMICalculator();
Problem <Edge> problem2 = new Problem <Edge>(invalidator2, calculator, evaluator, localSearch2);
ABCMinerPlusI abcMinerPlusI = new ABCMinerPlusI(iterations, colonySize, localColonySize, convergence, problem2, problem1, maxParents, trainingSet, performLocalSearch);
if (fireEvents)
{
abcMinerPlusI.ABCAlgorithm.OnPostAntSolutionContruction += new EventHandler(abclassifier_OnPostAntSolutionContruction);
abcMinerPlusI.ABCAlgorithm.OnPostColonyIteration += new EventHandler(abclassifier_OnPostColonyIteration);
abcMinerPlusI.ABCMinerAlgorithm.OnPostAntSolutionContruction += new EventHandler(abclassifier_OnPostAntSolutionContruction);
abcMinerPlusI.ABCMinerAlgorithm.OnPostColonyIteration += new EventHandler(abclassifier_OnPostColonyIteration);
}
BayesianNetworks.Model.BayesianNetworkClassifier bnclassifier = abcMinerPlusI.CreateClassifier() as BayesianNetworkClassifier;
return(bnclassifier);
}
public static BayesianNetworkClassifier CreateGreedyBayesianClassifier(int maxDependencies, int maxEvaluations, Dataset trainingSet, DataMining.ClassificationMeasures.IClassificationQualityMeasure qualityEvaluator, bool fireEvents)
{
CyclicRelationInvalidator invalidator = new CyclicRelationInvalidator();
invalidator.MaxDependencies = maxDependencies;
BayesianClassificationQualityEvaluator evaluator = new BayesianClassificationQualityEvaluator(qualityEvaluator);
evaluator.ValidationSet = trainingSet;
BackwardRemovalLocalSearch localSearch = new BackwardRemovalLocalSearch(evaluator);
Problem <Edge> problem = new Problem <Edge>(invalidator, null, evaluator, localSearch);
GHC hcblassifier = new GHC(0, 0, 0, problem, maxEvaluations, trainingSet, trainingSet);
if (fireEvents)
{
hcblassifier.OnPostEvaluation += new EventHandler(hcblassifier_OnPostEvaluation);
hcblassifier.OnProgress += new EventHandler(hcblassifier_OnProgress);
}
hcblassifier.Work();
BayesianNetworks.Model.BayesianNetworkClassifier bnclassifier = hcblassifier.BayesianNetworkClassifier;
return(bnclassifier);
}
public iFourmi.DataMining.Model.IClassifier CreateClassifier()
{
Solution <Edge> solution = new Solution <Edge>();
CyclicRelationInvalidator invalidator = new CyclicRelationInvalidator();
invalidator.MaxDependencies = 1;
ConstructionGraph <Edge> constructionGraph = ConstructionGraphBuilder.BuildBNConstructionGraph(this._trainingset.Metadata);
CMICalculator cmiCalculator = new CMICalculator();
cmiCalculator.Dataset = this._trainingset;
constructionGraph.SetHeuristicValues(cmiCalculator, false);
List <DecisionComponent <Edge> > components = constructionGraph.Components.OrderByDescending(e => e.Heuristic).ToList();
while (components.Count != 0)
{
DecisionComponent <Edge> component = components[0];
solution.Components.Add(component);
invalidator.Invalidate(component, solution, constructionGraph);
components = constructionGraph.Components.Where(e => e.IsValid).OrderByDescending(e => e.Heuristic).ToList();
}
BayesianNetworkClassifier BNClassifier = new BayesianNetworks.Model.BayesianNetworkClassifier(this._trainingset.Metadata, solution.ToList());
BNClassifier.LearnParameters(this._trainingset);
return(BNClassifier);
}
public void EvaluateSolutionQuality(Solution <VariableTypeAssignment> solution)
{
double quality = 0;
BayesianNetworks.Model.BayesianNetworkClassifier bnclassifier = null;
if (InputVariableDependencies == null)
{
bnclassifier = new BayesianNetworks.Model.BayesianNetworkClassifier(this._validationSet.Metadata, solution.ToList());
}
else
{
bnclassifier = new BayesianNetworks.Model.BayesianNetworkClassifier(this._validationSet.Metadata, solution.ToList(), InputVariableDependencies);
}
bnclassifier.LearnParameters(this._learningSet);
DataMining.ClassificationMeasures.ConfusionMatrix[] list = DataMining.ClassificationMeasures.ConfusionMatrix.GetConfusionMatrixes(bnclassifier, _validationSet);
quality = _measure.CalculateMeasure(list);
//penalty
int x = solution.Components.FindAll(c => c.Element.Type == VariableType.Cause).Count;
double penality = Math.Pow(2, x - solution.Components.Count);
solution.Quality = quality - penality;
}
public override void Work()
{
this.CreateSolution();
this._bnclassifier = new BayesianNetworks.Model.BayesianNetworkClassifier(_trainingSet.Metadata, _solution.ToList());
this._bnclassifier.LearnParameters(this._trainingSet);
}
public IClassifier CreateClassifier()
{
this.Initialize();
this.Work();
this._bnclassifier = new BayesianNetworks.Model.BayesianNetworkClassifier(this._trainingSet.Metadata, this._bestAnt2.Solution.ToList(), this._bestAnt1.Solution.ToList());
this._bnclassifier.LearnParameters(this._trainingSet);
return(this._bnclassifier);
}
public K2Algorithm(int maxIterations, int colonySize, int convergenceIterations, Problem<Edge> problem, int maxEvaluations, Dataset trainingset, Dataset validationSet)
: base(maxIterations, colonySize, convergenceIterations, BuildConstructionGraph(trainingset.Metadata), problem)
{
this._maxEvaluations = maxEvaluations;
this._solution = new Solution<Edge>();
this._trainingSet = trainingset;
this._validationSet = validationSet;
this._variablesK2 = new double[this._trainingSet.Metadata.Attributes.Length];
this._K2Calculator = new BayesianNetworks.Utilities.K2Calculator();
this._bayesianNetwork = new BayesianNetworkClassifier(trainingset.Metadata);
}
public override void Work()
{
for (this._currentIteration = 0; this._currentIteration < this._maxIterations; this._currentIteration++)
{
if (this._currentIteration % 5 == 0)
{
DataMining.Data.Dataset[] datasets = this._trainingSet.SplitRandomly(0.7);
((BayesianClassificationQualityEvaluator)this._problem.SolutionQualityEvaluator).LearningSet = datasets[0];
((BayesianClassificationQualityEvaluator)this._problem.SolutionQualityEvaluator).ValidationSet = datasets[1];
}
this.CreateSolution();
if (_performLocalSearch)
{
this.PerformLocalSearch(this._iterationBestAnt);
}
this.UpdateBestAnt();
if (this.IsConverged())
{
break;
}
this.UpdatePheromoneLevels();
if (OnPostColonyIteration != null)
{
this.OnPostColonyIteration(this, null);
}
}
if (!_performLocalSearch)
{
this.PerformLocalSearch(this._bestAnt);
}
if (_variableTypeAssignemts != null)
{
this._bnclassifier = new BayesianNetworks.Model.BayesianNetworkClassifier(this._trainingSet.Metadata, this._variableTypeAssignemts, this._bestAnt.Solution.ToList());
}
else
{
this._bnclassifier = new BayesianNetworks.Model.BayesianNetworkClassifier(this._trainingSet.Metadata, this._bestAnt.Solution.ToList());
}
this._bnclassifier.LearnParameters(this._trainingSet);
}
public static string ExportToGaphSharpXml(BayesianNetworks.Model.BayesianNetworkClassifier graph)
{
StringBuilder builder = new StringBuilder();
builder.Append("<graphml>");
builder.Append(Environment.NewLine);
builder.Append("<graph id=\"" + graph.Metadata.DatasetName + "\" ");
builder.Append("edgedefault=\"directed\" ");
builder.Append("parse.nodes=\"" + graph.Variables.Length.ToString() + "\" ");
builder.Append("parse.edges=\"" + graph.Edges.Length.ToString() + "\" ");
builder.Append("parse.order=\"nodesfirst\" ");
builder.Append("parse.nodeids=\"free\" ");
builder.Append("parse.edgeids=\"free\" >");
builder.Append(Environment.NewLine);
foreach (BayesianNetworks.Model.Variable variable in graph.Variables)
{
builder.Append("<node id=\"" + variable.Attribute.Name + "\" />");
builder.Append(Environment.NewLine);
}
int counter = 0;
foreach (BayesianNetworks.Model.Edge edge in graph.Edges)
{
string parent = graph.Metadata.Target.Index == edge.ParentIndex?graph.Metadata.Target.Name: graph.Metadata.Attributes[edge.ParentIndex].Name;
string child = graph.Metadata.Target.Index == edge.ChildIndex ? graph.Metadata.Target.Name : graph.Metadata.Attributes[edge.ChildIndex].Name;
builder.Append("<edge id=\"" + counter.ToString() + "\" source=\"" + parent + "\" target=\"" + child + "\" />");
builder.Append(Environment.NewLine);
counter++;
}
builder.Append("</graph>");
builder.Append(Environment.NewLine);
builder.Append("</graphml>");
return(builder.ToString());
}
public static BayesianNetworkClassifier CreateABCClassifier(int seed, int iterations, int colonySize, int convergence, Dataset trainingSet, DataMining.ClassificationMeasures.IClassificationQualityMeasure measure, bool performLocalSearch, bool fireEvents)
{
DataMining.Utilities.RandomUtility.Initialize(seed);
VariableTypeAssigmentInvalidator invalidator = new VariableTypeAssigmentInvalidator();
BayesianClassificationQualityEvaluator evaluator = new BayesianClassificationQualityEvaluator(measure);
VariableTypeAssignmentLocalSearch localSearch = new VariableTypeAssignmentLocalSearch(evaluator);
DefaultHeuristicCalculator <VariableTypeAssignment> calculator = new DefaultHeuristicCalculator <VariableTypeAssignment>();
Problem <VariableTypeAssignment> problem = new Problem <VariableTypeAssignment>(invalidator, calculator, evaluator, localSearch);
ABC abc = new ABC(iterations, colonySize, convergence, problem, trainingSet, performLocalSearch);
if (fireEvents)
{
abc.OnPostAntSolutionContruction += new EventHandler(abclassifier_OnPostAntSolutionContruction);
abc.OnPostColonyIteration += new EventHandler(abclassifier_OnPostColonyIteration);
}
BayesianNetworks.Model.BayesianNetworkClassifier bnclassifier = abc.CreateClassifier() as BayesianNetworkClassifier;
return(bnclassifier);
}
public static BayesianNetworkClassifier CreateABCMinerClassifier(int seed, int iterations, int colonySize, int convergence, int dependencies, Dataset trainingSet, DataMining.ClassificationMeasures.IClassificationQualityMeasure qualityEvaluator, IHeuristicValueCalculator <Edge> calculator, bool performLocalSearch, bool fireEvents)
{
DataMining.Utilities.RandomUtility.Initialize(seed);
CyclicRelationInvalidator invalidator = new CyclicRelationInvalidator();
BayesianClassificationQualityEvaluator evaluator = new BayesianClassificationQualityEvaluator(qualityEvaluator);
BackwardRemovalLocalSearch localSearch = new BackwardRemovalLocalSearch(evaluator);
Problem <Edge> problem = new Problem <Edge>(invalidator, calculator, evaluator, localSearch);
ABCMiner abcminer = new ABCMiner(iterations, colonySize, convergence, problem, dependencies, performLocalSearch);
abcminer.Dataset = trainingSet;
if (fireEvents)
{
abcminer.OnPostAntSolutionContruction += new EventHandler(abclassifier_OnPostAntSolutionContruction);
abcminer.OnPostColonyIteration += new EventHandler(abclassifier_OnPostColonyIteration);
}
BayesianNetworks.Model.BayesianNetworkClassifier bnclassifier = abcminer.CreateClassifier() as BayesianNetworkClassifier;
return(bnclassifier);
}
public static BayesianNetworkClassifier CreateK2BayesianClassifier(int maxDependencies, int maxEvaluations, Dataset trainingSet, bool fireEvents)
{
CyclicRelationInvalidator invalidator = new CyclicRelationInvalidator();
invalidator.MaxDependencies = maxDependencies;
Problem <Edge> problem = new Problem <Edge>(invalidator, null, null, null);
K2Algorithm k2blassifier = new K2Algorithm(0, 0, 0, problem, maxEvaluations, trainingSet, trainingSet);
if (fireEvents)
{
k2blassifier.OnPostEvaluation += new EventHandler(hcblassifier_OnPostEvaluation);
k2blassifier.OnProgress += new EventHandler(hcblassifier_OnProgress);
}
k2blassifier.Work();
BayesianNetworks.Model.BayesianNetworkClassifier bnclassifier = k2blassifier.BayesianNetworkClassifier;
return(bnclassifier);
}
