Abstract Base class for Machine Learning parameters. More...

#include <ModelParam.h>

Inheritance diagram for KKMLL::ModelParam:

Public Types
enum	EncodingMethodType { EncodingMethodType::Null, EncodingMethodType::NoEncoding, EncodingMethodType::Binary, EncodingMethodType::Scaled }

typedef ModelParam *	ModelParamPtr

enum	ModelParamTypes { ModelParamTypes::Null, ModelParamTypes::Dual, ModelParamTypes::KNN, ModelParamTypes::OldSVM, ModelParamTypes::SvmBase, ModelParamTypes::UsfCasCor }

Public Member Functions
	ModelParam ()

	ModelParam (const ModelParam &_param)

virtual	~ModelParam ()

virtual float	A_Param () const

virtual void	A_Param (float _prob)

virtual float	AvgMumOfFeatures () const

virtual double	C_Param () const

virtual void	C_Param (double _cost)

virtual double	Cost () const

virtual void	Cost (double _cost)

virtual ModelParamPtr	Duplicate () const =0

virtual EncodingMethodType	EncodingMethod () const

virtual void	EncodingMethod (EncodingMethodType _encodingMethod)

virtual KKStr	EncodingMethodStr () const

virtual kkint32	ExamplesPerClass () const

virtual void	ExamplesPerClass (kkint32 _examplesPerClass)

virtual const KKStr &	FileName () const

virtual void	FileName (const KKStr &_fileName)

virtual double	Gamma () const

virtual void	Gamma (double _gamma)

virtual kkint32	MemoryConsumedEstimated () const

virtual ModelParamTypes	ModelParamType () const =0

virtual KKStr	ModelParamTypeStr () const

virtual bool	NormalizeNominalFeatures () const

virtual kkint32	NumOfFeaturesAfterEncoding (FileDescPtr fileDesc, RunLog &log) const

virtual void	ParseCmdLine (KKStr _cmdLineStr, bool &_validFormat, RunLog &_log)

virtual void	ParseCmdLinePost (RunLog &log)
	Called after 'ParseCmdLine' is completed. Classed derived from 'ModelParam' can implement this method to do any processing that they want after the entire command line has been processed. More...

virtual float	Prob () const

virtual void	Prob (float _prob)

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

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

virtual FeatureNumListConstPtr	SelectedFeatures () const

virtual void	SelectedFeatures (FeatureNumListConst &_selectedFeatures)

virtual KKStr	ToCmdLineStr () const
	Creates a a Command Line String that represents these parameters. More...

virtual bool	ValidParam () const

virtual void	ValidParam (bool _validParam)

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

void	WriteXMLFields (std::ostream &o) const

Static Public Member Functions
static EncodingMethodType	EncodingMethodFromStr (const KKStr &encodingMethodStr)

static KKStr	EncodingMethodToStr (EncodingMethodType encodingMethod)

static ModelParamTypes	ModelParamTypeFromStr (const KKStr &_modelParamTypeStr)

static KKStr	ModelParamTypeToStr (ModelParamTypes _modelParamType)

Detailed Description

Abstract Base class for Machine Learning parameters.

Author: Kurt Kramer

For each Machine Learning algorithm implemented you would create a specialization of this class to manage the parameters required by the algorithm. Specifically for each new class that you create that is derived from 'Model' you will create a class derived from 'ModelParam'. This class encapsulates general parameters that are common to all Machine Learning Models.

See also: Model

Definition at line 35 of file ModelParam.h.

Member Typedef Documentation

typedef ModelParam* KKMLL::ModelParam::ModelParamPtr

Definition at line 38 of file ModelParam.h.

Member Enumeration Documentation

enum KKMLL::ModelParam::EncodingMethodType

strong

Needs to be synchronized with SVMparam::SVM_EncodingMethod

Enumerator
Null
NoEncoding
Binary
Scaled

Definition at line 56 of file ModelParam.h.

     {
       Null,
       NoEncoding,
       Binary,
       Scaled
     };

enum KKMLL::ModelParam::ModelParamTypes

strong

Enumerator
Null
Dual
KNN
OldSVM
SvmBase
UsfCasCor

