#include <Classifier2.h>

Public Types
typedef Classifier2 *	Classifier2Ptr

Public Member Functions
	Classifier2 (TrainingProcess2Ptr _trainer, RunLog &_log)

virtual	~Classifier2 ()

bool	Abort () const

MLClassPtr	ClassifyAExample (FeatureVector &example)

void	ClassifyAExample (FeatureVector &example, MLClassPtr &predClass1, MLClassPtr &predClass2, kkint32 &predClass1Votes, kkint32 &predClass2Votes, double &knownClassProb, double &predClass1Prob, double &predClass2Prob, kkint32 &numOfWinners, double &breakTie)

MLClassPtr	ClassifyAExample (FeatureVector &example, kkint32 &numOfWinners, bool &knownClassOneOfTheWinners)

MLClassPtr	ClassifyAExample (FeatureVector &example, double &probability, kkint32 &numOfWinners, bool &knownClassOneOfTheWinners, double &breakTie)

const KKStr &	ConfigRootName () const

std::vector< ProbNamePair >	FindWorstSupportVectors (FeatureVectorPtr example, kkint32 numToFind, MLClassPtr c1, MLClassPtr c2)
	For a given two class pair return the names of the 'numToFind' worst S/V's. More...

std::vector< ProbNamePair >	FindWorstSupportVectors2 (FeatureVectorPtr example, kkint32 numToFind, MLClassPtr c1, MLClassPtr c2)
	For a given two class pair return the names of the 'numToFind' worst S/V's. More...

virtual kkint32	MemoryConsumedEstimated () const

void	PredictRaw (FeatureVectorPtr example, MLClassPtr &predClass, double &dist)

ClassProbList const *	PriorProbability () const
	Returns the distribution of the training data used to build the classifier. More...

void	ProbabilitiesByClass (const MLClassList &classes, FeatureVectorPtr example, kkint32 votes, double probabilities)
	For a given feature vector return back the probabilities and votes for each class. More...

ClassProbListPtr	ProbabilitiesByClass (FeatureVectorPtr example)

void	ProbabilitiesByClassDual (FeatureVectorPtr example, KKStr &classifier1Desc, KKStr &classifier2Desc, ClassProbListPtr &classifier1Results, ClassProbListPtr &classifier2Results)

void	RetrieveCrossProbTable (MLClassList &classes, double **crossProbTable)

SVM_SelectionMethod	SelectionMethod () const

std::vector< KKStr >	SupportVectorNames (MLClassPtr c1, MLClassPtr c2)

Detailed Description

Definition at line 75 of file Classifier2.h.

Member Typedef Documentation

typedef Classifier2* KKMLL::Classifier2::Classifier2Ptr

Definition at line 78 of file Classifier2.h.

Constructor & Destructor Documentation

Classifier2::Classifier2	(	TrainingProcess2Ptr	_trainer,
		RunLog &	_log
	)

Definition at line 42 of file Classifier2.cpp.

References KKMLL::TrainingProcess2::Abort(), KKB::KKStr::Concat(), KKMLL::TrainingProcess2::Config(), KKMLL::TrainingConfiguration2::ConfigRootName(), KKMLL::TrainingProcess2::FeaturesAlreadyNormalized(), KKMLL::MLClassList::GetNoiseClass(), KKMLL::MLClassList::GetUnKnownClass(), KKB::KKException::KKException(), KKB::KKStr::KKStr(), KKMLL::TrainingProcess2::MLClasses(), KKMLL::MLClassList::MLClassList(), KKMLL::Model::ModelType(), KKMLL::Model::OldSVM, KKB::KKStr::operator=(), KKMLL::ModelOldSVM::SvmModel(), KKMLL::TrainingProcess2::TrainedModel(), and KKMLL::Model::ValidModel().

