KKMLL::TrainingConfiguration2 Class Reference

#include <TrainingConfiguration2.h>

Inheritance diagram for KKMLL::TrainingConfiguration2:

Classes
class	Factory

Public Types
typedef Model::ModelTypes	ModelTypes
typedef TrainingConfiguration2 const	TrainingConfiguration2Const
typedef TrainingConfiguration2Const *	TrainingConfiguration2ConstPtr
typedef TrainingConfiguration2 *	TrainingConfiguration2Ptr

Public Member Functions
	TrainingConfiguration2 ()
	TrainingConfiguration2 (const TrainingConfiguration2 &tc)
	TrainingConfiguration2 (MLClassListPtr _mlClasses, FactoryFVProducerPtr _fvFactoryProducer, const KKStr &_parameterStr, RunLog &_log)
	Use this one if you want to create a default Configuration object. More...
	TrainingConfiguration2 (MLClassListPtr _mlClasses, FileDescPtr _fileDesc, const KKStr &_parameterStr, RunLog &_log)
	Use this one if you want to create a default Configuration object. More...
	TrainingConfiguration2 (MLClassListPtr _mlClasses, FileDescPtr _fileDesc, ModelParamPtr _modelParameters, RunLog &_log)
	Creates a configuration file using the parameters specified in '_modelParameters'; does not read from a configuration file. More...
virtual	~TrainingConfiguration2 ()
float	A_Param () const
void	A_Param (float _aParam)
void	AddATrainingClass (TrainingClassPtr _trainClass)
	Adds specified Training Class to list taking ownership of it. More...
void	AddATrainingClass (MLClassPtr _newClass)
	Will assume that images for this class will be saved off the RootDirectory using its own name for the subdirectory name. More...
float	AvgNumOfFeatures () const
float	AvgNumOfFeatures (FeatureVectorListPtr trainExamples) const
double	C_Param () const
double	C_Param (MLClassPtr class1, MLClassPtr class2) const
void	C_Param (double _CCC)
void	C_Param (MLClassPtr class1, MLClassPtr class2, double cParam)
const KKStr &	ConfigFileNameSpecified () const
const KKStr &	ConfigRootName () const
virtual FactoryFVProducerPtr	DefaultFeatureVectorProducer (RunLog &runLog) const
KKStr	DirectoryPathForClass (MLClassPtr mlClass) const
	Fully expanded directory path for specified class. More...
virtual TrainingConfiguration2Ptr	Duplicate () const
void	EmptyTrainingClasses ()
	Removes all training classes from the configuration; example use would be to remove all classes and then add the two needed by a Binary-Class-Pair classifier. More...
SVM_EncodingMethod	EncodingMethod () const
void	EncodingMethod (SVM_EncodingMethod _encodingMethod)
kkint32	ExamplesPerClass () const
void	ExamplesPerClass (kkint32 _examplesPerClass)
MLClassListPtr	ExtractClassList () const
MLClassListPtr	ExtractFullHierachyOfClasses () const
MLClassListPtr	ExtractListOfClassesForAGivenHierarchialLevel (kkuint32 level) const
virtual KKStr	FactoryName () const
FileDescPtr	FileDesc () const
FactoryFVProducerPtr	FvFactoryProducer (RunLog &log) const
bool	FvFactoryProducerSpecified () const
double	Gamma () const
void	Gamma (double _gamma)
TrainingConfiguration2Ptr	GenerateAConfiguraionForAHierarchialLevel (kkuint32 level, RunLog &log) const
BinaryClassParmsPtr	GetBinaryClassParms (MLClassPtr class1, MLClassPtr class2)
FeatureNumList	GetFeatureNums () const
FeatureNumList	GetFeatureNums (MLClassPtr class1, MLClassPtr class2)
	Returns features selected for the specified class-pairIf none were specified for that pair will return global feature nums. More...
const BinaryClassParmsPtr	GetParamtersToUseFor2ClassCombo (MLClassPtr class1, MLClassPtr class2) const
kkint32	ImagesPerClass () const
void	ImagesPerClass (kkint32 _imagesPerClass)
SVM_KernalType	KernalType () const
void	KernalType (SVM_KernalType _kernalType)
virtual void	Load (const KKStr &_configFileName, bool _validateDirectories, RunLog &log)
FeatureVectorListPtr	LoadFeatureDataFromTrainingLibraries (KKB::DateTime &latestImageTimeStamp, bool &changesMadeToTrainingLibraries, VolConstBool &cancelFlag, RunLog &log)
	Load training data from the training library directories. More...
FeatureVectorListPtr	LoadOtherClasssExamples (RunLog &runLog)
TrainingClassPtr	LocateByMLClassName (const KKStr &className)
SVM_MachineType	MachineType () const
void	MachineType (SVM_MachineType _machineType)
MLClassListPtr	MlClasses () const
Model::ModelTypes	ModelingMethod () const
KKStr	ModelParameterCmdLine () const
ModelParamPtr	ModelParameters () const
void	ModelParameters (ModelParamPtr _modelParameters)
Model::ModelTypes	ModelType () const
KKStr	ModelTypeStr () const
MLClassPtr	NoiseMLClass () const
const TrainingClassPtr	NoiseTrainingClass () const
bool	NormalizeNominalFeatures ()
kkint32	Number_of_rounds () const
void	Number_of_rounds (kkint32 _number_of_rounds)
kkuint32	NumHierarchialLevels () const
kkint32	NumOfFeaturesAfterEncoding (RunLog &log) const
kkint32	NumOfRounds () const
void	NumOfRounds (kkint32 _numOfRounds)
MLClassPtr	OtherClass () const
virtual void	ReadXML (XmlStream &s, XmlTagConstPtr tag, VolConstBool &cancelFlag, RunLog &log)
const KKStr &	RootDir () const
	The root directory where Training library images are stored. More...
void	RootDir (const KKStr &_rootDir)
KKStr	RootDirExpanded () const
virtual void	Save (const KKStr &fileName) const
virtual void	Save (std::ostream &o) const
SVM_SelectionMethod	SelectionMethod () const
void	SelectionMethod (SVM_SelectionMethod _selectionMethod)
void	SetBinaryClassFields (MLClassPtr class1, MLClassPtr class2, const SVM233::svm_parameter &_param, const FeatureNumList &_features, float _weight)
void	SetFeatureNums (const FeatureNumList &features)
void	SetFeatureNums (MLClassPtr class1, MLClassPtr class2, const FeatureNumList &_features, float _weight=-1)
void	SetModelParameters (ModelParamPtr _svmParanters, kkint32 _examplesPerClass)
void	SetTrainingClasses (TrainingClassListPtr _trainingClasses)
TrainingConfiguration2ListPtr	SubClassifiers () const
const SVMparam &	SVMparamREF (RunLog &log) const
const TrainingClassList &	TrainingClasses () const
void	WriteXML (const KKStr &varName, std::ostream &o) const
Public Member Functions inherited from KKB::Configuration
	Configuration (const KKB::KKStr &_fileName, RunLog &_log)
	Configuration ()
	Configuration (const Configuration &c)
virtual	~Configuration ()
const KKB::KKStr &	FileName () const
const VectorKKStr &	FormatErrors () const
void	FormatErrorsAdd (kkint32 lineNum, const KKStr &error)
void	FormatErrorsClear ()
	Call this to clear all format error messages. More...
const VectorInt &	FormatErrorsLineNums () const
VectorKKStr	FormatErrorsWithLineNumbers () const
bool	FormatGood () const
void	FormatGood (bool _formatGood)
void	GetSetting (const char *sectiopnName, kkint32 settingNum, KKStrConstPtr &name, KKStrConstPtr &value, kkint32 &lineNum)
virtual void	Load (const KKB::KKStr &_fileName, RunLog &_log)
void	LoadFile (RunLog &log)
virtual kkint32	MemoryConsumedEstimated () const
kkint32	NumOfSections ()
kkint32	NumOfSettings (const KKB::KKStr &sectionName) const
kkint32	NumOfSettings (kkint32 sectionNum) const
	Returns number of settings for the specified section,. More...
void	PrintFormatErrors (std::ostream &o)
bool	SectionDefined (const KKB::KKStr &sectionName) const
	Returns true if the section is defined. More...
kkint32	SectionLineNum (kkint32 sectionNum) const
KKStrConstPtr	SectionName (kkint32 sectionNum) const
	Returns the name of the section for specified index, if index not defined will return NULL. More...
kkint32	SectionNum (const KKB::KKStr &sectionName) const
KKStrConstPtr	SettingName (const KKB::KKStr &sectionName, kkint32 settingNum) const
KKStrConstPtr	SettingName (kkint32 sectionNum, kkint32 settingNum) const
KKStrConstPtr	SettingValue (const KKB::KKStr &sectionName, const KKB::KKStr &settingName, kkint32 &lineNum) const
KKStrConstPtr	SettingValue (kkint32 sectionNum, const KKB::KKStr &settingName, kkint32 &lineNum) const
KKStrConstPtr	SettingValue (kkint32 sectionNum, kkint32 settingNum, kkint32 &lineNum) const
KKStr	SettingValueToStr (const KKB::KKStr &sectionName, const KKB::KKStr &settingName, kkint32 &lineNum) const
KKStr	SettingValueToStr (kkint32 sectionNum, const KKB::KKStr &settingName, kkint32 &lineNum) const

Static Public Member Functions
static bool	ConfigFileExists (const KKStr &_configFileName)
static TrainingConfiguration2 *	CreateFromDirectoryStructure (const KKStr &_existingConfigFileName, const KKStr &_subDir, FactoryFVProducerPtr _fvFactoryProducer, RunLog &_log, bool &_successful, KKStr &_errorMessage)
	Will create a instance using a sub-directory tree to drive the TraningClassList. More...
static TrainingConfiguration2 *	CreateFromFeatureVectorList (FeatureVectorList &_examples, FileDescPtr _fileDesc, const KKStr &_parameterStr, RunLog &_log)
static Factory *	FactoryInstace ()
static KKStr	GetEffectiveConfigFileName (const KKStr &configFileName)
	Determine the correct configuration file name. More...
static TrainingConfiguration2Ptr	Manufacture (const KKStr &_className, const KKStr &_configFileName, bool _validateDirectories, RunLog &_log)
static ModelTypes	ModelTypeFromStr (const KKStr &_modelTypeStr)
static KKStr	ModelTypeToStr (ModelTypes _modelType)
static void	RegisterFatory (const KKStr &className, Factory *factory)

Static Public Attributes
static Factory *	factoryInstace = NULL

Protected Member Functions
void	BuildTrainingClassListFromDirectoryStructure (const KKStr &_subDir, bool &_successful, KKStr &_errorMessage, RunLog &_log)
XmlTokenPtr	ReadXMLBaseToken (XmlTokenPtr t, VolConstBool &cancelFlag, RunLog &log)
void	ReadXMLPost (VolConstBool &cancelFlag, RunLog &log)
void	WriteXMLFields (std::ostream &o) const
	To be used by both Base Class and Derived classes to write fields that are specific to 'TrainingConfiguration2'. More...

Detailed Description

Definition at line 54 of file TrainingConfiguration2.h.

Member Typedef Documentation

typedef Model::ModelTypes KKMLL::TrainingConfiguration2::ModelTypes

Definition at line 57 of file TrainingConfiguration2.h.

typedef TrainingConfiguration2 const KKMLL::TrainingConfiguration2::TrainingConfiguration2Const

Definition at line 61 of file TrainingConfiguration2.h.

typedef TrainingConfiguration2Const* KKMLL::TrainingConfiguration2::TrainingConfiguration2ConstPtr

Definition at line 62 of file TrainingConfiguration2.h.

typedef TrainingConfiguration2* KKMLL::TrainingConfiguration2::TrainingConfiguration2Ptr

Definition at line 60 of file TrainingConfiguration2.h.