Definition at line 40 of file ModelParam.h.

Constructor & Destructor Documentation

ModelParam::ModelParam ( )

Definition at line 31 of file ModelParam.cpp.

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

Referenced by KKMLL::ModelParamDual::ModelParamDual(), KKMLL::ModelParamKnn::ModelParamKnn(), KKMLL::ModelParamOldSVM::ModelParamOldSVM(), KKMLL::ModelParamSvmBase::ModelParamSvmBase(), and KKMLL::ModelParamUsfCasCor::ModelParamUsfCasCor().

                         :
 
   encodingMethod            (EncodingMethodType::NoEncoding),
   examplesPerClass          (int32_max),
   fileName                  (),
   normalizeNominalFeatures  (false),
   selectedFeatures          (NULL), 
   validParam                (true),
   // SVM related parameters
   cost                      (0.0),
   gamma                     (0.0),
   prob                      (0.0f)
 {
   /*
   if  (!fileDesc)
   {
     log.Level (-1) << endl
                    << "ModelParam::ModelParam      *** ERROR ***" << endl
                    << "                       fileDesc == NULL" << endl
                    << endl;
     osWaitForEnter ();
     exit (-1);
   }
   */
 }

ModelParam::ModelParam ( const ModelParam & _param )

Definition at line 61 of file ModelParam.cpp.

References KKMLL::FeatureNumList::FeatureNumList(), and KKB::KKStr::KKStr().

Referenced by KKMLL::ModelParamDual::ModelParamDual(), KKMLL::ModelParamKnn::ModelParamKnn(), KKMLL::ModelParamOldSVM::ModelParamOldSVM(), and KKMLL::ModelParamSvmBase::ModelParamSvmBase().

                                                  :
 
   encodingMethod             (_param.encodingMethod),
   examplesPerClass           (_param.examplesPerClass),
   fileName                   (_param.fileName),
   normalizeNominalFeatures   (_param.normalizeNominalFeatures),
   selectedFeatures           (NULL),
   validParam                 (_param.validParam),
   // SVM related parameters
   cost                       (_param.cost),
   gamma                      (_param.gamma),
   prob                       (_param.prob)
 {
   if  (_param.selectedFeatures)
     selectedFeatures = new FeatureNumList (*(_param.selectedFeatures));
 }

ModelParam::~ModelParam ( )

virtual

Definition at line 80 of file ModelParam.cpp.

 {
   delete  selectedFeatures;
   selectedFeatures = NULL;
 }

Member Function Documentation

float ModelParam::A_Param ( ) const

virtual

Reimplemented in KKMLL::ModelParamOldSVM.

Definition at line 172 of file ModelParam.cpp.

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

 {
   return  prob;
 }

void ModelParam::A_Param ( float _prob )

virtual

Reimplemented in KKMLL::ModelParamOldSVM.

Definition at line 201 of file ModelParam.cpp.

Referenced by KKMLL::ModelParamOldSVM::A_Param(), KKMLL::TrainingConfiguration2::A_Param(), and KKMLL::ModelParamOldSVM::ParseCmdLine().

 {
   prob = _prob;
 }

float ModelParam::AvgMumOfFeatures ( ) const

virtual

Definition at line 99 of file ModelParam.cpp.

References KKMLL::FeatureNumList::NumOfFeatures().

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

 {
   if  (selectedFeatures)
     return   (float)selectedFeatures->NumOfFeatures ();
   else
     return  0;
 }

double ModelParam::C_Param ( ) const

virtual

Reimplemented in KKMLL::ModelParamOldSVM.

Definition at line 177 of file ModelParam.cpp.

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

 {
   return cost;
 }

void ModelParam::C_Param ( double _cost )

virtual

Reimplemented in KKMLL::ModelParamOldSVM.

Definition at line 207 of file ModelParam.cpp.

Referenced by KKMLL::TrainingConfiguration2::C_Param(), and KKMLL::ModelParamOldSVM::ParseCmdLine().

 {
   cost = _cost;
 }

double ModelParam::Cost ( ) const

virtual

