Specify where training examples and other related data for a MLClass that is needed to train a classifier. More...

#include <TrainingClass.h>

Public Member Functions
	TrainingClass ()

	TrainingClass (const VectorKKStr &_directories, KKStr _name, float _weight, float _countFactor, TrainingConfiguration2Ptr _subClassifier, MLClassList &_mlClasses)
	Constructor, Creates a new instance of TrainingClass and populates fields with respective data from parameters. More...

	TrainingClass (const TrainingClass &tc)

void	AddDirectories (const VectorKKStr &_directories)

void	AddDirectory (const KKStr &_directory)

float	CountFactor () const

void	CountFactor (float _countFactor)

const VectorKKStr &	Directories () const

const KKStr &	Directory (kkuint32 idx) const

void	Directory (kkuint32 idx, const KKStr &directory)

kkuint32	DirectoryCount () const

KKStr	ExpandedDirectory (const KKStr &rootDir, kkuint32 idx)

const KKStr &	FeatureFileName () const

void	FeatureFileName (const KKStr &_featureFileName)

const MLClassPtr	MLClass () const

void	MLClass (MLClassPtr _mlClass)

const KKStr &	Name () const

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

TrainingConfiguration2Ptr	SubClassifier () const

void	SubClassifier (TrainingConfiguration2Ptr _subClassifier)

const KKStr &	SubClassifierName () const

void	SubClassifierName (const KKStr &_subClassifierName)

float	Weight () const

void	Weight (float _weight)

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

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

Detailed Description

Specify where training examples and other related data for a MLClass that is needed to train a classifier.

You create one instance of this object for each MLClass instance that you want to include in a classifier. Each instance will tie a class to the directories where you can find training examples. Other info that is included is 'CountFator', training Weight, dun-classifier that is to be used to further define the prediction.

Definition at line 38 of file TrainingClass.h.

Constructor & Destructor Documentation

TrainingClass::TrainingClass ( )

Definition at line 24 of file TrainingClass.cpp.

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

                              :
      countFactor     (0.0f),
      directories     (),
      featureFileName (),
      mlClass         (NULL),
      subClassifier   (NULL),
      weight          (0.0f)
 {
 }

TrainingClass::TrainingClass	(	const VectorKKStr &	_directories,
		KKStr	_name,
		float	_weight,
		float	_countFactor,
		TrainingConfiguration2Ptr	_subClassifier,
		MLClassList &	_mlClasses
	)

Constructor, Creates a new instance of TrainingClass and populates fields with respective data from parameters.

Parameters

[in]	_directories	A list of directories where training examples for class '_name' can be found.
[in]	_name	The name of the class that this'TrainingClass' instance will be pointing to.
[in]	_weight	You can give extra weight to a class with this parameter; its impact/use varies with particular algorithm(Model) used.
[in]	_countFactor
[in]	_subClassifier	If not NULL points to the configuration that is to be used if this class is predicted. This is how multi-level classifier is implemented.
[in,out]	_mlClasses	List of classes.

Definition at line 35 of file TrainingClass.cpp.

References KKMLL::MLClass::CountFactor(), KKMLL::MLClassList::GetMLClassPtr(), KKB::KKStr::KKStr(), and KKB::VectorKKStr::VectorKKStr().

Referenced by KKMLL::TrainingConfiguration2::AddATrainingClass(), KKMLL::TrainingConfiguration2::GenerateAConfiguraionForAHierarchialLevel(), and KKMLL::TrainingConfiguration2::TrainingConfiguration2().

                               :
                 countFactor     (_countFactor),
                 directories     (_directories),
                 featureFileName (_name),
                 mlClass         (NULL),
                 weight          (_weight),
                 subClassifier   (_subClassifier)
 {
   featureFileName << ".data";   // Will be equal to ClassName + ".data".     ex:  "Copepods.data"
 
   mlClass = _mlClasses.GetMLClassPtr (_name);
   mlClass->CountFactor (_countFactor);
 }

TrainingClass::TrainingClass ( const TrainingClass & tc )

