#include <ModelSvmBase.h>

Inheritance diagram for KKMLL::ModelSvmBase:

Public Types
typedef ModelSvmBase *	ModelSvmBasePtr

Public Types inherited from KKMLL::Model
typedef Model *	ModelPtr

enum	ModelTypes : int { ModelTypes::Null = 0, ModelTypes::OldSVM = 1, ModelTypes::SvmBase = 2, ModelTypes::KNN = 3, ModelTypes::UsfCasCor = 4, ModelTypes::Dual = 5 }

Public Member Functions
	ModelSvmBase ()

	ModelSvmBase (FactoryFVProducerPtr _factoryFVProducer)

	ModelSvmBase (const KKStr &_name, const ModelParamSvmBase &_param, FactoryFVProducerPtr _factoryFVProducer)

	ModelSvmBase (const ModelSvmBase &_model)

virtual	~ModelSvmBase ()
	Frees any memory allocated by, and owned by the ModelSvmBase. More...

virtual KKStr	Description () const

virtual ModelSvmBasePtr	Duplicate () const

virtual kkint32	MemoryConsumedEstimated () const

virtual ModelTypes	ModelType () const

virtual kkint32	NumOfSupportVectors () const

ModelParamSvmBasePtr	Param ()

virtual MLClassPtr	Predict (FeatureVectorPtr image, RunLog &log)

virtual void	Predict (FeatureVectorPtr example, MLClassPtr knownClass, MLClassPtr &predClass1, MLClassPtr &predClass2, kkint32 &predClass1Votes, kkint32 &predClass2Votes, double &probOfKnownClass, double &predClass1Prob, double &predClass2Prob, kkint32 &numOfWinners, bool &knownClassOneOfTheWinners, double &breakTie, RunLog &log)

virtual ClassProbListPtr	ProbabilitiesByClass (FeatureVectorPtr example, RunLog &log)

virtual void	ProbabilitiesByClass (FeatureVectorPtr example, const MLClassList &_mlClasses, kkint32 _votes, double _probabilities, RunLog &_log)

virtual void	ProbabilitiesByClass (FeatureVectorPtr _example, const MLClassList &_mlClasses, double *_probabilities, RunLog &_log)
	Derives predicted probabilities by class. More...

virtual void	ReadXML (XmlStream &s, XmlTagConstPtr tag, VolConstBool &cancelFlag, RunLog &log)
	To be implemented by derived classes; the parent classes fields will be updated by the derived class calling ReadXMLModelToken. More...

virtual void	RetrieveCrossProbTable (MLClassList &classes, double **crossProbTable, RunLog &log)

virtual void	TrainModel (FeatureVectorListPtr _trainExamples, bool _alreadyNormalized, bool _takeOwnership, VolConstBool &_cancelFlag, RunLog &_log)
	Performs operations such as FeatureEncoding, and Normalization. The actual training of models occurs in the specific derived implementation of 'Model'. More...

virtual void	WriteXML (const KKStr &varName, ostream &o) const

Public Member Functions inherited from KKMLL::Model
	Model ()

	Model (FactoryFVProducerPtr _factoryFVProducer)
	Use this when you are planning on creating a empty model without parameters. More...

	Model (const KKStr &_name, const ModelParam &_param, FactoryFVProducerPtr _factoryFVProducer)
	Construct a instance of 'Model' using the parameters specified in '_param'. More...

	Model (const Model &_madel)
	Copy Constructor. More...

virtual	~Model ()
	Frees any memory allocated by, and owned by the Model. More...

bool	AlreadyNormalized () const

const FeatureEncoder2 &	Encoder () const

FactoryFVProducerPtr	FactoryFVProducer () const

virtual FeatureNumListConstPtr	GetFeatureNums () const

MLClassListPtr	MLClasses () const

MLClassListPtr	MLClassesNewInstance () const

virtual KKStr	ModelTypeStr () const

const KKStr &	Name () const

void	Name (const KKStr &_name)

virtual bool	NormalizeNominalAttributes () const

ModelParamPtr	Param () const

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

virtual FeatureVectorPtr	PrepExampleForPrediction (FeatureVectorPtr fv, bool &newExampleCreated)
	Every prediction method in every class that is inherited from this class should call this method before performing there prediction. Such things as Normalization and Feature Encoding. More...

virtual void	ProbabilitiesByClassDual (FeatureVectorPtr example, KKStr &classifier1Desc, KKStr &classifier2Desc, ClassProbListPtr &classifier1Results, ClassProbListPtr &classifier2Results, RunLog &log)
	Only applied to ModelDual classifier. More...

const KKStr &	RootFileName () const

void	RootFileName (const KKStr &_rootFileName)

virtual FeatureNumListConstPtr	SelectedFeatures () const

const KKB::DateTime &	TimeSaved () const

double	TrainingTime () const

void	TrainingTimeEnd ()
	Derived classes call this method to stop the clock for 'trainingTime'. More...

void	TrainingTimeStart ()
	Derived classes call this method to start the clock for 'trainingTime'. More...