Reimplemented in KKMLL::ModelParamSvmBase.

Definition at line 182 of file ModelParam.cpp.

 {
   return cost;
 }

void ModelParam::Cost ( double _cost )

virtual

Reimplemented in KKMLL::ModelParamSvmBase.

Definition at line 213 of file ModelParam.cpp.

Referenced by KKMLL::ModelParamOldSVM::C_Param(), KKMLL::ModelParamSvmBase::Cost(), and ParseCmdLine().

 {
   cost = _cost;
 }

virtual ModelParamPtr KKMLL::ModelParam::Duplicate ( ) const

pure virtual

Implemented in KKMLL::ModelParamDual, KKMLL::ModelParamOldSVM, KKMLL::ModelParamSvmBase, KKMLL::ModelParamUsfCasCor, and KKMLL::ModelParamKnn.

Referenced by KKMLL::Model::Model(), KKMLL::TrainingConfiguration2::ModelParameters(), KKMLL::TrainingConfiguration2::SetModelParameters(), and KKMLL::TrainingConfiguration2::TrainingConfiguration2().

virtual EncodingMethodType KKMLL::ModelParam::EncodingMethod ( ) const

inlinevirtual

Definition at line 111 of file ModelParam.h.

Referenced by KKMLL::FeatureEncoder2::FeatureEncoder2(), KKMLL::Model::NormalizeNominalAttributes(), NumOfFeaturesAfterEncoding(), and KKMLL::Model::TrainModel().

111 {return encodingMethod;}

virtual void KKMLL::ModelParam::EncodingMethod ( EncodingMethodType _encodingMethod )

inlinevirtual

Reimplemented in KKMLL::ModelParamOldSVM.

Definition at line 128 of file ModelParam.h.

Referenced by KKMLL::ModelParamOldSVM::EncodingMethod(), KKMLL::TrainingConfiguration2::EncodingMethod(), and KKMLL::ModelParamOldSVM::ParseCmdLine().

128 {encodingMethod = _encodingMethod;}

ModelParam::EncodingMethodType ModelParam::EncodingMethodFromStr ( const KKStr & encodingMethodStr )

static

Definition at line 444 of file ModelParam.cpp.

References Binary, KKB::KKStr::Concat(), NoEncoding, Null, KKB::KKStr::operator==(), Scaled, and KKB::KKStr::ToUpper().

Referenced by ParseCmdLine(), and ReadXMLModelParamToken().

 {
   KKStr  encodingMethodUpper = encodingMethodStr.ToUpper ();
 
   if  ((encodingMethodUpper == "BINARY")  ||  (encodingMethodUpper == "BIN"))
      return  EncodingMethodType::Binary;
 
   if  (encodingMethodUpper == "SCALE")
      return  EncodingMethodType::Scaled;
 
   if  (encodingMethodUpper == "NONE")
     return  EncodingMethodType::NoEncoding;
 
   return  EncodingMethodType::Null;
 }  /* EncodingMethodFromStr */

virtual KKStr KKMLL::ModelParam::EncodingMethodStr ( ) const

inlinevirtual

Definition at line 112 of file ModelParam.h.

References EncodingMethodToStr().

112 {return EncodingMethodToStr (encodingMethod);}

KKMLL::ModelParam::EncodingMethodToStr

static KKStr EncodingMethodToStr(EncodingMethodType encodingMethod)

Definition: ModelParam.cpp:428

KKStr ModelParam::EncodingMethodToStr ( EncodingMethodType encodingMethod )

static

Definition at line 428 of file ModelParam.cpp.

References Binary, and Scaled.

Referenced by EncodingMethodStr(), ToCmdLineStr(), and WriteXMLFields().

 {
   if  (encodingMethod == EncodingMethodType::Binary)
     return  "Binary";
 
   else if  (encodingMethod == EncodingMethodType::Scaled)
     return  "Scale";
 
   else
     return  "None";
 }  /* EncodingMethodToStr */

virtual kkint32 KKMLL::ModelParam::ExamplesPerClass ( ) const

inlinevirtual

Definition at line 113 of file ModelParam.h.

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