Constructor & Destructor Documentation

TrainingConfiguration2::TrainingConfiguration2

(

)

Definition at line 102 of file TrainingConfiguration2.cpp.

References KKB::Configuration::Configuration(), KKB::KKStr::KKStr(), KKMLL::Model::Null, and TrainingConfiguration2().

Referenced by KKMLL::TrainingProcess2::CreateTrainingProcessForLevel(), KKMLL::TrainingConfiguration2::Factory::Manufacture(), KKMLL::FactoryFVProducer::ManufacturTrainingConfiguration(), and TrainingConfiguration2().

                                               :
 Configuration (),

  configFileNameSpecified    (),
  configRootName             (),
  fileDesc                   (NULL),
  fvFactoryProducer          (NULL),
  fvFactoryProducerSpecified (false),
  mlClasses                  (NULL),
  mlClassesWeOwnIt           (false),
  modelingMethod             (Model::ModelTypes::Null),
  examplesPerClass           (0),
  modelParameters            (NULL),
  noiseMLClass               (NULL),
  noiseTrainingClass         (NULL),
  otherClass                 (NULL),
  otherClassLineNum          (-1),
  rootDir                    (),
  rootDirExpanded            (),
  subClassifiers             (NULL),
  subClassifierNameList      (NULL),
  trainingClasses            ("", true),
  validateDirectories        (true)
{
}

TrainingConfiguration2::TrainingConfiguration2

(

const TrainingConfiguration2 &

tc

)

Definition at line 364 of file TrainingConfiguration2.cpp.

References KKMLL::ModelParam::Duplicate(), KKB::KKStr::KKStr(), KKMLL::MLClassList::MLClassList(), TrainingConfiguration2(), and KKMLL::TrainingConfiguration2List::TrainingConfiguration2List().

Referenced by Duplicate(), GenerateAConfiguraionForAHierarchialLevel(), and TrainingConfiguration2().

                                                                                :
  Configuration (tc),
  configFileNameSpecified    (tc.configFileNameSpecified),
  configRootName             (tc.configRootName),
  fileDesc                   (tc.fileDesc),
  fvFactoryProducer          (tc.fvFactoryProducer),
  fvFactoryProducerSpecified (tc.fvFactoryProducerSpecified),
  mlClasses                  (NULL),
  mlClassesWeOwnIt           (false),
  modelingMethod             (tc.modelingMethod),
  examplesPerClass           (tc.examplesPerClass),
  modelParameters            (NULL),
  noiseMLClass               (tc.noiseMLClass),
  noiseTrainingClass         (tc.noiseTrainingClass),
  otherClass                 (tc.otherClass),
  otherClassLineNum          (tc.otherClassLineNum),
  rootDir                    (tc.rootDir),
  rootDirExpanded            (tc.rootDirExpanded),
  subClassifiers             (NULL),
  subClassifierNameList      (NULL),
  trainingClasses            (tc.rootDir, true),
  validateDirectories        (tc.validateDirectories)
{
  {
    kkint32  x;

    for  (x = 0;  x < tc.trainingClasses.QueueSize ();  x++)
    {
      TrainingClassPtr  trainingClass = tc.trainingClasses.IdxToPtr (x);
      trainingClasses.PushOnBack (new TrainingClass (*trainingClass));
    }
  }

  if  (tc.mlClasses)
  {
    mlClasses = new MLClassList (*tc.mlClasses);
    mlClassesWeOwnIt = true;
  }

  if  (tc.modelParameters)
    modelParameters  = tc.modelParameters->Duplicate ();

  if  (tc.subClassifiers)
  {
    subClassifiers = new TrainingConfiguration2List (true);
    TrainingConfiguration2List::const_iterator  idx;
    for  (idx = tc.subClassifiers->begin ();  idx != tc.subClassifiers->end ();  ++idx)
    {
      TrainingConfiguration2Ptr  subClassifier = *idx;
      subClassifiers->PushOnBack (new TrainingConfiguration2 (*subClassifier));
    }
  }
}

TrainingConfiguration2::TrainingConfiguration2	(	MLClassListPtr	_mlClasses,
		FactoryFVProducerPtr	_fvFactoryProducer,
		const KKStr &	_parameterStr,
		RunLog &	_log
	)

Use this one if you want to create a default Configuration object.

Parameters

[in]	_mlClasses	Will make copy of list of MLClasses and NOT take ownership.
[in]	_fvFactoryProducer	If NULL will default to "GrayScaleImagesFVProducerFactory".
[in]	_parameterStr	Sting with Machine Learning Parameters.
[in]	_log	Where to send logging messages to.

Definition at line 172 of file TrainingConfiguration2.cpp.

References KKB::Configuration::Configuration(), DefaultFeatureVectorProducer(), KKMLL::FeatureNumList::FeatureNumList(), KKMLL::FactoryFVProducer::FileDesc(), KKB::KKStr::KKStr(), KKMLL::MLClassList::MLClassList(), KKMLL::MLClass::Name(), KKMLL::Model::Null, KKMLL::Model::OldSVM, KKMLL::FeatureNumList::SetAllFeatures(), KKMLL::TrainingClass::TrainingClass(), TrainingConfiguration2(), and KKMLL::ModelParam::ValidParam().

Referenced by CreateFromDirectoryStructure(), and TrainingConfiguration2().

                                                :
  Configuration              (),
  configFileNameSpecified    (""),
  configRootName             (),
  fileDesc                   (NULL),
  fvFactoryProducer          (_fvFactoryProducer),
  fvFactoryProducerSpecified (true),
  modelingMethod             (Model::ModelTypes::Null),
  mlClasses                  (NULL),
  mlClassesWeOwnIt           (false),
  examplesPerClass           (0),
  modelParameters            (NULL),
  noiseMLClass               (NULL),
  noiseTrainingClass         (NULL),
  otherClass                 (NULL),
  otherClassLineNum          (-1),
  rootDir                    (),
  rootDirExpanded            (),
  subClassifiers             (NULL),
  subClassifierNameList      (NULL),
  trainingClasses            ("", true),
  validateDirectories        (false)
{
  if  (!fvFactoryProducer)
    fvFactoryProducer =  DefaultFeatureVectorProducer (_log);
  fileDesc = fvFactoryProducer->FileDesc ();

  if  (_mlClasses)
    mlClasses = new MLClassList (*_mlClasses);
  else
    mlClasses = new MLClassList ();

  mlClassesWeOwnIt = true;

  {
    MLClassList::iterator idx;
    for  (idx = mlClasses->begin ();  idx != mlClasses->end ();  idx++)
    {
      MLClassPtr mlClass = *idx;
      VectorKKStr  directories;
      TrainingClassPtr  tc = new TrainingClass (directories, mlClass->Name (), 1.0f, 1.0f, NULL, *mlClasses);
      trainingClasses.PushOnBack (tc);
    }
  }

  if  (modelingMethod == Model::ModelTypes::Null)
    modelingMethod = Model::ModelTypes::OldSVM;

  {
    examplesPerClass = int32_max;
    FeatureNumList  selectedFeatures (fileDesc);
    selectedFeatures.SetAllFeatures (fileDesc);
    CreateModelParameters (_parameterStr, selectedFeatures, 1, 1, 1, _log);
    if  (!modelParameters  ||  (!modelParameters->ValidParam ()))
    {
      _log.Level (-1) << endl
                     << "TrainingConfiguration2   ***ERROR***   Invalid Parameters." << endl
                     << "    Parameters[" << _parameterStr << "]" << endl
                     << endl;
      FormatGood (false);
    }
  }
}

TrainingConfiguration2::TrainingConfiguration2	(	MLClassListPtr	_mlClasses,
		FileDescPtr	_fileDesc,
		const KKStr &	_parameterStr,
		RunLog &	_log
	)

Use this one if you want to create a default Configuration object.

We know what the underlying feature data is from _fileDesc but we do not know how they are computed; that is why we do not provide a "FactoryFVProducer" instance.

Parameters

[in]	_mlClasses	Will make copy of list of MLClasses and NOT take ownership.
[in]	_fileDesc	Description of the Feature-Vector fields.
[in]	_parameterStr	Sting with Machine Learning Parameters.
[in]	_log	Where to send logging messages to.

Definition at line 242 of file TrainingConfiguration2.cpp.

References KKB::Configuration::Configuration(), KKMLL::FeatureNumList::FeatureNumList(), KKB::KKStr::KKStr(), KKMLL::MLClassList::MLClassList(), KKMLL::MLClass::Name(), KKMLL::Model::Null, KKMLL::Model::OldSVM, KKMLL::FeatureNumList::SetAllFeatures(), KKMLL::TrainingClass::TrainingClass(), TrainingConfiguration2(), and KKMLL::ModelParam::ValidParam().

Referenced by CreateFromFeatureVectorList(), and TrainingConfiguration2().

                                                :
  Configuration              (),
  configFileNameSpecified    (""),
  configRootName             (),
  fileDesc                   (_fileDesc),
  fvFactoryProducer          (NULL),
  fvFactoryProducerSpecified (false),
  mlClasses                  (NULL),
  mlClassesWeOwnIt           (false),
  modelingMethod             (Model::ModelTypes::Null),
  examplesPerClass           (0),
  modelParameters            (NULL),
  noiseMLClass               (NULL),
  noiseTrainingClass         (NULL),
  otherClass                 (NULL),
  otherClassLineNum          (-1),
  rootDir                    (),
  rootDirExpanded            (),
  subClassifiers             (NULL),
  subClassifierNameList      (NULL),
  trainingClasses            ("", true),
  validateDirectories        (false)
{
  if  (_mlClasses)
    mlClasses = new MLClassList (*_mlClasses);
  else
    mlClasses = new MLClassList ();

  mlClassesWeOwnIt = true;

  {
    MLClassList::iterator idx;
    for  (idx = mlClasses->begin ();  idx != mlClasses->end ();  idx++)
    {
      MLClassPtr mlClass = *idx;
      VectorKKStr  directories;
      TrainingClassPtr  tc = new TrainingClass (directories, mlClass->Name (), 1.0f, 1.0f, NULL, *mlClasses);
      trainingClasses.PushOnBack (tc);
    }
  }

  if  (modelingMethod == Model::ModelTypes::Null)
    modelingMethod = Model::ModelTypes::OldSVM;

  {
    examplesPerClass = int32_max;
    FeatureNumList  selectedFeatures (fileDesc);
    selectedFeatures.SetAllFeatures (fileDesc);
    CreateModelParameters (_parameterStr, selectedFeatures, 1, 1, 1, _log);
    if  (!modelParameters  ||  (!modelParameters->ValidParam ()))
    {
      _log.Level (-1) << endl
                      << "TrainingConfiguration2   ***ERROR***   Invalid Parameters." << endl
                      << "    Parameters[" << _parameterStr << "]" << endl
                      << endl;
      FormatGood (false);
    }
  }
}

TrainingConfiguration2::TrainingConfiguration2	(	MLClassListPtr	_mlClasses,
		FileDescPtr	_fileDesc,
		ModelParamPtr	_modelParameters,
		RunLog &	_log
	)

Creates a configuration file using the parameters specified in '_modelParameters'; does not read from a configuration file.

For each class specified in '_mlClasses' a 'TrainingClass' instance will be created. All feature-numbers will be assumed to be selected and unlimited examples per class will be allowed.

Parameters

[in]	_mlClasses
[in]	_fileDesc	Description of the Feature-Vector fields.
[in]	_modelParameters	Will take ownership of this instance.
[in]	_log

Definition at line 308 of file TrainingConfiguration2.cpp.