double	TrianingPrepTime () const

bool	ValidModel () const

void	WriteModelXMLFields (std::ostream &o) const
	The "WriteXML" method in Derived classes call this method to include the parents classes fields in the XML data. More...

virtual void	WriteXML (const KKStr &varName, std::ostream &o) const =0

Protected Attributes
ModelParamSvmBasePtr	param

SVM289_MFS::Svm_Model *	svmModel

Protected Attributes inherited from KKMLL::Model
bool	alreadyNormalized

MLClassListPtr	classes

MLClassIndexListPtr	classesIndex

double *	classProbs

double **	crossClassProbTable

kkint32	crossClassProbTableSize

FeatureEncoder2Ptr	encoder

VectorKKStr	errors

FactoryFVProducerPtr	factoryFVProducer

FileDescPtr	fileDesc

NormalizationParmsPtr	normParms

kkint32	numOfClasses

ModelParamPtr	param

KKStr	rootFileName

FeatureVectorListPtr	trainExamples

bool	validModel

kkint32 *	votes

bool	weOwnTrainExamples

Additional Inherited Members
Static Public Member Functions inherited from KKMLL::Model
static ModelPtr	CreateAModel (ModelTypes _modelType, const KKStr &_name, const ModelParam &_param, FactoryFVProducerPtr _factoryFVProducer, VolConstBool &_cancelFlag, RunLog &_log)
	A factory method that will instantiate the appropriate class of training model based off '_modelType'. More...

static ModelTypes	ModelTypeFromStr (const KKStr &_modelingTypeStr)

static KKStr	ModelTypeToStr (ModelTypes _modelingType)

Protected Member Functions inherited from KKMLL::Model
void	AddErrorMsg (const KKStr &errMsg, kkint32 lineNum)

void	AllocatePredictionVariables ()

void	DeAllocateSpace ()

void	NormalizeProbabilitiesWithAMinumum (kkint32 numClasses, double *probabilities, double minProbability)

void	ReadXMLModelPost (RunLog &log)

XmlTokenPtr	ReadXMLModelToken (XmlTokenPtr t, RunLog &log)
	Will process any tokens that belong to 'ModelParam' and return NULL ones that are not will be passed back. More...

void	ReduceTrainExamples (RunLog &log)
	Reduces the Training Images down to the size dictated by the 'examplesPerClass' parameter. More...

Detailed Description

Definition at line 22 of file ModelSvmBase.h.

Member Typedef Documentation

typedef ModelSvmBase* KKMLL::ModelSvmBase::ModelSvmBasePtr

Definition at line 26 of file ModelSvmBase.h.

Constructor & Destructor Documentation

ModelSvmBase::ModelSvmBase ( )

Definition at line 35 of file ModelSvmBase.cpp.

References KKMLL::Model::Model(), param, and svmModel.

                            :
   Model (),
   param     (NULL),
   svmModel  (NULL)
 {
 }

ModelSvmBase::ModelSvmBase ( FactoryFVProducerPtr _factoryFVProducer )

Definition at line 43 of file ModelSvmBase.cpp.

References KKMLL::Model::Model(), param, and svmModel.

                                                                    :
   Model (_factoryFVProducer),
   param     (NULL),
   svmModel  (NULL)
 {
 }

ModelSvmBase::ModelSvmBase	(	const KKStr &	_name,
		const ModelParamSvmBase &	_param,
		FactoryFVProducerPtr	_factoryFVProducer
	)

Definition at line 52 of file ModelSvmBase.cpp.

References KKMLL::Model::Model(), param, KKMLL::Model::param, and svmModel.

Referenced by KKMLL::Model::CreateAModel().

                             :
   Model (_name, _param, _factoryFVProducer),
   param     (NULL),
   svmModel  (NULL)
 {
   param = dynamic_cast<ModelParamSvmBasePtr> (Model::param);
 }

ModelSvmBase::ModelSvmBase ( const ModelSvmBase & _model )

Definition at line 66 of file ModelSvmBase.cpp.

References KKMLL::Model::fileDesc, KKMLL::Model::Model(), param, KKMLL::Model::param, SVM289_MFS::Svm_Model::Svm_Model(), and svmModel.

Referenced by Duplicate().

                                                        :
   Model (_model),
   param     (NULL),
   svmModel  (NULL)
 {
   param = dynamic_cast<ModelParamSvmBasePtr> (Model::param);
   if  (_model.svmModel)
   {
     svmModel = new SVM289_MFS::Svm_Model (*_model.svmModel, fileDesc);
   }
 }

ModelSvmBase::~ModelSvmBase ( )

virtual

Frees any memory allocated by, and owned by the ModelSvmBase.

Definition at line 85 of file ModelSvmBase.cpp.

References SVM289_MFS::svm_destroy_model(), and svmModel.

 {
   // The base class owns param,  so we do not delete it.
   // delete  param;
   if  (svmModel)
   {
     svm_destroy_model (svmModel);   // 'svm_destroy_model'  will also delete  'svmModel'.
     delete  svmModel;
     svmModel = NULL;
   }
 }

