#include <TrainingProcess2.h>

Public Types
typedef TrainingProcess2 *	TrainingProcess2Ptr

enum	WhenToRebuild { WhenToRebuild::AlwaysRebuild, WhenToRebuild::NotUpToDate, WhenToRebuild::NotValid, WhenToRebuild::NeverRebuild }

Public Member Functions
	TrainingProcess2 ()
	The default constructor; What will be used when creating an instance while reading in from a XML Stream file. All members will be set to default values. The XMLRead method. More...

virtual	~TrainingProcess2 ()

void	Abort (bool _abort)

bool	Abort () const

const KKB::DateTime &	BuildDateTime () const

void	BuildTrainingProcess (TrainingConfiguration2Const *_config, WhenToRebuild _whenToRebuild, FeatureVectorListPtr _trainingExamples, bool _takeOwnerShipOfTrainingExamples, bool _checkForDuplicates, VolConstBool &_cancelFlag, RunLog &_log)
	Call this method just after you construct a new instance of "TrainingProcess2". More...

TrainingConfiguration2Const *	Config ()

VectorKKStr	ConfigFileFormatErrors () const
	If there is a config file; will return a list of its FormatErrors (). More...

const KKStr &	ConfigFileName () const

void	CreateModelsFromTrainingData (WhenToRebuild whenToRebuild, VolConstBool &cancelFlag, RunLog &log)

kkint32	DuplicateCount () const

kkint32	DuplicateDataCount () const

MLClassListPtr	ExtractFullHierachyOfClasses () const
	Extracts the list of classes including ones from Sub-Classifiers. More...

bool	FeaturesAlreadyNormalized () const

void	FeaturesAlreadyNormalized (bool _featuresAlreadyNormalized)

FactoryFVProducerPtr	FvFactoryProducer () const

FeatureVectorListPtr	Images ()

void	LoadPrevTrainedOtherwiseRebuild (bool _forceRebuild, bool _checkForDuplicates)

kkint32	MemoryConsumedEstimated () const

MLClassListPtr	MLClasses () const

SVMModelPtr	Model3 ()

KKStr	ModelDescription () const

Model::ModelTypes	ModelType () const

KKStr	ModelTypeStr () const

kkint32	NumOfSupportVectors () const

ModelOldSVMPtr	OldSVMModel () const

ModelParamPtr	Parameters () const

ClassProbList const *	PriorProbability () const

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

void	ReportTraningClassStatistics (std::ostream &report)

void	SaveTrainingProcess (RunLog &log)
	Saves the built training model into the Save file in Xml Format. More...

TrainingProcess2ListPtr	SubTrainingProcesses () const

void	SupportVectorStatistics (kkint32 &numSVs, kkint32 &totalNumSVs)

ModelPtr	TrainedModel () const

TrainingProcess2Ptr	TrainingProcessLeft ()
	summary> Returns back pointer to 2nd classifier of Dual Classifier; if not a Dual classifier will return back NULL. More...

TrainingProcess2Ptr	TrainingProcessRight ()

double	TrainingTime () const

void	ValidateConfiguration ()

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

Static Public Member Functions
static TrainingProcess2Ptr	CreateTrainingProcess (TrainingConfiguration2Const *config, bool checkForDuplicates, WhenToRebuild whenToRebuild, bool saveTrainedModel, VolConstBool &cancelFlag, RunLog &log)

static TrainingProcess2Ptr	CreateTrainingProcessForLevel (TrainingConfiguration2Const *config, kkuint32 level, VolConstBool &cancelFlag, RunLog &log)

static TrainingProcess2Ptr	CreateTrainingProcessForLevel (const KKStr &configFileName, kkuint32 level, VolConstBool &cancelFlag, RunLog &log)

static TrainingProcess2Ptr	CreateTrainingProcessFromTrainingExamples (TrainingConfiguration2Const *config, FeatureVectorListPtr trainingExamples, bool takeOwnershipOfTrainingExamples, bool featuresAlreadyNormalized, VolConstBool &cancelFlag, RunLog &log)
	Will Construct an instance using provided list of examples rather than loading from training library. More...

static FeatureVectorListPtr	ExtractTrainingClassFeatures (TrainingConfiguration2ConstPtr config, KKB::DateTime &latestImageTimeStamp, bool &changesMadeToTrainingLibraries, VolConstBool &cancelFlag, RunLog &log)

static TrainingProcess2Ptr	LoadExistingTrainingProcess (const KKStr &configRootName, VolConstBool &cancelFlag, RunLog &log)
	Loads an existing TrainingProcess; if one does not exist will return NULL. More...

Detailed Description

Definition at line 78 of file TrainingProcess2.h.

Member Typedef Documentation

typedef TrainingProcess2* KKMLL::TrainingProcess2::TrainingProcess2Ptr

Definition at line 81 of file TrainingProcess2.h.

Member Enumeration Documentation

enum KKMLL::TrainingProcess2::WhenToRebuild

strong

Enumerator
AlwaysRebuild
NotUpToDate
NotValid
NeverRebuild

Definition at line 83 of file TrainingProcess2.h.

     {
       AlwaysRebuild,
       NotUpToDate,
       NotValid,
       NeverRebuild
     };

Constructor & Destructor Documentation

TrainingProcess2::TrainingProcess2 ( )

The default constructor; What will be used when creating an instance while reading in from a XML Stream file. All members will be set to default values. The XMLRead method.

Definition at line 405 of file TrainingProcess2.cpp.

References KKB::DateTime::DateTime(), and KKB::KKStr::KKStr().

Referenced by CreateTrainingProcess(), and CreateTrainingProcessForLevel().

                                    :
 
   abort                     (false),
   buildDateTime             (DateTime (1900,1,1,0, 0, 0)),
   config                    (NULL),
   configOurs                (NULL),
   configFileName            (""),
   configFileNameSpecified   (""),
   duplicateCount            (0),
   duplicateDataCount        (0),
   featuresAlreadyNormalized (false),
   fileDesc                  (NULL),
   fvFactoryProducer         (NULL),
   mlClasses                 (NULL),
   model                     (NULL),
   priorProbability          (NULL),
   report                    (NULL),
   savedModelName            (),
   subTrainingProcesses      (NULL),
   trainingExamples          (NULL),
   weOwnTrainingExamples     (true),
   weOwnMLClasses            (true)
 {
 }

TrainingProcess2::~TrainingProcess2 ( )

virtual

Definition at line 434 of file TrainingProcess2.cpp.

 {
   cout << "TrainingProcess2::~TrainingProcess2  for Config[" << configFileName << "]" << endl;
 
   try
   {
     delete  model; 
     model = NULL;
   }
   catch (...)
   {
     cerr  << "TrainingProcess2::~TrainingProcess2   ***ERROR***    Exception deleting model." << endl;
   }
   model = NULL;
 
 
   delete  subTrainingProcesses;  subTrainingProcesses = NULL;
   delete  priorProbability;      priorProbability     = NULL;
 
   if  (weOwnTrainingExamples)
   {
     delete  trainingExamples;
     trainingExamples  = NULL;
   }
 
   if  (weOwnMLClasses)
   {
     delete mlClasses;  mlClasses = NULL;
   }
 
   delete  configOurs;
   configOurs = NULL;
 }