References KKB::Configuration::Configuration(), KKMLL::ModelParam::Dual, KKMLL::Model::Dual, KKB::KKStr::KKStr(), KKMLL::ModelParam::KNN, KKMLL::Model::KNN, KKMLL::MLClassList::MLClassList(), KKMLL::ModelParam::ModelParamType(), KKMLL::MLClass::Name(), KKMLL::Model::Null, KKMLL::ModelParam::OldSVM, KKMLL::Model::OldSVM, KKMLL::ModelParam::SvmBase, KKMLL::Model::SvmBase, KKMLL::TrainingClass::TrainingClass(), TrainingConfiguration2(), KKMLL::ModelParam::UsfCasCor, and KKMLL::Model::UsfCasCor.

Referenced by TrainingConfiguration2().

                                                :
  Configuration              (),
  configFileNameSpecified    (""),
  configRootName             (""),
  fileDesc                   (_fileDesc),
  fvFactoryProducer          (NULL),
  fvFactoryProducerSpecified (false),
  mlClasses                  (NULL),
  mlClassesWeOwnIt           (false),
  modelingMethod             (Model::ModelTypes::Null),
  examplesPerClass           (0),
  modelParameters            (_modelParameters),
  noiseMLClass               (NULL),
  noiseTrainingClass         (NULL),
  otherClass                 (NULL),
  otherClassLineNum          (-1),
  rootDir                    (),
  rootDirExpanded            (),
  subClassifiers             (NULL),
  subClassifierNameList      (NULL),
  trainingClasses            ("", true),
  validateDirectories        (false)
{
  if  (_mlClasses)
    mlClasses = new MLClassList (*_mlClasses);
  else
    mlClasses = new MLClassList ();
  mlClassesWeOwnIt = true;

  {
    MLClassList::iterator idx;
    for  (idx = mlClasses->begin ();  idx != mlClasses->end ();  idx++)
    {
      MLClassPtr      mlClass = *idx;
      VectorKKStr  directories;
      TrainingClassPtr  tc = new TrainingClass (directories, mlClass->Name (), 1.0f, 1.0f, NULL, *mlClasses);
      trainingClasses.PushOnBack (tc);
    }
  }

  switch  (_modelParameters->ModelParamType ())
  {
  case  ModelParam::ModelParamTypes::Dual:      modelingMethod = Model::ModelTypes::Dual;       break;
  case  ModelParam::ModelParamTypes::KNN:       modelingMethod = Model::ModelTypes::KNN;        break;
  case  ModelParam::ModelParamTypes::OldSVM:    modelingMethod = Model::ModelTypes::OldSVM;     break;
  case  ModelParam::ModelParamTypes::SvmBase:   modelingMethod = Model::ModelTypes::SvmBase;    break;
  case  ModelParam::ModelParamTypes::UsfCasCor: modelingMethod = Model::ModelTypes::UsfCasCor;  break;
  }
}

TrainingConfiguration2::~TrainingConfiguration2 ( )

virtual

Definition at line 420 of file TrainingConfiguration2.cpp.

{
  delete  noiseTrainingClass;     noiseTrainingClass    = NULL;
  delete  modelParameters;        modelParameters       = NULL;
  delete  subClassifierNameList;  subClassifierNameList = NULL;
  delete  subClassifiers;         subClassifiers        = NULL;

  if  (mlClassesWeOwnIt)
  {
    delete  mlClasses;
    mlClasses = NULL;
  }
}

Member Function Documentation

float TrainingConfiguration2::A_Param

(

)

const

Definition at line 1054 of file TrainingConfiguration2.cpp.

References KKMLL::ModelParam::A_Param().

{
  if  (modelParameters)
    return  modelParameters->A_Param ();
  else
    return 0.0f;
}

void TrainingConfiguration2::A_Param

(

float

_aParam

)

Definition at line 1064 of file TrainingConfiguration2.cpp.

References KKMLL::ModelParam::A_Param().

{
  if  (modelParameters)
    modelParameters->A_Param (_aParam);
}  /* A_Param */

void TrainingConfiguration2::AddATrainingClass

(

TrainingClassPtr

_trainClass

)

Adds specified Training Class to list taking ownership of it.

Add a Training class to configuration Will take ownership of allocation.

Definition at line 993 of file TrainingConfiguration2.cpp.

Referenced by AddATrainingClass(), and GenerateAConfiguraionForAHierarchialLevel().

{
  trainingClasses.PushOnBack (_trainClass);
}  /* AddATrainingClass */

void TrainingConfiguration2::AddATrainingClass

(

MLClassPtr

_newClass

)

Will assume that images for this class will be saved off the RootDirectory using its own name for the subdirectory name.

Will assume that images for this class will be saved off the RootDirectory using its own name for the subdirectory name.

< Weight given to this Class during training

< CountFactor.

< Sub-Classifier.

Definition at line 1004 of file TrainingConfiguration2.cpp.

References AddATrainingClass(), KKMLL::MLClass::Name(), and KKMLL::TrainingClass::TrainingClass().

{
  VectorKKStr directories;
  TrainingClassPtr  tc 
    = new TrainingClass (directories,
                         _newClass->Name (),
                         1.0f,                /**< Weight given to this Class during training  */
                         1.0f,                /**< CountFactor.                                */
                         NULL,                /**< Sub-Classifier.                             */
                         *mlClasses
                        );
  AddATrainingClass (tc);
}

float TrainingConfiguration2::AvgNumOfFeatures

(

)

const

Definition at line 1263 of file TrainingConfiguration2.cpp.

References KKMLL::ModelParam::AvgMumOfFeatures().

{
  if  (modelParameters)
    return modelParameters->AvgMumOfFeatures ();
  return 0.0f;
}  /* AvgMumOfFeatures */

float TrainingConfiguration2::AvgNumOfFeatures

(

FeatureVectorListPtr

trainExamples

)

const

Definition at line 1272 of file TrainingConfiguration2.cpp.

References KKMLL::SVMparam::AvgNumOfFeatures().

{
  const SVMparamPtr  param = SVMparamToUse ();
  if  (param)
    return param->AvgNumOfFeatures (trainExamples);
  else
    return  0.0f;
}

void TrainingConfiguration2::BuildTrainingClassListFromDirectoryStructure ( const KKStr &  _subDir, bool &  _successful, KKStr &  _errorMessage, RunLog &  _log  )

protected

Definition at line 877 of file TrainingConfiguration2.cpp.

References KKB::KKStr::Concat(), KKMLL::TrainingClassList::DuplicateListAndContents(), EmptyTrainingClasses(), KKMLL::TrainingClass::ExpandedDirectory(), KKMLL::TrainingClass::FeatureFileName(), ImagesPerClass(), KKMLL::TrainingClassList::LocateByDirectory(), KKMLL::TrainingClass::MLClass(), ModelParameters(), KKMLL::ModelParamOldSVM::ModelParamOldSVM(), KKMLL::ModelParamOldSVM::ParseCmdLine(), and TrainingClasses().

Referenced by CreateFromDirectoryStructure().

{
  _log.Level (10) << "TrainingConfiguration2::BuildTrainingClassListFromDirectoryStructure"  << endl
                  << "                       Feature Data from SubDir[" << _subDir << "]." << endl
                  << endl;

  _successful = true;

  if  (ModelParameters () == NULL)
  {
    bool  _validFormat = true;
    KKStr  svmParameterStr = "-s 0 -n 0.11 -t 2 -g 0.01507  -c 12  -u 100  -up  -mt OneVsOne  -sm P";

    ModelParamOldSVMPtr  oldSVMparameters = new ModelParamOldSVM ();
    oldSVMparameters->ParseCmdLine (svmParameterStr, _validFormat, _log);
    ModelParameters (oldSVMparameters);
    ImagesPerClass (1000);
    delete  oldSVMparameters;
    oldSVMparameters = NULL;
  }
  
  TrainingClassListPtr  origTraniningClasses = TrainingClasses ().DuplicateListAndContents ();

  EmptyTrainingClasses ();
  
  if  (mlClasses)
  {
    while  (mlClasses->QueueSize () > 1)
      mlClasses->PopFromBack ();
  }

  KKStr  subDirUnderRoot = "";
  BuildTrainingClassListFromDirectoryEntry (_subDir,
                                            subDirUnderRoot,
                                            _successful, 
                                            _errorMessage,
                                            _log
                                           );

  {
    // We can now update the traningClasses found with that which is in origTraniningClasses.
    TrainingClassList::iterator  idx;

    for  (idx = trainingClasses.begin ();  idx != trainingClasses.end ();  idx++)
    {
      TrainingClassPtr  tc = *idx;

      // I am not sure about this line.  Might need to use rootDir from original configuration file.
      TrainingClassPtr  origTC = origTraniningClasses->LocateByDirectory (tc->ExpandedDirectory (_subDir, 0));
      if  (origTC)
      {
        tc->MLClass      (origTC->MLClass ());
        tc->FeatureFileName (origTC->FeatureFileName ());
      }
    }
  }

  delete  origTraniningClasses;
  origTraniningClasses = NULL;
}  /* BuildTrainingClassListFromDirectoryStructure */

double TrainingConfiguration2::C_Param

(

)

const

Definition at line 1090 of file TrainingConfiguration2.cpp.

References KKMLL::ModelParam::C_Param().

{
  if  (modelParameters)
    return  modelParameters->C_Param ();
  else
    return 0.0;
}

double TrainingConfiguration2::C_Param	(	MLClassPtr	class1,
		MLClassPtr	class2
	)		const

Definition at line 1213 of file TrainingConfiguration2.cpp.

References KKMLL::ModelParamOldSVM::C_Param().

{
  ModelParamOldSVMPtr  oldSVMparms = OldSvmParameters ();
  if  (oldSVMparms)
    return  oldSVMparms->C_Param (class1, class2);
  else
    return 0.0;
}

void TrainingConfiguration2::C_Param

(

double

_CCC

)

Definition at line 1100 of file TrainingConfiguration2.cpp.

References KKMLL::ModelParam::C_Param().

{
  if  (modelParameters)
    modelParameters->C_Param (_CCC);
}

void TrainingConfiguration2::C_Param	(	MLClassPtr	class1,
		MLClassPtr	class2,
		double	cParam
	)

Definition at line 1226 of file TrainingConfiguration2.cpp.

References KKMLL::ModelParamOldSVM::C_Param().

{
  ModelParamOldSVMPtr  oldSVMparms = OldSvmParameters ();
  if  (oldSVMparms)
    oldSVMparms->C_Param (class1, class2, cParam);
}  /* C_Param */

bool TrainingConfiguration2::ConfigFileExists ( const KKStr &  _configFileName )

static

Definition at line 2296 of file TrainingConfiguration2.cpp.

References KKB::KKStr::Concat(), GetEffectiveConfigFileName(), and KKB::osFileExists().

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

{
  KKStr  effectiveName = GetEffectiveConfigFileName (_configFileName);
  return osFileExists (effectiveName);
}  /* ConfigFileExists */

const KKStr& KKMLL::TrainingConfiguration2::ConfigFileNameSpecified ( ) const

inline

Definition at line 186 of file TrainingConfiguration2.h.

Referenced by KKMLL::TrainingProcess2::BuildTrainingProcess(), and KKMLL::TrainingProcess2::SaveTrainingProcess().

{return configFileNameSpecified;}

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

inline

Definition at line 187 of file TrainingConfiguration2.h.

Referenced by KKMLL::Classifier2::Classifier2(), KKMLL::TrainingProcess2::CreateTrainingProcess(), and KKMLL::TrainingConfiguration2List::LookUp().

{return configRootName;}

TrainingConfiguration2Ptr TrainingConfiguration2::CreateFromDirectoryStructure ( const KKStr &  _existingConfigFileName, const KKStr &  _subDir, FactoryFVProducerPtr  _fvFactoryProducer, RunLog &  _log, bool &  _successful, KKStr &  _errorMessage  )

static

Will create a instance using a sub-directory tree to drive the TraningClassList.

