Base class to all Learning Algorithms. More...

#include <Model.h>

Inheritance diagram for KKMLL::Model:

Public Types
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
	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

virtual KKStr	Description () const

virtual ModelPtr	Duplicate () const =0

const FeatureEncoder2 &	Encoder () const

FactoryFVProducerPtr	FactoryFVProducer () const

virtual FeatureNumListConstPtr	GetFeatureNums () const

virtual kkint32	MemoryConsumedEstimated () const

MLClassListPtr	MLClasses () const

MLClassListPtr	MLClassesNewInstance () const

virtual ModelTypes	ModelType () const =0

virtual KKStr	ModelTypeStr () const

const KKStr &	Name () const

void	Name (const KKStr &_name)

virtual bool	NormalizeNominalAttributes () const

ModelParamPtr	Param () const

virtual MLClassPtr	Predict (FeatureVectorPtr example, RunLog &log)=0

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)=0

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 ClassProbListPtr	ProbabilitiesByClass (FeatureVectorPtr example, RunLog &log)=0

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

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

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

virtual void	ReadXML (XmlStream &s, XmlTagConstPtr tag, VolConstBool &cancelFlag, RunLog &log)=0
	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)

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...

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...

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

Static Public Member Functions
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
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...

Protected Attributes
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

Detailed Description

Base class to all Learning Algorithms.

Author: Kurt Kramer

Base class to be used by all Learning Algorithm Models. The idea is that all learning algorithms all follow the same basic flow. The two obvious functions that they all support are Training from supplied labeled examples(List of FeatureVector objects), Prediction of an unlabeled example.

Definition at line 82 of file Model.h.

Member Typedef Documentation

typedef Model* KKMLL::Model::ModelPtr

Definition at line 85 of file Model.h.

Member Enumeration Documentation

enum KKMLL::Model::ModelTypes : int

strong

Enumerator
Null
OldSVM
SvmBase
KNN
UsfCasCor
Dual

Definition at line 87 of file Model.h.

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

Constructor & Destructor Documentation

Model::Model ( )

Definition at line 43 of file Model.cpp.

References alreadyNormalized, classes, classesIndex, classProbs, crossClassProbTable, crossClassProbTableSize, encoder, factoryFVProducer, fileDesc, KKB::KKStr::KKStr(), normParms, numOfClasses, param, rootFileName, trainExamples, validModel, votes, and weOwnTrainExamples.

Referenced by KKMLL::ModelDual::ModelDual(), KKMLL::ModelKnn::ModelKnn(), KKMLL::ModelOldSVM::ModelOldSVM(), KKMLL::ModelSvmBase::ModelSvmBase(), and KKMLL::ModelUsfCasCor::ModelUsfCasCor().

              :
     alreadyNormalized        (false),
     classes                  (NULL),
     classesIndex             (NULL),
     classProbs               (NULL),
     crossClassProbTable      (NULL),
     crossClassProbTableSize  (0),
     encoder                  (NULL),
     factoryFVProducer        (NULL),
     fileDesc                 (NULL),
     name                     (),
     normParms                (NULL),
     numOfClasses             (0),
     param                    (NULL),
     rootFileName             (),
     trainExamples            (NULL),
     trianingPrepTime         (0.0),
     trainingTime             (0.0),
     trainingTimeStart        (0.0),
     validModel               (true),
     votes                    (NULL),
     weOwnTrainExamples       (false)
 {
 }

Model::Model ( FactoryFVProducerPtr _factoryFVProducer )

Use this when you are planning on creating a empty model without parameters.

Definition at line 117 of file Model.cpp.

References alreadyNormalized, classes, classesIndex, classProbs, crossClassProbTable, crossClassProbTableSize, encoder, factoryFVProducer, KKMLL::FactoryFVProducer::FileDesc(), fileDesc, KKB::KKStr::KKStr(), normParms, numOfClasses, param, rootFileName, trainExamples, validModel, votes, and weOwnTrainExamples.

Referenced by KKMLL::ModelDual::ModelDual(), KKMLL::ModelKnn::ModelKnn(), KKMLL::ModelOldSVM::ModelOldSVM(), KKMLL::ModelSvmBase::ModelSvmBase(), and KKMLL::ModelUsfCasCor::ModelUsfCasCor().

                                                      :
     alreadyNormalized        (false),
     classes                  (NULL),
     classesIndex             (NULL),
     classProbs               (NULL),
     crossClassProbTable      (NULL),
     crossClassProbTableSize  (0),
     encoder                  (NULL),
     factoryFVProducer        (_factoryFVProducer),
     fileDesc                 (NULL),
     name                     (),
     normParms                (NULL),
     numOfClasses             (0),
     param                    (NULL),
     rootFileName             (),
     trainExamples            (NULL),
     trianingPrepTime         (0.0),
     trainingTime             (0.0),
     trainingTimeStart        (0.0),
     validModel               (true),
     votes                    (NULL),
     weOwnTrainExamples       (false)
 {
   fileDesc = factoryFVProducer->FileDesc ();
 }

Model::Model	(	const KKStr &	_name,
		const ModelParam &	_param,
		FactoryFVProducerPtr	_factoryFVProducer
	)

Construct a instance of 'Model' using the parameters specified in '_param'.

Creates a new svm model from the provided example data.

Parameters

[in]	_name	Name of training model.
[in]	_param	Parameters for learning algorithm; we will create a duplicate copy.
[in]	_fileDesc	Description of the dataset that will be used to train the classifier and examples that will be classified.
[in]	_cancelFlag	Will monitor; if at any point it turns true this instance is to terminate and return to caller.
[in,out]	_log	Logging file.
[in]	_name
[in]	_param	Will make own local copy.
[in]	_fileDesc	A description of the data file.
[in]	_log	A log-file stream. All important events will be output to this stream

Definition at line 152 of file Model.cpp.

References alreadyNormalized, classes, classesIndex, classProbs, crossClassProbTable, crossClassProbTableSize, KKMLL::ModelParam::Duplicate(), encoder, factoryFVProducer, KKMLL::FactoryFVProducer::FileDesc(), fileDesc, KKB::KKStr::KKStr(), normParms, numOfClasses, param, rootFileName, trainExamples, validModel, votes, and weOwnTrainExamples.

Referenced by KKMLL::ModelDual::ModelDual(), KKMLL::ModelKnn::ModelKnn(), KKMLL::ModelOldSVM::ModelOldSVM(), KKMLL::ModelSvmBase::ModelSvmBase(), and KKMLL::ModelUsfCasCor::ModelUsfCasCor().

               :
     alreadyNormalized        (false),
     classes                  (NULL),
     classesIndex             (NULL),
     classProbs               (NULL),
     crossClassProbTable      (NULL),
     crossClassProbTableSize  (0),
     encoder                  (NULL),
     factoryFVProducer        (_factoryFVProducer),
     fileDesc                 (NULL),
     name                     (_name),
     normParms                (NULL),
     numOfClasses             (0),
     param                    (NULL),
     rootFileName             (),
     trainExamples            (NULL),
     trianingPrepTime         (0.0),
     trainingTime             (0.0),
     trainingTimeStart        (0.0),
     validModel               (true),
     votes                    (NULL),
     weOwnTrainExamples       (false)
 {
   fileDesc = factoryFVProducer->FileDesc ();
   param = _param.Duplicate ();
 }

Model::Model ( const Model & _madel )

Copy Constructor.

Definition at line 69 of file Model.cpp.

References AllocatePredictionVariables(), alreadyNormalized, classes, classesIndex, classProbs, crossClassProbTable, crossClassProbTableSize, KKMLL::ModelParam::Duplicate(), encoder, factoryFVProducer, KKMLL::FeatureEncoder2::FeatureEncoder2(), fileDesc, KKB::KKStr::KKStr(), KKMLL::MLClassIndexList::MLClassIndexList(), KKMLL::MLClassList::MLClassList(), normParms, numOfClasses, param, rootFileName, trainExamples, validModel, votes, and weOwnTrainExamples.