Member Function Documentation

void KKMLL::TrainingProcess2::Abort ( bool _abort )

inline

Definition at line 243 of file TrainingProcess2.h.

Referenced by CreateModelsFromTrainingData(), and ReadXML().

243 {abort = _abort;}

bool KKMLL::TrainingProcess2::Abort ( ) const

inline

Definition at line 245 of file TrainingProcess2.h.

Referenced by BuildTrainingProcess(), KKMLL::Classifier2::Classifier2(), CreateTrainingProcess(), and KKMLL::ModelDual::TrainModel().

245 {return abort;}

const KKB::DateTime& KKMLL::TrainingProcess2::BuildDateTime ( ) const

inline

Definition at line 246 of file TrainingProcess2.h.

Referenced by CreateTrainingProcess().

246 {return buildDateTime;}

void TrainingProcess2::BuildTrainingProcess	(	TrainingConfiguration2Const *	_config,
		WhenToRebuild	_whenToRebuild,
		FeatureVectorListPtr	_trainingExamples,
		bool	_takeOwnerShipOfTrainingExamples,
		bool	_checkForDuplicates,
		VolConstBool &	_cancelFlag,
		RunLog &	_log
	)

Call this method just after you construct a new instance of "TrainingProcess2".

Parameters

[in]	_config
[in]	_whenToRebuild	Used for any sub classifiers that this instance of TrainingProcess2 might need to build.
[in]	_trainingExamples
[in]	_takeOwnerShipOfTrainingExamples	If true this instance of 'TrainingProcess2' will take ownership of '_trainingExamples' and delete it when done with them.
[in]	_checkForDuplicates	If true will remove duplicate examples from '_trainingExamples'.
[in]	_cancelFlag
[in]	_log

Definition at line 506 of file TrainingProcess2.cpp.

References Abort(), KKMLL::TrainingConfiguration2::ConfigFileNameSpecified(), CreateModelsFromTrainingData(), KKMLL::TrainingConfiguration2::Duplicate(), KKMLL::TrainingConfiguration2::FvFactoryProducer(), KKB::RunLog::Level(), and KKB::KKStr::operator=().

Referenced by CreateTrainingProcess(), and CreateTrainingProcessForLevel().

 {
   if  (_cancelFlag)
     return;
 
   _log.Level (20) << "TrainingProcess2   Building Support Vector Machine";
 
   if  (weOwnTrainingExamples)
   {
     delete  trainingExamples;
     trainingExamples = NULL;
   }
 
   configOurs = _config->Duplicate ();
   config = configOurs;
 
   configFileName = config->ConfigFileNameSpecified ();
 
   fvFactoryProducer = _config->FvFactoryProducer (_log);
 
   trainingExamples = _trainingExamples;
   weOwnTrainingExamples = _takeOwnerShipOfTrainingExamples;
 
   if  (_checkForDuplicates)
     CheckForDuplicates (true, _log);
 
   // trainer->ReportTraningClassStatistics (*report);
   CreateModelsFromTrainingData (_whenToRebuild,   
                                 _cancelFlag, 
                                 _log
                                );
   if  (Abort ())
   {
     _log.Level (-1) << endl
        << "TrainingProcess2::BuildTrainingProcess    ***ERROR***   Aborted During Model Creation ***" << endl
        << endl;
     return;
   }
 }  /* BuildTrainingProcess */

TrainingConfiguration2Const* KKMLL::TrainingProcess2::Config ( )

inline

Definition at line 247 of file TrainingProcess2.h.

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

247 {return config;}

VectorKKStr TrainingProcess2::ConfigFileFormatErrors ( ) const

If there is a config file; will return a list of its FormatErrors ().

Definition at line 1113 of file TrainingProcess2.cpp.

References KKB::VectorKKStr::VectorKKStr().

 {
   if  (config)
     return config->FormatErrorsWithLineNumbers ();
   else
     return VectorKKStr ();
 }  /* ConfigFileFormatErrors */

const KKStr& KKMLL::TrainingProcess2::ConfigFileName ( ) const

inline

Definition at line 248 of file TrainingProcess2.h.

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

248 {return configFileName;}

void TrainingProcess2::CreateModelsFromTrainingData	(	WhenToRebuild	whenToRebuild,
		VolConstBool &	cancelFlag,
		RunLog &	log
	)

< false = DON'T check for duplicates.

Definition at line 938 of file TrainingProcess2.cpp.

References Abort(), KKMLL::Model::CreateAModel(), KKMLL::FactoryFVProducer::FileDesc(), KKMLL::TrainingConfiguration2::FvFactoryProducer(), KKMLL::FeatureVectorList::GetClassDistribution(), KKMLL::Model::MLClassesNewInstance(), KKMLL::TrainingConfiguration2::ModelingMethod(), KKMLL::TrainingConfiguration2::ModelParameters(), KKB::DateTime::operator=(), KKB::osGetLocalDateTime(), KKB::osGetRootName(), KKMLL::Model::TrainModel(), and KKMLL::Model::ValidModel().

Referenced by BuildTrainingProcess().

 {
   log.Level (20) << "TrainingProcess2::CreateModelsFromTrainingData    Starting" << endl;
 
   if  (config->ModelParameters () == NULL)
   {
     log.Level (-1) << endl 
                    << "TrainingProcess2::CreateModelsFromTrainingData    ***ERROR***"  << endl
                    << endl
                    << "                   Parameters not specified in configuration file." << endl
                    << endl;
     Abort (true);
     return;
   }
 
   if  (!fvFactoryProducer)
     fvFactoryProducer = config->FvFactoryProducer (log);
 
   if  (!fileDesc)
     fileDesc = fvFactoryProducer->FileDesc ();
 
   delete  priorProbability;
   priorProbability = trainingExamples->GetClassDistribution ();
 
   // Will Create the Appropriate Model class given 'config->ModelingMethod ()'.
   model = Model::CreateAModel (config->ModelingMethod (),
                                osGetRootName (configFileName),
                                *(config->ModelParameters ()), 
                                fvFactoryProducer, 
                                cancelFlag, 
                                log
                               );
 
   try
   {
     model->TrainModel (trainingExamples, 
                        featuresAlreadyNormalized,
                        false,     // false = 'model' We are not giving ownership of TrainingExdamples to model.
                        cancelFlag,
                        log
                       );
   }
   catch  (const KKException&  e)
   {
     log.Level (-1) << endl << endl
       << "TrainingProcess2::CreateModelsFromTrainingData   ***ERROR***   Exception occurred while running 'Model::TrainModel'." << endl
       << "     Exception[" << e.ToString () << endl
       << endl;
     Abort (true);
   }
   catch  (...)
   {
     log.Level (-1) << endl << endl
       << "TrainingProcess2::CreateModelsFromTrainingData   ***ERROR***   Exception occurred while running 'Model::TrainModel'." << endl
       << endl;
     Abort (true);
   }
 
   if  (!model->ValidModel ())
   {
     Abort (true);
   }
 
   else if  (cancelFlag)
   {
     Abort (true);
   }
 
   else
   {
     delete  mlClasses;
     mlClasses = model->MLClassesNewInstance ();
 
     // Need to LOad Sub Processors.
     LoadSubClassifiers (whenToRebuild,
                         false,          /**< false = DON'T check for duplicates. */
                         cancelFlag, 
                         log
                        );
   }
 
   //trainingExamples->Owner (false);
   buildDateTime = osGetLocalDateTime ();
   log.Level (20) << "TrainingProcess2::CreateModelsFromTrainingData    Ending" << endl;
 } /* CreateModelsFromTrainingData */