Referenced by KKMLL::ModelDual::ReadXML(), and KKMLL::ModelDual::TrainModel().

                           :
 
   abort                     (false),
   classifierClassIndex      (),
   classClassifierIndex      (),
   featuresAlreadyNormalized (false),
   mlClasses                 (NULL),
   log                       (_log),
   subClassifiers            (NULL),
   configRootName            (),
   trainedModel              (NULL),
   trainedModelOldSVM        (NULL),
   trainedModelSVMModel      (NULL),
   noiseMLClass              (NULL),
   trainingProcess           (_trainer),
   unKnownMLClass            (NULL)
 {
   if  (!_trainer)
   {
     log.Level (-1) << endl
       << "Classifier2::Classifier2    ***ERROR***     (_trainer == NULL)" << endl
       << endl;
     throw KKException ("Classifier2::Classifier2    ***ERROR***     (_trainer == NULL)");
   }
 
   if  (_trainer->Abort ())
   {
     log.Level (-1) << endl
       << "Classifier2::Classifier2    ***ERROR***     '_trainer' is invalid." << endl
       << endl;
     throw KKException ("Classifier2::Classifier2    ***ERROR***     '_trainer' is invalid.");
   }
 
   if  (trainingProcess->Config () != NULL)
     configRootName = trainingProcess->Config ()->ConfigRootName ();
 
   featuresAlreadyNormalized = trainingProcess->FeaturesAlreadyNormalized ();
   mlClasses = new MLClassList (*(_trainer->MLClasses ()));
   trainedModel = _trainer->TrainedModel ();
   if  (trainedModel == NULL)
   {
     KKStr errMsg = "Classifier2::Classifier2    ***ERROR***     (trainedModel == NULL).";
     log.Level (-1) << endl << endl << errMsg << endl << endl;
     throw KKException (errMsg);
   }
 
   if  (!trainedModel->ValidModel ())
   {
     KKStr errMsg = "Classifier2::Classifier2    ***ERROR***     trainedModel is not valid.";
     log.Level (-1) << endl << endl << errMsg << endl << endl;
     throw KKException (errMsg);
   }
 
   log.Level (20) << "Classifier2::Classifier2" << endl;
   noiseMLClass   = mlClasses->GetNoiseClass ();
   unKnownMLClass = mlClasses->GetUnKnownClass ();
 
   if  (trainedModel->ModelType () == Model::ModelTypes::OldSVM)
   {
     trainedModelOldSVM = dynamic_cast<ModelOldSVMPtr> (trainedModel);
     if  (trainedModelOldSVM)
       trainedModelSVMModel = trainedModelOldSVM->SvmModel ();
   }
 
   BuildSubClassifierIndex ();
 }

Classifier2::~Classifier2 ( )

virtual

Definition at line 113 of file Classifier2.cpp.

 {
   delete mlClasses;       mlClasses      = NULL;
   delete subClassifiers;  subClassifiers = NULL;
 }

Member Function Documentation

bool KKMLL::Classifier2::Abort ( ) const

inline

Definition at line 86 of file Classifier2.h.

86 {return abort;}

MLClassPtr Classifier2::ClassifyAExample ( FeatureVector & example )

Definition at line 413 of file Classifier2.cpp.

References ClassifyAExample().

Referenced by KKMLL::ModelDual::Predict().

 {
   kkint32 numOfWinners = 0;
   bool   knownClassOneOfTheWinners = false;
   return  ClassifyAExample (example, numOfWinners, knownClassOneOfTheWinners);
 }

void Classifier2::ClassifyAExample	(	FeatureVector &	example,
		MLClassPtr &	predClass1,
		MLClassPtr &	predClass2,
		kkint32 &	predClass1Votes,
		kkint32 &	predClass2Votes,
		double &	knownClassProb,
		double &	predClass1Prob,
		double &	predClass2Prob,
		kkint32 &	numOfWinners,
		double &	breakTie
	)

Definition at line 270 of file Classifier2.cpp.

References ClassifyAExample(), KKMLL::FeatureVector::MLClass(), and KKMLL::Model::Predict().