Member Function Documentation

KKStr ModelSvmBase::Description ( ) const

virtual

Return short user readable description of model.

Reimplemented from KKMLL::Model.

Definition at line 121 of file ModelSvmBase.cpp.

References KKB::KKStr::Concat(), KKMLL::Model::Name(), KKB::KKStr::operator+(), KKB::operator+(), param, and KKMLL::ModelParamSvmBase::SvmParam().

 {
   KKStr  result = "SvmBase(" + Name () + ")";
 
   if  (param)
   {
     const SVM289_MFS::svm_parameter&  svmParam = param->SvmParam ();
     
     //result << " " << MachineTypeToStr     (svmParam.MachineType ())
     //       << " " << SelectionMethodToStr (svmParam.SelectionMethod ());
   }
   return  result;
 }

ModelSvmBasePtr ModelSvmBase::Duplicate ( ) const

virtual

Implements KKMLL::Model.

Definition at line 113 of file ModelSvmBase.cpp.

References ModelSvmBase().

 {
   return new ModelSvmBase (*this);
 }

kkint32 ModelSvmBase::MemoryConsumedEstimated ( ) const

virtual

Reimplemented from KKMLL::Model.

Definition at line 99 of file ModelSvmBase.cpp.

References KKMLL::Model::MemoryConsumedEstimated(), SVM289_MFS::Svm_Model::MemoryConsumedEstimated(), and svmModel.

 {
   kkint32  memoryConsumedEstimated = Model::MemoryConsumedEstimated () + 
                                  sizeof (SVM289_MFS::Svm_Model*)   + 
                                  sizeof (ModelParamSvmBasePtr);
 
   if  (svmModel)
     memoryConsumedEstimated += svmModel->MemoryConsumedEstimated ();
   return  memoryConsumedEstimated;
 }

virtual ModelTypes KKMLL::ModelSvmBase::ModelType ( ) const

inlinevirtual

Implements KKMLL::Model.

Definition at line 48 of file ModelSvmBase.h.

References KKMLL::Model::SvmBase.

48 {return ModelTypes::SvmBase;}

KKMLL::Model::ModelTypes::SvmBase

kkint32 ModelSvmBase::NumOfSupportVectors ( ) const

virtual

Definition at line 608 of file ModelSvmBase.cpp.

References SVM289_MFS::Svm_Model::numSVs, and svmModel.

 {
   kkint32  numOfSupportVectors = 0;
   if  (!svmModel)
     return  0;
 
   return  svmModel->numSVs;
 }  /* NumOfSupportVectors */

ModelParamSvmBasePtr ModelSvmBase::Param ( )

Definition at line 137 of file ModelSvmBase.cpp.

References param.

 {
   return param;
 }

MLClassPtr ModelSvmBase::Predict	(	FeatureVectorPtr	image,
		RunLog &	log
	)

virtual

Implements KKMLL::Model.

Definition at line 252 of file ModelSvmBase.cpp.

References KKMLL::Model::classesIndex, KKMLL::MLClassIndexList::GetMLClass(), KKMLL::Model::PrepExampleForPrediction(), SVM289_MFS::svm_predict(), and svmModel.

 {
   if  (!svmModel)
   {
     log.Level (-1) << endl << endl << "ModelSvmBase::Predict   ***ERROR***      (svmModel == NULL)" << endl << endl;
     return NULL;
   }
 
   if  (!classesIndex)
   {
     log.Level (-1) << endl << endl << "ModelSvmBase::Predict   ***ERROR***      (classesIndex == NULL)" << endl << endl;
     return NULL;
   }
 
   bool  newExampleCreated = false;
   FeatureVectorPtr  encodedExample = PrepExampleForPrediction (example, newExampleCreated);
   double  y = (kkint32)SVM289_MFS::svm_predict  (svmModel, *encodedExample);
   if  (newExampleCreated)
   {
     delete encodedExample;
     encodedExample = NULL;
   }
 
   kkint16  label = (kkint16)y;
 
   MLClassPtr  ic = classesIndex->GetMLClass (label);
   if  (!ic)
     log.Level (-1) << endl << endl << "ModelSvmBase::Predict   ***ERROR***      Label[" << y << "] Returned from the SVM was not in the ClassAssignments list." << endl << endl;
 
   return  ic;
 }  /* Predict */

void ModelSvmBase::Predict	(	FeatureVectorPtr	example,
		MLClassPtr	knownClass,
		MLClassPtr &	predClass1,
		MLClassPtr &	predClass2,
		kkint32 &	predClass1Votes,
		kkint32 &	predClass2Votes,
		double &	probOfKnownClass,
		double &	predClass1Prob,
		double &	predClass2Prob,
		kkint32 &	numOfWinners,
		bool &	knownClassOneOfTheWinners,
		double &	breakTie,
		RunLog &	log
	)

virtual

Implements KKMLL::Model.

Definition at line 289 of file ModelSvmBase.cpp.