TrainingProcess2Ptr TrainingProcess2::CreateTrainingProcess	(	TrainingConfiguration2Const *	config,
		bool	checkForDuplicates,
		WhenToRebuild	whenToRebuild,
		bool	saveTrainedModel,
		VolConstBool &	cancelFlag,
		RunLog &	log
	)

static

summary>Build a new model from scratch for the specified class level removing duplicate training examples.

remarks> Using the parameter level will construct a classifier that groups classes together by group hierarchy. Underscore characters in the class name will be used to differentiate group levels. Ex: Crustacean_Copepod_Calanoid has three levels of grouping where Crustacean belongs to level 1, Copeod to level 2, and Calanoid to level 3. /remarks> param name="config"> Configuration that will provide parameters such as classes and their related directories where training examples are found and sub-classifiers. /param> param name="level"> The grouping level to build a classifier for. Ex: if level = 2 is specified and referring to the class name "Crustacean_Copepod_Calanoid" above all classes that start with "Crustacean_Copepod</em>" will be combined as one logical class. /param> param name="cancelFlag"> Will monitor if it ever is set to true will stop processing at earliest convenience and return to caller. /param> param name="log"> Logging file.

< true = Take ownership of 'trainingExamples'.

Definition at line 91 of file TrainingProcess2.cpp.

References Abort(), AlwaysRebuild, BuildDateTime(), BuildTrainingProcess(), KKB::KKStr::Concat(), KKMLL::TrainingConfiguration2::ConfigRootName(), ExtractTrainingClassFeatures(), KKMLL::TrainingConfiguration2::GetEffectiveConfigFileName(), LoadExistingTrainingProcess(), NeverRebuild, NotValid, KKB::DateTime::operator<(), KKB::osGetFileDateTime(), SaveTrainingProcess(), and TrainingProcess2().

 {
   log.Level (10) << "TrainingProcess2::CreateTrainingProcess." << endl;
 
   bool  weShouldRebuild = false;
   TrainingProcess2Ptr trainer = NULL;
 
   if  (whenToRebuild == TrainingProcess2::WhenToRebuild::NeverRebuild)
   {
     trainer = LoadExistingTrainingProcess (config->ConfigRootName (), cancelFlag, log);
     if  (!trainer)
     {
       log.Level (-1) << endl
         << "TrainingProcess2::CreateTrainingProcess   ***ERROR***   Could not load existing save model." << endl
         << endl;
     }
     else if  (trainer->Abort ())
     {
       log.Level (-1) << endl
         << "TrainingProcess2::CreateTrainingProcess   ***ERROR***   Existing Save model is Invalid." << endl
         << endl;
       delete  trainer;
       trainer = NULL;
     }
 
     return trainer;
   }
 
   FeatureVectorListPtr  trainingExamples = NULL;
   KKStr  configRootName = config->ConfigRootName ();
   KKStr  configFileFullName = TrainingConfiguration2::GetEffectiveConfigFileName (configRootName);
   DateTime  configFileTimeStamp = KKB::osGetFileDateTime (configFileFullName);
   DateTime  latestTrainingImageTimeStamp;
   bool      changesMadeToTrainingLibrary = true;    
 
   if  (whenToRebuild == TrainingProcess2::WhenToRebuild::AlwaysRebuild)
   {
     trainingExamples = ExtractTrainingClassFeatures (config, latestTrainingImageTimeStamp, changesMadeToTrainingLibrary, cancelFlag, log);
     if  (!trainingExamples)
     {
       log.Level (-1) << endl
         << "TrainingProcess2::CreateTrainingProcess   ***ERROR***  Failed to load training data." << endl
         << endl;
       return NULL;
     }
 
     if  (cancelFlag)
     {
       delete trainingExamples;
       trainingExamples = NULL;
     }
     else
     {
       trainer = new TrainingProcess2 ();
       trainer->BuildTrainingProcess (config,
                                      whenToRebuild,
                                      trainingExamples,
                                      true,                 /**<  true = Take ownership of 'trainingExamples'. */
                                      checkForDuplicates,
                                      cancelFlag,
                                      log
                                     );
       if  (saveTrainedModel  &&   (!cancelFlag)  &&  (!trainer->Abort ()))
         trainer->SaveTrainingProcess (log);
     }
 
     trainingExamples = NULL;
 
     return trainer;
   }
 
   trainer = LoadExistingTrainingProcess (config->ConfigRootName (), cancelFlag, log);
   if  ((trainer)  &&  (trainer->Abort ()))
   {
     delete  trainer;
     trainer = NULL;
   }
 
   if  (trainer  &&  (whenToRebuild == TrainingProcess2::WhenToRebuild::NotValid))
   {
     // Model is valid and 'whenToRebuild' specifies to use existing model as long as valid.
     log.Level (20) << "CreateTrainingProcess   Existing model[" << configFileFullName << "] Valid!" << endl;
     return  trainer;
   }
 
   bool  rebuildTrainingProcess = false;
   if  (!trainer)
     rebuildTrainingProcess = true;
 
   else if  ((trainer->BuildDateTime () < configFileTimeStamp)  ||
             (trainer->BuildDateTime () < latestTrainingImageTimeStamp)
            )
   {
     log.Level (-1) << endl
       << "TrainingProcess2::CreateTrainingProcess   ***WARNING***  Saved model was not up to date;  we will rebuild." << endl
       << endl;
     rebuildTrainingProcess = true;
   }
 
   if  (rebuildTrainingProcess)
   {
     delete trainer;
     trainer = NULL;
     trainingExamples = ExtractTrainingClassFeatures (config, latestTrainingImageTimeStamp, changesMadeToTrainingLibrary, cancelFlag, log);
     if  (!trainingExamples)
     {
       log.Level (-1) << endl
         << "TrainingProcess2::CreateTrainingProcess   ***ERROR***  Failed to load training data." << endl
         << endl;
       return NULL;
     }
 
     if  (cancelFlag)
     {
       log.Level (-1) << "TrainingProcess2::CreateTrainingProcess   Canceled !!!" << endl;
       delete  trainingExamples;
       trainingExamples = NULL;
       return NULL;
     }
 
     trainer = new TrainingProcess2 ();
     trainer->BuildTrainingProcess (config,
                                    whenToRebuild,
                                    trainingExamples,
                                    true,                 /**<  true = Take ownership of 'trainingExamples'. */
                                    checkForDuplicates,
                                    cancelFlag,
                                    log
                                   );
     if  (saveTrainedModel  &&   (!cancelFlag)  &&  (!trainer->Abort ()))
       trainer->SaveTrainingProcess (log);
 
     // Since 'trainer' now has ownership to 'trainingExamples' we will set 'trainingExamples' to NULL
     trainingExamples = NULL;
     return trainer;
   }
 
   else
   {
     // The model that we loaded is valid and up-to-date; we can use as is and discard the training data we just loaded.
     delete  trainingExamples;
     trainingExamples = NULL;
 
     log.Level (10) << "TrainingProcess2::CreateTrainingProcess    Existing saved model["  << trainer->ConfigFileName () << "]." << endl;
     return  trainer;
   }
 } /* CreateTrainingProcess */