Referenced by KKMLL::ModelDual::ModelDual(), KKMLL::ModelKnn::ModelKnn(), KKMLL::ModelOldSVM::ModelOldSVM(), KKMLL::ModelSvmBase::ModelSvmBase(), and KKMLL::ModelUsfCasCor::ModelUsfCasCor().

                                  :
     alreadyNormalized       (false),
     classes                 (NULL),
     classesIndex            (NULL),
     classProbs              (NULL),
     crossClassProbTable     (NULL),
     crossClassProbTableSize (0),
     encoder                 (NULL),
     factoryFVProducer       (_model.factoryFVProducer),
     fileDesc                (_model.fileDesc),
     name                    (_model.name),
     normParms               (NULL),
     numOfClasses            (_model.numOfClasses),
     param                   (NULL),
     rootFileName            (_model.rootFileName),
     trainExamples           (NULL),
     trianingPrepTime        (0.0),
     trainingTime            (_model.trainingTime),
     trainingTimeStart       (_model.trainingTime),
     validModel              (_model.validModel),
     votes                   (NULL),
     weOwnTrainExamples      (false)
 {
   numOfClasses = 0;
   if  (_model.param != NULL)
     param = _model.param->Duplicate ();
 
   if  (_model.classes)
   {
     classes = new MLClassList (*_model.classes);
     numOfClasses = classes->QueueSize ();
 
     AllocatePredictionVariables ();
   }
 
   if  (_model.classesIndex)
     classesIndex = new MLClassIndexList (*_model.classesIndex);
 
 
   if  (_model.encoder)
     encoder = new FeatureEncoder2 (*_model.encoder);
 }

Model::~Model ( )

virtual

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

Definition at line 188 of file Model.cpp.

References classes, classesIndex, DeAllocateSpace(), encoder, normParms, param, trainExamples, and weOwnTrainExamples.

 {
   DeAllocateSpace ();
 
   delete  classesIndex;  classesIndex = NULL;
   delete  classes;       classes = NULL;
   delete  encoder;       encoder = NULL;
   delete  normParms;     normParms = NULL;
 
   if  (weOwnTrainExamples)
   {
     delete  trainExamples;
     trainExamples = NULL;
   }
 
   delete  param;
   param = NULL;
 }

Member Function Documentation

void Model::AddErrorMsg	(	const KKStr &	errMsg,
		kkint32	lineNum
	)

protected

Definition at line 239 of file Model.cpp.

Referenced by KKMLL::ModelKnn::ReadXML(), KKMLL::ModelUsfCasCor::ReadXML(), KKMLL::ModelSvmBase::ReadXML(), KKMLL::ModelDual::ReadXML(), KKMLL::ModelOldSVM::ReadXML(), ReadXMLModelPost(), and ReadXMLModelToken().

 {
   errors.push_back (errMsg);
 }

void Model::AllocatePredictionVariables ( )

protected

Definition at line 343 of file Model.cpp.

References classes, classProbs, crossClassProbTable, crossClassProbTableSize, DeAllocateSpace(), numOfClasses, validModel, and votes.

Referenced by Model(), and TrainModel().

 {
   kkint32 x = 0;
   kkint32 y = 0;
 
   DeAllocateSpace ();
 
   if  (classes == NULL)
   {
     cerr << endl << endl 
       << "Model::AllocatePredictionVariables   ***ERROR***      (classes == NULL)"  << endl
       << endl;
 
     validModel = false;
     return;
   }
 
   numOfClasses = classes->QueueSize ();
 
   if  (numOfClasses > 0)
   {
     crossClassProbTableSize = numOfClasses;
     classProbs    = new double[numOfClasses];
     votes         = new kkint32 [numOfClasses];
     crossClassProbTable = new double*[numOfClasses];
     for  (x = 0;  x < numOfClasses;  x++)
     {
       classProbs         [x] = 0.0;
       votes              [x] = 0;
       crossClassProbTable[x] = new double[numOfClasses];
       for  (y = 0;  y < numOfClasses;  y++)
         crossClassProbTable[x][y] = 0.0f;
     }
   }
 }  /* AllocatePredictionVariables*/

bool KKMLL::Model::AlreadyNormalized ( ) const

inline

Definition at line 157 of file Model.h.

References alreadyNormalized.

157 {return alreadyNormalized;}

KKMLL::Model::alreadyNormalized

bool alreadyNormalized

Definition: Model.h:388

ModelPtr Model::CreateAModel	(	ModelTypes	_modelType,
		const KKStr &	_name,
		const ModelParam &	_param,
		FactoryFVProducerPtr	_factoryFVProducer,
		VolConstBool &	_cancelFlag,
		RunLog &	_log
	)

static

A factory method that will instantiate the appropriate class of training model based off '_modelType'.

This method is used to construct a model that is going to be built from training data.

Parameters

[in]	_modelType	Type of model to be created; ex: mtOldSVM, mtSvmBase, or mtKNN.
[in]	_name
[in]	_param	Parameters used to drive the creating of the model.
[in]	_fileDesc	Description of the dataset that will be used to train the classifier and examples that will be classified.
[in]	_cancelFlag	Will monitor; if at any point it turns true this instance is to terminate and return to caller.
[in,out]	_log	Logging file.

Parameters

_param Will make a duplicate copy of

Definition at line 287 of file Model.cpp.

References KKB::KKStr::Concat(), Dual, KKB::KKException::KKException(), KNN, KKMLL::ModelDual::ModelDual(), KKMLL::ModelKnn::ModelKnn(), KKMLL::ModelOldSVM::ModelOldSVM(), KKMLL::ModelSvmBase::ModelSvmBase(), KKMLL::ModelUsfCasCor::ModelUsfCasCor(), OldSVM, KKB::KKStr::operator+(), KKB::operator+(), KKB::StrFromInt16(), KKMLL::ModelOldSVM::SupportVectorNames(), SvmBase, and UsfCasCor.

Referenced by KKMLL::TrainingProcess2::CreateModelsFromTrainingData().

 {
   ModelPtr  model = NULL;
   try
   {
     switch  (_modelType)
     {
     case  ModelTypes::OldSVM:    
           model = new ModelOldSVM    (_name, dynamic_cast<const ModelParamOldSVM&>    (_param), _factoryFVProducer);
           break;
 
     case  ModelTypes::SvmBase:
           model = new ModelSvmBase   (_name, dynamic_cast<const ModelParamSvmBase&>   (_param), _factoryFVProducer);
           break;
 
     case  ModelTypes::KNN:
           model = new ModelKnn       (_name, dynamic_cast<const ModelParamKnn&>       (_param), _factoryFVProducer);
           break;
 
     case  ModelTypes::UsfCasCor:
           model = new ModelUsfCasCor (_name, dynamic_cast<const ModelParamUsfCasCor&> (_param), _factoryFVProducer);
           break;
 
     case  ModelTypes::Dual:
           model = new ModelDual      (_name, dynamic_cast<const ModelParamDual&>      (_param), _factoryFVProducer);
           break;
 
     default:
           KKStr errMsg = "Model::CreateAModel   ***ERROR***  Invalid _modelType[" + KKB::StrFromInt16((kkint16)_modelType) + "].";
           _log.Level (-1) << endl << errMsg << endl << endl;
           throw KKException(errMsg);
     }  /* end of switch */
   }
   catch  (const KKException&  e)
   {
     delete  model; model = NULL;
     throw  KKException ("Model::CreateAModel  Exception calling constructor.", e);
   }
   catch  (...)
   {
     delete  model;  model = NULL;
     throw  KKException ("Model::CreateAModel  Exception calling constructor.  No info provided.");
   }
 
   return  model;
 }  /*  CreateAModel */

void Model::DeAllocateSpace ( )

protected

Definition at line 383 of file Model.cpp.