References KKMLL::Model::classesIndex, KKMLL::Model::classProbs, KKB::KKStr::Concat(), KKMLL::MLClassIndexList::GetClassIndex(), KKMLL::MLClassIndexList::GetMLClass(), KKB::KKException::KKException(), KKMLL::Model::numOfClasses, KKMLL::Model::PrepExampleForPrediction(), SVM289_MFS::svm_predict_probability(), svmModel, and KKMLL::Model::votes.

 {
   if  (!svmModel)
   {
     KKStr errMsg = "ModelSvmBase::Predict   ***ERROR***      (svmModel == NULL)";
     log.Level (-1) << endl << endl << errMsg << endl << endl;
     throw KKException (errMsg);
   }
 
   if  (!classesIndex)
   {
     KKStr errMsg = "ModelSvmBase::Predict   ***ERROR***      (classesIndex == NULL)";
     log.Level (-1) << endl << endl << errMsg << endl << endl;
     throw KKException (errMsg);
   }
 
   kkint32  knownClassIdx = classesIndex->GetClassIndex (knownClass);
 
   bool  newExampleCreated = false;
   FeatureVectorPtr  encodedExample = PrepExampleForPrediction (example, newExampleCreated);
 
   double  y = SVM289_MFS::svm_predict_probability (svmModel,  *encodedExample, classProbs, votes);
 
   if  (newExampleCreated)
   {
     delete encodedExample;
     encodedExample = NULL;
   }
 
   kkint32  maxIndex1 = 0;
   kkint32  maxIndex2 = 0;
 
   double  maxProb1 = -1.0;
   double  maxProb2 = -1.0;
 
   numOfWinners = 0;
   kkint32  winnerNumVotes = 0;
 
   for  (kkint32 idx = 0;  idx < numOfClasses;  ++idx)
   {
     if  (classProbs[idx] > maxProb1)
     {
       maxProb2  = maxProb1;
       maxIndex2 = maxIndex1;
       maxProb1  = classProbs[idx];
       maxIndex1 = idx;
     }
     else if  (classProbs[idx] > maxProb2)
     {
       maxProb2 = classProbs[idx];
       maxIndex2 = idx;
     }
 
     if  (votes[idx] > winnerNumVotes)
     {
       // We have a new winner.
       knownClassOneOfTheWinners = false;
       numOfWinners = 1;
       winnerNumVotes = votes[idx];
       if  (knownClassIdx == idx) 
         knownClassOneOfTheWinners = true;
     }
     else if  (votes[idx] == winnerNumVotes)
     {
       numOfWinners++;
       if  (knownClassIdx == idx) 
         knownClassOneOfTheWinners = true;
     }
   }
 
   predClass1 = classesIndex->GetMLClass (maxIndex1);
   predClass2 = classesIndex->GetMLClass (maxIndex2);
   predClass1Votes = votes[maxIndex1];
   predClass2Votes = votes[maxIndex2];
   predClass1Prob = maxProb1;
   predClass2Prob = maxProb2;
 
   breakTie = predClass1Prob - predClass2Prob;
 
   if  ((knownClassIdx < 0)  ||  (knownClassIdx >= numOfClasses))
   {
     probOfKnownClass = 0.0;
     knownClassOneOfTheWinners = false;
   }
   else
   {
     probOfKnownClass = (float)classProbs[knownClassIdx];
   }
 
   return;
 }  /* Predict */

ClassProbListPtr ModelSvmBase::ProbabilitiesByClass	(	FeatureVectorPtr	example,
		RunLog &	log
	)

virtual

Implements KKMLL::Model.

Definition at line 398 of file ModelSvmBase.cpp.

References KKMLL::Model::classesIndex, KKMLL::ClassProb::ClassProb(), KKMLL::ClassProbList::ClassProbList(), KKMLL::Model::classProbs, KKB::KKStr::Concat(), KKMLL::MLClassIndexList::GetMLClass(), KKB::KKException::KKException(), KKMLL::Model::numOfClasses, KKMLL::Model::PrepExampleForPrediction(), KKMLL::ClassProbList::PushOnBack(), KKMLL::ClassProbList::SortByVotes(), SVM289_MFS::svm_predict_probability(), svmModel, and KKMLL::Model::votes.

 {
   if  (!svmModel)
   {
     KKStr errMsg = "ModelSvmBase::ProbabilitiesByClass   ***ERROR***      (svmModel == NULL)";
     log.Level (-1) << endl << endl << errMsg << endl << endl;
     throw KKException (errMsg);
   }
 
   if  (!classesIndex)
   {
     KKStr errMsg = "ModelSvmBase::ProbabilitiesByClass   ***ERROR***      (classesIndex == NULL)";
     log.Level (-1) << endl << endl << errMsg << endl << endl;
     throw KKException (errMsg);
   }
 
   bool  newExampleCreated = false;
   FeatureVectorPtr  encodedExample = PrepExampleForPrediction (example, newExampleCreated);
 
   double  y = SVM289_MFS::svm_predict_probability (svmModel,  *encodedExample, classProbs, votes);
 
   if  (newExampleCreated)
   {
     delete encodedExample;
     encodedExample = NULL;
   }
 
   ClassProbListPtr  results = new ClassProbList ();
   kkint32 idx = 0;
   for  (idx = 0;  idx < numOfClasses;  idx++)
   {
     MLClassPtr  ic = classesIndex->GetMLClass (idx);
     results->PushOnBack (new ClassProb (ic, classProbs[idx], (float)votes[idx]));
   }
 
   results->SortByVotes (true);
 
   return  results;
 }  /* ProbabilitiesByClass */