113 {return examplesPerClass;}

virtual void KKMLL::ModelParam::ExamplesPerClass ( kkint32 _examplesPerClass )

inlinevirtual

Definition at line 129 of file ModelParam.h.

129 {examplesPerClass = _examplesPerClass;}

virtual const KKStr& KKMLL::ModelParam::FileName ( ) const

inlinevirtual

Definition at line 114 of file ModelParam.h.

114 {return fileName;}

virtual void KKMLL::ModelParam::FileName ( const KKStr & _fileName )

inlinevirtual

Definition at line 130 of file ModelParam.h.

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

130 {fileName = _fileName;}

double ModelParam::Gamma ( ) const

virtual

Reimplemented in KKMLL::ModelParamOldSVM, and KKMLL::ModelParamSvmBase.

Definition at line 187 of file ModelParam.cpp.

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

 {
   return  gamma;
 }

void ModelParam::Gamma ( double _gamma )

virtual

Reimplemented in KKMLL::ModelParamOldSVM, and KKMLL::ModelParamSvmBase.

Definition at line 219 of file ModelParam.cpp.

Referenced by KKMLL::ModelParamSvmBase::Gamma(), KKMLL::ModelParamOldSVM::Gamma(), KKMLL::TrainingConfiguration2::Gamma(), KKMLL::ModelParamOldSVM::Gamma_Param(), ParseCmdLine(), and KKMLL::ModelParamOldSVM::ParseCmdLine().

 {
   gamma = _gamma;
 }

kkint32 ModelParam::MemoryConsumedEstimated ( ) const

virtual

Definition at line 87 of file ModelParam.cpp.

References KKMLL::FeatureNumList::MemoryConsumedEstimated(), and KKB::KKStr::MemoryConsumedEstimated().

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

 {
   kkint32  memoryConsumedEstimated = sizeof (ModelParam)
     +  fileName.MemoryConsumedEstimated ();
 
   if  (selectedFeatures)
     memoryConsumedEstimated += selectedFeatures->MemoryConsumedEstimated ();
   return  memoryConsumedEstimated;
 }

virtual ModelParamTypes KKMLL::ModelParam::ModelParamType ( ) const

pure virtual

Implemented in KKMLL::ModelParamDual, KKMLL::ModelParamOldSVM, KKMLL::ModelParamSvmBase, KKMLL::ModelParamUsfCasCor, and KKMLL::ModelParamKnn.

Referenced by ModelParamTypeStr(), KKMLL::TrainingConfiguration2::Number_of_rounds(), KKMLL::ModelOldSVM::Param(), and KKMLL::TrainingConfiguration2::TrainingConfiguration2().

ModelParam::ModelParamTypes ModelParam::ModelParamTypeFromStr ( const KKStr & _modelParamTypeStr )

static

Definition at line 148 of file ModelParam.cpp.

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

 {
   if  (_modelParamTypeStr.EqualIgnoreCase ("ModelParamDual"))
     return ModelParamTypes::Dual;
 
   else if  (_modelParamTypeStr.EqualIgnoreCase ("ModelParamOldSVM"))
     return ModelParamTypes::OldSVM;
 
   else if  (_modelParamTypeStr.EqualIgnoreCase ("ModelParamSvmBase"))
     return ModelParamTypes::SvmBase;
 
   else if  (_modelParamTypeStr.EqualIgnoreCase ("ModelParamKnn"))
     return ModelParamTypes::KNN;
 
   else if  (_modelParamTypeStr.EqualIgnoreCase ("UsfCasCor"))
     return ModelParamTypes::UsfCasCor;
 
   else
     return ModelParamTypes::Null;
 }

virtual KKStr KKMLL::ModelParam::ModelParamTypeStr ( ) const

inlinevirtual

Definition at line 108 of file ModelParam.h.

References ModelParamType(), and ModelParamTypeToStr().

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

108 {return ModelParamTypeToStr (ModelParamType ());}

KKMLL::ModelParam::ModelParamTypeToStr

static KKStr ModelParamTypeToStr(ModelParamTypes _modelParamType)

Definition: ModelParam.cpp:122

