/// <summary> Updates all the statistics about a classifiers performance for
/// the current test instance.
///
/// </summary>
/// <param name="predictedDistribution">the probabilities assigned to
/// each class
/// </param>
/// <param name="instance">the instance to be classified
/// </param>
/// <throws> Exception if the class of the instance is not </throws>
/// <summary> set
/// </summary>
protected internal virtual void updateStatsForClassifier(double[] predictedDistribution, Instance instance)
{
//UPGRADE_WARNING: Data types in Visual C# might be different. Verify the accuracy of narrowing conversions. "ms-help://MS.VSCC.v80/dv_commoner/local/redirect.htm?index='!DefaultContextWindowIndex'&keyword='jlca1042'"
int actualClass = (int) instance.classValue();
if (!instance.classIsMissing())
{
updateMargins(predictedDistribution, actualClass, instance.weight());
// Determine the predicted class (doesn't detect multiple
// classifications)
int predictedClass = - 1;
double bestProb = 0.0;
for (int i = 0; i < m_NumClasses; i++)
{
if (predictedDistribution[i] > bestProb)
{
predictedClass = i;
bestProb = predictedDistribution[i];
}
}
m_WithClass += instance.weight();
// Determine misclassification cost
if (m_CostMatrix != null)
{
if (predictedClass < 0)
{
// For missing predictions, we assume the worst possible cost.
// This is pretty harsh.
// Perhaps we could take the negative of the cost of a correct
// prediction (-m_CostMatrix.getXmlElement(actualClass,actualClass)),
// although often this will be zero
m_TotalCost += instance.weight() * m_CostMatrix.getMaxCost(actualClass);
}
else
{
m_TotalCost += instance.weight() * m_CostMatrix.getXmlElement(actualClass, predictedClass);
}
}
// Update counts when no class was predicted
if (predictedClass < 0)
{
m_Unclassified += instance.weight();
return ;
}
double predictedProb = System.Math.Max(MIN_SF_PROB, predictedDistribution[actualClass]);
double priorProb = System.Math.Max(MIN_SF_PROB, m_ClassPriors[actualClass] / m_ClassPriorsSum);
if (predictedProb >= priorProb)
{
m_SumKBInfo += (Utils.log2(predictedProb) - Utils.log2(priorProb)) * instance.weight();
}
else
{
m_SumKBInfo -= (Utils.log2(1.0 - predictedProb) - Utils.log2(1.0 - priorProb)) * instance.weight();
}
m_SumSchemeEntropy -= Utils.log2(predictedProb) * instance.weight();
m_SumPriorEntropy -= Utils.log2(priorProb) * instance.weight();
updateNumericScores(predictedDistribution, makeDistribution(instance.classValue()), instance.weight());
// Update other stats
m_ConfusionMatrix[actualClass][predictedClass] += instance.weight();
if (predictedClass != actualClass)
{
m_Incorrect += instance.weight();
}
else
{
m_Correct += instance.weight();
}
}
else
{
m_MissingClass += instance.weight();
}
}
/// <summary> Updates all the statistics about a predictors performance for
/// the current test instance.
///
/// </summary>
/// <param name="predictedValue">the numeric value the classifier predicts
/// </param>
/// <param name="instance">the instance to be classified
/// </param>
/// <throws> Exception if the class of the instance is not </throws>
/// <summary> set
/// </summary>
protected internal virtual void updateStatsForPredictor(double predictedValue, Instance instance)
{
if (!instance.classIsMissing())
{
// Update stats
m_WithClass += instance.weight();
if (Instance.isMissingValue(predictedValue))
{
m_Unclassified += instance.weight();
return ;
}
m_SumClass += instance.weight() * instance.classValue();
m_SumSqrClass += instance.weight() * instance.classValue() * instance.classValue();
m_SumClassPredicted += instance.weight() * instance.classValue() * predictedValue;
m_SumPredicted += instance.weight() * predictedValue;
m_SumSqrPredicted += instance.weight() * predictedValue * predictedValue;
if (m_ErrorEstimator == null)
{
setNumericPriorsFromBuffer();
}
double predictedProb = Math.Max(m_ErrorEstimator.getProbability(predictedValue - instance.classValue()), MIN_SF_PROB);
double priorProb = Math.Max(m_PriorErrorEstimator.getProbability(instance.classValue()), MIN_SF_PROB);
m_SumSchemeEntropy -= Utils.log2(predictedProb) * instance.weight();
m_SumPriorEntropy -= Utils.log2(priorProb) * instance.weight();
m_ErrorEstimator.addValue(predictedValue - instance.classValue(), instance.weight());
updateNumericScores(makeDistribution(predictedValue), makeDistribution(instance.classValue()), instance.weight());
}
else
m_MissingClass += instance.weight();
}
/// <summary> Updates the class prior probabilities (when incrementally
/// training)
///
/// </summary>
/// <param name="instance">the new training instance seen
/// </param>
/// <throws> Exception if the class of the instance is not </throws>
/// <summary> set
/// </summary>
public virtual void updatePriors(Instance instance)
{
if (!instance.classIsMissing())
{
if (!m_ClassIsNominal)
{
if (!instance.classIsMissing())
{
addNumericTrainClass(instance.classValue(), instance.weight());
}
}
else
{
//UPGRADE_WARNING: Data types in Visual C# might be different. Verify the accuracy of narrowing conversions. "ms-help://MS.VSCC.v80/dv_commoner/local/redirect.htm?index='!DefaultContextWindowIndex'&keyword='jlca1042'"
m_ClassPriors[(int) instance.classValue()] += instance.weight();
m_ClassPriorsSum += instance.weight();
}
}
}