References classProbs, crossClassProbTable, numOfClasses, and votes.

Referenced by AllocatePredictionVariables(), and ~Model().

 {
   kkint32 x = 0;
   if  (crossClassProbTable)
   {
     for  (x = 0;  x < numOfClasses;  x++)
     {
       delete  [] crossClassProbTable[x];
       crossClassProbTable[x] = NULL;
     }
     delete[]  crossClassProbTable;
     crossClassProbTable = NULL;
   }
 
   delete[] classProbs;
   classProbs = NULL;
 
   delete[] votes;
   votes = NULL;
 }

KKStr Model::Description ( ) const

virtual

Return short user readable description of model.

Reimplemented in KKMLL::ModelDual, KKMLL::ModelOldSVM, and KKMLL::ModelSvmBase.

Definition at line 248 of file Model.cpp.

References ModelTypeStr(), Name(), and KKB::KKStr::operator+().

Referenced by KKMLL::TrainingProcess2::ModelDescription(), and ProbabilitiesByClassDual().

 {
   return ModelTypeStr () + "(" + Name () + ")";
 }

virtual ModelPtr KKMLL::Model::Duplicate ( ) const

pure virtual

Implemented in KKMLL::ModelDual, KKMLL::ModelOldSVM, KKMLL::ModelUsfCasCor, KKMLL::ModelSvmBase, and KKMLL::ModelKnn.

const FeatureEncoder2 & Model::Encoder ( ) const

Definition at line 406 of file Model.cpp.

References encoder, and KKB::KKException::KKException().

 {
   if  (!encoder)
     throw KKException ("Model::GetFeatureNums  'encoder == NULL'.");
   return *encoder;
 }

FactoryFVProducerPtr KKMLL::Model::FactoryFVProducer ( ) const

inline

Definition at line 164 of file Model.h.

References factoryFVProducer.

164 {return factoryFVProducer;}

KKMLL::Model::factoryFVProducer

FactoryFVProducerPtr factoryFVProducer

Definition: Model.h:404

FeatureNumListConstPtr Model::GetFeatureNums ( ) const

virtual

Reimplemented in KKMLL::ModelOldSVM.

Definition at line 415 of file Model.cpp.

References KKB::KKException::KKException(), param, and KKMLL::ModelParam::SelectedFeatures().

 {
   if  (!param)
     throw KKException ("Model::GetFeatureNums  'param == NULL'.");
   return  param->SelectedFeatures ();
 }

kkint32 Model::MemoryConsumedEstimated ( ) const

virtual

Reimplemented in KKMLL::ModelDual, KKMLL::ModelOldSVM, KKMLL::ModelSvmBase, and KKMLL::ModelUsfCasCor.

Definition at line 208 of file Model.cpp.

References classes, classesIndex, classProbs, crossClassProbTable, encoder, KKMLL::FeatureEncoder2::MemoryConsumedEstimated(), KKMLL::ModelParam::MemoryConsumedEstimated(), KKMLL::NormalizationParms::MemoryConsumedEstimated(), KKMLL::MLClassList::MemoryConsumedEstimated(), KKB::KKStr::MemoryConsumedEstimated(), KKMLL::FeatureVectorList::MemoryConsumedEstimated(), KKMLL::MLClassIndexList::MemoryConsumedEstimated(), normParms, numOfClasses, param, rootFileName, trainExamples, votes, and weOwnTrainExamples.

Referenced by KKMLL::ModelSvmBase::MemoryConsumedEstimated(), KKMLL::ModelUsfCasCor::MemoryConsumedEstimated(), KKMLL::ModelOldSVM::MemoryConsumedEstimated(), KKMLL::ModelDual::MemoryConsumedEstimated(), and KKMLL::TrainingProcess2::MemoryConsumedEstimated().

 {
   kkint32  memoryConsumedEstimated = sizeof (Model) + rootFileName.MemoryConsumedEstimated ();
   if  (classes)              memoryConsumedEstimated += classes->MemoryConsumedEstimated ();
   if  (classesIndex)         memoryConsumedEstimated += classesIndex->MemoryConsumedEstimated ();
   if  (classProbs)           memoryConsumedEstimated += numOfClasses * sizeof (double);
   if  (crossClassProbTable)  memoryConsumedEstimated += (numOfClasses * sizeof (double*)  +  numOfClasses * numOfClasses * sizeof (double));
   if  (encoder)              memoryConsumedEstimated += encoder->MemoryConsumedEstimated ();
   if  (normParms)            memoryConsumedEstimated += normParms->MemoryConsumedEstimated ();
   if  (param)                memoryConsumedEstimated += param->MemoryConsumedEstimated ();
   if  (votes)                memoryConsumedEstimated += numOfClasses * sizeof (kkint32);
 
   if  (weOwnTrainExamples  &&  (trainExamples != NULL))
     memoryConsumedEstimated += trainExamples->MemoryConsumedEstimated ();
 
   return  memoryConsumedEstimated;
 }

MLClassListPtr KKMLL::Model::MLClasses ( ) const

inline

Definition at line 170 of file Model.h.

References classes.

Referenced by KKMLL::TrainingProcess2::ReadXML().

170 {return classes;}

KKMLL::Model::classes

MLClassListPtr classes

Definition: Model.h:390

MLClassListPtr Model::MLClassesNewInstance ( ) const

Returns a new instances of 'classes' by calling copy constructor.

Definition at line 228 of file Model.cpp.

References classes, and KKMLL::MLClassList::MLClassList().

Referenced by KKMLL::TrainingProcess2::CreateModelsFromTrainingData().

 {
   if  (classes)
     return new MLClassList (*classes);
   else
     return NULL;
 }  /* MLClassesNewInstance */

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

pure virtual

Implemented in KKMLL::ModelDual, KKMLL::ModelOldSVM, KKMLL::ModelSvmBase, KKMLL::ModelUsfCasCor, and KKMLL::ModelKnn.

Referenced by KKMLL::Classifier2::Classifier2(), KKMLL::TrainingProcess2::ModelType(), ModelTypeStr(), KKMLL::TrainingProcess2::OldSVMModel(), ReadXMLModelToken(), KKMLL::TrainingProcess2::TrainingProcessLeft(), and KKMLL::TrainingProcess2::TrainingProcessRight().

Model::ModelTypes Model::ModelTypeFromStr ( const KKStr & _modelingTypeStr )

static

Definition at line 271 of file Model.cpp.

References Dual, KKB::KKStr::EqualIgnoreCase(), KNN, Null, OldSVM, SvmBase, and UsfCasCor.

Referenced by KKMLL::TrainingConfiguration2::ModelTypeFromStr(), and ReadXMLModelToken().

 {
   if       (_modelingTypeStr.EqualIgnoreCase ("OldSVM")  ||  
             _modelingTypeStr.EqualIgnoreCase ("One_Level"))   return ModelTypes::OldSVM;
   else if  (_modelingTypeStr.EqualIgnoreCase ("SvmBase"))     return ModelTypes::SvmBase;
   else if  (_modelingTypeStr.EqualIgnoreCase ("KNN"))         return ModelTypes::KNN;
   else if  (_modelingTypeStr.EqualIgnoreCase ("UsfCasCor"))   return ModelTypes::UsfCasCor;
   else if  (_modelingTypeStr.EqualIgnoreCase ("Dual"))        return ModelTypes::Dual;
 
   else
     return ModelTypes::Null;
 }  /* ModelingMethodFromStr */

virtual KKStr KKMLL::Model::ModelTypeStr ( ) const

inlinevirtual

Definition at line 176 of file Model.h.

References ModelType(), and ModelTypeToStr().

Referenced by Description(), KKMLL::TrainingProcess2::ModelTypeStr(), ReadXMLModelToken(), and WriteModelXMLFields().

176 {return ModelTypeToStr (ModelType ());}

KKMLL::Model::ModelTypeToStr