void ModelSvmBase::ProbabilitiesByClass	(	FeatureVectorPtr	example,
		const MLClassList &	_mlClasses,
		kkint32 *	_votes,
		double *	_probabilities,
		RunLog &	_log
	)

virtual

Implements KKMLL::Model.

Definition at line 443 of file ModelSvmBase.cpp.

References KKMLL::Model::classesIndex, KKMLL::Model::classProbs, KKB::KKStr::Concat(), KKMLL::MLClassIndexList::GetClassIndex(), KKB::KKException::KKException(), KKMLL::MLClass::Name(), KKMLL::Model::numOfClasses, KKMLL::Model::PrepExampleForPrediction(), SVM289_MFS::svm_predict_probability(), svmModel, and KKMLL::Model::votes.

 {
   if  (!svmModel)
   {
     KKStr errMsg = "ModelSvmBase::ProbabilitiesByClass   ***ERROR***      (svmModel == NULL)";
     _log.Level (-1) << endl << errMsg << endl << endl;
     throw KKException (errMsg);
   }
 
   if  (!classesIndex)
   {
     KKStr errMsg = "ModelSvmBase::ProbabilitiesByClass   ***ERROR***      (classesIndex == NULL)";
     _log.Level (-1) << endl << errMsg << endl << endl;
     throw KKException (errMsg);
   }
 
   bool  newExampleCreated = false;
   FeatureVectorPtr  encodedExample = PrepExampleForPrediction (example, newExampleCreated);
 
   double  y = SVM289_MFS::svm_predict_probability (svmModel,  *encodedExample, classProbs, votes);
 
   if  (newExampleCreated)
   {
     delete encodedExample;
     encodedExample = NULL;
   }
 
   kkuint32  idx;
   for  (idx = 0;  idx < _mlClasses.size ();  idx++)
   {
     MLClassPtr  ic = _mlClasses.IdxToPtr (idx);
     kkint32 classIndex = classesIndex->GetClassIndex (ic);
     if  ((classIndex < 0)  ||  (classIndex >= (kkint32)numOfClasses))
     {
       KKStr  errMsg = "ModelSvmBase::Predict  ***ERROR***   ";
       errMsg << "Class[" << ic->Name () << "] was asked for but is not defined in this instance of 'ModelSvmBase'.";
       _log.Level (-1) << endl << errMsg << endl << endl;
       _votes         [idx] = 0;
       _probabilities [idx] = 0.0f;
     }
     else
     {
       _votes         [idx] = votes      [classIndex];
       _probabilities [idx] = classProbs [classIndex];
     }
   }
 
   return;
 }  /* ProbabilitiesByClass */

void ModelSvmBase::ProbabilitiesByClass	(	FeatureVectorPtr	_example,
		const MLClassList &	_mlClasses,
		double *	_probabilities,
		RunLog &	_log
	)

virtual

Derives predicted probabilities by class.

Will get the probabilities assigned to each class by the classifier. The '_mlClasses' parameter dictates the order of the classes. That is the probabilities for any given index in '_probabilities' will be for the class specified in the same index in '_mlClasses'.

Parameters

[in]	_example	FeatureVector object to calculate predicted probabilities for.
[in]	_mlClasses	List image classes that caller is aware of. This should be the same list that was used when constructing this Model object. The list must be the same but not necessarily in the same order as when Model was 1st constructed.
[out]	_probabilities	An array that must be as big as the number of classes as in mlClasses. The probability of class in mlClasses[x] will be returned in probabilities[x].

Implements KKMLL::Model.

Definition at line 502 of file ModelSvmBase.cpp.

