public Prediction Classify(DataMining.Data.Example example)
{
example = example.Clone() as DataMining.Data.Example;
example.Label = -1;
this._classProbabilities = new double[this._metadata.Target.Values.Length];
int resultIndex = 0;
for (int classIndex = 0; classIndex < this._metadata.Target.Values.Length; classIndex++)
{
BayesianNetwork bayesianNetwork = this._bayesianNetworks[classIndex];
double probability = this._metadata.Target.ValueCounts[classIndex] / (double)this._metadata.Size;
probability *= bayesianNetwork.GetProbability(example);
this._classProbabilities[classIndex] = probability;
if (probability > this._classProbabilities[resultIndex])
{
resultIndex = classIndex;
}
}
double sum = this._classProbabilities.Sum();
for (int i = 0; i < this._classProbabilities.Length; i++)
{
this._classProbabilities[i] /= sum;
}
return(new Prediction(resultIndex, this._classProbabilities[resultIndex]));
}
public Prediction Classify(DataMining.Data.Example example)
{
example = example.Clone() as DataMining.Data.Example;
example.Label = -1;
double[] classProbabilities = new double[this._metadata.Target.Values.Length];
int resultIndex = 0;
for (int classIndex = 0; classIndex < classProbabilities.Length; classIndex++)
{
double probability = this.GetProbability(example, classIndex);
classProbabilities[classIndex] = probability;
if (probability > classProbabilities[resultIndex])
{
resultIndex = classIndex;
}
}
double sum = classProbabilities.Sum();
for (int i = 0; i < classProbabilities.Length; i++)
{
classProbabilities[i] /= sum;
}
return(new Prediction(resultIndex, classProbabilities[resultIndex]));
}
public Prediction Classify(DataMining.Data.Example example)
{
example = example.Clone() as DataMining.Data.Example;
example.Label = -1;
int clusterIndex = this._clusteringSolution.GetExampleNativeCluster(example);
Prediction prediction = this._bayesianNetworkClassfiers[clusterIndex].Classify(example);
return(prediction);
}
public double GetProbability(DataMining.Data.Example example, int classValueIndex)
{
//initial proir class probability
double probability = this._metadata.Target.ValueCounts[classValueIndex] / (double)this._metadata.Size;
double termProbability = 0;
Variable classVariable = this.Variables[this._metadata.Target.Index];
if (classVariable.Parents != null)
{
List <Term> parentValues = new List <Term>();
foreach (Variable parent in classVariable.Parents)
{
parentValues.Add(new Term(parent.Index, example[parent.Index]));
}
//proir class probability when it has parents
probability = this.GetConditionalProbability(new Term(classVariable.Index, classValueIndex), parentValues);
}
//------------------------------------------------------------------------------------
//liklihood (probability of child varibales)
for (int attributeIndex = 0; attributeIndex < example.Values.Length; attributeIndex++)
{
Variable variable = this.Variables[attributeIndex];
int valueIndex = example[attributeIndex];
if (variable.Parents == null)
{
continue;
}
List <Term> parentValues = new List <Term>();
foreach (Variable parent in variable.Parents)
{
if (parent.Index == this._metadata.Target.Index)
{
parentValues.Add(new Term(parent.Index, classValueIndex));
}
else
{
parentValues.Add(new Term(parent.Index, example[parent.Index]));
}
}
termProbability = this.GetConditionalProbability(new Term(attributeIndex, example[attributeIndex]), parentValues);
probability *= termProbability;
}
return(probability);
}
public Prediction Classify(DataMining.Data.Example example)
{
for (int i = 0; i < this._inputLayer.Length; i++)
{
this._inputLayer[i].Output = example[i];
}
for (int i = 0; i < this._hiddenLayer.Length; i++)
{
SetOutput(this._hiddenLayer[i]);
}
for (int i = 0; i < this._outputLayer.Length; i++)
{
SetOutput(this._outputLayer[i]);
}
;
int maxLabel = 0;
double [] scores = new double[_outputLayer.Length];
for (int i = 0; i < this._outputLayer.Length; i++)
{
scores[i] = this._outputLayer[i].Output;
if (scores[i] > scores[maxLabel])
{
maxLabel = i;
}
}
Prediction prediction = new Prediction(maxLabel, scores);
return(prediction);
}
public double GetProbability(DataMining.Data.Example example)
{
double probability = 1;
double termProbability = 0;
for (int attributeIndex = 0; attributeIndex < example.Values.Length; attributeIndex++)
{
Variable variable = this.Variables[attributeIndex];
int valueIndex = example[attributeIndex];
if (variable.Parents == null)
{
termProbability = variable.Attribute.ValueCounts[valueIndex] / (double)this._metadata.Size;
if (termProbability == 0)
{
termProbability = BayesianNetwork.default_value;
}
}
else
{
List <Term> parentValues = new List <Term>();
foreach (Variable parent in variable.Parents)
{
if (parent.Index != this._metadata.Target.Index)
{
parentValues.Add(new Term(parent.Index, example[parent.Index]));
}
}
termProbability = this.GetConditionalProbability(new Term(attributeIndex, example[attributeIndex]), parentValues);
}
probability *= termProbability;
}
return(probability);
}