KKMLL::ModelParam::ModelParamType

virtual ModelParamTypes ModelParamType() const =0

KKStr ModelParam::ModelParamTypeToStr ( ModelParamTypes _modelParamType )

static

Definition at line 122 of file ModelParam.cpp.

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

Referenced by ModelParamTypeStr().

 {
   if  (_modelParamType == ModelParamTypes::Null)
     return "NULL";
   
   else if  (_modelParamType == ModelParamTypes::Dual)
     return "ModelParamDual";
 
   else if  (_modelParamType == ModelParamTypes::KNN)
     return "ModelParamKnn";
 
   else if  (_modelParamType == ModelParamTypes::OldSVM)
     return "ModelParamOldSVM";
   
   else if  (_modelParamType == ModelParamTypes::SvmBase)
     return "ModelParamSvmBase";
 
   else if  (_modelParamType == ModelParamTypes::UsfCasCor)
     return  "UsfCasCor";
 
   else
     return "NULL";
 }

virtual bool KKMLL::ModelParam::NormalizeNominalFeatures ( ) const

inlinevirtual

Definition at line 115 of file ModelParam.h.

Referenced by KKMLL::NormalizationParms::NormalizationParms(), and KKMLL::TrainingConfiguration2::NormalizeNominalFeatures().

115 {return normalizeNominalFeatures;}

kkint32 ModelParam::NumOfFeaturesAfterEncoding	(	FileDescPtr	fileDesc,
		RunLog &	log
	)		const

virtual

Reimplemented in KKMLL::ModelParamOldSVM.

Definition at line 387 of file ModelParam.cpp.

References Binary, KKMLL::FileDesc::Cardinality(), EncodingMethod(), KKMLL::FeatureNumList::FeatureNumList(), NoEncoding, KKMLL::Nominal, KKMLL::FeatureNumList::NumOfFeatures(), KKMLL::FeatureNumList::operator[](), Scaled, KKMLL::Symbolic, and KKMLL::FileDesc::Type().

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

 {
   kkint32 z;
   kkint32 numFeaturesAfterEncoding = 0;
 
   if  (!selectedFeatures)
     selectedFeatures = new FeatureNumList (fileDesc);
 
   kkint32 numOfFeaturesSelected = selectedFeatures->NumOfFeatures ();
 
   switch (EncodingMethod ())
   {
   case EncodingMethodType::Binary:
     for  (z = 0; z < numOfFeaturesSelected; z++)
     {
       kkint32  fieldNum = (*selectedFeatures)[z];
       if  ((fileDesc->Type (fieldNum) == AttributeType::Nominal)  ||
            (fileDesc->Type (fieldNum) == AttributeType::Symbolic)
           )
         numFeaturesAfterEncoding += fileDesc->Cardinality (fieldNum);
       else
         numFeaturesAfterEncoding ++;
     }
     break;
 
   case EncodingMethodType::Scaled:
   case EncodingMethodType::NoEncoding:
   default:
     //numFeaturesAfterEncoding = fileDesc->NumOfFields ( );
     numFeaturesAfterEncoding = selectedFeatures->NumOfFeatures ();
     break;
   }
 
   return  numFeaturesAfterEncoding;
 }  // NumOfFeaturesAfterEncoding 

void ModelParam::ParseCmdLine	(	KKStr	_cmdLineStr,
		bool &	_validFormat,
		RunLog &	_log
	)

virtual

Reimplemented in KKMLL::ModelParamOldSVM.

Definition at line 234 of file ModelParam.cpp.