References KKMLL::Model::classesIndex, KKMLL::Model::classProbs, KKB::KKStr::Concat(), KKMLL::MLClassIndexList::GetClassIndex(), KKB::KKException::KKException(), KKMLL::MLClass::Name(), KKMLL::Model::numOfClasses, KKMLL::Model::PrepExampleForPrediction(), SVM289_MFS::svm_predict_probability(), svmModel, and KKMLL::Model::votes.

 {
   if  (!svmModel)
   {
     KKStr errMsg = "ModelSvmBase::ProbabilitiesByClass   ***ERROR***      (svmModel == NULL)";
     _log.Level (-1) << endl << endl << errMsg << endl << endl;
     throw KKException (errMsg);
   }
 
   if  (!classesIndex)
   {
     KKStr errMsg = "ModelSvmBase::ProbabilitiesByClass   ***ERROR***      (classesIndex == NULL)";
     _log.Level (-1) << endl << endl << errMsg << endl << endl;
     throw KKException (errMsg);
   }
 
   bool  newExampleCreated = false;
   FeatureVectorPtr  encodedExample = PrepExampleForPrediction (_example, newExampleCreated);
 
   double  y = SVM289_MFS::svm_predict_probability (svmModel,  *encodedExample, classProbs, votes);
 
   if  (newExampleCreated)
   {
     delete encodedExample;
     encodedExample = NULL;
   }
 
   kkuint32  idx;
   for  (idx = 0;  idx < _mlClasses.size ();  idx++)
   {
     MLClassPtr  ic = _mlClasses.IdxToPtr (idx);
     kkint32 classIndex = classesIndex->GetClassIndex (ic);
     if  ((classIndex < 0)  ||  (classIndex >= (kkint32)numOfClasses))
     {
       KKStr  errMsg = "ModelSvmBase::Predict  ***ERROR***   ";
       errMsg << "Class[" << ic->Name () << "] was asked for but is not defined in this instance of 'ModelSvmBase'.";
       _log.Level (-1) << endl << endl << errMsg << endl << endl;
       _probabilities [idx] = 0.0f;
     }
     else
     {
       _probabilities [idx] = classProbs [classIndex];
     }
   }
 
   return;
 }  /* ProbabilitiesByClass */

void ModelSvmBase::ReadXML	(	XmlStream &	s,
		XmlTagConstPtr	tag,
		VolConstBool &	cancelFlag,
		RunLog &	log
	)

virtual

To be implemented by derived classes; the parent classes fields will be updated by the derived class calling ReadXMLModelToken.

Implements KKMLL::Model.

Definition at line 648 of file ModelSvmBase.cpp.

References KKMLL::Model::AddErrorMsg(), KKB::KKStr::Concat(), KKB::XmlStream::GetNextToken(), KKB::KKStr::KKStr(), KKMLL::ModelParam::ModelParamTypeStr(), param, KKMLL::Model::param, KKMLL::Model::ReadXMLModelPost(), KKMLL::Model::ReadXMLModelToken(), and svmModel.

 {
   delete  svmModel;
   svmModel = NULL;
   XmlTokenPtr  t = s.GetNextToken (cancelFlag, log);
   while  (t)
   {
     t = ReadXMLModelToken (t, log);  // 1st see if the base class has this data field.
     if  (t)
     {
       if  ((t->VarName ().EqualIgnoreCase ("SvmModel"))  &&  (typeid(*t) == typeid(XmlElementSvm_Model)))
       {
         delete  svmModel;
         svmModel = dynamic_cast<XmlElementSvm_ModelPtr> (t)->TakeOwnership ();
       }
       else
       {
         KKStr errMsg (128);
         errMsg << "ModelSvmBase::ReadXML  ***ERROR***  Unexpected Token;  Section:" << t->SectionName () << "  VarName: " << t->VarName ();
         AddErrorMsg (errMsg, 0);
         log.Level (-1) << endl << errMsg << endl << endl;
       }
     }
 
     delete  t;
     t = s.GetNextToken (cancelFlag, log);
   }
   delete  t;
   t = NULL;
 
   if  (!cancelFlag)
   {
     if  (!param)
       param = dynamic_cast<ModelParamSvmBasePtr> (Model::param);
 
     if  (Model::param == NULL)
     {
       KKStr errMsg (128);
       errMsg << "ModelSvmBase::ReadXML  ***ERROR***  Base class 'Model' does not have 'param' defined.";
       AddErrorMsg (errMsg, 0);
       log.Level (-1) << endl << errMsg << endl << endl;
     }
 
     else if  (typeid (*Model::param) != typeid(ModelParamSvmBase))
     { 
       KKStr errMsg (128);
       errMsg << "ModelSvmBase::ReadXML  ***ERROR***  Base class 'Model' param parameter is of the wrong type;  found: " << Model::param->ModelParamTypeStr ();
       AddErrorMsg (errMsg, 0);
       log.Level (-1) << endl << errMsg << endl << endl;
     }
 
     else
     {
       param = dynamic_cast<ModelParamSvmBasePtr> (Model::param);
     } 
 
     ReadXMLModelPost (log);
   }
 }  /* ReadXML */

void ModelSvmBase::RetrieveCrossProbTable	(	MLClassList &	classes,
		double **	crossProbTable,
		RunLog &	log
	)

virtual

Parameters

crossProbTable two dimension matrix that needs to be classes.QueueSize () squared.

Reimplemented from KKMLL::Model.

Definition at line 557 of file ModelSvmBase.cpp.