static KKStr ModelTypeToStr(ModelTypes _modelingType)

Definition: Model.cpp:256

KKMLL::Model::ModelType

virtual ModelTypes ModelType() const =0

KKStr Model::ModelTypeToStr ( ModelTypes _modelingType )

static

Definition at line 256 of file Model.cpp.

References Dual, KNN, Null, OldSVM, SvmBase, and UsfCasCor.

Referenced by ModelTypeStr(), KKMLL::TrainingConfiguration2::ModelTypeStr(), and KKMLL::TrainingConfiguration2::ModelTypeToStr().

 {
   if       (_modelingType == ModelTypes::Null)      return "NULL";
   else if  (_modelingType == ModelTypes::OldSVM)    return "OldSVM";
   else if  (_modelingType == ModelTypes::SvmBase)   return "SvmBase";
   else if  (_modelingType == ModelTypes::KNN)       return "KNN";
   else if  (_modelingType == ModelTypes::UsfCasCor) return "UsfCasCor";
   else if  (_modelingType == ModelTypes::Dual)      return "Dual";
   else
     return "NULL";
 }  /* ModelingMethodToStr */

const KKStr& KKMLL::Model::Name ( ) const

inline

Definition at line 178 of file Model.h.

Referenced by KKMLL::ModelSvmBase::Description(), KKMLL::ModelOldSVM::Description(), KKMLL::ModelDual::Description(), Description(), and WriteModelXMLFields().

178 {return name;}

void KKMLL::Model::Name ( const KKStr & _name )

inline

Definition at line 179 of file Model.h.

References KKB::KKStr::operator=().

179 {name = _name;}

bool Model::NormalizeNominalAttributes ( ) const

virtual

Return true, if nominal fields need to be normalized.

Reimplemented in KKMLL::ModelOldSVM.

Definition at line 423 of file Model.cpp.

References KKMLL::ModelParam::EncodingMethod(), KKB::KKException::KKException(), KKMLL::ModelParam::NoEncoding, and param.

 {
   if  (!param)
     throw KKException ("Model::NormalizeNominalAttributes  'param == NULL'.");
 
   if  (param->EncodingMethod () == ModelParam::EncodingMethodType::NoEncoding)
     return  true;
   else
     return  false;
 }  /* NormalizeNominalAttributes */

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

protected

Will normalize probabilities such that the sum of all equal 1.0 and no one probability will be less than 'minProbability'.

Definition at line 614 of file Model.cpp.

 {
   double  sumGreaterOrEqualMin = 0.0;
   kkint32 numLessThanMin = 0;
 
   kkint32 x = 0;
   for  (x = 0;  x < numClasses;  ++x)
   {
     if  (probabilities[x] < minProbability)
       ++numLessThanMin;
     else
       sumGreaterOrEqualMin += probabilities[x];
   }
 
   double probLessMinTotal = numLessThanMin * minProbability;
   double probLeftToAllocate  = 1.0 - probLessMinTotal;  
 
   for  (x = 0;  x < numClasses;  ++x)
   {
     if  (probabilities[x] < minProbability)
       probabilities[x] = minProbability;
     else
       probabilities[x] = (probabilities[x] / sumGreaterOrEqualMin) * probLeftToAllocate;
   }
 }  /* NormalizeProbabilitiesWithAMinumum */

ModelParamPtr KKMLL::Model::Param ( ) const

inline

Definition at line 183 of file Model.h.

References param.

Referenced by KKMLL::TrainingProcess2::Parameters().

183 {return param;}

KKMLL::Model::param

ModelParamPtr param

Definition: Model.h:412

virtual MLClassPtr KKMLL::Model::Predict	(	FeatureVectorPtr	example,
		RunLog &	log
	)

pure virtual

Implemented in KKMLL::ModelDual, KKMLL::ModelOldSVM, KKMLL::ModelUsfCasCor, KKMLL::ModelSvmBase, and KKMLL::ModelKnn.

virtual void KKMLL::Model::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
	)

pure virtual

Implemented in KKMLL::ModelDual, KKMLL::ModelOldSVM, KKMLL::ModelUsfCasCor, KKMLL::ModelSvmBase, and KKMLL::ModelKnn.

Referenced by KKMLL::Classifier2::ClassifyAExample().

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

inlinevirtual

Reimplemented in KKMLL::ModelOldSVM.

Definition at line 230 of file Model.h.

Referenced by KKMLL::Classifier2::PredictRaw().

     {
       predClass = NULL;
       dist = 0.0;
     }

FeatureVectorPtr Model::PrepExampleForPrediction	(	FeatureVectorPtr	fv,
		bool &	newExampleCreated
	)

virtual

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.

Parameters

[in]	fv	Feature vector of example that needs to be prepared.
[out]	newExampleCreated	Indicates if either Feature Encoding and/or Normalization needed to be done. If neither then the original instance is returned. If Yes then a new instance which the caller will have to delete will be returned.
[in]	fv	Feature vector of example that needs to be prepared.
[out]	newExampleCreated	Indicates if either Feature Encoding and/or Normalization needed to be done. If neither then the original instance is returned. If Yes then a new instance which the caller will have to be delete will be returned.

Reimplemented in KKMLL::ModelOldSVM.

Definition at line 574 of file Model.cpp.

References alreadyNormalized, KKMLL::FeatureEncoder2::EncodeAExample(), encoder, normParms, and KKMLL::NormalizationParms::ToNormalized().

Referenced by KKMLL::ModelSvmBase::Predict(), KKMLL::ModelUsfCasCor::Predict(), KKMLL::ModelDual::Predict(), KKMLL::ModelKnn::ProbabilitiesByClass(), KKMLL::ModelSvmBase::ProbabilitiesByClass(), KKMLL::ModelUsfCasCor::ProbabilitiesByClass(), and KKMLL::ModelDual::ProbabilitiesByClassDual().

 {
   FeatureVectorPtr  oldFV = NULL;
   newExampleCreated = false;
   if  ((!alreadyNormalized)  &&  (normParms))
   {
     oldFV = fv;
     fv = normParms->ToNormalized (fv);
     if  (newExampleCreated)
     {
       delete  oldFV;
       oldFV = NULL;
     }
     newExampleCreated = true;
   }
 
   // I do not believe we need the encoder at this point. At least not for the Features Selected part. Maybe the conversion from minimal fields will make sense.
   if  (encoder)
   {
     oldFV = fv;
     fv = encoder->EncodeAExample (fv);
     if  (newExampleCreated)
     {
       delete  oldFV;
       oldFV = NULL;
     }
     newExampleCreated = true;
   }
 
   return  fv;
 }  /* PrepExampleForPrediction */

virtual ClassProbListPtr KKMLL::Model::ProbabilitiesByClass	(	FeatureVectorPtr	example,
		RunLog &	log
	)

pure virtual

Implemented in KKMLL::ModelDual, KKMLL::ModelOldSVM, KKMLL::ModelUsfCasCor, KKMLL::ModelSvmBase, and KKMLL::ModelKnn.

Referenced by KKMLL::Classifier2::ProbabilitiesByClass(), and ProbabilitiesByClassDual().

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

pure virtual

Implemented in KKMLL::ModelOldSVM, KKMLL::ModelDual, KKMLL::ModelUsfCasCor, KKMLL::ModelSvmBase, and KKMLL::ModelKnn.

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

pure 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 of 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. The ordering of this list will dictate the order that '_probabilities' will be populated.
[out]	_probabilities	An array that must be as big as the number of classes in '_mlClasses'. The probability of class in '_mlClasses[x]' will be returned in probabilities[x].

Implemented in KKMLL::ModelDual, KKMLL::ModelOldSVM, KKMLL::ModelUsfCasCor, KKMLL::ModelSvmBase, and KKMLL::ModelKnn.