Definition at line 57 of file TrainingClass.cpp.

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

                                                      : 
     countFactor     (tc.countFactor),
     directories     (tc.directories),
     featureFileName (tc.featureFileName),
     mlClass         (tc.mlClass),
     subClassifier   (NULL),
     weight          (tc.weight)
 {
 }

Member Function Documentation

void TrainingClass::AddDirectories ( const VectorKKStr & _directories )

Definition at line 103 of file TrainingClass.cpp.

 {
   VectorKKStr::const_iterator  idx;
   for  (idx = _directories.begin ();  idx != _directories.end ();  ++idx)
     AddDirectory (*idx);
 }

void TrainingClass::AddDirectory ( const KKStr & _directory )

Definition at line 96 of file TrainingClass.cpp.

 {
   directories.push_back (_directory);
 }

float KKMLL::TrainingClass::CountFactor ( ) const

inline

Definition at line 65 of file TrainingClass.h.

65 {return countFactor;}

void KKMLL::TrainingClass::CountFactor ( float _countFactor )

inline

Definition at line 84 of file TrainingClass.h.

84 {countFactor = _countFactor;}

const VectorKKStr& KKMLL::TrainingClass::Directories ( ) const

inline

Definition at line 68 of file TrainingClass.h.

Referenced by KKMLL::TrainingConfiguration2::GenerateAConfiguraionForAHierarchialLevel().

68 {return directories;}

const KKStr & TrainingClass::Directory ( kkuint32 idx ) const

Definition at line 79 of file TrainingClass.cpp.

 {
   if  (idx >= directories.size ())
     return KKStr::EmptyStr();
   else
     return  directories[idx];
 }

void TrainingClass::Directory	(	kkuint32	idx,
		const KKStr &	directory
	)

Definition at line 113 of file TrainingClass.cpp.

 {
   while  (idx >= directories.size ())
     directories.push_back ("");
   directories[idx] = directory;
 }

kkuint32 TrainingClass::DirectoryCount ( ) const

Definition at line 88 of file TrainingClass.cpp.

Referenced by KKMLL::TrainingClassList::LocateByDirectory().

 {
   return  directories.size ();
 }

KKStr TrainingClass::ExpandedDirectory	(	const KKStr &	rootDir,
		kkuint32	idx
	)

Definition at line 124 of file TrainingClass.cpp.

References KKB::KKStr::Concat(), KKB::KKStr::Empty(), KKB::KKStr::FirstChar(), KKMLL::MLClass::Name(), KKB::KKStr::operator+(), KKB::KKStr::operator=(), KKB::KKStr::operator[](), KKB::osAddSlash(), and KKB::osSubstituteInEnvironmentVariables().

Referenced by KKMLL::TrainingConfiguration2::BuildTrainingClassListFromDirectoryStructure(), KKMLL::TrainingConfiguration2::DirectoryPathForClass(), and KKMLL::TrainingClassList::LocateByDirectory().

 {
   KKStr  rootDirWithSlash = "";
   if  (!rootDir.Empty ())
     rootDirWithSlash = osAddSlash (rootDir);
 
   KKStr  directory = "";
 
   if  (idx >= directories.size ())
     return  KKStr::EmptyStr ();
 
   directory = directories[idx];
 
   if  (directory.Empty ())
   {
     directory = rootDirWithSlash + mlClass->Name ();
     return  directory;
   }
 
   directory = osSubstituteInEnvironmentVariables (directory);
 
   char  firstChar = directory.FirstChar ();
   if  ((firstChar == '/')  ||  (firstChar == '\\'))
     return  directory;
 
   if  (directory[1] == ':')
     return directory;
 
   return osSubstituteInEnvironmentVariables (rootDirWithSlash + directory);
 }  /* ExpandedDirectory */

const KKStr& KKMLL::TrainingClass::FeatureFileName ( ) const

inline

Definition at line 69 of file TrainingClass.h.

Referenced by KKMLL::TrainingConfiguration2::BuildTrainingClassListFromDirectoryStructure().

69 {return featureFileName;}

void KKMLL::TrainingClass::FeatureFileName ( const KKStr & _featureFileName )

inline

Definition at line 85 of file TrainingClass.h.

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

Referenced by KKMLL::TrainingConfiguration2::BuildTrainingClassListFromDirectoryStructure().