References KKMLL::Model::classesIndex, KKB::KKStr::Concat(), KKMLL::MLClassIndexList::GetClassIndex(), KKMLL::MLClass::Name(), KKMLL::Model::numOfClasses, SVM289_MFS::Svm_Model::PairwiseProb(), and svmModel.

 {
   kkuint32  idx1, idx2;
   VectorInt  pairWiseIndexes (_classes.size (), 0);
   for  (idx1 = 0;  idx1 < _classes.size ();  idx1++)
   {
     MLClassPtr  ic = _classes.IdxToPtr (idx1);
     kkint32 pairWiseIndex = classesIndex->GetClassIndex (ic);
     if  ((pairWiseIndex < 0)  ||  (pairWiseIndex >= (kkint32)numOfClasses))
     {
       KKStr  errMsg = "ModelSvmBase::RetrieveCrossProbTable  ***ERROR***   ";
       errMsg << "Class[" << ic->Name () << "] was asked for but is not defined in this instance of 'ModelSvmBase'.";
       _log.Level (-1) << endl << endl << errMsg << endl << endl;
       pairWiseIndexes[idx1] = 0;
     }
     else
     {
       pairWiseIndexes[idx1] = pairWiseIndex;
     }
 
     for  (idx2 = 0;  idx2 < _classes.size ();  idx2++)
       _crossProbTable[idx1][idx2] = 0.0;
   }
 
   double** pairWiseProb = svmModel->PairwiseProb ();
   if  (!pairWiseProb)
     return;
 
   for  (idx1 = 0;  idx1 < (_classes.size () - 1);  idx1++)
   {
     kkint32 pairWiseIndex1 = pairWiseIndexes [idx1];
     if  ((pairWiseIndex1 >= 0)  &&  (pairWiseIndex1 < (kkint32)numOfClasses))
     {
       for  (idx2 = idx1 + 1;  idx2 < _classes.size ();  idx2++)
       {
         kkint32 pairWiseIndex2 = pairWiseIndexes [idx2];
         if  ((pairWiseIndex2 >= 0)  &&  (pairWiseIndex2 < (kkint32)numOfClasses))
         {
           _crossProbTable[idx1][idx2] = pairWiseProb[pairWiseIndex1][pairWiseIndex2];
           _crossProbTable[idx2][idx1] = pairWiseProb[pairWiseIndex2][pairWiseIndex1];
         }
       }
     }
   }
 }  /* RetrieveCrossProbTable */

void ModelSvmBase::TrainModel	(	FeatureVectorListPtr	_trainExamples,
		bool	_alreadyNormalized,
		bool	_takeOwnership,
		VolConstBool &	_cancelFlag,
		RunLog &	_log
	)

virtual

Performs operations such as FeatureEncoding, and Normalization. The actual training of models occurs in the specific derived implementation of 'Model'.

Performs operations such as FeatureEncoding, and Normalization; the actual training of models occurs in the specific implementation of 'Model'.

Parameters

[in]	_trainExamples	Training data that classifier will be built from. If the examples need to be normalized or encoded and we are not taking ownership then a duplicate list of examples will be created that this method and class will be free to modify.
[in]	_alreadyNormalized	Indicates if contents of '_trainExamples' are normalized already; if not they will be normalized.
[in]	_takeOwnership	This instance of Model will take ownership of '_examples' and is free to modify its contents.

Parameters

_takeOwnership Model will take ownership of these examples

Reimplemented from KKMLL::Model.

Definition at line 144 of file ModelSvmBase.cpp.