for each unique sub-directory entry below it that contains 'bmp' files a TrainingClass' instance will be created using the root-name as the class name. If an existing Config file already exists then parameters will be taken from it otherwise a default configuration will be created.

Parameters

[in]	_existingConfigFileName	Caller can specify an existing Configuration file to extract configuration parameters from; if left blank then a configuration file with the same name of the last name in the directory path specified by _subDir will be assumed in the default TraningModel directory. If still no configuration file found then one will be created using default parameters.
[in]	_subDir	The root directory entry to the Sub-Directory structure that is to be used to construct training class list from.
[in]	_fvFactoryProducer	The FeatureVector computation routines you want to use; if NULL will default.
[in]	_log
[out]	_successful
[out]	_errorMessage	Will contain description of errors encountered.

Definition at line 790 of file TrainingConfiguration2.cpp.

References BuildTrainingClassListFromDirectoryStructure(), KKB::KKStr::Concat(), KKB::KKStr::Empty(), KKMLL::GrayScaleImagesFVProducerFactory::Factory(), Gamma(), Load(), KKMLL::FactoryFVProducer::ManufacturTrainingConfiguration(), KKB::KKStr::operator+(), KKB::KKStr::operator=(), KKB::osAddSlash(), KKB::osFileExists(), KKB::osGetRootNameOfDirectory(), RootDir(), Save(), TrainingConfiguration2(), and KKMLL::KKMLVariables::TrainingModelsDir().

{
  _log.Level (10) << "TrainingConfiguration2::CreateFromDirectoryStructure"  << endl
                  << "                       Feature Data from SubDir[" << _subDir << "]." << endl
                  << endl;

  _successful = true;

  KKStr  directoryConfigFileName = osGetRootNameOfDirectory (_subDir);
  if  (directoryConfigFileName.Empty ())
    directoryConfigFileName = osAddSlash (KKMLVariables::TrainingModelsDir ()) + "Root.cfg";
  else
    directoryConfigFileName = osAddSlash (KKMLVariables::TrainingModelsDir ()) + directoryConfigFileName + ".cfg";

  TrainingConfiguration2Ptr  config = NULL;

  if  (!_existingConfigFileName.Empty ())
  {
    if  (osFileExists (_existingConfigFileName))
    {
      config = _fvFactoryProducer->ManufacturTrainingConfiguration ();
      config->Load (_existingConfigFileName, 
                    false,  //  false = DO NOT Validate Directories.
                    _log
                   );
      config->RootDir (_subDir);
      if  (!(config->FormatGood ()))
      {
        delete  config;
        config = NULL;
      }
    }
  }

  if  (!config)
  {
    if  (osFileExists (directoryConfigFileName))
    {
      config = _fvFactoryProducer->ManufacturTrainingConfiguration ();
      config->Load (directoryConfigFileName,
                    false,  // false = Do Not Validate Directories.
                    _log 
                   );

      config->RootDir (_subDir);
      if  (!(config->FormatGood ()))
      {
        delete  config;
        config = NULL;
      }
    }
  }

  if  (!config)
  {
    if  (_fvFactoryProducer != NULL)
      _fvFactoryProducer = GrayScaleImagesFVProducerFactory::Factory (&_log);
    config = new TrainingConfiguration2 (NULL,      // Not supplying the MLClassList
                                         _fvFactoryProducer,
                                         "=-s 0 -n 0.11 -t 2 -g 0.01507  -c 12  -u 100  -up  -mt OneVsOne  -sm P",
                                         _log
                                        );
    config->RootDir (_subDir);
  }

  config->BuildTrainingClassListFromDirectoryStructure (_subDir,
                                                        _successful, 
                                                        _errorMessage,
                                                        _log
                                                       );

  if  (config->Gamma () == 0.0)
    config->Gamma (0.01507);

  config->Save (directoryConfigFileName);

  return  config;
} /* CreateFromDirectoryTree */

TrainingConfiguration2Ptr TrainingConfiguration2::CreateFromFeatureVectorList ( FeatureVectorList &  _examples, FileDescPtr  _fileDesc, const KKStr &  _parameterStr, RunLog &  _log  )

static

Definition at line 758 of file TrainingConfiguration2.cpp.

References KKMLL::FeatureVectorList::AllFeatures(), KKB::KKStr::Concat(), KKB::KKStr::Empty(), KKMLL::FeatureVectorList::ExtractListOfClasses(), KKMLL::FeatureVectorList::FileDesc(), KKB::KKStr::operator=(), SetFeatureNums(), KKMLL::MLClassList::SortByName(), and TrainingConfiguration2().

{
  _log.Level (10) << "TrainingConfiguration2::CreateFromFeatureVectorList" << endl;
  FileDescPtr  fileDesc = _examples.FileDesc ();

  MLClassListPtr  mlClasses = _examples.ExtractListOfClasses ();
  mlClasses->SortByName ();
  KKStr  parameterStr = _parameterStr;
  if  (parameterStr.Empty ())
    parameterStr = "-m 200 -s 0 -n 0.11 -t 2 -g 0.024717  -c 10  -u 100  -up  -mt OneVsOne  -sm P";

  TrainingConfiguration2Ptr  config 
      = new TrainingConfiguration2 (mlClasses,
                                    _fileDesc,
                                    parameterStr,
                                   _log
                                  );

  config->SetFeatureNums (_examples.AllFeatures ());

  delete  mlClasses;  mlClasses = NULL;

  return  config;
}  /* CreateFromFeatureVectorList */

FactoryFVProducerPtr TrainingConfiguration2::DefaultFeatureVectorProducer ( RunLog &  runLog ) const

virtual

Definition at line 452 of file TrainingConfiguration2.cpp.

References KKMLL::GrayScaleImagesFVProducerFactory::Factory().

Referenced by FvFactoryProducer(), ReadXMLPost(), and TrainingConfiguration2().

{
  return  GrayScaleImagesFVProducerFactory::Factory (&runLog);
}

KKStr TrainingConfiguration2::DirectoryPathForClass

(

MLClassPtr

mlClass

)

const

Fully expanded directory path for specified class.

Parameters

mlClass

Class that we want to get directory path for training images.

Returns

Returns full patch where images for mlClass are stored; directory path is fully expended.

Definition at line 476 of file TrainingConfiguration2.cpp.

References KKB::KKStr::Concat(), KKB::KKStr::EmptyStr(), KKMLL::TrainingClass::ExpandedDirectory(), and KKMLL::TrainingClass::MLClass().

{
  TrainingClassList::const_iterator  idx;
  for  (idx = trainingClasses.begin ();  idx != trainingClasses.end ();  idx++)
  {
    const TrainingClassPtr  tc = *idx;
    if  (tc->MLClass () == mlClass)
      return  tc->ExpandedDirectory (rootDir, 0);
  }

  return  KKStr::EmptyStr ();
}  /* DirectoryPathForClass */

TrainingConfiguration2Ptr TrainingConfiguration2::Duplicate ( ) const

virtual

Definition at line 436 of file TrainingConfiguration2.cpp.

References TrainingConfiguration2().

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

{
  return new TrainingConfiguration2 (*this);
}

void TrainingConfiguration2::EmptyTrainingClasses

(

)

Removes all training classes from the configuration; example use would be to remove all classes and then add the two needed by a Binary-Class-Pair classifier.

Definition at line 1974 of file TrainingConfiguration2.cpp.

Referenced by BuildTrainingClassListFromDirectoryStructure(), GenerateAConfiguraionForAHierarchialLevel(), and SetTrainingClasses().

{
  while  (trainingClasses.QueueSize () > 0)
  {
    TrainingClassPtr  trainingClass = trainingClasses.PopFromBack ();
    delete  trainingClass;
  }
}  /* DeleteTrainingClasses */

SVM_EncodingMethod TrainingConfiguration2::EncodingMethod

(

)

const

Definition at line 1202 of file TrainingConfiguration2.cpp.

References KKMLL::SVMparam::EncodingMethod(), and KKMLL::NoEncoding.

{
  const SVMparamPtr  param = SVMparamToUse ();
  if  (param)
    return  param->EncodingMethod ();
  else
    return  SVM_EncodingMethod::NoEncoding;
}  /* EncodingMethod */

void TrainingConfiguration2::EncodingMethod

(

SVM_EncodingMethod

_encodingMethod

)

Definition at line 1194 of file TrainingConfiguration2.cpp.

References KKMLL::ModelParam::EncodingMethod().

{
  if  (modelParameters)
    modelParameters->EncodingMethod ((ModelParam::EncodingMethodType)_encodingMethod);
}

kkint32 TrainingConfiguration2::ExamplesPerClass

(

)

const

Definition at line 1335 of file TrainingConfiguration2.cpp.

Referenced by KKMLL::CrossValidation::CrossValidation(), and ImagesPerClass().

{
  return examplesPerClass;
}  /* ImagesPerClass */

void TrainingConfiguration2::ExamplesPerClass

(

kkint32

_examplesPerClass

)

Definition at line 1328 of file TrainingConfiguration2.cpp.

Referenced by ImagesPerClass().

{
  examplesPerClass = _examplesPerClass;
}

MLClassListPtr TrainingConfiguration2::ExtractClassList

(

)

const

Constructs new list of classes that caller will own.

Definition at line 701 of file TrainingConfiguration2.cpp.

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

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

{
  TrainingClassList::const_iterator  idx;

  MLClassListPtr  classes = new MLClassList ();

  for  (idx = trainingClasses.begin ();  idx != trainingClasses.end ();  idx++)
  {
    TrainingClassPtr  tc = *idx;

    if  (classes->PtrToIdx (tc->MLClass ()) < 0)
      classes->PushOnBack (tc->MLClass ());
  }

  classes->SortByName ();

  return  classes;
}   /* ExtractClassList */

MLClassListPtr TrainingConfiguration2::ExtractFullHierachyOfClasses

(

)

const

Extracts the list of classes including ones from Sub-Classifiers

Definition at line 722 of file TrainingConfiguration2.cpp.

References ExtractFullHierachyOfClasses(), KKMLL::MLClassList::MLClassList(), KKMLL::MLClassList::SortByName(), and KKMLL::TrainingClass::SubClassifier().

Referenced by KKMLL::TrainingProcess2::ExtractFullHierachyOfClasses(), and ExtractFullHierachyOfClasses().

{
  TrainingClassList::const_iterator  idx;

  MLClassListPtr  classes = new MLClassList ();

  for  (idx = trainingClasses.begin ();  idx != trainingClasses.end ();  idx++)
  {
    TrainingClassPtr  tc = *idx;
    if  (tc->SubClassifier () == NULL)
    {
      if  (classes->PtrToIdx (tc->MLClass ()) < 0)
        classes->PushOnBack (tc->MLClass ());
    }
    else
    {
      MLClassListPtr  subClassifierClasses = tc->SubClassifier ()->ExtractFullHierachyOfClasses ();
      MLClassList::const_iterator  idx2;
      for  (idx2 = subClassifierClasses->begin();  idx2 != subClassifierClasses->end ();  ++idx2)
      {
        MLClassPtr       subClass = *idx2;
        if  (classes->PtrToIdx (subClass) < 0)
          classes->PushOnBack (subClass);
      }
      delete  subClassifierClasses;
      subClassifierClasses = NULL;
    }
  }

  classes->SortByName ();
  return  classes;
}  /* ExtractFullHierachyOfClasses */

MLClassListPtr TrainingConfiguration2::ExtractListOfClassesForAGivenHierarchialLevel

(

kkuint32

level

)

const

Definition at line 530 of file TrainingConfiguration2.cpp.

References KKMLL::MLClass::MLClassForGivenHierarchialLevel(), and KKMLL::MLClassList::MLClassList().

Referenced by GenerateAConfiguraionForAHierarchialLevel().