Referenced by ClassifyAExample(), and KKMLL::ModelDual::Predict().

 {
   bool   knownClassOneOfTheWiners = false;
 
   predClass1     = NULL;
   predClass2     = NULL;
   knownClassProb = -1.0f;
   predClass1Prob = -1.0f;
   predClass2Prob = -1.0f;
 
   MLClassPtr origClass  = example.MLClass ();
 
 
   trainedModel->Predict (&example,
                          origClass,
                          predClass1,
                          predClass2,
                          predClass1Votes,
                          predClass2Votes,
                          knownClassProb,
                          predClass1Prob,
                          predClass2Prob,
                          numOfWinners,
                          knownClassOneOfTheWiners,
                          breakTie,
                          log
                         );
 
   if  (!predClass1)
     predClass1 = noiseMLClass;
 
 
   if  (subClassifiers)
   {
     Classifier2Ptr  subClassifer = LookUpSubClassifietByClass (predClass1);
     if  (subClassifer)
     {
       MLClassPtr       subPredClass1      = NULL;
       MLClassPtr       subPredClass2      = NULL;
       kkint32          subPredClass1Votes = 0;
       kkint32          subPredClass2Votes = 0;
       double           subKnownClassProb  = 0.0;
       double           subPredClass1Prob  = 0.0;
       double           subPredClass2Prob  = 0.0;
       kkint32          subNumOfWinners    = 0;
       double           subBreakTie        = 0.0;
 
       subClassifer->ClassifyAExample (example, subPredClass1, subPredClass2, 
                                     subPredClass1Votes, subPredClass2Votes, subKnownClassProb,
                                     subPredClass1Prob,  subPredClass2Prob,  subNumOfWinners,
                                     subBreakTie
                                    );
       predClass1 = subPredClass1;
       predClass1Votes += subPredClass1Votes;
       predClass1Prob  *= subPredClass1Prob;
       knownClassProb  *= subKnownClassProb;
       numOfWinners    += subNumOfWinners;
       breakTie        += subBreakTie * (1.0 - breakTie);
     }
 
     subClassifer = LookUpSubClassifietByClass (predClass2);
     if  (subClassifer)
     {
       MLClassPtr       subPredClass1      = NULL;
       MLClassPtr       subPredClass2      = NULL;
       kkint32          subPredClass1Votes = 0;
       kkint32          subPredClass2Votes = 0;
       double           subKnownClassProb  = 0.0;
       double           subPredClass1Prob  = 0.0;
       double           subPredClass2Prob  = 0.0;
       kkint32          subNumOfWinners    = 0;
       double           subBreakTie        = 0.0;
 
       subClassifer->ClassifyAExample (example, subPredClass1, subPredClass2, 
                                     subPredClass1Votes, subPredClass2Votes, subKnownClassProb,
                                     subPredClass1Prob,  subPredClass2Prob,  subNumOfWinners,
                                     subBreakTie        
                                    );
       predClass2 = subPredClass1;
       predClass2Votes += subPredClass1Votes;
       predClass2Prob  *= subPredClass1Prob;
     }
   }
 
   example.MLClass (predClass1);
 
   return;
 }  /* ClassifyAExample */

MLClassPtr Classifier2::ClassifyAExample	(	FeatureVector &	example,
		kkint32 &	numOfWinners,
		bool &	knownClassOneOfTheWinners
	)

Definition at line 396 of file Classifier2.cpp.

Referenced by ClassifyAExample().

 {
   MLClassPtr       predictedClass = NULL;
 
   // Lets first Normalize Feature Data.
 
   predictedClass = ClassifyAImageOneLevel (example, numOfWinners, knownClassOneOfTheWinners);
 
   return  predictedClass;
 } /* ClassifyAExample */

MLClassPtr Classifier2::ClassifyAExample	(	FeatureVector &	example,
		double &	probability,
		kkint32 &	numOfWinners,
		bool &	knownClassOneOfTheWinners,
		double &	breakTie
	)

Definition at line 373 of file Classifier2.cpp.

 {
   MLClassPtr       predictedClass = NULL;
 
   probability       = 0.0;
 
   predictedClass = ClassifyAImageOneLevel (example, 
                                            probability, 
                                            numOfWinners, 
                                            knownClassOneOfTheWinners,
                                            breakTie
                                           );
   return  predictedClass;
 }  /* ClassifyAExample */

const KKStr& KKMLL::Classifier2::ConfigRootName ( ) const

inline