References KKB::KKStr::Concat(), KKB::KKException::KKException(), KKB::KKStr::operator+(), KKB::operator+(), param, KKMLL::Model::rootFileName, KKMLL::ModelParam::SelectedFeatures(), SVM289_MFS::svm_destroy_model(), SVM289_MFS::svm_problem::svm_problem(), SVM289_MFS::svm_train(), svmModel, KKMLL::ModelParamSvmBase::SvmParam(), KKMLL::Model::trainExamples, KKMLL::Model::TrainingTimeEnd(), KKMLL::Model::TrainingTimeStart(), KKMLL::Model::TrainModel(), and KKMLL::Model::validModel.

 {
   _log.Level (10) << "ModelSvmBase::TrainModel[" << param->FileName () << "]." << endl;
 
   if  (param == NULL)
   {
     validModel = false;
     KKStr  errMsg = "ModelSvmBase::TrainModel   (param == NULL)";
     _log.Level (-1) << endl << endl << errMsg << endl << endl;
     throw KKException (errMsg);
   }
 
   if  (svmModel)
   {
     svm_destroy_model (svmModel);
     delete  svmModel;
     svmModel = NULL;
   }
 
   try 
   {
     Model::TrainModel (_trainExamples, _alreadyNormalized, _takeOwnership, _cancelFlag, _log);
   }
   catch (const KKException&  e)
   {
     validModel = false;
     KKStr  errMsg = "ModelSvmBase::TrainModel  ***ERROR*** Exception occurred calling 'Model::TrainModel'.";
     _log.Level (-1) << endl << errMsg << endl << e.ToString () << endl << endl;
     throw  KKException (errMsg, e);
   }
   catch (const exception& e2)
   {
     validModel = false;
     KKStr errMsg = "ModelSvmBase::TrainModel  ***ERROR*** Exception occurred calling 'Model::TrainModel'.";
     _log.Level (-1) << endl << errMsg << endl << e2.what () << endl << endl;
     throw KKException (errMsg, e2);
   }
   catch (...)
   {
     validModel = false;
     KKStr errMsg = "ModelSvmBase::TrainModel  ***ERROR*** Exception occurred calling 'Model::TrainModel'.";
     _log.Level (-1) << endl << errMsg << endl << endl;
     throw KKException (errMsg);
   }
     
 
   // 'Model::TrainModel'  Will have performed any Feature Encoding that needed to be done.  
   // Also the data structures 'classes', 'encoder', and 'fileDesc' will have been built.
   // 'classes' will already be sorted in name order.
   // The Prediction variables 'probabilities', 'votes', and 'crossClassProbTable' will
   // have been built.
 
 
   // Build the Label array that libSVM expects.
   float*  y = new float[trainExamples->QueueSize ()];
   {
     for  (kkint32 labelIndex = 0;  labelIndex < trainExamples->QueueSize ();  labelIndex++)
     {
       kkint16  label = classesIndex->GetClassIndex (trainExamples->IdxToPtr (labelIndex)->MLClass ());
       if  (label < 0)
       {
         _log.Level (-1) << endl << " ModelSvmBase::TrainModel   ***ERROR***   Label computed to -1; should not be able to happen." << endl << endl;
       }
       y[labelIndex] = (float)label;
     }
   }
 
   SVM289_MFS::svm_problem  prob (*trainExamples, y, *(param->SelectedFeatures ()));
   delete[]  y;  y = NULL;
 
   try
   {
     TrainingTimeStart ();
     svmModel = SVM289_MFS::svm_train (prob, param->SvmParam (), _log);
     TrainingTimeEnd ();
   }
   catch (const std::exception&  e)
   {
     validModel = false;
     KKStr  errMsg = "ModelSvmBase::TrainModel   ***ERROR*** Exception occurred in 'SVM289_MFS::svm_train' building training model[" + rootFileName + "].";
     errMsg << endl << "        Exception[" << e.what () << "]";
     _log.Level (-1) << endl << endl << errMsg << endl << endl;
     throw KKException (errMsg);
   }
   catch (...)
   {
     validModel = false;
     KKStr  errMsg = "ModelSvmBase::TrainModel   ***ERROR*** Exception occurred in 'SVM289_MFS::svm_train' building training model[" + rootFileName + "].";
     _log.Level (-1) << endl << endl << errMsg << endl << endl;
     throw KKException (errMsg);
   }
 
   if  (svmModel == NULL)
   {
     validModel = false;
     KKStr  errMsg = "ModelSvmBase::TrainModel   ***ERROR*** Building 'LibSVM' training model[" + rootFileName + "].";
     _log.Level (-1) << endl << endl << errMsg << endl << endl;
     throw KKException (errMsg);
   }
 }  /* TrainModel */

void ModelSvmBase::WriteXML	(	const KKStr &	varName,
		ostream &	o
	)		const

virtual

Definition at line 621 of file ModelSvmBase.cpp.

References KKB::XmlTag::AddAtribute(), KKB::KKStr::Empty(), svmModel, KKB::XmlTag::tagEnd, KKB::XmlTag::tagStart, KKMLL::Model::WriteModelXMLFields(), SVM289_MFS::Svm_Model::WriteXML(), KKB::XmlTag::WriteXML(), and KKB::XmlTag::XmlTag().

 {
   XmlTag  startTag ("ModelSvmBase",  XmlTag::TagTypes::tagStart);
   if  (!varName.Empty ())
     startTag.AddAtribute ("VarName", varName);
   startTag.WriteXML (o);
 
   WriteModelXMLFields (o);  // Write the PArent class fields 1st.
 
   if  (svmModel)
     svmModel->WriteXML ("SvmModel", o);
 
   //  Turns out the base class "Model" owns this data field and will also be writing it
   // out so no point in re-reading again.
   //if  (param)  param->WriteXML ("Param", o);
 
   XmlTag  endTag ("ModelSvmBase", XmlTag::TagTypes::tagEnd);
   endTag.WriteXML (o);
   o << endl;
 }  /* WriteXML */

Member Data Documentation

ModelParamSvmBasePtr KKMLL::ModelSvmBase::param

protected

We will NOT own this instance. It will point to same instance defined in parent class Model.

Definition at line 144 of file ModelSvmBase.h.

Referenced by Description(), ModelSvmBase(), Param(), ReadXML(), and TrainModel().

SVM289_MFS::Svm_Model* KKMLL::ModelSvmBase::svmModel

protected

Definition at line 143 of file ModelSvmBase.h.

Referenced by MemoryConsumedEstimated(), ModelSvmBase(), NumOfSupportVectors(), Predict(), ProbabilitiesByClass(), ReadXML(), RetrieveCrossProbTable(), TrainModel(), WriteXML(), and ~ModelSvmBase().

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

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

Public Types

Public Member Functions

Protected Attributes

Additional Inherited Members

Detailed Description

Member Typedef Documentation

Constructor & Destructor Documentation

Member Function Documentation

Member Data Documentation