void Model::ProbabilitiesByClassDual	(	FeatureVectorPtr	example,
		KKStr &	classifier1Desc,
		KKStr &	classifier2Desc,
		ClassProbListPtr &	classifier1Results,
		ClassProbListPtr &	classifier2Results,
		RunLog &	log
	)

virtual

Only applied to ModelDual classifier.

Reimplemented in KKMLL::ModelDual.

Definition at line 830 of file Model.cpp.

References KKMLL::ClassProbList::ClassProbList(), Description(), KKB::KKStr::operator=(), and ProbabilitiesByClass().

Referenced by KKMLL::Classifier2::ProbabilitiesByClassDual().

 {
   delete classifier1Results;  classifier1Results = NULL;
   delete classifier2Results;  classifier2Results = NULL;
 
   classifier1Desc = Description ();
   classifier2Desc = Description ();
 
   classifier1Results = ProbabilitiesByClass (example, log);
   if  (classifier1Results)
     classifier2Results = new ClassProbList (*classifier1Results);
 }  /* ProbabilitiesByClassDual */

virtual void KKMLL::Model::ReadXML	(	XmlStream &	s,
		XmlTagConstPtr	tag,
		VolConstBool &	cancelFlag,
		RunLog &	log
	)

pure virtual

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

Implemented in KKMLL::ModelOldSVM, KKMLL::ModelDual, KKMLL::ModelSvmBase, KKMLL::ModelUsfCasCor, and KKMLL::ModelKnn.

void Model::ReadXMLModelPost ( RunLog & log )

protected

Definition at line 987 of file Model.cpp.

References AddErrorMsg(), classes, KKB::KKStr::Concat(), fileDesc, param, and KKMLL::ModelParam::ValidParam().

Referenced by KKMLL::ModelKnn::ReadXML(), KKMLL::ModelUsfCasCor::ReadXML(), KKMLL::ModelSvmBase::ReadXML(), KKMLL::ModelDual::ReadXML(), and KKMLL::ModelOldSVM::ReadXML().

 {
   if  (!param)
   {
     KKStr errMsg = "Model::ReadXMLModelPost   ***ERROR***   'param' not defined.";
     AddErrorMsg (errMsg, 0);
     log.Level (-1) << endl << errMsg << endl << endl;
   }
 
   else if  (!param->ValidParam ())
   {
     KKStr errMsg = "Model::ReadXMLModelPost   ***ERROR***   'Param' is NOT Valid .";
     AddErrorMsg (errMsg, 0);
     log.Level (-1) << endl << errMsg << endl << endl;
   }
 
   if  (!classes)
   {
     KKStr errMsg = "Model::ReadXMLModelPost   ***ERROR***   'classes' not defined.";
     AddErrorMsg (errMsg, 0);
     log.Level (-1) << endl << errMsg << endl << endl;
   }
 
   if  (!fileDesc)
   {
     KKStr errMsg = "Model::ReadXMLModelPost   ***ERROR***   'fileDesc' not defined.";
     AddErrorMsg (errMsg, 0);
     log.Level (-1) << endl << errMsg << endl << endl;
   }
 
   if  (errors.size () > 0)
   {
     log.Level (-1) << "Model::ReadXMLModelPost    Errors were detected;  model is INVALID." << endl;
     validModel = false;
   }
   else
   {
     AllocatePredictionVariables ();
   }
 
 }  /* ReadXMLModelPost */

XmlTokenPtr Model::ReadXMLModelToken	(	XmlTokenPtr	t,
		RunLog &	log
	)

protected

Will process any tokens that belong to 'ModelParam' and return NULL ones that are not will be passed back.

Definition at line 884 of file Model.cpp.

References AddErrorMsg(), classes, KKB::KKStr::Concat(), KKB::KKStr::EqualIgnoreCase(), KKB::KKStr::KKStr(), ModelType(), ModelTypeFromStr(), ModelTypeStr(), KKB::KKStr::operator=(), rootFileName, KKMLL::XmlElementMLClassNameList::TakeOwnership(), KKB::XmlToken::tokElement, KKB::XmlToken::TokenType(), KKB::XmlElement::ToKKStr(), KKB::XmlToken::VarName(), and KKB::XmlElement::VarName().

Referenced by KKMLL::ModelKnn::ReadXML(), KKMLL::ModelUsfCasCor::ReadXML(), KKMLL::ModelSvmBase::ReadXML(), KKMLL::ModelDual::ReadXML(), and KKMLL::ModelOldSVM::ReadXML().

 {
   const KKStr&  varName = t->VarName ();
   if  (t->TokenType () == XmlToken::TokenTypes::tokElement)
   {
     bool  tokenFound = true;
 
     XmlElementPtr  e = dynamic_cast<XmlElementPtr> (t);
 
     const KKStr&  varName = e->VarName ();
 
     if  (varName.EqualIgnoreCase ("ModelType"))
     {
       if  (ModelType ()  != Model::ModelTypeFromStr (e->ToKKStr ()))
       {
         KKStr errMsg (128);
         errMsg << "Model::ReadXMLModelToken   ***ERROR***   Wrong ModelType encountered;  Expected[" << ModelTypeStr () << "] "
                << "ModelType Specified[" << e->ToKKStr () << "].";
 
         log.Level (-1) << endl << errMsg << endl << endl;
         AddErrorMsg (errMsg, 0);
       }
     }
 
     else if  (varName.EqualIgnoreCase ("Name"))
       name = e->ToKKStr ();
 
     else if  (varName.EqualIgnoreCase ("RootFileName"))
       rootFileName = e->ToKKStr ();
 
     else if  ((varName.EqualIgnoreCase ("Classes"))  &&  (typeid(*e) == typeid (XmlElementMLClassNameList)))
     {
       delete classes;
       classes = dynamic_cast<XmlElementMLClassNameListPtr> (t)->TakeOwnership ();
     }
 
     else if  (varName.EqualIgnoreCase ("ClassesIndex")  &&  (typeid(*e) == typeid (XmlElementMLClassIndexList)))
     {
       delete classesIndex;
       classesIndex = dynamic_cast<XmlElementMLClassIndexListPtr>(t)->TakeOwnership ();
     }
 
     else if  (varName.EqualIgnoreCase ("FvFactoryProducer"))
     {
       factoryFVProducer = FactoryFVProducer::LookUpFactory (e->ToKKStr ());
     }
 
     else if  (varName.EqualIgnoreCase ("FileDesc")  &&  (typeid(*e) == typeid (XmlElementFileDesc)))
     {
       fileDesc = dynamic_cast<XmlElementFileDescPtr>(t)->Value ();
     }
 
     else if  (varName.EqualIgnoreCase ("Param")) 
     {
       XmlElementModelParamPtr  xmlParameterElement = dynamic_cast<XmlElementModelParamPtr> (e);
       if  (xmlParameterElement)
       {
         delete param;
         param = xmlParameterElement->TakeOwnership ();
       }
       else
       {
         KKStr errMsg (128);
         errMsg << "Model::ReadXMLModelToken   ***ERROR***   ModelParam variable 'param' not defined correctly.";
         log.Level (-1) << endl << errMsg << endl << endl;
         AddErrorMsg (errMsg, 0);
       }
     }
 
     else if  (varName.EqualIgnoreCase ("TimeSaved"))
       timeSaved = DateTime (e->ToKKStr ());
 
     else if  (varName.EqualIgnoreCase ("TrainingTime"))
       trainingTime = e->ToDouble ();
 
     else if  (varName.EqualIgnoreCase ("AlreadyNormalized"))
       alreadyNormalized = e->ToBool ();
 
     else if  ((varName.EqualIgnoreCase ("NormParms"))  &&  (typeid (*e) == typeid (XmlElementNormalizationParms)))
     {
       delete  normParms;
       normParms = dynamic_cast<XmlElementNormalizationParmsPtr> (e)->TakeOwnership ();
     }
 
     else
     {
       tokenFound = false;
     }
 
     if  (tokenFound)
     {
       delete t;
       t = NULL;
     }
   }
 
   return  t;
 }  /* ReadXMLModelToken */