References KKB::KKStr::Concat(), Cost(), KKB::KKStr::Empty(), EncodingMethodFromStr(), KKB::KKStr::EqualIgnoreCase(), KKB::KKStr::ExtractToken(), KKB::KKStr::ExtractTokenBool(), KKMLL::FeatureNumList::FeatureNumList(), KKB::KKStr::FirstChar(), Gamma(), KKB::KKStr::KKStr(), KKB::KKStr::Len(), KKB::KKStr::operator=(), KKB::KKStr::operator==(), ParseCmdLinePost(), KKB::KKStr::ToInt(), KKB::KKStr::TrimLeft(), and KKB::KKStr::Upper().

 {
   _validFormat = true;
 
   //DecodeParamStr (_cmdLineStr, param);
 
   KKStr  field (_cmdLineStr.ExtractToken (" \t\n\r"));
   KKStr  value;
 
   double  valueNum;
 
   while  (!field.Empty ()  &&  _validFormat)
   {
     if  (field.FirstChar () != '-')
     {
       _log.Level (-1) << "ModelParam::ParseCmdLine  *** Invalid Parameter["
         << field << "] ***"
         << endl;
       _validFormat = false;
       break;
     }
 
     // See if next field is a Switch field or a parameter.
     _cmdLineStr.TrimLeft (" \t\n\r");
     value == "";
     if  (_cmdLineStr.Len () > 0)
     {
       if  (_cmdLineStr.FirstChar () != '-')
         value = _cmdLineStr.ExtractToken (" \t\n\r");
     }
 
     valueNum = atof (value.Str ()); 
 
     field.Upper ();
     KKStr valueUpper (value);
 
     valueUpper.Upper ();
 
     if  ((field == "-FS")  ||  (field == "-FEATURESSELECTED")  ||  (field == "-FEATURESSEL")  ||  (field == "FEATURESEL"))
     {
       delete  selectedFeatures;
       bool  valid = true;
       selectedFeatures = new FeatureNumList (value, valid);
       if  (!selectedFeatures)
         _validFormat= false;
     }
 
     else if  (field.EqualIgnoreCase ("-C")  ||  field.EqualIgnoreCase ("-Cost"))
     {
       Cost (valueNum);
     }
 
     else if ((field == "-ENCODE"))
     {
       encodingMethod = EncodingMethodFromStr (valueUpper);
     }
 
     else if  ((field.EqualIgnoreCase ("-EPC"))  ||  
               (field.EqualIgnoreCase ("-ExamplesPerClass"))
              )
     {
       examplesPerClass = value.ToInt ();
       if  (examplesPerClass < 1)
       {
         _log.Level (-1) 
           << endl << endl
           << "ModelParam::ParseCmdLine ***ERROR***  Invalid '-ExamplsPerClass' parameter specified[" << value << "]" << endl
           << endl;
         _validFormat = false;
         examplesPerClass = int32_max;
         break;
       }
     }
 
     else if  (field.EqualIgnoreCase ("-G")  ||  field.EqualIgnoreCase ("-Gamma"))
     {
       Gamma (valueNum);
     }
 
     else if  ((field.EqualIgnoreCase ("-NormNominal"))               ||
               (field.EqualIgnoreCase ("-NormalizeNominal"))          ||
               (field.EqualIgnoreCase ("-NormalizeNominalFeatures"))  ||
               (field.EqualIgnoreCase ("-NN"))
              )
     {
       if  (value.Empty ())
         normalizeNominalFeatures = true;
       else
         normalizeNominalFeatures = value.ExtractTokenBool ("\t");
     }
 
     else
     {
       bool  parameterUsed = false;
       ParseCmdLineParameter (field, value, parameterUsed, _log);
       if  (!parameterUsed)
       {
         _log.Level (-1) << "ModelParam::ParseCmdLine - Invalid Parameter["  
           << field << "]  Value[" << value << "]."
           << endl;
         _validFormat = false;
         break;
       }
     }
 
     field = _cmdLineStr.ExtractToken (" \t\n\r");
   } 
 
   ParseCmdLinePost (_log);
 
   validParam = _validFormat;
 }  /* ParseCmdLine */

void ModelParam::ParseCmdLinePost ( RunLog & log )

virtual

Called after 'ParseCmdLine' is completed. Classed derived from 'ModelParam' can implement this method to do any processing that they want after the entire command line has been processed.

An example use of this is in 'ModelParamSvmBase' where the local 'ParseCmdLineParameter' routine processes parameters that 'Model' needs to be aware of.

Definition at line 358 of file ModelParam.cpp.

Referenced by ParseCmdLine().

359 {

360 }

float ModelParam::Prob ( ) const

virtual