{
  MLClassListPtr  classes = new MLClassList ();
  TrainingClassList::const_iterator  idx;

  for  (idx = trainingClasses.begin ();  idx !=  trainingClasses.end ();  idx++)
  {
    MLClassPtr  ic = (*idx)->MLClass ();
    MLClassPtr  claassForGivenLevel = ic->MLClassForGivenHierarchialLevel (level);
    if  (classes->PtrToIdx (claassForGivenLevel) < 0)
      classes->AddMLClass (claassForGivenLevel);
  }

  return  classes;
}  /* ExtractListOfClassesForAGivenHierarchialLevel */

TrainingConfiguration2::Factory * TrainingConfiguration2::FactoryInstace ( )

static

Definition at line 2415 of file TrainingConfiguration2.cpp.

References KKB::GlobalGoalKeeper::EndBlock(), KKMLL::TrainingConfiguration2::Factory::Factory(), factoryInstace, RegisterFatory(), and KKB::GlobalGoalKeeper::StartBlock().

{
  if  (factoryInstace)
    return  factoryInstace;

  GlobalGoalKeeper::StartBlock ();
  factoryInstace = new Factory ();
  RegisterFatory ("TrainingConfiguration2", factoryInstace );
  GlobalGoalKeeper::EndBlock ();
  return  factoryInstace;
}

virtual KKStr KKMLL::TrainingConfiguration2::FactoryName ( ) const

inlinevirtual

The name of the Factory class that produces an instance of this class.

Definition at line 500 of file TrainingConfiguration2.h.

FileDescPtr KKMLL::TrainingConfiguration2::FileDesc ( ) const

inline

Definition at line 190 of file TrainingConfiguration2.h.

Referenced by KKMLL::NormalizationParms::NormalizationParms().

{return  fileDesc;}

FactoryFVProducerPtr TrainingConfiguration2::FvFactoryProducer

(

RunLog &

log

)

const

Definition at line 443 of file TrainingConfiguration2.cpp.

References DefaultFeatureVectorProducer().

Referenced by KKMLL::TrainingProcess2::BuildTrainingProcess(), KKMLL::TrainingProcess2::CreateModelsFromTrainingData(), KKMLL::TrainingProcess2::CreateTrainingProcessForLevel(), KKMLL::CrossValidation::CrossValidation(), KKMLL::TrainingProcess2::ExtractTrainingClassFeatures(), and KKMLL::TrainingProcess2::ReadXML().

{
  if  (!fvFactoryProducerSpecified)
    return  DefaultFeatureVectorProducer (log);
  else
    return  fvFactoryProducer;
}

bool KKMLL::TrainingConfiguration2::FvFactoryProducerSpecified ( ) const

inline

Definition at line 192 of file TrainingConfiguration2.h.

{return fvFactoryProducerSpecified;}

double TrainingConfiguration2::Gamma

(

)

const

Definition at line 1072 of file TrainingConfiguration2.cpp.

References KKMLL::ModelParam::Gamma().

Referenced by CreateFromDirectoryStructure().

{
  if  (modelParameters)
    return  modelParameters->Gamma ();
  else
    return 0.0;
}  /* Gamma */

void TrainingConfiguration2::Gamma

(

double

_gamma

)

Definition at line 1082 of file TrainingConfiguration2.cpp.

References KKMLL::ModelParam::Gamma().

Referenced by CreateFromDirectoryStructure().

{
  if  (modelParameters)
    modelParameters->Gamma (_gamma);
}  /* Gamma */

TrainingConfiguration2Ptr TrainingConfiguration2::GenerateAConfiguraionForAHierarchialLevel	(	kkuint32	level,
		RunLog &	log
	)		const

Definition at line 548 of file TrainingConfiguration2.cpp.

References AddATrainingClass(), KKMLL::TrainingClass::Directories(), EmptyTrainingClasses(), ExtractListOfClassesForAGivenHierarchialLevel(), KKMLL::TrainingClass::MLClass(), KKMLL::MLClass::MLClassForGivenHierarchialLevel(), KKMLL::MLClass::Name(), KKMLL::TrainingClass::TrainingClass(), and TrainingConfiguration2().

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

{
  log.Level (10) << "TrainingConfiguration2::GenerateAConfiguraionForAHierarchialLevel  level[" << level << "]" << endl;
  TrainingConfiguration2Ptr  hierarchialConfig = new TrainingConfiguration2 (*this);
  hierarchialConfig->EmptyTrainingClasses ();

  MLClassListPtr  hierarchialClassList = ExtractListOfClassesForAGivenHierarchialLevel (level);

  TrainingClassList::const_iterator  idx;
  
  for  (idx = trainingClasses.begin ();  idx != trainingClasses.end ();  idx++)
  {
    const TrainingClassPtr tc = *idx;
    MLClassPtr  ic = tc->MLClass ()->MLClassForGivenHierarchialLevel (level);
    hierarchialConfig->AddATrainingClass (new TrainingClass (tc->Directories (), ic->Name (), 1.0f, 1.0f, NULL, *hierarchialClassList));
  }

  hierarchialConfig->SyncronizeMLClassListWithTrainingClassList ();

  delete  hierarchialClassList;
  return  hierarchialConfig;
} /* GenerateAConfiguraionForAHierarchialLevel */

BinaryClassParmsPtr TrainingConfiguration2::GetBinaryClassParms	(	MLClassPtr	class1,
		MLClassPtr	class2
	)

if BinaryClass parms exist for the two specified classes will return otherwise NULL.

Definition at line 2382 of file TrainingConfiguration2.cpp.

References KKMLL::SVMparam::GetBinaryClassParms().

{
  const SVMparamPtr  param = SVMparamToUse ();
  if  (!param)
    return NULL;

  return param->GetBinaryClassParms (class1, class2);
}

KKStr TrainingConfiguration2::GetEffectiveConfigFileName ( const KKStr &  configFileName )

static

Determine the correct configuration file name.

If  no extension then add ".cfg" to end of file name.

if  Path Provided
{
   Return name as submitted with added extension.
}
else
{
   a. If file exists in default directory;  then return name with default directory path.
   b. If file exists in Training Model Directory  $(HomeDir) + "\\DataFiles\\TrainingModels"
      then return with Training Model Directory.
   c. Since not found then we will return name passed in with extension.
}

Definition at line 2259 of file TrainingConfiguration2.cpp.

References KKB::KKStr::Concat(), KKB::KKStr::Empty(), KKB::KKStr::operator+(), KKB::KKStr::operator=(), KKB::osAddSlash(), KKB::osFileExists(), KKB::osGetCurrentDirectory(), KKB::osGetFileExtension(), KKB::osGetPathPartOfFile(), KKB::osGetRootNameWithExtension(), KKB::osRemoveExtension(), and KKMLL::KKMLVariables::TrainingModelsDir().

Referenced by ConfigFileExists(), KKMLL::TrainingProcess2::CreateTrainingProcess(), Load(), KKMLL::TrainingProcess2::LoadExistingTrainingProcess(), and KKMLL::TrainingProcess2::SaveTrainingProcess().

{
  if  (osFileExists (configFileName))
    return  configFileName;

  KKStr  rootNameEithExtension = osGetRootNameWithExtension (configFileName);
  KKStr  extension = osGetFileExtension (configFileName);
  KKStr  path = osGetPathPartOfFile (configFileName);

  KKStr  configFileNameWithExtension = configFileName;
  if  (extension.Empty ())
  {
    configFileNameWithExtension = osRemoveExtension (configFileName) + ".cfg";
  }

  if  (!path.Empty ())
  {
    // Caller is telling us which directory to look in.  In this case there is nothing to do
    return configFileNameWithExtension;
  }

  // See if file exists
  KKStr  configFileNameInDefaultDirectory = osAddSlash (osGetCurrentDirectory ()) + configFileNameWithExtension;
  if  (osFileExists (configFileNameInDefaultDirectory))
    return  configFileNameInDefaultDirectory;

  KKStr  configNameInTrainingModelDir = osAddSlash (KKMLVariables::TrainingModelsDir ()) + configFileNameWithExtension;
  if  (osFileExists (configNameInTrainingModelDir))
  {
    return  configNameInTrainingModelDir;
  }

  return  configFileNameInDefaultDirectory;
}  /* GetEffectiveConfigFileName */

FeatureNumList TrainingConfiguration2::GetFeatureNums

(

)

const

Definition at line 1302 of file TrainingConfiguration2.cpp.

References KKMLL::FeatureNumList::FeatureNumList(), and KKMLL::ModelParam::SelectedFeatures().

{
  if  (modelParameters)
  {
    FeatureNumListConstPtr fnl = modelParameters->SelectedFeatures ();
    if  (fnl)
      return *fnl;
  }
  if  (fileDesc)
    return FeatureNumList (fileDesc);
  else
    return FeatureNumList (1);
}  /* GetFeatureNums */

FeatureNumList TrainingConfiguration2::GetFeatureNums	(	MLClassPtr	class1,
		MLClassPtr	class2
	)

Returns features selected for the specified class-pairIf none were specified for that pair will return global feature nums.

Definition at line 1342 of file TrainingConfiguration2.cpp.

References KKMLL::FeatureNumList::AllFeatures(), and KKMLL::ModelParamOldSVM::GetFeatureNums().

{
  ModelParamOldSVMPtr  oldSVMparms = OldSvmParameters ();
  if  (oldSVMparms)
  {
    FeatureNumListConstPtr  fnl = oldSVMparms->GetFeatureNums (fileDesc, class1, class2);
    if  (fnl)
      return *fnl;
  }

  return  FeatureNumList::AllFeatures (fileDesc);
}  /* GetFeatureNums */

const BinaryClassParmsPtr TrainingConfiguration2::GetParamtersToUseFor2ClassCombo	(	MLClassPtr	class1,
		MLClassPtr	class2
	)		const

Definition at line 2370 of file TrainingConfiguration2.cpp.

References KKMLL::SVMparam::GetParamtersToUseFor2ClassCombo().

{
  const SVMparamPtr  param = SVMparamToUse ();
  if  (!param)
    return NULL;

  return param->GetParamtersToUseFor2ClassCombo (class1, class2);
}  /* BinaryClassParms */

kkint32 KKMLL::TrainingConfiguration2::ImagesPerClass ( ) const

inline

Definition at line 194 of file TrainingConfiguration2.h.

References ExamplesPerClass().

{return  ExamplesPerClass ();};

void KKMLL::TrainingConfiguration2::ImagesPerClass ( kkint32  _imagesPerClass )

inline

Definition at line 248 of file TrainingConfiguration2.h.

References ExamplesPerClass().

Referenced by BuildTrainingClassListFromDirectoryStructure().

{ExamplesPerClass (_imagesPerClass);}

SVM_KernalType TrainingConfiguration2::KernalType

(

)

const

Definition at line 1283 of file TrainingConfiguration2.cpp.

References KKMLL::SVMparam::KernalType(), and KKMLL::Linear.

{
  const SVMparamPtr  param = SVMparamToUse ();
  if  (param)
    return param->KernalType ();
  return  SVM_KernalType::Linear;
}  /* KernalType */

void TrainingConfiguration2::KernalType

(

SVM_KernalType

_kernalType

)

Definition at line 1293 of file TrainingConfiguration2.cpp.

References KKMLL::SVMparam::KernalType().

{
  const SVMparamPtr  param = SVMparamToUse ();
  if  (param)
    return param->KernalType (_kernalType);
}  /* KernalType */

void TrainingConfiguration2::Load ( const KKStr &  _configFileName, bool  _validateDirectories, RunLog &  log  )

virtual

Definition at line 130 of file TrainingConfiguration2.cpp.

References KKB::KKStr::Concat(), GetEffectiveConfigFileName(), KKMLL::MLClassList::MLClassList(), KKB::KKStr::operator=(), and KKB::osGetRootName().

Referenced by CreateFromDirectoryStructure(), KKMLL::TrainingProcess2::CreateTrainingProcessForLevel(), KKMLL::TrainingConfiguration2::Factory::Manufacture(), and KKMLL::ModelDual::TrainModel().