TrainingProcess2Ptr TrainingProcess2::CreateTrainingProcessForLevel	(	TrainingConfiguration2Const *	config,
		kkuint32	level,
		VolConstBool &	cancelFlag,
		RunLog &	log
	)

static

summary> Build a new model from scratch for the specified class level removing duplicate training examples.

remarks> Using the parameter level will construct a classifier that groups classes together by group hierarchy. Underscore characters in the class name will be used to differentiate group levels. Ex: Crustacean_Copepod_Calanoid has three levels of grouping where Crustacean, Copepod, and Calanoid belong to levels 1, 2, 3 respectively. /remarks> param name="configFileName"> Name of Configuration file that is to be used to construct instance of TrainingConfiguration2. Will provide parameters such as classes and their related directories where training examples are found and sub-classifiers. /param> param name="level"> The grouping level to build a classifier for. Ex: if level = 2 is specified and referring to the class name Crustacean_Copepod_Calanoid above all classes that start with Crustacean_Copepod will be combined as one logical class. /param> param name="cancelFlag"> Will monitor if it ever is set to true will stop processing at earliest convenience and return to caller.

param name="log">Logging file.

< true = Take ownership of 'trainingExamples'

Definition at line 248 of file TrainingProcess2.cpp.

References AlwaysRebuild, BuildTrainingProcess(), KKB::KKStr::Concat(), KKMLL::DuplicateImages::DuplicateImages(), KKMLL::TrainingConfiguration2::ExtractClassList(), KKMLL::FeatureVectorList::ExtractExamplesForHierarchyLevel(), ExtractTrainingClassFeatures(), KKMLL::FeatureVectorList::FileDesc(), KKMLL::TrainingConfiguration2::FvFactoryProducer(), KKMLL::TrainingConfiguration2::GenerateAConfiguraionForAHierarchialLevel(), KKMLL::DuplicateImages::PurgeDuplicates(), and TrainingProcess2().

 {
   log.Level (20) << "TrainingProcess2::CreateTrainingProcessForLevel" << endl;
   if  (config == NULL)
   {
     KKStr errMsg = "CreateTrainingProcessForLevel  ***ERROR***   Configuration file was not provided.";
     log.Level (-1) << endl << errMsg << endl << endl;
     return  NULL;
   }
 
   DateTime  latestTrainingImageTimeStamp;
   bool  changesMadeToTrainingLibrary = false;
   FactoryFVProducerPtr  fvFactoryProducer = config->FvFactoryProducer (log);
 
   FeatureVectorListPtr  trainingExamples 
     = ExtractTrainingClassFeatures (config, latestTrainingImageTimeStamp, changesMadeToTrainingLibrary, cancelFlag, log);
   if  (!trainingExamples)
   {
     log.Level (-1) << endl
       << "TrainingProcess2::CreateTrainingProcessForLevel   ***ERROR***   Failed to load training data." << endl
       << endl;
     return NULL;
   }
 
 
   {
     DuplicateImagesPtr  dupDetector = new DuplicateImages (trainingExamples->FileDesc (), log);
     dupDetector->PurgeDuplicates (trainingExamples, true, NULL);
     delete  dupDetector;
     dupDetector = NULL;
   }
     
   MLClassListPtr  mlClasses = config->ExtractClassList ();
 
   {
     // We need to build data that is specific to the specified _level.
     FeatureVectorListPtr  newExamples = trainingExamples->ExtractExamplesForHierarchyLevel (level);
     delete  trainingExamples;
     trainingExamples = newExamples;
     newExamples = NULL;
   }
 
   TrainingConfiguration2Ptr  levelSpecificConfig = config->GenerateAConfiguraionForAHierarchialLevel (level, log);
 
   TrainingProcess2Ptr  trainer = new TrainingProcess2 ();
   trainer->BuildTrainingProcess (levelSpecificConfig,
                                  WhenToRebuild::AlwaysRebuild,
                                  trainingExamples, 
                                  true,        /**<  true = Take ownership of 'trainingExamples' */
                                  false,
                                  cancelFlag,
                                  log
                                 );
 
   delete  levelSpecificConfig;
   levelSpecificConfig = NULL;
   trainingExamples = NULL;
 
   return  trainer;
 }  /* CreateTrainingProcessForLevel */

TrainingProcess2Ptr TrainingProcess2::CreateTrainingProcessForLevel	(	const KKStr &	configFileName,
		kkuint32	level,
		VolConstBool &	cancelFlag,
		RunLog &	log
	)

static

Definition at line 316 of file TrainingProcess2.cpp.

References KKMLL::TrainingConfiguration2::Load(), and KKMLL::TrainingConfiguration2::TrainingConfiguration2().

 {
   log.Level (20) << "TrainingProcess2::CreateTrainingProcessForLevel  configFileName: " << configFileName << endl;
 
   TrainingProcess2Ptr trainer = NULL;
 
   TrainingConfiguration2Ptr  config = new TrainingConfiguration2 ();
   config->Load (configFileName, true, log);
   if  (!config->FormatGood ())
   {
     log.Level (-1) << endl 
       << "TrainingProcess2::CreateTrainingProcessForLevel   ***ERROR***   Config File[" << configFileName << "]  Format is invalid." << endl
       << endl;
   }
   else
   {
     trainer = CreateTrainingProcessForLevel (config, level, cancelFlag, log);
   }
   delete  config;
   config = NULL;
 
   return  trainer;
 }  /* CreateTrainingProcessForLevel */

TrainingProcess2Ptr TrainingProcess2::CreateTrainingProcessFromTrainingExamples	(	TrainingConfiguration2Const *	config,
		FeatureVectorListPtr	trainingExamples,
		bool	takeOwnershipOfTrainingExamples,
		bool	featuresAlreadyNormalized,
		VolConstBool &	cancelFlag,
		RunLog &	log
	)

static

Will Construct an instance using provided list of examples rather than loading from training library.

Training examples are typically loaded from a training library as specified in the TrainingConfiguration2 structure. Rather than loading and/or computing feature data it will utilize the feature-vectors provided by the 'trainingExamples' parameter.

Parameters

[in]	config	A configuration that is already loaded in memory.
[in]	trainingExamples	Training data to train classifier with.
[in]	takeOwnershipOfTrainingExamples	If set to true then we will take ownership of the feature-vectors in 'trainingExamples'. This means we are free to modify or delete them as needed. If this flag is set to false will make duplicate copy of the feature-vectors if it is required to modify them; such as normalize them.
[in]	featuresAlreadyNormalized	If set to true will assume that all features in the training data are normalized.
[in]	cancelFlag	Will monitor if it ever is set to true will stop processing at earliest convenience and return to caller.
[in]	log	Logging file.