void Model::ReduceTrainExamples ( RunLog & log )

protected

Reduces the Training Images down to the size dictated by the 'examplesPerClass' parameter.

Definition at line 649 of file Model.cpp.

References KKMLL::ModelParam::ExamplesPerClass(), KKMLL::FeatureVectorList::ExtractExamplesForAGivenClass(), KKMLL::FeatureVectorList::GetClassStatistics(), KKMLL::FeatureVectorList::ManufactureEmptyList(), param, trainExamples, validModel, and weOwnTrainExamples.

Referenced by TrainModel().

 {
   kkint32  examplesPerClass = param->ExamplesPerClass ();
   kkuint32  zed = 0;
 
   if  (examplesPerClass < 0)
     examplesPerClass = int32_max;
 
   bool  reductionNeeded = false;
 
   {
     // First lets see if reduction is even necessary.
     ClassStatisticListPtr  stats = trainExamples->GetClassStatistics ();
     if  (!stats)
     {
       log.Level (-1) << endl
         << "Model::ReduceTrainExamples   ***ERROR***  can not retrieve Class Stat's for training data." << endl
         << endl;
       validModel = false;
       return;
     }
 
     for  (zed = 0;  (zed < stats->size ())  &&  (!reductionNeeded);  zed++)
     {
       if  (stats->IdxToPtr (zed)->Count () > (kkuint32)examplesPerClass)
         reductionNeeded  = true;
     }
 
     delete  stats;
     stats = NULL;
   }
 
   if  (!reductionNeeded)
   {
     log.Level (20) << "Model::ReduceTrainExamples    Was not needed.  No classes exceeded 'examplesPerClass'." << endl;
     return;
   }
 
   FeatureVectorListPtr  reducedSet = trainExamples->ManufactureEmptyList (false);
   FeatureVectorListPtr  deleteSet  = trainExamples->ManufactureEmptyList (false);  // Examples that we do not use will need to be deleted.
   MLClassList::iterator  idx;
 
   for  (idx = classes->begin ();  idx != classes->end ();  idx++)
   {
     MLClassPtr  ic = *idx;
     FeatureVectorListPtr  examplesThisClass = trainExamples->ExtractExamplesForAGivenClass (ic);
     if  ((!examplesThisClass)  ||  (examplesThisClass->size () < 1))
     {
       log.Level (-1) << endl
         << "Model::ReduceTrainExamples   ***ERROR***   No Training Examples for class[" << ic->Name () << "]." << endl
         << endl;
       continue;
     }
 
     if  (examplesThisClass->size () <= (kkuint32)examplesPerClass)
     {
       reducedSet->AddQueue (*examplesThisClass);
     }
     else
     {
       examplesThisClass->RandomizeOrder ();
       zed = 0;
       while  (zed < (kkuint32)examplesPerClass)
       {
         reducedSet->PushOnBack (examplesThisClass->IdxToPtr (zed));
         zed++;
       }
       while  (zed < examplesThisClass->size ())
       {
         deleteSet->PushOnBack (examplesThisClass->IdxToPtr (zed));
         zed++;
       }
     }
 
     delete  examplesThisClass;
     examplesThisClass = NULL;
   }
 
   if  (weOwnTrainExamples)
   {
     trainExamples->Owner (false);
     delete trainExamples;
     trainExamples = reducedSet;
     reducedSet = NULL;
 
     trainExamples->Owner (true);
     deleteSet->Owner (true);
     delete  deleteSet;
     deleteSet = NULL;
   }
   else
   {
     // Since we are replacing 'trainExamples' with 'reducedSet' we will now own 'trainExamples' but not its contents.
     reducedSet->Owner (false);
     weOwnTrainExamples = true;
     trainExamples = reducedSet;
     reducedSet = NULL;
     deleteSet->Owner (false);
     delete  deleteSet;
     deleteSet = NULL;
   }
 }  /* ReduceTrainExamples */

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

virtual

Parameters

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

Reimplemented in KKMLL::ModelOldSVM, KKMLL::ModelDual, and KKMLL::ModelSvmBase.

Definition at line 755 of file Model.cpp.

References crossClassProbTable.

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

 {
   if  (classes.QueueSize () != crossClassProbTableSize)
   {
     // There Class List does not have the same number of entries as our 'CrossProbTable'
     log.Level (-1) << endl
                    << "SVMModel::RetrieveCrossProbTable   ***ERROR***" << endl
                    << "            classes.QueueSize ()[" << classes.QueueSize () << "] != crossClassProbTableSize[" << crossClassProbTableSize << "]" << endl
                    << endl;
     return;
   }
 
   kkint32*  indexTable = new kkint32[classes.QueueSize ()];
   kkint32  x, y;
   for  (x = 0;  x < classes.QueueSize ();  x++)
   {
     for  (y = 0;  y < classes.QueueSize ();  y++)
        crossClassProbTable[x][y] = 0.0;
 
     indexTable[x] = classesIndex->GetClassIndex (classes.IdxToPtr (x));
     if  (indexTable[x] < 0)
     {
       log.Level (-1) << endl
                      << "SVMModel::RetrieveCrossProbTable   ***WARNING***" << endl
                      << endl
                      << "      Class Index[" << x << "]  Name[" << classes[x].Name () << "]" << endl
                      << "      will populate this index with zeros."                         << endl
                      << endl;
     }
   }
 
   if  (classes.QueueSize () != crossClassProbTableSize)
   {
     log.Level (-1) << endl
                    << "SVMModel::RetrieveCrossProbTable   ***ERROR***"                                       << endl
                    << "                                  'classes.QueueSize () != crossClassProbTableSize'"  << endl
                    << endl;
     return;
   }
 
 
   // x,y         = 'Callers'   Class Indexes..
   // xIdx, yIdx  = 'SVMNodel'  Class Indexed.
   for  (x = 0;  x < classes.QueueSize ();  x++)
   {
     kkint32 xIdx = indexTable[x];
     if  (xIdx >= 0)
     {
       for  (y = 0;  y < classes.QueueSize ();  y++)
       {
         kkint32  yIdx = indexTable[y];
         if  (yIdx >= 0)
         {
           if  ((x != xIdx)  ||  (y != yIdx))
           {
             //kak  I just added this check to see when this situation actually occurs.
             kkint32 zed = 111;
           }
 
           crossClassProbTable[x][y] = this->crossClassProbTable[xIdx][yIdx];
         }
       }
     }
   }
 
   delete[]  indexTable;  indexTable = NULL;
   return;
 }  /* RetrieveCrossProbTable */

const KKStr& KKMLL::Model::RootFileName ( ) const

inline

Definition at line 187 of file Model.h.

References rootFileName.

187 {return rootFileName;}

KKMLL::Model::rootFileName

KKStr rootFileName

Definition: Model.h:414

void KKMLL::Model::RootFileName ( const KKStr & _rootFileName )

inline

Definition at line 199 of file Model.h.

References KKB::KKStr::operator=(), and rootFileName.

199 {rootFileName = _rootFileName;}

KKMLL::Model::rootFileName

KKStr rootFileName

Definition: Model.h:414

FeatureNumListConstPtr Model::SelectedFeatures ( ) const

virtual

Definition at line 436 of file Model.cpp.

References KKB::KKException::KKException(), param, and KKMLL::ModelParam::SelectedFeatures().

Referenced by KKMLL::ModelUsfCasCor::TrainModel().

 {
   if  (!param)
     throw KKException ("Model::GetFeatureNums  'param'.");
   return  param->SelectedFeatures ();
 }

const KKB::DateTime& KKMLL::Model::TimeSaved ( ) const

inline

Definition at line 189 of file Model.h.

189 {return timeSaved;}

double KKMLL::Model::TrainingTime ( ) const

inline

Definition at line 191 of file Model.h.