Definition at line 87 of file Classifier2.h.

Referenced by KKMLL::Classifier2List::LookUpByName().

87 {return configRootName;}

vector< ProbNamePair > Classifier2::FindWorstSupportVectors	(	FeatureVectorPtr	example,
		kkint32	numToFind,
		MLClassPtr	c1,
		MLClassPtr	c2
	)

For a given two class pair return the names of the 'numToFind' worst S/V's.

This method will iterate through all the S/V's removing them one at a time and re-compute the decision boundary and probability. It will then return the S/V's that when removed improve the probability in 'c1's the most.

Parameters

[in]	example	The example that was classified incorrectly.
[in]	numToFind	The number of the worst examples you are looking for.
[in]	c1	Class that the 'example; parameter should have been classed as.
[in]	c2	Class that it was classified as.

Definition at line 442 of file Classifier2.cpp.

 {
   if  (!trainedModelSVMModel)
   {
     vector<ProbNamePair>  results;
     return  results;
   }
 
   return  trainedModelSVMModel->FindWorstSupportVectors (example, numToFind, c1, c2);
 }

vector< ProbNamePair > Classifier2::FindWorstSupportVectors2	(	FeatureVectorPtr	example,
		kkint32	numToFind,
		MLClassPtr	c1,
		MLClassPtr	c2
	)

For a given two class pair return the names of the 'numToFind' worst S/V's.

This method will iterate through all the S/V's removing them one at a time and rebuild a new SVM then submit example for testing.

Parameters

[in]	example	The example that was classified incorrectly.
[in]	numToFind	The number of the worst examples you are looking for.
[in]	c1	Class that the 'example; parameter should have been classed as.
[in]	c2	Class that it was classified as.

Definition at line 460 of file Classifier2.cpp.

 {
   if  (!trainedModelSVMModel)
   {
     vector<ProbNamePair>  results;
     return  results;
   }
 
   return  trainedModelSVMModel->FindWorstSupportVectors2 (example, numToFind, c1, c2);
 }

kkint32 Classifier2::MemoryConsumedEstimated ( ) const

virtual

Definition at line 120 of file Classifier2.cpp.

References KKMLL::MLClassList::MemoryConsumedEstimated().

Referenced by KKMLL::ModelDual::MemoryConsumedEstimated().

 {
   kkint32  memoryConsumedEstimated = sizeof (*this);
   if  (mlClasses)  memoryConsumedEstimated += mlClasses->MemoryConsumedEstimated ();
   return  memoryConsumedEstimated;
 }  /* MemoryConsumedEstimated */

void Classifier2::PredictRaw	(	FeatureVectorPtr	example,
		MLClassPtr &	predClass,
		double &	dist
	)

Definition at line 478 of file Classifier2.cpp.

References PredictRaw(), and KKMLL::Model::PredictRaw().

Referenced by PredictRaw().

 {
   trainedModel->PredictRaw (example, predClass, dist);
   if  (subClassifiers)
   {
     Classifier2Ptr  subClassifer = LookUpSubClassifietByClass (predClass);
     if  (subClassifer)
       subClassifer->PredictRaw (example, predClass, dist);
   }
 }  /* PredictRaw */

ClassProbList const * Classifier2::PriorProbability ( ) const

Returns the distribution of the training data used to build the classifier.

The caller will NOT own this list. Ownership will remain with 'trainingProcess' member of this class.

Definition at line 139 of file Classifier2.cpp.

References KKMLL::TrainingProcess2::PriorProbability().

 {
   if  (!trainingProcess)
     return NULL;
 
   return  trainingProcess->PriorProbability ();
 }  /* PriorProbability */

void Classifier2::ProbabilitiesByClass	(	const MLClassList &	classes,
		FeatureVectorPtr	example,
		kkint32 *	votes,
		double *	probabilities
	)

For a given feature vector return back the probabilities and votes for each class.

Parameters

classes	[in] List of classes that we can be predicted for The ordering of 'votes' and 'probabilities' will be dictated by this list.
example	[in] Feature Vector to make prediction on.
votes	[out] Pointer to list of int's, must be as large as 'classes' The number of votes for each corresponding class will be stored hear.
probabilities	[out] Pointer to list of double's, must be as large as 'classes' The probability for each corresponding class will be stored hear.

