C# Instance.classIsMissing方法代码示例

		/// <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();
				}
			}
		}