Definition at line 352 of file TrainingProcess2.cpp.

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

 {
   log.Level (20) << "TrainingProcess2::TrainingProcess2" << endl;
 
   if  (!config)
   {
     log.Level (-1) << endl
       << "TrainingProcess2::CreateTrainingProcessFromTrainingExamples   ***ERROR***   No Configuration File Specified." << endl
       << endl;
     return NULL;
   }
 
   else  if  (!config->FormatGood ())
   {
     log.Level (-1) << endl
       <<  "TrainingProcess2::CreateTrainingProcessFromTrainingExamples   ***ERROR***   Format error in Configuration File[" << config->FileName () << "]."  << endl
       << endl;
     return NULL;
   }
 
   else
   {
     TrainingProcess2Ptr  trainer = new TrainingProcess2 ();
     trainer->FeaturesAlreadyNormalized (featuresAlreadyNormalized);
     trainer->BuildTrainingProcess (config,
                                    WhenToRebuild::AlwaysRebuild,
                                    trainingExamples, 
                                    takeOwnershipOfTrainingExamples, 
                                    true, 
                                    cancelFlag, 
                                    log
                                   );
     return  trainer;
   }
 }  /* CreateTrainingProcessFromTrainingExamples */

kkint32 KKMLL::TrainingProcess2::DuplicateCount ( ) const

inline

Definition at line 250 of file TrainingProcess2.h.

250 {return duplicateCount;}

kkint32 KKMLL::TrainingProcess2::DuplicateDataCount ( ) const

inline

Definition at line 251 of file TrainingProcess2.h.

251 {return duplicateDataCount;}

MLClassListPtr TrainingProcess2::ExtractFullHierachyOfClasses ( ) const

Extracts the list of classes including ones from Sub-Classifiers.

Definition at line 1095 of file TrainingProcess2.cpp.

References KKMLL::TrainingConfiguration2::ExtractFullHierachyOfClasses(), and KKMLL::MLClassList::MLClassList().

 {
   if  (config)
     return config->ExtractFullHierachyOfClasses ();
   
   else if  (mlClasses)
     return  new  MLClassList (*mlClasses);
 
   else
     return  NULL;
 }

FeatureVectorListPtr TrainingProcess2::ExtractTrainingClassFeatures	(	TrainingConfiguration2ConstPtr	config,
		KKB::DateTime &	latestImageTimeStamp,
		bool &	changesMadeToTrainingLibraries,
		VolConstBool &	cancelFlag,
		RunLog &	log
	)

static

Definition at line 756 of file TrainingProcess2.cpp.

References KKMLL::FeatureVectorList::AddQueue(), KKMLL::TrainingConfiguration2::FvFactoryProducer(), KKMLL::FactoryFVProducer::ManufacturFeatureVectorList(), KKMLL::TrainingConfiguration2::MlClasses(), KKMLL::MLClassList::MLClassList(), KKMLL::TrainingConfiguration2::NoiseTrainingClass(), KKB::DateTime::operator=(), KKB::DateTime::operator>(), and KKMLL::TrainingConfiguration2::TrainingClasses().

Referenced by CreateTrainingProcess(), and CreateTrainingProcessForLevel().

 {
   log.Level (10) << "TrainingProcess2::ExtractTrainingClassFeatures - Starting." << endl;
 
   changesMadeToTrainingLibraries = false;
   bool   abort = false;
 
   FactoryFVProducerPtr  fvFactoryProdcer = config->FvFactoryProducer (log);
 
   FeatureVectorListPtr  trainingExamples = fvFactoryProdcer->ManufacturFeatureVectorList (true, log);
 
   //****************************************************************************
   // Make sure that there are no existing *.data files that we are going to use.
   // We need to do this in a separate pass because more than one entry may refer 
   // to the same Class and hence the same *.data file.
 
 
   //***********************************************************
   //  We will first extract the Raw features from each Class 
 
   const TrainingClassList&   trainingClasses = config->TrainingClasses ();
 
   bool  weOwnMlClasses = false; 
   MLClassListPtr mlClasses = config->MlClasses ();
   if  (!mlClasses)
   {
     mlClasses = new MLClassList ();
     weOwnMlClasses = true;
   }
 
 
   DateTime  latestTimeStamp;
   bool      changesMadeToThisTrainingClass = false;
 
   for  (auto  tcIDX: trainingClasses)
   {
     if  (cancelFlag ||  abort)
       break;
 
     const TrainingClassPtr trainingClass = tcIDX;
 
     log.Level (20) << "TrainingProcess2::ExtractTrainingClassFeatures Starting on Class[" << trainingClass->Name () << "]." << endl;
 
     FeatureVectorListPtr  examplesThisClass 
       = ExtractFeatures (config, *mlClasses, trainingClass, latestTimeStamp, changesMadeToThisTrainingClass, cancelFlag, log);
 
     if  (latestTimeStamp > latestImageTimeStamp)
       latestImageTimeStamp = latestTimeStamp;
 
     if  (changesMadeToThisTrainingClass)
       changesMadeToTrainingLibraries = true;
 
     if  (!examplesThisClass)
     {
       abort = true;
       log.Level (-1) << "TrainingProcess2::ExtractTrainingClassFeatures   ***ERROR***   No examples returned by 'ExtractTrainingClassFeatures': " << trainingClass->Name ()  << endl;
     }
     else
     {
       trainingExamples->AddQueue (*examplesThisClass);
       examplesThisClass->Owner (false);
       delete  examplesThisClass;
       examplesThisClass = NULL;
     }
   }
 
   // DONE Extracting Raw features from All classes.
   if  ((!abort)  &&  (!cancelFlag))
   {
     const TrainingClassPtr  noiseTC = config->NoiseTrainingClass ();
     if  (noiseTC)
     {
       FeatureVectorListPtr  examplesThisClass  = 
             ExtractFeatures (config, 
                              *mlClasses, 
                              noiseTC,
                              latestTimeStamp,
                              changesMadeToThisTrainingClass,
                              cancelFlag,
                              log
                             );
       if  (latestTimeStamp > latestImageTimeStamp)
         latestImageTimeStamp = latestTimeStamp;
 
       if  (changesMadeToThisTrainingClass)
         changesMadeToTrainingLibraries = true;
       if  (!examplesThisClass)
       {
         log.Level (-1) << endl
           << "TrainingProcess2::ExtractTrainingClassFeatures   ***ERROR***   Loading NoiseClass[" << noiseTC->Name () << "]." << endl
           << endl;
         abort = true;
       }
       else
       {
         trainingExamples->AddQueue (*examplesThisClass);
         examplesThisClass->Owner (false);
         delete  examplesThisClass;
         examplesThisClass = NULL;
       }
     }
 
     trainingExamples->RandomizeOrder ();
 
     if  (weOwnMlClasses)
     {
       delete  mlClasses;
       mlClasses = NULL;
     }
   }
 
   if  (abort)
   {
     delete  trainingExamples;
     trainingExamples = NULL;
     log.Level (10) << "TrainingProcess2::ExtractTrainingClassFeatures   Loading of training data failed." << endl;
   }
   else
   {
     log.Level (20) << "TrainingProcess2::ExtractTrainingClassFeatures   Exiting" << endl;
   }
   return  trainingExamples;
 }  /*  ExtractTrainingClassFeatures */

bool KKMLL::TrainingProcess2::FeaturesAlreadyNormalized ( ) const

inline