Definition at line 192 of file ModelParam.cpp.

 {
   return  prob;
 }

void ModelParam::Prob ( float _prob )

virtual

Definition at line 225 of file ModelParam.cpp.

 {
   prob = _prob;
 }

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

pure virtual

Implemented in KKMLL::ModelParamOldSVM, KKMLL::ModelParamDual, KKMLL::ModelParamUsfCasCor, KKMLL::ModelParamSvmBase, and KKMLL::ModelParamKnn.

XmlTokenPtr ModelParam::ReadXMLModelParamToken ( XmlTokenPtr t )

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

Definition at line 487 of file ModelParam.cpp.

References KKB::KKStr::Concat(), EncodingMethodFromStr(), KKB::KKStr::EqualIgnoreCase(), KKB::KKStr::operator=(), KKB::XmlElement::ToBool(), KKB::XmlElement::ToInt32(), KKB::XmlToken::tokElement, KKB::XmlToken::TokenType(), KKB::XmlElement::ToKKStr(), and KKB::XmlToken::VarName().

Referenced by KKMLL::ModelParamKnn::ReadXML(), KKMLL::ModelParamSvmBase::ReadXML(), KKMLL::ModelParamUsfCasCor::ReadXML(), KKMLL::ModelParamDual::ReadXML(), and KKMLL::ModelParamOldSVM::ReadXML().

 {
   const KKStr&  varName = t->VarName ();
   if  (t->TokenType () == XmlToken::TokenTypes::tokElement)
   {
     XmlElementPtr  e = dynamic_cast<XmlElementPtr> (t);
 
     bool  tokenFound = true;
 
     if  (varName.EqualIgnoreCase ("EncodingMethod"))
     {
       encodingMethod = EncodingMethodFromStr (e->ToKKStr ());
     }
 
     else if  (varName.EqualIgnoreCase ("ExamplesPerClass"))
     {
       examplesPerClass = e->ToInt32 ();
     }
 
     else if  (varName.EqualIgnoreCase ("FileName"))
     {
       fileName = e->ToKKStr ();
     }
 
     else if  (varName.EqualIgnoreCase ("NormalizeNominalFeatures"))
     {
       normalizeNominalFeatures = e->ToBool ();;
     }
 
     else if  ((varName.EqualIgnoreCase ("SelectedFeatures"))  &&  (typeid (*e) == typeid (XmlElementFeatureNumList)))
     {
       selectedFeatures = dynamic_cast<XmlElementFeatureNumListPtr> (e)->TakeOwnership ();
     }
 
     else if  (varName.EqualIgnoreCase ("Cost"))
     {
       cost = e->ToDouble ();
     }
 
     else if  (varName.EqualIgnoreCase ("Gamma"))
     {
       gamma = e->ToDouble ();
     }
 
     else if  (varName.EqualIgnoreCase ("Prob"))
     {
       prob = (float)(e->ToDouble ());
     }
 
     else if  (varName.EqualIgnoreCase ("ValidParam"))
     {
       validParam = e->ToBool ();
     }
     else
     {
       tokenFound = false;
     }
 
     if  (tokenFound)
     {
       delete t;
       t = NULL;
     }
   }
 
   return  t;
 }  /* ReadXMLModelParamToken */

virtual FeatureNumListConstPtr KKMLL::ModelParam::SelectedFeatures ( ) const

inlinevirtual

Reimplemented in KKMLL::ModelParamOldSVM.

Definition at line 116 of file ModelParam.h.

Referenced by KKMLL::FeatureEncoder2::FeatureEncoder2(), KKMLL::Model::GetFeatureNums(), KKMLL::TrainingConfiguration2::GetFeatureNums(), KKMLL::ModelParamOldSVM::ReadXML(), KKMLL::Model::SelectedFeatures(), and KKMLL::ModelSvmBase::TrainModel().

116 {return selectedFeatures;}

void ModelParam::SelectedFeatures ( FeatureNumListConst & _selectedFeatures )

virtual

Definition at line 109 of file ModelParam.cpp.

References KKMLL::FeatureNumList::FeatureNumList().