{
  KKStr  effectiveConfigName = GetEffectiveConfigFileName (_configFileName);

  Configuration::Load (effectiveConfigName, log);

  configFileNameSpecified  = _configFileName;
  configRootName           = KKB::osGetRootName (_configFileName);
  validateDirectories = _validateDirectories;
  if  (!FormatGood ())
  {
    log.Level (-1) << endl 
                   << "TrainingConfiguration2   ***ERROR***  Format of Configuration File is Invalid." << endl 
                   << endl;
    return;
  }

  mlClasses = new MLClassList ();
  mlClassesWeOwnIt = true;

 ValidateConfiguration (log);
 if  (examplesPerClass < 1)
  {
    log.Level (10) << "TrainingConfiguration2 - examplesPerClass not specified.  Defaulting to 1300." << endl;
    examplesPerClass = 1300;
  }

  if  (!FormatGood ())
    log.Level (-1) << endl
                   << "TrainingConfiguration2   ***ERROR***  Format of Configuration File is Invalid." << endl
                   << endl;

  else if  (rootDir.Empty ())
    DetermineWhatTheRootDirectoryIs ();

}  /* Load */

FeatureVectorListPtr TrainingConfiguration2::LoadFeatureDataFromTrainingLibraries	(	KKB::DateTime &	latestImageTimeStamp,
		bool &	changesMadeToTrainingLibraries,
		VolConstBool &	cancelFlag,
		RunLog &	log
	)

Load training data from the training library directories.

Loads all the FeatureData from the Training Library. The images in the sub-directories specified by the 'TrainingClass' entries will be used as the primary source. Data from existing FeatureData files will be used unless they are out of date. In that case the data will be recomputed from the original images.

The 'ExampleFileName' A field that is in each 'FeatureVector' instance will reflect the sub-directory from where it was retrieved. Between that and the 'rootDir' field you will be able to get the full path to then original image.

Parameters

[out]	latestImageTimeStamp	Time-stamp of the most current image loaded.
[out]	changesMadeToTrainingLibraries	True if any image needed to have its features recalculated or images were removed or added to a training directory.
[in]	cancelFlag	Will monitor this flag; if turns true will terminate the load and return.
[in]	log	Logging File.

Definition at line 2077 of file TrainingConfiguration2.cpp.

References KKMLL::FeatureVectorList::AddQueue(), KKMLL::FactoryFVProducer::ManufacturFeatureVectorList(), NoiseTrainingClass(), KKB::DateTime::operator=(), and KKB::DateTime::operator>().

{
  log.Level (10) << "TrainingConfiguration2::LoadFeatureDataFromTrainingLibraries - Starting." << endl;

  bool  errorOccured = false;

  FeatureVectorListPtr  featureData = fvFactoryProducer->ManufacturFeatureVectorList (true, log);

  changesMadeToTrainingLibraries = false;

  //****************************************************************************
  // 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 

  TrainingClassList::const_iterator  tcIDX;

  DateTime  latestTimeStamp;
  bool      changesMadeToThisTrainingClass = false;

  for  (tcIDX = trainingClasses.begin ();  (tcIDX != trainingClasses.end ()  &&  (!cancelFlag)  &&  (!errorOccured));  tcIDX++)
  {
    const TrainingClassPtr trainingClass = *tcIDX;

    log.Level (20) << "LoadFeatureDataFromTrainingLibraries   Starting on Class[" << trainingClass->Name () << "]." << endl;

    FeatureVectorListPtr  featureDataThisClass = ExtractFeatures (trainingClass, latestTimeStamp, changesMadeToThisTrainingClass, cancelFlag, log);

    if  (!featureDataThisClass)
    {
      log.Level (-1) << endl
                     << "Error Loading Feature data for class[" << trainingClass->Name () << "]." << endl
                     << endl;
      errorOccured = true;
    }
    else
    {
      if  (latestTimeStamp > latestImageTimeStamp)
        latestImageTimeStamp = latestTimeStamp;

      if  (changesMadeToThisTrainingClass)
        changesMadeToTrainingLibraries = true;

      featureData->AddQueue (*featureDataThisClass);
      featureDataThisClass->Owner (false);
    }
    delete  featureDataThisClass;  featureDataThisClass = NULL;
  }

  if  (NoiseTrainingClass ()  &&  (!cancelFlag)  &&  (!errorOccured))
  {
    log.Level (30) << "LoadFeatureDataFromTrainingLibraries  Loading Noise Class [" << NoiseTrainingClass ()->ExpandedDirectory (rootDir, 0) << "]" << endl;
    FeatureVectorListPtr  noiseFeatureData = ExtractFeatures (NoiseTrainingClass (), latestTimeStamp, changesMadeToThisTrainingClass, cancelFlag, log);
    if  (!noiseFeatureData)
    {
      log.Level (-1) << endl
                     << "TrainingConfiguration2::LoadFeatureDataFromTrainingLibraries   ***ERROR***  Error Loading feature data for Noise Images, Directory[" 
                     << NoiseTrainingClass ()->ExpandedDirectory (rootDir, 0) 
                     << "]." 
                     << endl
                     << endl;
      delete  featureData;  featureData = NULL;
      errorOccured = true;
    }
    else
    {
      if  (latestTimeStamp > latestImageTimeStamp)
        latestImageTimeStamp = latestTimeStamp;

      if  (changesMadeToThisTrainingClass)
        changesMadeToTrainingLibraries = true;

      featureData->AddQueue (*noiseFeatureData);
      noiseFeatureData->Owner (false);
      delete  noiseFeatureData;  noiseFeatureData = NULL;
    }
  }

  if  (cancelFlag  ||  errorOccured)
  {
    log.Level (-1) << "LoadFeatureDataFromTrainingLibraries     ***ERROR***    CancelFlag or ErrorOcured  set to 'true'." << endl;
    delete  featureData;  
    featureData = NULL;
  }

  log.Level (20) << "LoadFeatureDataFromTrainingLibraries   Exiting" << endl;
  return  featureData;
}  /*  LoadFeatureDataFromTrainingLibraries */

FeatureVectorListPtr TrainingConfiguration2::LoadOtherClasssExamples

(

RunLog &

runLog

)

Definition at line 2023 of file TrainingConfiguration2.cpp.

References KKB::KKStr::Concat(), KKMLL::FactoryFVProducer::DefaultFeatureFileIO(), KKB::KKStr::Empty(), KKMLL::FeatureFileIO::FeatureDataReSink(), KKMLL::MLClass::Name(), KKB::KKStr::operator+(), KKB::KKStr::operator=(), KKB::osAddSlash(), and KKB::osSubstituteInEnvironmentVariables().

{
  if  (!otherClass)
    return NULL;

  KKStr otherClassDirName = "";

  if  (rootDir.Empty ())
    otherClassDirName = otherClass->Name ();
  else
    otherClassDirName = osAddSlash (rootDir) + otherClass->Name ();

  otherClassDirName = osSubstituteInEnvironmentVariables (otherClassDirName);

  MLClassList  tempClasses;
  bool  cancelFlag  = false;
  bool  changesMade = false;
  DateTime  latestTimeStamp;

  FeatureVectorListPtr  otherClassExamples = fvFactoryProducer->DefaultFeatureFileIO ()->FeatureDataReSink 
                                (fvFactoryProducer, 
                                 otherClassDirName,
                                 otherClass->Name () + ".data",
                                 otherClass,
                                 true,   //  true = Use-Directory-name-For-Class-Name (otherClass->Name ())
                                 tempClasses,
                                 cancelFlag,
                                 changesMade,
                                 latestTimeStamp,
                                 runLog
                                );

  return  otherClassExamples;
}  /* LoadOtherClasssExamples */

TrainingClassPtr TrainingConfiguration2::LocateByMLClassName

(

const KKStr &

className

)

Definition at line 1967 of file TrainingConfiguration2.cpp.

{
  return  trainingClasses.LocateByMLClassName (className);
}

SVM_MachineType TrainingConfiguration2::MachineType

(

)

const

Definition at line 1142 of file TrainingConfiguration2.cpp.

References KKMLL::ModelParamOldSVM::MachineType(), and KKMLL::Null.

{
  ModelParamOldSVMPtr  oldSVMparms = OldSvmParameters ();
  if  (oldSVMparms)
    return oldSVMparms->MachineType ();
  else
    return  SVM_MachineType::Null;
}  /* MachineType */

void TrainingConfiguration2::MachineType

(

SVM_MachineType

_machineType

)

Definition at line 1132 of file TrainingConfiguration2.cpp.

References KKMLL::ModelParamOldSVM::MachineType().

{
  ModelParamOldSVMPtr  oldSVMparms = OldSvmParameters ();
  if  (oldSVMparms)
    oldSVMparms->MachineType (_machineType);

}  /* MachineType */

TrainingConfiguration2Ptr TrainingConfiguration2::Manufacture ( const KKStr &  _className, const KKStr &  _configFileName, bool  _validateDirectories, RunLog &  _log  )

static

Definition at line 2430 of file TrainingConfiguration2.cpp.

References KKB::GlobalGoalKeeper::EndBlock(), and KKB::GlobalGoalKeeper::StartBlock().

{
  if  (!registeredFactories)
  {
    log.Level (-1)  << endl << "TrainingConfiguration2::Manufacture   ***ERROR***   registeredFactories == NULL Will construct default 'TrainingConfiguration2' instance." << endl << endl;
    TrainingConfiguration2Ptr  config = new TrainingConfiguration2 ();
    config->Load (configFileName, validateDirectories, log);
    return  config;
  }

  GlobalGoalKeeper::StartBlock ();

  TrainingConfiguration2Ptr  newInstance = NULL;

  map<KKStr,Factory*>::const_iterator  idx;
  idx = registeredFactories->find (className);
  if  (idx == registeredFactories->end ())
  {
    log.Level (-1) << endl << "TrainingConfiguration2::Manufacture   Factory: " << className << "  Is not defined;  will return instance of 'TrainingConfiguration2'." << endl << endl;
    newInstance = new TrainingConfiguration2 ();
    newInstance->Load (configFileName, validateDirectories, log);
  }
  else
  {
    newInstance = idx->second->Manufacture (configFileName, validateDirectories, log);
  }

  GlobalGoalKeeper::EndBlock ();
  return  newInstance;
}  /* Manufacture */

MLClassListPtr KKMLL::TrainingConfiguration2::MlClasses ( ) const

inline

Definition at line 197 of file TrainingConfiguration2.h.

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

{return  mlClasses;}

Model::ModelTypes KKMLL::TrainingConfiguration2::ModelingMethod ( ) const

inline

Definition at line 198 of file TrainingConfiguration2.h.

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

{return  modelingMethod;}

KKStr TrainingConfiguration2::ModelParameterCmdLine

(

)

const

Definition at line 690 of file TrainingConfiguration2.cpp.

References ModelParameters(), and KKMLL::ModelParam::ToCmdLineStr().

{
  ModelParamPtr  p = ModelParameters ();
  if  (!p)
    return "";
  else
    return p->ToCmdLineStr ();
}  /* ModelParameterCmdLine */

ModelParamPtr KKMLL::TrainingConfiguration2::ModelParameters ( ) const

inline

Definition at line 212 of file TrainingConfiguration2.h.

Referenced by BuildTrainingClassListFromDirectoryStructure(), KKMLL::TrainingProcess2::CreateModelsFromTrainingData(), and ModelParameterCmdLine().

{return  modelParameters;}

void TrainingConfiguration2::ModelParameters

(

ModelParamPtr

_modelParameters

)

Definition at line 682 of file TrainingConfiguration2.cpp.

References KKMLL::ModelParam::Duplicate().

Referenced by BuildTrainingClassListFromDirectoryStructure().