Definition at line 252 of file TrainingProcess2.h.

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

252 {return featuresAlreadyNormalized;}

void KKMLL::TrainingProcess2::FeaturesAlreadyNormalized ( bool _featuresAlreadyNormalized )

inline

Definition at line 270 of file TrainingProcess2.h.

270 {featuresAlreadyNormalized = _featuresAlreadyNormalized;}

FactoryFVProducerPtr KKMLL::TrainingProcess2::FvFactoryProducer ( ) const

inline

Definition at line 253 of file TrainingProcess2.h.

253 {return fvFactoryProducer;}

FeatureVectorListPtr KKMLL::TrainingProcess2::Images ( )

inline

Definition at line 254 of file TrainingProcess2.h.

254 {return trainingExamples;}

TrainingProcess2Ptr TrainingProcess2::LoadExistingTrainingProcess	(	const KKStr &	configRootName,
		VolConstBool &	cancelFlag,
		RunLog &	log
	)

static

Loads an existing TrainingProcess; if one does not exist will return NULL.

Parameters

[in]	configRootName	Root name of training model;
[in]	cancelFlag	Will monitor if it ever is set to true will stop processing at earliest convenience and return to caller.
[in]	log	Logging file.

Definition at line 52 of file TrainingProcess2.cpp.

References KKB::KKStr::Concat(), KKMLL::TrainingConfiguration2::GetEffectiveConfigFileName(), KKB::XmlStream::GetNextToken(), KKB::KKStr::operator+(), KKB::osFileExists(), KKB::osRemoveExtension(), and KKB::XmlStream::XmlStream().

Referenced by CreateTrainingProcess().

 {
   TrainingProcess2Ptr  trainer = NULL;
 
   KKStr  configFileFullName = TrainingConfiguration2::GetEffectiveConfigFileName (configRootName);
 
   KKStr  savedModelName = osRemoveExtension (configFileFullName) + ".Save";
   if  (!osFileExists (savedModelName))
   {
     log.Level (-1) << endl
       << "TrainingProcess2::LoadExistingTrainingProcess   ***ERROR***    SaveFile[" << savedModelName << "]  does not exist." << endl
       << endl;
     return NULL;
   }
 
   XmlStreamPtr  stream = new XmlStream (savedModelName, log);
   XmlTokenPtr  t = stream->GetNextToken (cancelFlag, log);
   while  (t  &&  (typeid (*t)  !=  typeid (XmlElementTrainingProcess2)))
   {
     delete  t;
     t = stream->GetNextToken (cancelFlag, log);
   }
 
   if  (t)
     trainer = dynamic_cast<XmlElementTrainingProcess2Ptr> (t)->TakeOwnership ();
 
   delete  stream;  stream = NULL;
   delete  t;       t      = NULL;
 
   return  trainer;
 }  /* LoadExistingTrainingProcess */

void KKMLL::TrainingProcess2::LoadPrevTrainedOtherwiseRebuild	(	bool	_forceRebuild,
		bool	_checkForDuplicates
	)

kkint32 TrainingProcess2::MemoryConsumedEstimated ( ) const

Definition at line 471 of file TrainingProcess2.cpp.

References KKMLL::ClassProbList::MemoryConsumedEstimated(), KKMLL::Model::MemoryConsumedEstimated(), KKMLL::MLClassList::MemoryConsumedEstimated(), KKB::KKStr::MemoryConsumedEstimated(), KKMLL::TrainingProcess2List::MemoryConsumedEstimated(), and KKMLL::FeatureVectorList::MemoryConsumedEstimated().

Referenced by KKMLL::ModelDual::MemoryConsumedEstimated(), and KKMLL::TrainingProcess2List::MemoryConsumedEstimated().

 {
   kkint32  memoryConsumedEstimated = sizeof (TrainingProcess2)
     +  configFileName.MemoryConsumedEstimated ()
     +  configFileNameSpecified.MemoryConsumedEstimated ()
     +  savedModelName.MemoryConsumedEstimated ();
 
   if  (configOurs)
     memoryConsumedEstimated += configOurs->MemoryConsumedEstimated ();
 
   if  (weOwnTrainingExamples  &&  (trainingExamples != NULL))
     memoryConsumedEstimated += trainingExamples->MemoryConsumedEstimated ();
 
   if  ((mlClasses != NULL)  &&  weOwnMLClasses)
     memoryConsumedEstimated += mlClasses->MemoryConsumedEstimated ();
 
   if  (model)
     memoryConsumedEstimated += model->MemoryConsumedEstimated ();
 
   if  (priorProbability)
     memoryConsumedEstimated += priorProbability->MemoryConsumedEstimated ();
 
   if  (subTrainingProcesses)
     memoryConsumedEstimated += subTrainingProcesses->MemoryConsumedEstimated ();
 
   return  memoryConsumedEstimated;
 }  /* MemoryConsumedEstimated */

MLClassListPtr KKMLL::TrainingProcess2::MLClasses ( ) const

inline

Definition at line 255 of file TrainingProcess2.h.

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

255 {return mlClasses;}

SVMModelPtr TrainingProcess2::Model3 ( )

Definition at line 620 of file TrainingProcess2.cpp.

References OldSVMModel(), and KKMLL::ModelOldSVM::SvmModel().

 {
   ModelOldSVMPtr  oldSvmModel = OldSVMModel ();
   if  (oldSvmModel)
     return oldSvmModel->SvmModel ();
   else
     return NULL;
 }

KKStr TrainingProcess2::ModelDescription ( ) const

Definition at line 590 of file TrainingProcess2.cpp.

References KKMLL::Model::Description().

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

 {
   if  (model)
     return model->Description ();
   else
     return "No Model";
 }

Model::ModelTypes TrainingProcess2::ModelType ( ) const

Definition at line 600 of file TrainingProcess2.cpp.

References KKMLL::Model::ModelType(), and KKMLL::Model::Null.

 {
   if  (model)
     return model->ModelType ();
   else
     return Model::ModelTypes::Null;
 }

KKStr TrainingProcess2::ModelTypeStr ( ) const

Definition at line 610 of file TrainingProcess2.cpp.

References KKMLL::Model::ModelTypeStr().

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

 {
   if  (model)
     return model->ModelTypeStr ();
   else
     return "No_Model";
 }

kkint32 TrainingProcess2::NumOfSupportVectors ( ) const

Definition at line 1044 of file TrainingProcess2.cpp.

References KKMLL::ModelOldSVM::NumOfSupportVectors(), and OldSVMModel().

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

 {
   ModelOldSVMPtr  oldSvmModel = OldSVMModel ();
   if  (oldSvmModel)
     return oldSvmModel->NumOfSupportVectors ();
   else
     return 0;
 }

ModelOldSVMPtr TrainingProcess2::OldSVMModel ( ) const

Definition at line 580 of file TrainingProcess2.cpp.

References KKMLL::Model::ModelType(), and KKMLL::Model::OldSVM.

Referenced by Model3(), NumOfSupportVectors(), and SupportVectorStatistics().

 {
   if  (model->ModelType () == Model::ModelTypes::OldSVM)
     return dynamic_cast<ModelOldSVMPtr> (model);
   else
     return NULL;
 }

ModelParamPtr TrainingProcess2::Parameters ( ) const