85 {featureFileName = _featureFileName;}

const MLClassPtr KKMLL::TrainingClass::MLClass ( ) const

inline

Definition at line 70 of file TrainingClass.h.

Referenced by KKMLL::TrainingConfiguration2::BuildTrainingClassListFromDirectoryStructure(), KKMLL::TrainingConfiguration2::DirectoryPathForClass(), KKMLL::TrainingConfiguration2::GenerateAConfiguraionForAHierarchialLevel(), and KKMLL::TrainingClassList::LocateByMLClass().

70 {return mlClass;}

void KKMLL::TrainingClass::MLClass ( MLClassPtr _mlClass )

inline

Definition at line 86 of file TrainingClass.h.

Referenced by KKMLL::TrainingConfiguration2::BuildTrainingClassListFromDirectoryStructure().

86 {mlClass = _mlClass;}

const KKStr & TrainingClass::Name ( ) const

Definition at line 71 of file TrainingClass.cpp.

References KKMLL::MLClass::Name().

 {
   return  mlClass->Name ();
 }

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

virtual

Definition at line 239 of file TrainingClass.cpp.

References KKB::KKStr::EqualIgnoreCase(), KKB::XmlStream::GetNextToken(), and KKB::XmlToken::VarName().

 {
   directories.clear ();
   for  (auto idx:  tag->Attributes ())
   {
     const KKStr&  n = idx->Name ();
     const KKStr&  v = idx->Value ();
 
     if  (n.EqualIgnoreCase ("MLClass"))
       MLClass (MLClass::CreateNewMLClass (v));
 
     else if  (n.EqualIgnoreCase ("FeatureFileName"))
        FeatureFileName (v);
 
     else if  (n.EqualIgnoreCase ("Weight"))
       Weight (v.ToFloat ());
 
     else if  (n.EqualIgnoreCase ("CountFactor"))
       CountFactor (v.ToFloat ());
 
     else if  (n.EqualIgnoreCase ("SubClassifier"))
       SubClassifierName (v);
   }
 
   XmlTokenPtr  t = s.GetNextToken (cancelFlag, log);
   while  (t  &&  (!cancelFlag))
   {
     if  ((t->VarName ().EqualIgnoreCase ("Directory"))  &&  (typeid (*t) ==  typeid (XmlElementKKStr)))
     {
       XmlElementKKStrPtr xmlS = dynamic_cast<XmlElementKKStrPtr> (t);
       if  (xmlS  &&  xmlS->Value ())
       {
         directories.push_back (*(xmlS->Value ()));
       }
     }
 
     delete  t;
     t = s.GetNextToken (cancelFlag, log);
   }
   delete  t;
   t = NULL;
 }  /* ReadXML */

TrainingConfiguration2Ptr KKMLL::TrainingClass::SubClassifier ( ) const

inline

Definition at line 72 of file TrainingClass.h.

Referenced by KKMLL::TrainingConfiguration2::ExtractFullHierachyOfClasses().

72 {return subClassifier;}

void KKMLL::TrainingClass::SubClassifier ( TrainingConfiguration2Ptr _subClassifier )

inline

Definition at line 87 of file TrainingClass.h.

Referenced by KKMLL::TrainingConfiguration2::ReadXMLPost().

87 {subClassifier = _subClassifier;}

const KKStr& KKMLL::TrainingClass::SubClassifierName ( ) const

inline

Definition at line 73 of file TrainingClass.h.

Referenced by KKMLL::TrainingConfiguration2::ReadXMLPost().

73 {return subClassifierName;}

void KKMLL::TrainingClass::SubClassifierName ( const KKStr & _subClassifierName )

inline

Definition at line 88 of file TrainingClass.h.

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

88 {subClassifierName = _subClassifierName;}

float KKMLL::TrainingClass::Weight ( ) const

inline

Definition at line 75 of file TrainingClass.h.

75 {return weight;}

void KKMLL::TrainingClass::Weight ( float _weight )

inline

Definition at line 89 of file TrainingClass.h.

89 {weight = _weight;}

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

virtual

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

virtual

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

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

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

Public Member Functions

Detailed Description

Constructor & Destructor Documentation

Member Function Documentation