{
  delete  modelParameters;
  modelParameters = _modelParameters->Duplicate ();
}

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

inline

Definition at line 199 of file TrainingConfiguration2.h.

{return  modelingMethod;}

static ModelTypes KKMLL::TrainingConfiguration2::ModelTypeFromStr ( const KKStr &  _modelTypeStr )

inlinestatic

Definition at line 178 of file TrainingConfiguration2.h.

References KKMLL::Model::ModelTypeFromStr().

{return  Model::ModelTypeFromStr (_modelTypeStr);}

KKStr KKMLL::TrainingConfiguration2::ModelTypeStr ( ) const

inline

Definition at line 200 of file TrainingConfiguration2.h.

References KKMLL::Model::ModelTypeToStr().

{return  Model::ModelTypeToStr (modelingMethod);}

static KKStr KKMLL::TrainingConfiguration2::ModelTypeToStr ( ModelTypes  _modelType )

inlinestatic

Definition at line 177 of file TrainingConfiguration2.h.

References KKMLL::Model::ModelTypeToStr().

Referenced by KKMLL::operator<<().

{return  Model::ModelTypeToStr   (_modelType);}

MLClassPtr KKMLL::TrainingConfiguration2::NoiseMLClass ( ) const

inline

Definition at line 201 of file TrainingConfiguration2.h.

{return  noiseMLClass;}

const TrainingClassPtr KKMLL::TrainingConfiguration2::NoiseTrainingClass ( ) const

inline

Definition at line 202 of file TrainingConfiguration2.h.

Referenced by KKMLL::TrainingProcess2::ExtractTrainingClassFeatures(), and LoadFeatureDataFromTrainingLibraries().

{return  noiseTrainingClass;}

bool TrainingConfiguration2::NormalizeNominalFeatures

(

)

Definition at line 1985 of file TrainingConfiguration2.cpp.

References KKMLL::ModelParam::NormalizeNominalFeatures().

Referenced by KKMLL::NormalizationParms::NormalizationParms().

{
  ModelParamOldSVMPtr oldSvmParameters = OldSvmParameters ();
  if  (oldSvmParameters)
    return oldSvmParameters->NormalizeNominalFeatures ();

  else if  (modelParameters)
    return modelParameters->NormalizeNominalFeatures ();

  else
    return false;
}  /* NormalizeNominalFeatures */

kkint32 TrainingConfiguration2::Number_of_rounds

(

)

const

Definition at line 1108 of file TrainingConfiguration2.cpp.

References KKMLL::ModelParam::ModelParamType(), KKMLL::ModelParamUsfCasCor::Number_of_rounds(), and KKMLL::ModelParam::UsfCasCor.

Referenced by NumOfRounds().

{
  if  (modelParameters  &&  (modelParameters->ModelParamType () == ModelParam::ModelParamTypes::UsfCasCor))
  {
    return  dynamic_cast<ModelParamUsfCasCor*>(modelParameters)->Number_of_rounds ();
  }
  else
  {
    return  -1;
  }
}

void TrainingConfiguration2::Number_of_rounds

(

kkint32

_number_of_rounds

)

Definition at line 1122 of file TrainingConfiguration2.cpp.

References KKMLL::ModelParam::ModelParamType(), KKMLL::ModelParamUsfCasCor::Number_of_rounds(), and KKMLL::ModelParam::UsfCasCor.

Referenced by NumOfRounds().

{
  if  (modelParameters  &&  (modelParameters->ModelParamType () == ModelParam::ModelParamTypes::UsfCasCor))
  {
    dynamic_cast<ModelParamUsfCasCor*>(modelParameters)->Number_of_rounds (_number_of_rounds);
  }
}

kkuint32 TrainingConfiguration2::NumHierarchialLevels

(

)

const

returns back the number of hierarchical levels thereare in the trainingClass that has the most.

Definition at line 491 of file TrainingConfiguration2.cpp.

{
  TrainingClassList::const_iterator  idx;

  kkuint16 numHierarchialLevels = 0;

  for  (idx = trainingClasses.begin ();  idx !=  trainingClasses.end ();  idx++)
  {
    TrainingClassPtr  tc = *idx;
    numHierarchialLevels = Max (numHierarchialLevels, tc->MLClass ()->NumHierarchialLevels ());
  }

  return  numHierarchialLevels;
}  /* NumHierarchialLevels */

kkint32 TrainingConfiguration2::NumOfFeaturesAfterEncoding

(

RunLog &

log

)

const

Definition at line 1318 of file TrainingConfiguration2.cpp.

References KKMLL::ModelParam::NumOfFeaturesAfterEncoding().

{
  if  (modelParameters)
    return modelParameters->NumOfFeaturesAfterEncoding (fileDesc, log);
  else
    return 0;
}  /* NumOfFeaturesAfterEncoding */

kkint32 KKMLL::TrainingConfiguration2::NumOfRounds ( ) const

inline

Definition at line 204 of file TrainingConfiguration2.h.

References Number_of_rounds().

{return  Number_of_rounds ();}

void KKMLL::TrainingConfiguration2::NumOfRounds ( kkint32  _numOfRounds )

inline

Definition at line 253 of file TrainingConfiguration2.h.

References Number_of_rounds().

{Number_of_rounds  (_numOfRounds);}

MLClassPtr KKMLL::TrainingConfiguration2::OtherClass ( ) const

inline

Definition at line 206 of file TrainingConfiguration2.h.

{return  otherClass;}

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

virtual

Definition at line 2766 of file TrainingConfiguration2.cpp.

References KKB::XmlStream::GetNextToken(), ReadXMLBaseToken(), and ReadXMLPost().

{
  fileDesc          = NULL;
  fvFactoryProducer = NULL;
  if  (mlClassesWeOwnIt)
    delete  mlClasses;
  mlClasses = NULL;
  otherClass = NULL;
  delete  noiseTrainingClass;  noiseTrainingClass = NULL;
  delete  subClassifiers;      subClassifiers     = NULL;
  trainingClasses.DeleteContents ();

  VectorKKStr*  subClassifierNameList = NULL;

  XmlTokenPtr t = s.GetNextToken (cancelFlag, log);
  while  (t  &&  (!cancelFlag))
  {
    t = ReadXMLBaseToken (t, cancelFlag, log);
    delete  t;
    if  (cancelFlag)
      t = NULL;
    else
      t = s.GetNextToken (cancelFlag, log);
  }
  delete t;
  t = NULL;
  if  (!cancelFlag)
    ReadXMLPost (cancelFlag, log);
}  /* ReadXML */

XmlTokenPtr TrainingConfiguration2::ReadXMLBaseToken ( XmlTokenPtr  t, VolConstBool &  cancelFlag, RunLog &  log  )

protected

KKKK modelParameters

Definition at line 2589 of file TrainingConfiguration2.cpp.

References KKB::KKStr::Concat(), KKB::KKStr::EqualIgnoreCase(), KKMLL::XmlElementMLClassNameList::TakeOwnership(), KKB::XmlToken::tokElement, KKB::XmlToken::TokenType(), KKB::XmlElementBool::Value(), KKB::XmlToken::VarName(), and KKB::XmlElement::VarName().

Referenced by 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  (typeid (*e) == typeid (XmlElementKKStr))
    {
      XmlElementKKStrPtr  s = dynamic_cast<XmlElementKKStrPtr> (e);
      if  (s  &&  s->Value ())
      {
        KKStrConstPtr   str = s->Value ();
        if  (varName.EqualIgnoreCase ("ConfigFileNameSpecified"))
          configFileNameSpecified = *str;

        else if  (varName.EqualIgnoreCase ("configRootName"))
          configRootName = *str;

        else if  (varName.EqualIgnoreCase ("FvFactoryProducer"))
          fvFactoryProducer = FactoryFVProducer::LookUpFactory (*str);

        else if  (varName.EqualIgnoreCase ("ModelingMethod"))
          modelingMethod = Model::ModelTypeFromStr (*str);

        else if  (varName.EqualIgnoreCase ("NoiseMLClass"))
          noiseMLClass = MLClass::CreateNewMLClass (*str);

        else if  (varName.EqualIgnoreCase ("otherClass"))
          otherClass = MLClass::CreateNewMLClass (*str);

        else if  (varName.EqualIgnoreCase ("RootDir"))
          rootDir = *str;

        else if  (varName.EqualIgnoreCase ("RootDirExpanded"))
          rootDirExpanded = *str;

        else
          tokenFound = false;
      }
      else
      {
        tokenFound = false;
      }
    }

    else if  (varName.EqualIgnoreCase  ("ExamplesPerClass"))
    {
      XmlElementInt32Ptr  i = dynamic_cast<XmlElementInt32Ptr> (e);
      if  (i)
        examplesPerClass = i->Value ();
    }

    else if  (varName.EqualIgnoreCase  ("MLClasses"))
    {
      XmlElementMLClassNameListPtr  listOfClasses = dynamic_cast<XmlElementMLClassNameListPtr> (e);
      if  (listOfClasses)
      {
        if  (mlClassesWeOwnIt)
          delete  mlClasses;
        mlClasses = listOfClasses->TakeOwnership ();
        mlClassesWeOwnIt = true;
      }
    }

    else if  (varName.EqualIgnoreCase  ("ModelParameters"))
    {
      /** KKKK
       modelParameters
      ***/
    }

    else if  (varName.EqualIgnoreCase  ("NoiseTrainingClass"))
    {
      XmlElementTrainingClassPtr  ntc = dynamic_cast<XmlElementTrainingClassPtr> (e);
      if  (ntc)
      {
        delete  noiseTrainingClass;
        noiseTrainingClass = NULL;
        noiseTrainingClass = ntc->TakeOwnership ();
      }
    }

    else if  (varName.EqualIgnoreCase  ("FvFactoryProducerSpecified"))
    {
      XmlElementBoolPtr  vBool = dynamic_cast<XmlElementBoolPtr> (e);
      if  (vBool)
        fvFactoryProducerSpecified = vBool->Value ();
    }

    else if  (varName.EqualIgnoreCase  ("ValidateDirectories"))
    {
      XmlElementBoolPtr  vd = dynamic_cast<XmlElementBoolPtr> (e);
      if  (vd)
        validateDirectories = vd->Value ();
    }

    else if  (varName.EqualIgnoreCase  ("TrainingClasses"))
    {
      XmlElementTrainingClassListPtr  tcl = dynamic_cast<XmlElementTrainingClassListPtr> (e);
      if  (tcl)
      {
        TrainingClassListPtr  xmlTrainClasses = tcl->TakeOwnership ();
        if  (xmlTrainClasses)
        {
          trainingClasses.DeleteContents ();
          while  (xmlTrainClasses->QueueSize () > 0)
          {
            TrainingClassPtr  tc = xmlTrainClasses->PopFromBack ();
            trainingClasses.PushOnFront (tc);
          }
          delete  xmlTrainClasses;
          xmlTrainClasses = NULL;
        }
      }
    }

    else if  (varName.EqualIgnoreCase  ("SubClassifiers"))
    {
      XmlElementVectorKKStrPtr  sc = dynamic_cast<XmlElementVectorKKStrPtr> (e);
      if  (sc)
      {
        delete subClassifierNameList;
        subClassifierNameList = sc->TakeOwnership ();
      }
    }

    else
    {
      tokenFound = false;
    }

    if  (tokenFound)
    {
      delete  t;
      t = NULL;
    }
  }

  return  t;
}  /* ReadXMLBaseToken */

void TrainingConfiguration2::ReadXMLPost ( VolConstBool &  cancelFlag, RunLog &  log  )

protected

Definition at line 2740 of file TrainingConfiguration2.cpp.

References DefaultFeatureVectorProducer(), KKB::KKStr::Empty(), KKMLL::FactoryFVProducer::FileDesc(), KKMLL::TrainingClass::SubClassifier(), and KKMLL::TrainingClass::SubClassifierName().