Referenced by KKMLL::TrainingProcess2::TrainingTime().

191 {return trainingTime;}

void Model::TrainingTimeEnd ( )

Derived classes call this method to stop the clock for 'trainingTime'.

Definition at line 452 of file Model.cpp.

References KKB::osGetSystemTimeUsed().

Referenced by KKMLL::ModelUsfCasCor::TrainModel(), KKMLL::ModelSvmBase::TrainModel(), KKMLL::ModelDual::TrainModel(), and KKMLL::ModelOldSVM::TrainModel().

 {
   double  trainingTimeEnd = osGetSystemTimeUsed ();
   trainingTime = trainingTimeEnd - trainingTimeStart;
   if  (trainingTime < 0.0)
     trainingTime += (24.0 * 60.0 * 60.0);
 }

void Model::TrainingTimeStart ( )

Derived classes call this method to start the clock for 'trainingTime'.

Definition at line 445 of file Model.cpp.

References KKB::osGetSystemTimeUsed().

Referenced by KKMLL::ModelUsfCasCor::TrainModel(), KKMLL::ModelSvmBase::TrainModel(), KKMLL::ModelDual::TrainModel(), and KKMLL::ModelOldSVM::TrainModel().

 {
   trainingTimeStart = osGetSystemTimeUsed ();
 }

void Model::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 True = Model will take ownership of these examples

Reimplemented in KKMLL::ModelOldSVM, KKMLL::ModelDual, KKMLL::ModelSvmBase, KKMLL::ModelUsfCasCor, and KKMLL::ModelKnn.

Definition at line 467 of file Model.cpp.

References AllocatePredictionVariables(), alreadyNormalized, classes, classesIndex, KKB::KKStr::Concat(), KKMLL::FeatureVectorList::Duplicate(), KKMLL::FeatureEncoder2::EncodeAllExamples(), encoder, KKMLL::ModelParam::EncodingMethod(), KKMLL::ModelParam::ExamplesPerClass(), KKMLL::FeatureVectorList::ExtractListOfClasses(), KKMLL::FeatureEncoder2::FeatureEncoder2(), fileDesc, KKB::KKException::KKException(), KKMLL::MLClassIndexList::MLClassIndexList(), KKMLL::ModelParam::NoEncoding, KKMLL::NormalizationParms::NormalizationParms(), KKMLL::NormalizationParms::NormalizeExamples(), normParms, KKMLL::ModelParam::Null, KKB::osGetSystemTimeUsed(), param, ReduceTrainExamples(), KKMLL::MLClassList::SortByName(), trainExamples, and weOwnTrainExamples.

Referenced by KKMLL::TrainingProcess2::CreateModelsFromTrainingData(), KKMLL::ModelKnn::TrainModel(), KKMLL::ModelUsfCasCor::TrainModel(), KKMLL::ModelSvmBase::TrainModel(), KKMLL::ModelDual::TrainModel(), and KKMLL::ModelOldSVM::TrainModel().

 {
   _log.Level (10) << "Model::TrainModel   Preparing for training of Model[" << Name () << "]  Examples[" << _trainExamples->QueueSize () << "]" << endl;
 
   double  prepStartTime = osGetSystemTimeUsed ();
 
   if  (_trainExamples == NULL)
   {
     KKStr  errMsg = "ModelSvmBase::TrainModel   (_trainExamples == NULL)";
     _log.Level (-1) << endl << endl << errMsg << endl << endl;
     throw KKException (errMsg);
   }
 
   if  (_trainExamples->QueueSize () < 2)
   {
     KKStr  errMsg = "ModelSvmBase::TrainModel   (_trainExamples == NULL)";
     _log.Level (-1) << endl << endl << errMsg << endl << endl;
     throw KKException (errMsg);
   }
 
   weOwnTrainExamples = _takeOwnership;
   trainExamples      = _trainExamples;
   alreadyNormalized  = _alreadyNormalized;
   _trainExamples     = NULL;
 
   delete  classes;
   classes = trainExamples->ExtractListOfClasses ();
   classes->SortByName ();
 
   delete  classesIndex;
   classesIndex = new MLClassIndexList (*classes);
 
   if  (param->ExamplesPerClass () < int32_max)
     ReduceTrainExamples (_log);
 
   if  (!_alreadyNormalized)
   {
     if  (!weOwnTrainExamples)
     {
       // Since we do not own the WE will have to duplicate the trainExamples list and its contents before we normalize the data.
       FeatureVectorListPtr  temp = trainExamples->Duplicate (true);
       weOwnTrainExamples = true;
       trainExamples = temp;
     }
     else if  (!trainExamples->Owner ())
     {
       // Even though we own 'trainExamples' we do not own its contents; so we will need to create a new list and own those contents.
       FeatureVectorListPtr  temp = trainExamples->Duplicate (true);
       weOwnTrainExamples = true;
       delete  trainExamples;
       trainExamples = temp;
     }
     delete  normParms;
     normParms = new NormalizationParms (*param, *trainExamples, _log);
     normParms->NormalizeExamples (trainExamples, _log);
   }
 
   if  (param->EncodingMethod () == ModelParam::EncodingMethodType::Null)
   {
     // There is nothing for us to do.
     return;
   }
 
   if  ((param->EncodingMethod () != ModelParam::EncodingMethodType::Null)  &&   (param->EncodingMethod () != ModelParam::EncodingMethodType::NoEncoding))
   {
     if  (!encoder)
       encoder = new FeatureEncoder2 (*param, fileDesc);
 
     FeatureVectorListPtr  encodedImages = encoder->EncodeAllExamples (trainExamples);
     if  (weOwnTrainExamples)
     {
       delete  trainExamples;
       trainExamples = NULL;
     }
 
     trainExamples = encodedImages;
     weOwnTrainExamples = true;
   }
 
   AllocatePredictionVariables ();
 
   double  prepEndTime = osGetSystemTimeUsed ();
   trianingPrepTime = prepEndTime - prepStartTime;
   if  (trianingPrepTime < 0.0)
     trianingPrepTime += (24.0 * 60.0 * 60.0);
 
   _log.Level (40) << "Model::TrainModel   Exiting." << endl;
 }  /* TrainModel */

double KKMLL::Model::TrianingPrepTime ( ) const

inline

Definition at line 193 of file Model.h.

193 {return trianingPrepTime;} //*< Time ins sec's spent preparing training data in Model::TrainModel */

bool KKMLL::Model::ValidModel ( ) const

inline

Definition at line 195 of file Model.h.

References validModel.

Referenced by KKMLL::Classifier2::Classifier2(), KKMLL::TrainingProcess2::CreateModelsFromTrainingData(), and KKMLL::TrainingProcess2::ReadXML().

195 {return validModel;}

KKMLL::Model::validModel

bool validModel

Definition: Model.h:426

void Model::WriteModelXMLFields ( std::ostream & o ) const

The "WriteXML" method in Derived classes call this method to include the parents classes fields in the XML data.

Definition at line 854 of file Model.cpp.

References alreadyNormalized, classes, classesIndex, fileDesc, ModelTypeStr(), Name(), normParms, param, rootFileName, KKMLL::NormalizationParms::WriteXML(), KKMLL::ModelParam::WriteXML(), KKMLL::FileDesc::WriteXML(), KKB::XmlElementBool::WriteXML(), KKMLL::MLClassIndexList::WriteXML(), KKB::KKStr::WriteXML(), KKMLL::XmlElementMLClassNameList::WriteXML(), and KKB::DateTime::YYYY_MM_DD_HH_MM_SS().