Definition at line 1033 of file TrainingProcess2.cpp.

References KKMLL::Model::Param().

 {
   if  (!model)
     return NULL;
   else
     return model->Param ();
 }  /* Parameters */

ClassProbList const* KKMLL::TrainingProcess2::PriorProbability ( ) const

inline

Definition at line 262 of file TrainingProcess2.h.

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

262 {return priorProbability;}

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

virtual

Definition at line 1237 of file TrainingProcess2.cpp.

References Abort(), KKB::KKStr::Concat(), KKB::KKStr::EqualIgnoreCase(), KKMLL::FactoryFVProducer::FileDesc(), KKMLL::TrainingConfiguration2::FvFactoryProducer(), KKB::XmlStream::GetNextToken(), KKMLL::FactoryFVProducer::LookUpFactory(), KKMLL::Model::MLClasses(), NotValid, KKMLL::MLClassList::operator!=(), KKB::DateTime::operator=(), KKB::XmlElement::SectionName(), KKMLL::TrainingConfiguration2::SubClassifiers(), KKMLL::XmlElementModel::TakeOwnership(), KKMLL::XmlElementMLClassNameList::TakeOwnership(), KKB::XmlElement::ToBool(), KKB::XmlToken::tokElement, KKB::XmlToken::TokenType(), KKB::XmlElement::ToKKStr(), KKMLL::Model::ValidModel(), KKB::XmlElementDateTime::Value(), and KKB::XmlElement::VarName().

 {
   log.Level (20) << "TrainingProcess2::ReadXML" << endl;
 
   VectorKKStr*  subProcessorsNameList = NULL;
 
   delete  configOurs;
   configOurs = NULL;
   
   config = NULL;
   fileDesc = NULL;
   fvFactoryProducer = NULL;
 
   if  (weOwnMLClasses)
   {
     delete  mlClasses;
     mlClasses = NULL;
   }
 
   delete  model;             model            = NULL;
   delete  priorProbability;  priorProbability = NULL;
 
   delete  subTrainingProcesses;
   subTrainingProcesses = NULL;
 
   if  (weOwnTrainingExamples)
     delete  trainingExamples;
   trainingExamples = NULL;
 
   bool  errorsFound = false;
 
   XmlTokenPtr  t = s.GetNextToken (cancelFlag, log);
   while  (t)
   {
     if  (t->TokenType () == XmlToken::TokenTypes::tokElement)
     {
       XmlElementPtr  e = dynamic_cast<XmlElementPtr> (t);
       const KKStr&  varName = e->VarName ();
       const KKStr&  sectionName = e->SectionName ();
 
       if  (varName.EqualIgnoreCase ("BuildDateTime")  &&  (typeid (*e) == typeid (XmlElementDateTime)))
         buildDateTime = dynamic_cast<XmlElementDateTimePtr> (e)->Value ();
 
       else if  (varName.EqualIgnoreCase ("ConfigFileNameSpecified")  &&  (typeid (*e) == typeid (XmlElementKKStr)))
         configFileNameSpecified = *(dynamic_cast<XmlElementKKStrPtr> (e)->Value ());
 
       else if  (varName.EqualIgnoreCase ("ConfigFileName")  &&  (typeid (*e) == typeid (XmlElementKKStr)))
         configFileName = *(dynamic_cast<XmlElementKKStrPtr> (e)->Value ());
 
       else if  (varName.EqualIgnoreCase ("Config") )
       {
         delete  configOurs;
         XmlElementTrainingConfiguration2Ptr  xmlConfigElement = dynamic_cast<XmlElementTrainingConfiguration2Ptr> (e);
         if  (xmlConfigElement)
         {
           configOurs = xmlConfigElement->TakeOwnership ();
           config = configOurs;
           if  ((config != NULL)  &&  (fvFactoryProducer == NULL))
           {
             fvFactoryProducer = config->FvFactoryProducer (log);
             fileDesc = fvFactoryProducer->FileDesc ();
           }
         }
       }
 
       else if  (varName.EqualIgnoreCase ("FvFactoryProducer"))
       {
         fvFactoryProducer = FactoryFVProducer::LookUpFactory (e->ToKKStr ());
         if  (fvFactoryProducer)
           fileDesc = fvFactoryProducer->FileDesc ();
       }
       
       else if  (varName.EqualIgnoreCase ("FeaturesAlreadyNormalized"))
         featuresAlreadyNormalized = e->ToBool ();
 
       else if  (varName.EqualIgnoreCase ("MlClasses")  &&  (typeid (*e) == typeid (XmlElementMLClassNameList)))
       {
         if  (weOwnMLClasses)
           delete  mlClasses;
         mlClasses = dynamic_cast<XmlElementMLClassNameListPtr> (e)->TakeOwnership ();
         weOwnMLClasses= true;
       }
 
       else if  (varName.EqualIgnoreCase ("Model"))
       {
         delete  model;
         XmlElementModelPtr  xmlElementModel = dynamic_cast<XmlElementModelPtr> (e);
         if  (xmlElementModel)
         {
           model = xmlElementModel->TakeOwnership ();
           if  (!model->ValidModel ())
           {
             errorsFound = true;
             log.Level (-1) << endl
               << "TrainingProcess2::ReadXML   ***ERROR***    Loaded Model is Invalid" << endl
               << endl;
           }
         }
       }
 
       else if  (varName.EqualIgnoreCase ("PriorProbability")  &&  (typeid (*e) == typeid (XmlElementClassProbList)))
       {
         delete  priorProbability;
         priorProbability = dynamic_cast<XmlElementClassProbListPtr> (e)->TakeOwnership ();
       }
 
       else if  (varName.EqualIgnoreCase ("SubTrainingProcesses")  &&  (typeid (*e) == typeid (XmlElementVectorKKStr)))
       {
         delete  subProcessorsNameList;
         subProcessorsNameList = dynamic_cast<XmlElementVectorKKStrPtr> (e)->TakeOwnership ();
       }
       else
       {
         log.Level (-1) << endl
           << "TrainingProcess2::ReadXML   ***ERROR***  Unrecognized Element Section: " << e->NameTagStr () << endl
           << endl;
       }
     }
     delete  t;
     if  (cancelFlag)
       t = NULL;
     else
       t = s.GetNextToken (cancelFlag, log);
   }
   if  (!cancelFlag)
   {
     if  (!model)
     {
       log.Level (-1) << endl
         << "TrainingProcess2::ReadXML   ***ERROR***   'model' was not defined." << endl
         << endl;
       errorsFound = true;
     }
 
     if  (mlClasses == NULL)
     {
       log.Level (-1) << endl
         << "TrainingProcess2::ReadXML   ***ERROR***   'mlClasses' was not defined." << endl
         << endl;
       errorsFound = true;
     }
 
     if  (model  &&  (model->MLClasses ())  &&  mlClasses)
     {
       if  (*mlClasses != *(model->MLClasses ()))
       {
         log.Level (-1) << endl
           << "TrainingProcess2::ReadXML   ***ERROR***   TrainingProcess2::mlClasses  does not agree with model->MlClasses" << endl
           << endl;
         errorsFound = true;
       }
     }
 
     if (!errorsFound)
     {
       if  (config)
       {
         if  (config->SubClassifiers () != NULL)
         {
           LoadSubClassifiers (WhenToRebuild::NotValid,
                               true,    // CheckForDuplicates
                               cancelFlag,
                               log
                              );
         }
       }
     }
 
     delete  subProcessorsNameList;
     subProcessorsNameList = NULL;
   }
 
   if  (errorsFound  ||  cancelFlag)
      Abort (true);
 
   log.Level (20) << "TrainingProcess2::ReadXML    Exiting!" << endl;
 }  /* ReadXML */