Referenced by ReadXML().

{
  if  (!fvFactoryProducer)
    fvFactoryProducer = DefaultFeatureVectorProducer (log);

  fileDesc = fvFactoryProducer->FileDesc ();
  
  TrainingClassList::iterator  idx;
  for  (idx = trainingClasses.begin ();  (idx != trainingClasses.end ())  &&  (!cancelFlag);  ++idx)
  {
    TrainingClassPtr  tc = *idx;
    if  (!tc->SubClassifierName ().Empty ())
    {
      bool  errorsFound = false;

      TrainingConfiguration2Ptr subClassifeir = 
           ValidateSubClassifier (tc->SubClassifierName (), errorsFound, log);
      tc->SubClassifier (subClassifeir);
    }
  }
}  /* ReadXMLPost */

void TrainingConfiguration2::RegisterFatory ( const KKStr &  className, Factory *  factory  )

static

Definition at line 2467 of file TrainingConfiguration2.cpp.

References KKB::GlobalGoalKeeper::EndBlock(), and KKB::GlobalGoalKeeper::StartBlock().

Referenced by FactoryInstace().

{
  GlobalGoalKeeper::StartBlock ();
  if  (!registeredFactories)
  {
    registeredFactories = new map<KKStr,Factory*> ();
    atexit (FinalCleanUp);
  }

  map<KKStr,Factory*>::const_iterator  idx;
  idx = registeredFactories->find (className);
  if  (idx == registeredFactories->end ())
    registeredFactories->insert (pair<KKStr,Factory*> (className, factory));
  else
  {
    cerr << endl << "TrainingConfiguration2::RegisterFatory   ***ERROR***   'TrainingConfiguration2::Factory with same name[" << className << "]" << endl << endl;
  }

  GlobalGoalKeeper::EndBlock ();
}

const KKStr& KKMLL::TrainingConfiguration2::RootDir ( ) const

inline

The root directory where Training library images are stored.

Definition at line 207 of file TrainingConfiguration2.h.

void TrainingConfiguration2::RootDir

(

const KKStr &

_rootDir

)

Definition at line 673 of file TrainingConfiguration2.cpp.

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

Referenced by CreateFromDirectoryStructure().

{
  rootDir = _rootDir;
  rootDirExpanded = KKB::osSubstituteInEnvironmentVariables (rootDir);
  trainingClasses.RootDir (rootDir);
}

KKStr TrainingConfiguration2::RootDirExpanded

(

)

const

Definition at line 469 of file TrainingConfiguration2.cpp.

{
  return rootDirExpanded;
}

void TrainingConfiguration2::Save ( const KKStr &  fileName ) const

virtual

Definition at line 665 of file TrainingConfiguration2.cpp.

Referenced by CreateFromDirectoryStructure().

{
  ofstream  o (fileName.Str ());
  Save (o);
  o.close ();
} /* Save */

virtual void KKMLL::TrainingConfiguration2::Save ( std::ostream &  o ) const

virtual

SVM_SelectionMethod TrainingConfiguration2::SelectionMethod

(

)

const

Definition at line 1162 of file TrainingConfiguration2.cpp.

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

{
  ModelParamOldSVMPtr  oldSVMparms = OldSvmParameters ();
  if  (oldSVMparms)
    return (SVM_SelectionMethod)oldSVMparms->SelectionMethod ();
  else
    return SVM_SelectionMethod::Null;
}  /* SelectionMethod */

void TrainingConfiguration2::SelectionMethod

(

SVM_SelectionMethod

_selectionMethod

)

Definition at line 1153 of file TrainingConfiguration2.cpp.

References KKMLL::ModelParamOldSVM::SelectionMethod().

{
  ModelParamOldSVMPtr  oldSVMparms = OldSvmParameters ();
  if  (oldSVMparms)
    oldSVMparms->SelectionMethod (_selectionMethod);
}  /* SelectionMethod */

void TrainingConfiguration2::SetBinaryClassFields	(	MLClassPtr	class1,
		MLClassPtr	class2,
		const SVM233::svm_parameter &	_param,
		const FeatureNumList &	_features,
		float	_weight
	)

Definition at line 1238 of file TrainingConfiguration2.cpp.

References KKMLL::ModelParamOldSVM::SetBinaryClassFields().

{
  ModelParamOldSVMPtr  oldSVMparms = OldSvmParameters ();
  if  (oldSVMparms)
    oldSVMparms->SetBinaryClassFields (class1, class2, _param, &_features, _weight);
}  /* SetBinaryClassFields */

void TrainingConfiguration2::SetFeatureNums

(

const FeatureNumList &

features

)

Definition at line 1173 of file TrainingConfiguration2.cpp.

References KKMLL::ModelParam::SelectedFeatures().

Referenced by CreateFromFeatureVectorList().

{
  if  (modelParameters)
    modelParameters->SelectedFeatures (features);
}  /* SetFeatureNums */

void TrainingConfiguration2::SetFeatureNums	(	MLClassPtr	class1,
		MLClassPtr	class2,
		const FeatureNumList &	_features,
		float	_weight = -1
	)

Definition at line 1179 of file TrainingConfiguration2.cpp.

References KKMLL::ModelParamOldSVM::SetFeatureNums().

{
  ModelParamOldSVMPtr  oldSVMparms = OldSvmParameters ();
  if  (oldSVMparms)
  {
    oldSVMparms->SetFeatureNums (class1, class2, &_features, _weight);
  }
}  /* SetFeatureNums */

void TrainingConfiguration2::SetModelParameters	(	ModelParamPtr	_svmParanters,
		kkint32	_examplesPerClass
	)

Definition at line 1359 of file TrainingConfiguration2.cpp.

References KKMLL::ModelParam::Duplicate().

{
  delete  modelParameters;
  modelParameters   = _svmParanters->Duplicate ();
  examplesPerClass  = _examplesPerClass;
}  /* SetModel3Parameters */

void TrainingConfiguration2::SetTrainingClasses

(

TrainingClassListPtr

_trainingClasses

)

Definition at line 1252 of file TrainingConfiguration2.cpp.

References EmptyTrainingClasses().

{
  EmptyTrainingClasses ();
  TrainingClassList::iterator  idx;

  for  (idx = _trainingClasses->begin ();  idx != _trainingClasses->end ();  idx++)
    AddATrainingClass (*idx);
}  /* SetTrainingClasses */

TrainingConfiguration2ListPtr KKMLL::TrainingConfiguration2::SubClassifiers ( ) const

inline

Definition at line 210 of file TrainingConfiguration2.h.

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

{return  subClassifiers;}

const SVMparam & TrainingConfiguration2::SVMparamREF

(

RunLog &

log

)

const

Definition at line 1020 of file TrainingConfiguration2.cpp.

References KKB::KKStr::Concat(), KKB::KKException::KKException(), and KKMLL::ModelParamOldSVM::SvmParameters().

{
  ModelParamOldSVMPtr  oldSVMparms = OldSvmParameters ();
  if  (oldSVMparms)
  {
    SVMparamPtr s =  oldSVMparms->SvmParameters ();
    return  *s;
  }
  else
  {
    KKStr  errMsg = "TrainingConfiguration2::SVMparamREF   ***ERROR***   (modelingMethod != mmOldSVM)";
    log.Level (-1) << endl << errMsg << endl << endl;
    throw new KKException (errMsg);
  }
}  /* SVMparam */

const TrainingClassList& KKMLL::TrainingConfiguration2::TrainingClasses ( ) const

inline

Definition at line 211 of file TrainingConfiguration2.h.

Referenced by BuildTrainingClassListFromDirectoryStructure(), and KKMLL::TrainingProcess2::ExtractTrainingClassFeatures().

{return  trainingClasses;}

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

Definition at line 2570 of file TrainingConfiguration2.cpp.

References KKB::XmlTag::AddAtribute(), KKB::KKStr::Empty(), KKB::XmlTag::tagEnd, KKB::XmlTag::tagStart, KKB::XmlTag::WriteXML(), WriteXMLFields(), and KKB::XmlTag::XmlTag().

Referenced by KKMLL::ModelDual::WriteXML(), and KKMLL::TrainingProcess2::WriteXML().

{
  XmlTag  startTag ("TrainingConfiguration2", XmlTag::TagTypes::tagStart);
  if  (!varName.Empty ())
    startTag.AddAtribute ("VarName", varName);
  startTag.WriteXML (o);
  o << endl;

  WriteXMLFields (o);

  XmlTag  endTag ("TrainingConfiguration2", XmlTag::TagTypes::tagEnd);
  endTag.WriteXML (o);
  o << endl;
}  /* WriteXML */

void TrainingConfiguration2::WriteXMLFields ( std::ostream &  o ) const

protected

To be used by both Base Class and Derived classes to write fields that are specific to 'TrainingConfiguration2'.

Definition at line 2513 of file TrainingConfiguration2.cpp.

References KKMLL::ModelParam::WriteXML(), KKB::XmlElementBool::WriteXML(), and KKMLL::XmlElementMLClassNameList::WriteXML().

Referenced by WriteXML().

{
  if  (!configFileNameSpecified.Empty ())
    XmlElementKKStr::WriteXML (configFileNameSpecified, "ConfigFileNameSpecified", o);

  if  (!configRootName.Empty ())
    XmlElementKKStr::WriteXML (configFileNameSpecified, "ConfigRootName", o);

  XmlElementInt32::WriteXML (examplesPerClass, "ExamplesPerClass", o);

  if  (fvFactoryProducer)
    XmlElementKKStr::WriteXML (fvFactoryProducer->Name (), "FvFactoryProducer", o);

  XmlElementBool::WriteXML (fvFactoryProducerSpecified, "FvFactoryProducerSpecified", o);

  if  (mlClasses)
    XmlElementMLClassNameList::WriteXML (*mlClasses, "MLClasses", o);

  XmlElementKKStr::WriteXML (Model::ModelTypeToStr (modelingMethod), "ModelingMethod", o);

  if  (modelParameters)
    modelParameters->WriteXML ("ModelParameters", o);

  if  (noiseMLClass)
    XmlElementKKStr::WriteXML (noiseMLClass->Name (), "NoiseMLClass", o);

  if  (noiseTrainingClass)
      XmlElementTrainingClass::WriteXML (*noiseTrainingClass, "NoiseTrainingClass", o);

   if  (otherClass)
    XmlElementKKStr::WriteXML (otherClass->Name (), "OtherClass", o);

  if  (!rootDir.Empty ())
    XmlElementKKStr::WriteXML (rootDir, "RootDir", o);

  if  (!rootDirExpanded.Empty ())
    XmlElementKKStr::WriteXML (rootDirExpanded, "RootDirExpanded", o);
  
  XmlElementBool::WriteXML (validateDirectories, "validateDirectories", o);

  trainingClasses.WriteXML ("TrainingClasses", o);

  if  (subClassifiers)
  {
    VectorKKStr  subClassifierList;
    TrainingConfiguration2List::const_iterator  idx;
    for  (idx = subClassifiers->begin (); idx != subClassifiers->end (); ++idx)
    {
      TrainingConfiguration2Ptr  sc = *idx;
      subClassifierList.push_back (sc->ConfigFileNameSpecified ());
    }
    XmlElementVectorKKStr::WriteXML (subClassifierList, "subClassifiers", o);
  }
}  /* WriteXMLFields */

Member Data Documentation

TrainingConfiguration2::Factory * TrainingConfiguration2::factoryInstace = NULL

static

Definition at line 532 of file TrainingConfiguration2.h.

Referenced by FactoryInstace().

---

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

• C:/Users/Kurt/GitHub/KSquareLibraries/KKMachineLearning/TrainingConfiguration2.h
• C:/Users/Kurt/GitHub/KSquareLibraries/KKMachineLearning/TrainingConfiguration2.cpp