Definition at line 495 of file Classifier2.cpp.

References KKMLL::ClassProbList::LookUp(), ProbabilitiesByClass(), KKMLL::ClassProb::probability, and KKMLL::ClassProb::votes.

 {
   ClassProbListPtr  predictions = ProbabilitiesByClass (example);
 
   kkuint32  numClasses = classes.size ();
   for  (kkuint32 x = 0;  x < numClasses;  ++x)
   {
     votes[x] = 0;
     probabilities[x] = 0.0;
 
     MLClassPtr      c = classes.IdxToPtr (x);
     ClassProbPtr cp = predictions->LookUp (c);
     if  (cp)
     {
       votes[x] = (kkint32)(0.5f + cp->votes);
       probabilities[x] = cp->probability;
     }
   }
   delete  predictions;
   predictions= NULL;
 }  /* ProbabilitiesByClass */

ClassProbListPtr Classifier2::ProbabilitiesByClass ( FeatureVectorPtr example )

Definition at line 671 of file Classifier2.cpp.

References KKMLL::Model::ProbabilitiesByClass().

Referenced by KKMLL::ModelDual::ProbabilitiesByClass(), ProbabilitiesByClass(), KKMLL::ModelDual::ProbabilitiesByClassDual(), and KKMLL::ModelDual::ReconcileProbAndVotes().

 {
   if  (!trainedModel)
     return NULL;
 
   ClassProbListPtr  results = trainedModel->ProbabilitiesByClass (example, log);
   if  (!results)
     return NULL;
 
   ClassProbListPtr  expandedResults = ProcessSubClassifersMethod2 (example, results);
   delete  results;
   results = NULL;
 
 
   return  expandedResults;
 }  /* ProbabilitiesByClass */

void Classifier2::ProbabilitiesByClassDual	(	FeatureVectorPtr	example,
		KKStr &	classifier1Desc,
		KKStr &	classifier2Desc,
		ClassProbListPtr &	classifier1Results,
		ClassProbListPtr &	classifier2Results
	)

Definition at line 704 of file Classifier2.cpp.

References KKMLL::Model::ProbabilitiesByClassDual().

 {
   if  (trainedModel)
     trainedModel->ProbabilitiesByClassDual (example, classifier1Desc, classifier2Desc, classifier1Results, classifier2Results, log);
 }

void Classifier2::RetrieveCrossProbTable	(	MLClassList &	classes,
		double **	crossProbTable
	)

Definition at line 692 of file Classifier2.cpp.

References KKMLL::Model::RetrieveCrossProbTable().

Referenced by KKMLL::ModelDual::RetrieveCrossProbTable().

 {
   if  (trainedModel)
     trainedModel->RetrieveCrossProbTable (classes, crossProbTable, log);
   }

SVM_SelectionMethod Classifier2::SelectionMethod ( ) const

Definition at line 129 of file Classifier2.cpp.

References KKMLL::Null, and KKMLL::ModelOldSVM::SelectionMethod().

 {
   if  (!trainedModelOldSVM)
     return  SVM_SelectionMethod::Null;
   else
     return  trainedModelOldSVM->SelectionMethod ();
 }

vector< KKStr > Classifier2::SupportVectorNames	(	MLClassPtr	c1,
		MLClassPtr	c2
	)

Definition at line 423 of file Classifier2.cpp.

 {
   if  (!trainedModelSVMModel)
   {
     vector<KKStr>  results;
     return  results;
   }
   else
   {
     return  trainedModelSVMModel->SupportVectorNames (c1, c2);
   }
 }

The documentation for this class was generated from the following files:

C:/Users/Kurt/GitHub/KSquareLibraries/KKMachineLearning/Classifier2.h
C:/Users/Kurt/GitHub/KSquareLibraries/KKMachineLearning/Classifier2.cpp

Public Types

Public Member Functions

Detailed Description

Member Typedef Documentation

Constructor & Destructor Documentation

Member Function Documentation