void TrainingProcess2::ReportTraningClassStatistics ( std::ostream & report )

Definition at line 889 of file TrainingProcess2.cpp.

References KKMLL::FeatureVectorList::PrintClassStatistics().

 {
   report << endl
          << "Training Class Statistics" << endl
          << endl;
   trainingExamples->PrintClassStatistics (report);
 }  /* ReportTraningClassStatistics */

void TrainingProcess2::SaveTrainingProcess ( RunLog & log )

Saves the built training model into the Save file in Xml Format.

Definition at line 556 of file TrainingProcess2.cpp.

References KKMLL::TrainingConfiguration2::ConfigFileNameSpecified(), KKMLL::TrainingConfiguration2::GetEffectiveConfigFileName(), KKB::KKStr::operator+(), KKB::KKStr::operator=(), and KKB::osRemoveExtension().

Referenced by CreateTrainingProcess().

 {
   configFileName = TrainingConfiguration2::GetEffectiveConfigFileName (config->ConfigFileNameSpecified ());
   savedModelName = osRemoveExtension (configFileName) + ".Save";
   log.Level (20) << "TrainingProcess2::SaveTrainingProcess  Saving trained model: " << savedModelName << endl;
 
   ofstream f (savedModelName.Str ());
   if  (!f.is_open ())
   {
     log.Level (-1) << endl
       << "TrainingProcess2::SaveTrainingProcess   ***ERROR***   Could not open SavedModelName[" << savedModelName << "]." << endl
       << endl;
     return;
   }
 
   this->WriteXML ("TrainingProcess2", f);
 
   f.close ();
 }  /* SaveTrainingProcess */

TrainingProcess2ListPtr KKMLL::TrainingProcess2::SubTrainingProcesses ( ) const

inline

Definition at line 264 of file TrainingProcess2.h.

264 {return subTrainingProcesses;}

void TrainingProcess2::SupportVectorStatistics	(	kkint32 &	numSVs,
		kkint32 &	totalNumSVs
	)

summary> Returns back pointer to 1st classifier of Dual Classifier; if not a Dual classifier will return back NULL. Keep in mind that you will not own this classifier and that it can be deleted at any time. /summary>

Definition at line 1055 of file TrainingProcess2.cpp.

References OldSVMModel(), and KKMLL::ModelOldSVM::SupportVectorStatistics().

 {
   numSVs = 0;
   totalNumSVs = 0;
   ModelOldSVMPtr  oldSvmModel = OldSVMModel ();
   if  (oldSvmModel)
     oldSvmModel->SupportVectorStatistics (numSVs, totalNumSVs);
 }

ModelPtr KKMLL::TrainingProcess2::TrainedModel ( ) const

inline

Definition at line 265 of file TrainingProcess2.h.

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

265 {return model;}

TrainingProcess2Ptr TrainingProcess2::TrainingProcessLeft ( )

summary> Returns back pointer to 2nd classifier of Dual Classifier; if not a Dual classifier will return back NULL.

Definition at line 1069 of file TrainingProcess2.cpp.

References KKMLL::Model::Dual, KKMLL::Model::ModelType(), and KKMLL::ModelDual::Trainer1().

 {
   if  ((!model)  ||  (model->ModelType () != Model::ModelTypes::Dual))
     return NULL;
   return  dynamic_cast<ModelDualPtr>(model)->Trainer1 ();
 }

TrainingProcess2Ptr TrainingProcess2::TrainingProcessRight ( )

Definition at line 1078 of file TrainingProcess2.cpp.

References KKMLL::Model::Dual, KKMLL::Model::ModelType(), and KKMLL::ModelDual::Trainer2().

 {
   if  ((!model)  ||  (model->ModelType () != Model::ModelTypes::Dual))
     return NULL;
   return  dynamic_cast<ModelDualPtr>(model)->Trainer2 ();
 }

double TrainingProcess2::TrainingTime ( ) const

Definition at line 1084 of file TrainingProcess2.cpp.

References KKMLL::Model::TrainingTime().

 {
   if (model)
     return model->TrainingTime();
   else
     return 0.0;
 }

void KKMLL::TrainingProcess2::ValidateConfiguration ( )

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

virtual

Definition at line 1185 of file TrainingProcess2.cpp.

References KKB::XmlTag::AddAtribute(), KKB::KKStr::Empty(), KKMLL::FactoryFVProducer::Name(), KKB::XmlTag::tagEnd, KKB::XmlTag::tagStart, KKMLL::ClassProbList::WriteXML(), KKB::XmlTag::WriteXML(), KKMLL::TrainingConfiguration2::WriteXML(), KKMLL::Model::WriteXML(), KKB::XmlElementBool::WriteXML(), KKB::XmlElementDateTime::WriteXML(), KKB::KKStr::WriteXML(), KKMLL::XmlElementMLClassNameList::WriteXML(), and KKB::XmlTag::XmlTag().

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

 {
   XmlTag  startTag ("TrainingProcess2",  XmlTag::TagTypes::tagStart);
   if  (!varName.Empty ())
     startTag.AddAtribute ("VarName", varName);
   startTag.WriteXML (o);
   o << endl;
 
   XmlElementDateTime::WriteXML (buildDateTime, "BuildDateTime", o);
 
   configFileNameSpecified.WriteXML ("ConfigFileNameSpecified", o);
   configFileName.WriteXML ("ConfigFileName", o);
 
   if  (config)
     config->WriteXML ("Config", o);
 
   XmlElementBool::WriteXML (featuresAlreadyNormalized, "FeaturesAlreadyNormalized", o);
   if  (fvFactoryProducer)
     fvFactoryProducer->Name ().WriteXML ("FvFactoryProducer", o);
 
   if  (mlClasses)
     XmlElementMLClassNameList::WriteXML (*mlClasses, "MLClasses", o);
 
   if  (model)
     model->WriteXML ("Model", o);
 
   if  (priorProbability)
     priorProbability->WriteXML ("PriorProbability", o);
 
   if  (subTrainingProcesses)
   {
     VectorKKStr  subProcessorsNameList;
     for  (auto idx:  *subTrainingProcesses)
     {
       subProcessorsNameList.push_back (osGetRootName (idx->ConfigFileName ()));
     }
 
     XmlElementVectorKKStr::WriteXML (subProcessorsNameList, "SubTrainingProcesses", o);
   }
 
 
   XmlTag  endTag ("TrainingProcess2", XmlTag::TagTypes::tagEnd);
   endTag.WriteXML (o);
   o << endl;
 }  /* WriteXML */

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

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

Public Types

Public Member Functions

Static Public Member Functions

Detailed Description

Member Typedef Documentation

Member Enumeration Documentation

Constructor & Destructor Documentation

Member Function Documentation