Referenced by KKMLL::ModelParamOldSVM::SelectedFeatures(), and KKMLL::TrainingConfiguration2::SetFeatureNums().

 {
   delete  selectedFeatures;
   selectedFeatures = new FeatureNumList (_selectedFeatures);
 }

KKStr ModelParam::ToCmdLineStr ( ) const

virtual

Creates a a Command Line String that represents these parameters.

Convert all parameters to a command line string.

All derived classes should implement this method. They should first call this method and then append there own parameters that are specific to their implementation.

Reimplemented in KKMLL::ModelParamOldSVM, KKMLL::ModelParamDual, KKMLL::ModelParamUsfCasCor, and KKMLL::ModelParamSvmBase.

Definition at line 367 of file ModelParam.cpp.

References KKB::KKStr::Concat(), EncodingMethodToStr(), KKB::KKStr::KKStr(), NoEncoding, KKB::operator+(), and KKMLL::FeatureNumList::ToCommaDelStr().

Referenced by KKMLL::TrainingConfiguration2::ModelParameterCmdLine(), KKMLL::ModelParamKnn::ToCmdLineStr(), KKMLL::ModelParamSvmBase::ToCmdLineStr(), and KKMLL::ModelParamDual::ToCmdLineStr().

 {
   KKStr  cmdStr (300);
 
   if  (selectedFeatures)
     cmdStr << "-SF " + selectedFeatures->ToCommaDelStr ();
 
   if  (examplesPerClass < int32_max)
     cmdStr << "  -EPC " << examplesPerClass;
 
   if  (encodingMethod != EncodingMethodType::NoEncoding)
     cmdStr << "  -Encode " + EncodingMethodToStr (encodingMethod);
 
   return  cmdStr;
 }  /* ToCmdLineStr */

virtual bool KKMLL::ModelParam::ValidParam ( ) const

inlinevirtual

Definition at line 117 of file ModelParam.h.

Referenced by KKMLL::Model::ReadXMLModelPost(), and KKMLL::TrainingConfiguration2::TrainingConfiguration2().

117 {return validParam;}

virtual void KKMLL::ModelParam::ValidParam ( bool _validParam )

inlinevirtual

Definition at line 132 of file ModelParam.h.

Referenced by KKMLL::ModelParamOldSVM::ParseCmdLine().

132 {validParam = _validParam;}

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

pure virtual

Implemented in KKMLL::ModelParamOldSVM.

Referenced by KKMLL::Model::WriteModelXMLFields(), and KKMLL::TrainingConfiguration2::WriteXMLFields().

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

Definition at line 464 of file ModelParam.cpp.

References EncodingMethodToStr(), KKMLL::FeatureNumList::WriteXML(), KKB::XmlElementBool::WriteXML(), and KKB::KKStr::WriteXML().

Referenced by KKMLL::ModelParamKnn::WriteXML(), KKMLL::ModelParamSvmBase::WriteXML(), KKMLL::ModelParamUsfCasCor::WriteXML(), KKMLL::ModelParamDual::WriteXML(), and KKMLL::ModelParamOldSVM::WriteXML().

 {
   EncodingMethodToStr (encodingMethod).WriteXML ("EncodingMethod", o);
 
   XmlElementInt32::WriteXML (examplesPerClass, "ExamplesPerClass", o);
 
   fileName.WriteXML ("FileName", o);
 
   XmlElementBool::WriteXML (normalizeNominalFeatures, "NormalizeNominalFeatures", o);
 
   if  (selectedFeatures)
     selectedFeatures->WriteXML ("SelectedFeatures", o);
 
   XmlElementDouble::WriteXML (cost,       "Cost",       o);
   XmlElementDouble::WriteXML (gamma,      "Gamma",      o);
   XmlElementDouble::WriteXML (prob,       "Prob",       o);
   XmlElementBool::WriteXML   (validParam, "ValidParam", o);
 }  /* WriteXML */

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

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

Public Types

Public Member Functions

Static Public Member Functions

Detailed Description

Member Typedef Documentation

Member Enumeration Documentation

Constructor & Destructor Documentation

Member Function Documentation