Referenced by KKMLL::ModelKnn::WriteXML(), KKMLL::ModelUsfCasCor::WriteXML(), KKMLL::ModelSvmBase::WriteXML(), KKMLL::ModelDual::WriteXML(), and KKMLL::ModelOldSVM::WriteXML().

 {
   //timeSaved = osGetLocalDateTime ();
   ModelTypeStr ().WriteXML ("ModelType", o);
   Name ().WriteXML ("Name", o);
   rootFileName.WriteXML ("RootFileName", o);
   XmlElementMLClassNameList::WriteXML (*classes, "classes", o);
   if  (classesIndex)
     classesIndex->WriteXML ("ClassesIndex", o);
 
 
   if  (factoryFVProducer)
     XmlElementKKStr::WriteXML (factoryFVProducer->Name (), "FvFactoryProducer", o);
 
   if  (fileDesc)
     fileDesc->WriteXML ("FileDesc", o);
 
   if  (param)
     param->WriteXML ("Param", o);
 
   timeSaved.YYYY_MM_DD_HH_MM_SS ().WriteXML ("TimeSaved", o);
   XmlElementDouble::WriteXML (trainingTime, "TrainingTime", o);
   XmlElementBool::WriteXML (alreadyNormalized, "AlreadyNormalized", o);
   if  (normParms)
     normParms->WriteXML ("NormParms", o);
 } /* WriteModelXMLFields */

virtual void KKMLL::Model::WriteXML	(	const KKStr &	varName,
		std::ostream &	o
	)		const

pure virtual

Implemented in KKMLL::ModelOldSVM.

Referenced by KKMLL::TrainingProcess2::WriteXML().

Member Data Documentation

bool KKMLL::Model::alreadyNormalized

protected

Definition at line 388 of file Model.h.

Referenced by AlreadyNormalized(), Model(), KKMLL::ModelOldSVM::PrepExampleForPrediction(), PrepExampleForPrediction(), TrainModel(), and WriteModelXMLFields().

MLClassListPtr KKMLL::Model::classes

protected

Definition at line 390 of file Model.h.

Referenced by AllocatePredictionVariables(), MemoryConsumedEstimated(), MLClasses(), MLClassesNewInstance(), Model(), KKMLL::ModelUsfCasCor::Predict(), KKMLL::ModelOldSVM::ProbabilitiesByClass(), ReadXMLModelPost(), ReadXMLModelToken(), KKMLL::ModelOldSVM::TrainModel(), TrainModel(), WriteModelXMLFields(), and ~Model().

MLClassIndexListPtr KKMLL::Model::classesIndex

protected

Definition at line 392 of file Model.h.

Referenced by MemoryConsumedEstimated(), Model(), KKMLL::ModelSvmBase::Predict(), KKMLL::ModelKnn::ProbabilitiesByClass(), KKMLL::ModelSvmBase::ProbabilitiesByClass(), KKMLL::ModelSvmBase::RetrieveCrossProbTable(), TrainModel(), WriteModelXMLFields(), and ~Model().

double* KKMLL::Model::classProbs

protected

Definition at line 394 of file Model.h.

Referenced by AllocatePredictionVariables(), DeAllocateSpace(), MemoryConsumedEstimated(), Model(), KKMLL::ModelSvmBase::Predict(), KKMLL::ModelSvmBase::ProbabilitiesByClass(), and KKMLL::ModelOldSVM::ProbabilitiesByClass().

double** KKMLL::Model::crossClassProbTable

protected

Probabilities between Binary Classes From last Prediction

Definition at line 396 of file Model.h.

Referenced by AllocatePredictionVariables(), DeAllocateSpace(), MemoryConsumedEstimated(), Model(), and RetrieveCrossProbTable().

kkint32 KKMLL::Model::crossClassProbTableSize

protected

Definition at line 398 of file Model.h.

Referenced by AllocatePredictionVariables(), and Model().

FeatureEncoder2Ptr KKMLL::Model::encoder

protected

Definition at line 400 of file Model.h.

Referenced by Encoder(), MemoryConsumedEstimated(), Model(), PrepExampleForPrediction(), TrainModel(), and ~Model().

VectorKKStr KKMLL::Model::errors

protected

Definition at line 402 of file Model.h.

FactoryFVProducerPtr KKMLL::Model::factoryFVProducer

protected

Definition at line 404 of file Model.h.

Referenced by FactoryFVProducer(), Model(), and KKMLL::ModelDual::TrainModel().

FileDescPtr KKMLL::Model::fileDesc

protected

Definition at line 406 of file Model.h.

Referenced by Model(), KKMLL::ModelSvmBase::ModelSvmBase(), ReadXMLModelPost(), KKMLL::ModelOldSVM::TrainModel(), TrainModel(), and WriteModelXMLFields().

NormalizationParmsPtr KKMLL::Model::normParms

protected

Definition at line 408 of file Model.h.

Referenced by MemoryConsumedEstimated(), Model(), KKMLL::ModelOldSVM::PrepExampleForPrediction(), PrepExampleForPrediction(), TrainModel(), WriteModelXMLFields(), and ~Model().

kkint32 KKMLL::Model::numOfClasses

protected

Number of Classes defined in crossClassProbTable.

Definition at line 410 of file Model.h.

Referenced by AllocatePredictionVariables(), DeAllocateSpace(), MemoryConsumedEstimated(), Model(), KKMLL::ModelSvmBase::Predict(), KKMLL::ModelKnn::ProbabilitiesByClass(), KKMLL::ModelSvmBase::ProbabilitiesByClass(), KKMLL::ModelOldSVM::ProbabilitiesByClass(), and KKMLL::ModelSvmBase::RetrieveCrossProbTable().

ModelParamPtr KKMLL::Model::param

protected

KKStr KKMLL::Model::rootFileName

protected

This is the root name to be used by all component objects; such as svm_model, mlClasses, and svmParam(including selected features). Each one will have the same rootName with a different suffix.

mlClasses  "<rootName>.classes"
svmParam      "<rootName>.svm_parm"
model         "<rootName>"

Definition at line 414 of file Model.h.

Referenced by MemoryConsumedEstimated(), Model(), ReadXMLModelToken(), RootFileName(), KKMLL::ModelSvmBase::TrainModel(), and WriteModelXMLFields().

FeatureVectorListPtr KKMLL::Model::trainExamples

protected

Definition at line 424 of file Model.h.

Referenced by MemoryConsumedEstimated(), Model(), ReduceTrainExamples(), KKMLL::ModelUsfCasCor::TrainModel(), KKMLL::ModelSvmBase::TrainModel(), KKMLL::ModelDual::TrainModel(), KKMLL::ModelOldSVM::TrainModel(), TrainModel(), and ~Model().

bool KKMLL::Model::validModel

protected

Definition at line 426 of file Model.h.

Referenced by AllocatePredictionVariables(), Model(), KKMLL::ModelDual::ReadXML(), ReduceTrainExamples(), KKMLL::ModelKnn::TrainModel(), KKMLL::ModelUsfCasCor::TrainModel(), KKMLL::ModelSvmBase::TrainModel(), KKMLL::ModelDual::TrainModel(), KKMLL::ModelOldSVM::TrainModel(), and ValidModel().

kkint32* KKMLL::Model::votes

protected

Definition at line 428 of file Model.h.

Referenced by AllocatePredictionVariables(), DeAllocateSpace(), MemoryConsumedEstimated(), Model(), KKMLL::ModelSvmBase::Predict(), KKMLL::ModelSvmBase::ProbabilitiesByClass(), and KKMLL::ModelOldSVM::ProbabilitiesByClass().

bool KKMLL::Model::weOwnTrainExamples

protected

Indicates if we own the 'trainExamples'. This does not mean that we own its contents. That is determined by 'trainExamples->Owner ()'.

Definition at line 430 of file Model.h.

Referenced by MemoryConsumedEstimated(), Model(), ReduceTrainExamples(), KKMLL::ModelOldSVM::TrainModel(), TrainModel(), and ~Model().

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

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

Public Types

Public Member Functions

Static Public Member Functions

Protected Member Functions

Protected Attributes

Detailed Description

Member Typedef Documentation

Member Enumeration Documentation

Constructor & Destructor Documentation

Member Function Documentation

Member Data Documentation