KKMLL::SVMparam Class Reference

This class encapsulates are the information necessary to build a SVMModel class. More...

#include <SVMparam.h>

Public Member Functions
	SVMparam (KKStr &_cmdLineStr, FeatureNumListConstPtr _selectedFeatures, bool &_validFormat, RunLog &_log)
	SVMparam ()
	SVMparam (const SVMparam &_svmParam)
	~SVMparam ()
float	A_Param () const
void	A_Param (float _A)
void	AddBinaryClassParms (BinaryClassParmsPtr binaryClassParms)
void	AddBinaryClassParms (MLClassPtr _class1, MLClassPtr _class2, const svm_parameter &_param, FeatureNumListConstPtr _selectedFeatures, float _weight)
	Adding parameters that are specific to a class pair; this is used when using the BFS version of SVM. More...
float	AvgMumOfFeatures (FileDescPtr fileDesc) const
float	AvgNumOfFeatures (FeatureVectorListPtr trainExamples) const
	Returns back the class weighted average number of features per training example. More...
const BinaryClassParmsListPtr	BinaryParmsList () const
double	C_Param () const
double	C_Param (MLClassPtr class1, MLClassPtr class2) const
void	C_Param (double _CC)
void	C_Param (MLClassPtr class1, MLClassPtr class2, double cParam)
SVM_EncodingMethod	EncodingMethod () const
void	EncodingMethod (SVM_EncodingMethod _encodingMethod)
float	FeatureCountNet () const
double	Gamma () const
void	Gamma (double _gamma)
void	Gamma_Param (double _gamma)
BinaryClassParmsPtr	GetBinaryClassParms (MLClassPtr class1, MLClassPtr class2)
FeatureNumListConstPtr	GetFeatureNums () const
FeatureNumListConstPtr	GetFeatureNums (FileDescPtr fileDesc) const
FeatureNumListConstPtr	GetFeatureNums (FileDescPtr fileDesc, MLClassPtr class1, MLClassPtr class2) const
BinaryClassParmsPtr	GetParamtersToUseFor2ClassCombo (MLClassPtr class1, MLClassPtr class2)
SVM_KernalType	KernalType () const
void	KernalType (SVM_KernalType _kernalType)
SVM_MachineType	MachineType () const
void	MachineType (SVM_MachineType _machineType)
kkint32	MemoryConsumedEstimated () const
kkint32	NumOfFeaturesAfterEncoding (FileDescPtr fileDesc, RunLog &log) const
const svm_parameter &	Param () const
void	ParseCmdLineParameter (const KKStr &parameter, const KKStr &value, bool &parameterUsed, bool &_validFormat, RunLog &log)
const VectorFloat &	ProbClassPairs () const
void	ProbClassPairsInitialize (const ClassAssignments &assignments)
void	ProcessSvmParameter (svm_parameter &_param, KKStr cmd, KKStr value, double valueNum, bool &parmUsed)
virtual void	ReadXML (XmlStream &s, XmlTagConstPtr tag, VolConstBool &cancelFlag, RunLog &log)
float	SamplingRate () const
void	SamplingRate (float _samplingRate)
FeatureNumListConstPtr	SelectedFeatures () const
FeatureNumListConstPtr	SelectedFeatures (FileDescPtr fileDesc) const
void	SelectedFeatures (FeatureNumListConst &_selectedFeatures)
void	SelectedFeatures (FeatureNumListConstPtr _selectedFeatures)
SVM_SelectionMethod	SelectionMethod () const
void	SelectionMethod (SVM_SelectionMethod _selectionMethod)
void	SetBinaryClassFields (MLClassPtr _class1, MLClassPtr _class2, const svm_parameter &_param, FeatureNumListConstPtr _features, float _weight)
void	SetFeatureNums (FeatureNumListConstPtr _features)
void	SetFeatureNums (FeatureNumListConst &_features)
void	SetFeatureNums (MLClassPtr _class1, MLClassPtr _class2, FeatureNumListConstPtr _features, float _weight=-1)
	Sets the selected Features and Weight for the binary class SVM specified by _class1 and _class2. More...
KKStr	SvmParamToString (const svm_parameter &_param) const
	Convert a svm_parameter struct to a cmdline str. More...
KKStr	ToString () const
	Convert all parameters to a command line string. More...
bool	UseProbabilityToBreakTies () const
virtual void	WriteXML (const KKStr &varName, std::ostream &o) const

Detailed Description

This class encapsulates are the information necessary to build a SVMModel class.

See also

SVMModel

SVM233

BinaryClassParms

Definition at line 74 of file SVMparam.h.

Constructor & Destructor Documentation

SVMparam::SVMparam	(	KKStr &	_cmdLineStr,
		FeatureNumListConstPtr	_selectedFeatures,
		bool &	_validFormat,
		RunLog &	_log
	)

Parameters

_selectedFeatures

Will make own instance; caller maintains ownership status.

Definition at line 29 of file SVMparam.cpp.

References KKMLL::FeatureNumList::FeatureNumList(), KKB::KKStr::KKStr(), KKMLL::NoEncoding, SVM233::svm_parameter::svm_parameter(), and KKMLL::Voting.

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

                     :

  binaryParmsList           (NULL),
  encodingMethod            (SVM_EncodingMethod::NoEncoding),
  fileName                  (),
  param                     (),
  probClassPairs             (),
  samplingRate              (0.0f),
  selectedFeatures          (), 
  selectionMethod           (SVM_SelectionMethod::Voting),
  useProbabilityToBreakTies (false),
  validParam                (false)
{
  if  (_selectedFeatures)
    selectedFeatures = new FeatureNumList (*_selectedFeatures);
  ParseCmdLine (_cmdLineStr, _validFormat, _log);
}

SVMparam::SVMparam

(

)

Definition at line 55 of file SVMparam.cpp.

References KKB::KKStr::KKStr(), KKMLL::NoEncoding, KKMLL::OneVsOne, SVM233::svm_parameter::svm_parameter(), and KKMLL::Voting.

Referenced by KKMLL::ModelParamOldSVM::ModelParamOldSVM(), and KKMLL::SVMModel::SVMModel().

                    :

  binaryParmsList           (NULL),
  encodingMethod            (SVM_EncodingMethod::NoEncoding),
  fileName                  (),
  machineType               (SVM_MachineType::OneVsOne),
  param                     (),
  probClassPairs            (),
  samplingRate              (0.0f),
  selectedFeatures          (NULL), 
  selectionMethod           (SVM_SelectionMethod::Voting),
  useProbabilityToBreakTies (false),
  validParam                (false)
{
}

SVMparam::SVMparam

(

const SVMparam &

_svmParam

)

Definition at line 75 of file SVMparam.cpp.

References KKMLL::BinaryClassParmsList::DuplicateListAndContents(), KKMLL::FeatureNumList::FeatureNumList(), KKB::KKStr::KKStr(), SVM233::svm_parameter::operator=(), and SVM233::svm_parameter::svm_parameter().

Referenced by KKMLL::ModelParamOldSVM::ModelParamOldSVM(), and KKMLL::SVMModel::SVMModel().

                                              :

  binaryParmsList            (NULL),
  encodingMethod             (_svmParam.encodingMethod),
  fileName                   (_svmParam.fileName),
  machineType                (_svmParam.machineType),
  param                      (_svmParam.param),
  probClassPairs             (_svmParam.probClassPairs),
  samplingRate               (_svmParam.samplingRate),
  selectedFeatures           (_svmParam.selectedFeatures),
  selectionMethod            (_svmParam.selectionMethod),
  useProbabilityToBreakTies  (_svmParam.useProbabilityToBreakTies),
  validParam                 (_svmParam.validParam)
{
  if  (_svmParam.selectedFeatures)
    selectedFeatures = new FeatureNumList (*_svmParam.selectedFeatures);

  if  (_svmParam.binaryParmsList)
  {
    binaryParmsList = _svmParam.binaryParmsList->DuplicateListAndContents ();
      
    //  new BinaryClassParmsList (true, _svmParam.binaryParmsList->QueueSize ());
    //  binaryParmsList  = new BinaryClassParmsList (*(_svmParam.binaryParmsList));
  }
  param = _svmParam.param;
}

SVMparam::~SVMparam

(

)

Definition at line 104 of file SVMparam.cpp.

{
  delete  binaryParmsList;  binaryParmsList  = NULL;
  delete  selectedFeatures; selectedFeatures = NULL;
}

Member Function Documentation

float KKMLL::SVMparam::A_Param ( ) const

inline

Definition at line 132 of file SVMparam.h.

References SVM233::svm_parameter::A.

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

{return param.A;}

void SVMparam::A_Param

(

float

_A

)

Definition at line 187 of file SVMparam.cpp.

References SVM233::svm_parameter::A.

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

{
  param.A = _A;
}

void SVMparam::AddBinaryClassParms

(

BinaryClassParmsPtr

binaryClassParms

)

Definition at line 475 of file SVMparam.cpp.

References KKMLL::BinaryClassParmsList::BinaryClassParmsList(), and KKMLL::BinaryClassParmsList::PushOnBack().

Referenced by KKMLL::ModelParamOldSVM::AddBinaryClassParms(), and AddBinaryClassParms().

{
  if  (!binaryParmsList)
    binaryParmsList = new BinaryClassParmsList (true);

  binaryParmsList->PushOnBack (binaryClassParms);
}  /* AddBinaryClassParms */

void SVMparam::AddBinaryClassParms	(	MLClassPtr	_class1,
		MLClassPtr	_class2,
		const svm_parameter &	_param,
		FeatureNumListConstPtr	_selectedFeatures,
		float	_weight
	)

Adding parameters that are specific to a class pair; this is used when using the BFS version of SVM.

Add a Binary parameters using svm_parametr cmd line str. Typically used by TrainingConfiguration.

Parameters

_class1	First of two classes that is being added to this model.
_class2	Second of two classes that is being added to this model.
_param	Parameters that are to be used by two-class classifier.
_selectedFeatures	makes own copy; caller will retain ownership status.
_weight	You can specify the weight that you want to give to this binary-class SVM when voting or computing probability.

Definition at line 756 of file SVMparam.cpp.

References AddBinaryClassParms(), and KKMLL::BinaryClassParms::BinaryClassParms().

Referenced by KKMLL::ModelParamOldSVM::AddBinaryClassParms(), C_Param(), SetBinaryClassFields(), and SetFeatureNums().

{
  AddBinaryClassParms (new BinaryClassParms (_class1, _class2, _param, _selectedFeatures, _weight));
}  /* AddBinaryClassParms */

float SVMparam::AvgMumOfFeatures

(

FileDescPtr

fileDesc

)

const

Definition at line 485 of file SVMparam.cpp.

References KKMLL::BinaryCombos, KKMLL::BinaryClassParmsList::FeatureCountNet(), KKMLL::FeatureNumList::NumOfFeatures(), and SelectedFeatures().

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

{
  float  avgNumOfFeatures = 0.0f;

  if  ((machineType == SVM_MachineType::BinaryCombos)  &&  (binaryParmsList))
    avgNumOfFeatures = binaryParmsList->FeatureCountNet (fileDesc);

  if  (avgNumOfFeatures == 0.0f)
    avgNumOfFeatures = (float)SelectedFeatures (fileDesc)->NumOfFeatures ();

  return  avgNumOfFeatures;
}  /* AvgMumOfFeatures */

float SVMparam::AvgNumOfFeatures

(

FeatureVectorListPtr

trainExamples

)

const

Returns back the class weighted average number of features per training example.

Will calculate the average number of features per training example. For each binary class combination, multiplies the number of training examples for that pair by the number of features for that pair. the sum of all class pairs are then divided by the total number of examples.

Parameters

[in]

trainExamples

List of training examples that were or are to be used to train with.

Definition at line 508 of file SVMparam.cpp.

References KKMLL::BinaryCombos, KKMLL::ClassStatistic::Count(), KKMLL::FeatureVectorList::FileDesc(), KKMLL::FeatureVectorList::GetClassStatistics(), GetFeatureNums(), KKMLL::ClassStatistic::MLClass(), KKMLL::FeatureNumList::NumOfFeatures(), KKMLL::FeatureNumList::NumSelFeatures(), and SelectedFeatures().

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

{
  FileDescPtr  fileDesc = trainExamples->FileDesc ();
  if  (!selectedFeatures)
  {
    // The method "SelectedFeatures" will set 'selectedFeatures' to a new instance using 'fileDesc'.
    // This way we make sure that the variable exists.
    SelectedFeatures (fileDesc);
  }
  if  (machineType == SVM_MachineType::BinaryCombos)
  {
    kkint32 totalNumFeaturesUsed = 0;
    kkint32 toatlNumExamples     = 0;
    ClassStatisticListPtr  stats = trainExamples->GetClassStatistics ();
    if  (!stats)
    {
      return (float)selectedFeatures->NumOfFeatures ();
    }

    kkuint32  idx1 = 0;
    kkuint32  idx2 = 0;
    for  (idx1 = 0;  idx1 < (stats->size() - 1);  idx1++)
    {
      ClassStatisticPtr  class1Stats = stats->IdxToPtr (idx1);
      MLClassPtr  class1    = class1Stats->MLClass ();
      kkuint32    class1Qty = class1Stats->Count ();

      for  (idx2 = idx1 + 1;  idx2 < (stats->size());  idx2++)
      {
        ClassStatisticPtr  class2Stats = stats->IdxToPtr (idx2);
        MLClassPtr  class2    = class2Stats->MLClass ();
        kkuint32    class2Qty = class2Stats->Count ();

        kkint32  numFeaturesThisCombo = 0;
        FeatureNumListConstPtr  cpfn = GetFeatureNums (fileDesc, class1, class2);
        if  (cpfn)
          numFeaturesThisCombo = cpfn->NumSelFeatures ();

        kkint32  numExamplesThisCombo = class1Qty + class2Qty;

        totalNumFeaturesUsed += numFeaturesThisCombo * numExamplesThisCombo;
        toatlNumExamples     += numExamplesThisCombo;
      }
    }
    delete  stats;  stats = NULL;
    return  (float)totalNumFeaturesUsed / (float)toatlNumExamples;
  }
  else if  (!selectedFeatures)
  {
    return 0.0f;
  }
  else
  {
    return  (float)selectedFeatures->NumOfFeatures ();
  }
}  /* AvgMumOfFeatures */

const BinaryClassParmsListPtr KKMLL::SVMparam::BinaryParmsList ( ) const

inline

Definition at line 135 of file SVMparam.h.

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

{return binaryParmsList;}

double KKMLL::SVMparam::C_Param ( ) const

inline

Definition at line 137 of file SVMparam.h.

References SVM233::svm_parameter::C.

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

{return param.C;}

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

Definition at line 663 of file SVMparam.cpp.

References KKMLL::BinaryClassParms::C(), and KKMLL::BinaryClassParmsList::LookUp().

{
  if  (!binaryParmsList)
  {
    cerr << endl << endl
      << "SVMparam::C_Param   ***ERROR***     'binaryParmsList'  is not defined." << endl
      << endl;
    return 0.0;
  }

  BinaryClassParmsPtr  binaryParms = binaryParmsList->LookUp (class1, class2);
  if  (!binaryParms)
  {
    cerr << endl << endl 
      << "SVMparam::C_Param   ***ERROR***    No entry for Class[" << class1->Name () << ", " << class2->Name () << "]" << endl
      << endl;
    return 0.0;
  }
  else
  {
    return binaryParms->C ();
  }
}

void SVMparam::C_Param

(

double

_CC

)

Definition at line 195 of file SVMparam.cpp.

References SVM233::svm_parameter::C.

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

{
  param.C = _CC;
}

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

Definition at line 692 of file SVMparam.cpp.

References AddBinaryClassParms(), SVM233::svm_parameter::C, KKMLL::BinaryClassParms::C(), C_Param(), KKMLL::BinaryClassParmsList::LookUp(), and SelectedFeatures().

{
  if  (!binaryParmsList)
  {
    cerr << endl << endl
      << "SVMparam::C_Param   ***ERROR***     'binaryParmsList'  is not defined." << endl
      << endl;
    return;
  }

  BinaryClassParmsPtr  binaryParms = binaryParmsList->LookUp (class1, class2);
  if  (!binaryParms)
  {
    svm_parameter binaryParam = param;
    binaryParam.C = C_Param ();
    AddBinaryClassParms (class1, class2, binaryParam, SelectedFeatures (), 1.0f);
  }
  else
  {
    binaryParms->C (cParam);
  }
}  /* C_Param */

SVM_EncodingMethod KKMLL::SVMparam::EncodingMethod ( ) const

inline

Definition at line 143 of file SVMparam.h.

Referenced by KKMLL::TrainingConfiguration2::EncodingMethod(), KKMLL::SVMModel::NormalizeNominalAttributes(), NumOfFeaturesAfterEncoding(), KKMLL::ModelParamOldSVM::ParseCmdLine(), and KKMLL::SVMModel::ReadXML().

{return encodingMethod;}

void KKMLL::SVMparam::EncodingMethod ( SVM_EncodingMethod  _encodingMethod )

inline

Definition at line 182 of file SVMparam.h.

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

{encodingMethod    = _encodingMethod;}

float KKMLL::SVMparam::FeatureCountNet

(

)

const

double KKMLL::SVMparam::Gamma ( ) const

inline

Definition at line 147 of file SVMparam.h.

References SVM233::svm_parameter::Gamma().

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

{return param.Gamma ();}

void KKMLL::SVMparam::Gamma ( double  _gamma )

inline

Definition at line 183 of file SVMparam.h.

References SVM233::svm_parameter::Gamma().

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

{param.Gamma (_gamma);}

void KKMLL::SVMparam::Gamma_Param ( double  _gamma )

inline

Definition at line 184 of file SVMparam.h.

References Gamma().

{Gamma (_gamma);}

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

If binary class parms don't exist will return NULL.

Definition at line 423 of file SVMparam.cpp.

References KKMLL::BinaryClassParmsList::LookUp().

Referenced by KKMLL::ModelParamOldSVM::GetBinaryClassParms(), and KKMLL::TrainingConfiguration2::GetBinaryClassParms().

{
  if  (binaryParmsList == NULL)
    return NULL;
  else
    return binaryParmsList->LookUp (class1, class2);
}  /* GetBinaryClassParms */

FeatureNumListConstPtr SVMparam::GetFeatureNums

(

)

const

Definition at line 436 of file SVMparam.cpp.

Referenced by KKMLL::SVMModel::GetFeatureNums().

{
  return  selectedFeatures;
}

FeatureNumListConstPtr SVMparam::GetFeatureNums

(

FileDescPtr

fileDesc

)

const

Definition at line 443 of file SVMparam.cpp.

References SelectedFeatures().

Referenced by KKMLL::SVMModel::GetFeatureNums().

{
  if  (selectedFeatures == NULL)
    return SelectedFeatures (fileDesc);
  else
    return selectedFeatures;
}

FeatureNumListConstPtr SVMparam::GetFeatureNums	(	FileDescPtr	fileDesc,
		MLClassPtr	class1,
		MLClassPtr	class2
	)		const

Definition at line 453 of file SVMparam.cpp.

References KKMLL::BinaryClassParmsList::LookUp(), SelectedFeatures(), and KKMLL::BinaryClassParms::SelectedFeaturesFD().

Referenced by AvgNumOfFeatures(), KKMLL::ModelParamOldSVM::GetFeatureNums(), and KKMLL::SVMModel::GetFeatureNums().

{
  if  (!binaryParmsList)
  {
    // This configuration file does not specify feature selection by binary classes,
    // so return the general one specified for model.
    return  SelectedFeatures (fileDesc);
  }

  BinaryClassParmsPtr  twoClassComboParm =  binaryParmsList->LookUp (class1, class2);
  if  (!twoClassComboParm)
    return  SelectedFeatures (fileDesc);
  else
    return  twoClassComboParm->SelectedFeaturesFD  (fileDesc);
}  /* GetFeatureNums */

BinaryClassParmsPtr SVMparam::GetParamtersToUseFor2ClassCombo	(	MLClassPtr	class1,
		MLClassPtr	class2
	)

Definition at line 394 of file SVMparam.cpp.

References KKMLL::BinaryClassParms::BinaryClassParms(), KKMLL::BinaryClassParmsList::BinaryClassParmsList(), KKMLL::BinaryClassParmsList::LookUp(), and KKMLL::BinaryClassParmsList::PushOnBack().

Referenced by KKMLL::ModelParamOldSVM::GetParamtersToUseFor2ClassCombo(), and KKMLL::TrainingConfiguration2::GetParamtersToUseFor2ClassCombo().

{
  BinaryClassParmsPtr  twoClassComboParms = NULL;

  if  (binaryParmsList == NULL)
  {
    binaryParmsList = new BinaryClassParmsList (true);
    twoClassComboParms = NULL;
  }
  else
  {
    twoClassComboParms = binaryParmsList->LookUp (class1, class2);
  }

  if  (!twoClassComboParms)
  {
    twoClassComboParms = new BinaryClassParms (class1, class2, param, selectedFeatures, 1.0f);
    binaryParmsList->PushOnBack (twoClassComboParms);
  }

  return  twoClassComboParms;
}  /* GetParamtersToUSeFor2ClassCombo */

SVM_KernalType KKMLL::SVMparam::KernalType ( ) const

inline

Definition at line 149 of file SVMparam.h.

References SVM233::svm_parameter::KernalType().

Referenced by KKMLL::ModelParamOldSVM::KernalType(), and KKMLL::TrainingConfiguration2::KernalType().

{return (SVM_KernalType)param.KernalType ();}

void KKMLL::SVMparam::KernalType ( SVM_KernalType  _kernalType )

inline

Definition at line 185 of file SVMparam.h.

References SVM233::svm_parameter::KernalType().

Referenced by KKMLL::ModelParamOldSVM::KernalType(), and KKMLL::TrainingConfiguration2::KernalType().

{param.KernalType ((int)_kernalType);}

SVM_MachineType KKMLL::SVMparam::MachineType ( ) const

inline

Definition at line 151 of file SVMparam.h.

Referenced by KKMLL::ModelOldSVM::Description(), KKMLL::SVMModel::DistanceFromDecisionBoundary(), KKMLL::ModelParamOldSVM::MachineType(), KKMLL::SVMModel::NumOfSupportVectors(), KKMLL::SVMModel::Predict(), KKMLL::SVMModel::ProbabilitiesByClass(), KKMLL::SVMModel::ReadXML(), KKMLL::SVMModel::SupportVectorStatistics(), KKMLL::SVMModel::SVMModel(), and KKMLL::SVMModel::WriteXML().

{return machineType;}

void KKMLL::SVMparam::MachineType ( SVM_MachineType  _machineType )

inline

Definition at line 187 of file SVMparam.h.

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

{machineType        = _machineType;}

kkint32 SVMparam::MemoryConsumedEstimated

(

)

const

Definition at line 124 of file SVMparam.cpp.

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

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

  if  (binaryParmsList)
    memoryConsumedEstimated += binaryParmsList->MemoryConsumedEstimated ();

  return  memoryConsumedEstimated;
}  /* MemoryConsumedEstimated  */

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

Definition at line 567 of file SVMparam.cpp.

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

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

{
  if  (!selectedFeatures)
  {
    // The method "SelectedFeatures" will set 'selectedFeatures' to a new instance using 'fileDesc'.
    // This way we make sure that the variable exists.
    SelectedFeatures (fileDesc);
  }

  if  (!selectedFeatures)
    return 0;

  kkint32 z;
  kkint32 numFeaturesAfterEncoding = 0;
  kkint32 numOfFeaturesSelected = selectedFeatures->NumOfFeatures ();

  switch (EncodingMethod ())
  {
  case  SVM_EncodingMethod::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 SVM_EncodingMethod::Scaled:
  case SVM_EncodingMethod::NoEncoding:
  default:
    //numFeaturesAfterEncoding = fileDesc->NumOfFields ( );
    numFeaturesAfterEncoding = selectedFeatures->NumOfFeatures ();
    break;
  }

  return  numFeaturesAfterEncoding;
}  /* NumOfFeaturesAfterEncoding */

const svm_parameter& KKMLL::SVMparam::Param ( ) const

inline

Definition at line 159 of file SVMparam.h.

Referenced by KKMLL::ModelParamOldSVM::Param(), and KKMLL::SvmPredictClass().

{return param;}

void SVMparam::ParseCmdLineParameter	(	const KKStr &	parameter,
		const KKStr &	value,
		bool &	parameterUsed,
		bool &	_validFormat,
		RunLog &	log
	)

Definition at line 202 of file SVMparam.cpp.

References KKB::KKStr::Concat(), KKMLL::EncodingMethodFromStr(), KKB::KKStr::KKStr(), KKMLL::MachineTypeFromStr(), KKMLL::Null, KKB::KKStr::operator==(), SVM233::svm_parameter::ProcessSvmParameter(), KKMLL::SelectionMethodFromStr(), KKB::KKStr::ToDouble(), and KKB::KKStr::Upper().

{
  parameterUsed = true;
  _validFormat  = true;

  KKStr  field = parameter;
  double  valueNum = value.ToDouble ();

  field.Upper ();
  KKStr valueUpper (value);
  valueUpper.Upper ();

  param.ProcessSvmParameter (parameter,value, valueNum, parameterUsed);
  if  (parameterUsed)
    return;

  parameterUsed = true;

  if ((field == "-ENCODE"))
  {
    encodingMethod = EncodingMethodFromStr (valueUpper);
  }

  else if  (field == "-MT")
  {
    machineType = MachineTypeFromStr (valueUpper);
    if  (machineType == SVM_MachineType::Null)
    {
      _validFormat = false;
      log.Level (-1) << endl 
        << "SVMparam::ParseCmdLineParameter     *** ERROR ***" << endl
        << "                Invalid -MT Parm[" << value << "]" << endl
        << endl;
    }
  }

  else if  ((field == "-SM")  ||  (field == "-SELECTIONMETHOD"))
  {
    selectionMethod  = SelectionMethodFromStr (valueUpper);
    if  (selectionMethod == SVM_SelectionMethod::Null)
    {
      log.Level (-1) << endl
        << "SVMparam::ParseCmdLineParameter    *** ERROR ***"  << endl
        << "            Invalid SelectionMethod (-SM)[" << value << "]." << endl
        << endl;
      _validFormat = false;
    }
  }

  else if  ((field == "-SR")  ||  (field == "-SAMPLINGRATE"))
  {
    samplingRate = float (atof (value.Str ()));
  }


  else if  ((field == "-UP")  ||  (field == "-USEPROBABILITY"))
  {
    useProbabilityToBreakTies = true;
  }


  else
  {
    parameterUsed = false;
  }
}  /* ParseCmdLineParameter */

const VectorFloat& KKMLL::SVMparam::ProbClassPairs ( ) const

inline

Definition at line 161 of file SVMparam.h.

{return probClassPairs;}

void SVMparam::ProbClassPairsInitialize

(

const ClassAssignments &

assignments

)

Definition at line 153 of file SVMparam.cpp.

References KKMLL::ClassAssignments::GetMLClass(), and KKMLL::BinaryClassParmsList::LookUp().

{
  kkuint32  numClasses = assignments.size ();
  if  (numClasses < 1)
    return;

  kkuint32  numPairs   = numClasses * (numClasses - 1) / 2;
  probClassPairs.clear ();
  if  (binaryParmsList == NULL)
  {
    for  (kkuint32 x = 0;  x < numPairs;  ++x)
      probClassPairs.push_back (param.A);
  }
  else
  {
    for (kkuint32 class1IDX = 0;  class1IDX < (numClasses - 1);  ++class1IDX)
    {
      MLClassPtr       class1 = assignments.GetMLClass ((kkint16)class1IDX);
      for (kkuint32 class2IDX = class1IDX + 1;  class2IDX < numClasses;  ++class2IDX)
      {
        MLClassPtr       class2 = assignments.GetMLClass ((kkint16)class2IDX);
        BinaryClassParmsPtr  bcp = binaryParmsList->LookUp (class1, class2);
        if  (bcp)
          probClassPairs.push_back ((float)bcp->AParam ());
        else
          probClassPairs.push_back ((float)param.A);
      }
    }
  }
}  /* ProbClassPairsInitialize */

void KKMLL::SVMparam::ProcessSvmParameter	(	svm_parameter &	_param,
		KKStr	cmd,
		KKStr	value,
		double	valueNum,
		bool &	parmUsed
	)

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

virtual

Definition at line 815 of file SVMparam.cpp.

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

{
  XmlTokenPtr  t = s.GetNextToken (cancelFlag, log);
  while  (t  &&  (!cancelFlag))
  {
    const KKStr&  varName = t->VarName ();

    if  (varName.EqualIgnoreCase ("HeaderFields")  &&  (typeid (*t) == typeid (XmlElementKeyValuePairs)))
    {
      XmlElementKeyValuePairsPtr  kvp = dynamic_cast<XmlElementKeyValuePairsPtr> (t);
      if  (kvp  &&  (kvp->Value() != NULL))
      {
        for  (auto idx: *(kvp->Value ()))
        {
          if  (idx.first.EqualIgnoreCase ("EncodingMethod"))
            encodingMethod = EncodingMethodFromStr (idx.second);

          else if  (idx.first.EqualIgnoreCase ("FileName"))
            fileName = idx.second;

          else if  (idx.first.EqualIgnoreCase ("MachineType"))
            machineType = MachineTypeFromStr (idx.second);

          else if  (idx.first.EqualIgnoreCase ("SelectedFeatures"))
          {
            bool  successful = false;
            selectedFeatures = new FeatureNumList (idx.second, successful);
          }

          else if  (idx.first.EqualIgnoreCase ("Param"))
            param.ParseTabDelStr (idx.second);

          else if  (idx.first.EqualIgnoreCase ("SamplingRate"))
            samplingRate = idx.second.ToFloat ();

          else if  (idx.first.EqualIgnoreCase ("SelectionMethod"))
            selectionMethod = SelectionMethodFromStr (idx.second);

          else if  (idx.first.EqualIgnoreCase ("UseProbabilityToBreakTies"))
            useProbabilityToBreakTies = idx.second.ToBool ();

          else
          {
            log.Level (-1) << endl
              << "SVMparam::ReadXML   ***ERROR***   UnRecognozed Header Field: " << idx.first << ":" << idx.second << endl
              << endl;
          }
        }
      }
    }
    delete  t;
    t = s.GetNextToken (cancelFlag, log);
  }
  delete  t;
  t = NULL;
}  /* ReadXML */

float KKMLL::SVMparam::SamplingRate ( ) const

inline

Definition at line 163 of file SVMparam.h.

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

{return samplingRate;}

void KKMLL::SVMparam::SamplingRate ( float  _samplingRate )

inline

Definition at line 188 of file SVMparam.h.

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

{samplingRate       = _samplingRate;}

FeatureNumListConstPtr KKMLL::SVMparam::SelectedFeatures ( ) const

inline

Definition at line 165 of file SVMparam.h.

Referenced by C_Param(), KKMLL::ModelParamOldSVM::SelectedFeatures(), and KKMLL::SVMModel::SVMModel().

{return selectedFeatures;}

FeatureNumListConstPtr SVMparam::SelectedFeatures

(

FileDescPtr

fileDesc

)

const

Definition at line 112 of file SVMparam.cpp.

References KKMLL::FeatureNumList::FeatureNumList(), and KKMLL::FeatureNumList::SetAllFeatures().

Referenced by AvgMumOfFeatures(), AvgNumOfFeatures(), GetFeatureNums(), and NumOfFeaturesAfterEncoding().

{
  if  (!selectedFeatures)
  {
    selectedFeatures = new FeatureNumList (fileDesc);
    selectedFeatures->SetAllFeatures (fileDesc);
  }
  return  selectedFeatures;
}

void KKMLL::SVMparam::SelectedFeatures

(

FeatureNumListConst &

_selectedFeatures

)

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

void SVMparam::SelectedFeatures

(

FeatureNumListConstPtr

_selectedFeatures

)

Definition at line 145 of file SVMparam.cpp.

References KKMLL::FeatureNumList::FeatureNumList().

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

SVM_SelectionMethod KKMLL::SVMparam::SelectionMethod ( ) const

inline

Definition at line 169 of file SVMparam.h.

Referenced by KKMLL::ModelOldSVM::Description(), KKMLL::ModelOldSVM::ProbabilitiesByClass(), KKMLL::ModelParamOldSVM::SelectionMethod(), KKMLL::SVMModel::SelectionMethod(), and KKMLL::SvmPredictClass().

{return selectionMethod;}

void KKMLL::SVMparam::SelectionMethod ( SVM_SelectionMethod  _selectionMethod )

inline

Definition at line 218 of file SVMparam.h.

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

{selectionMethod  = _selectionMethod;}

void SVMparam::SetBinaryClassFields	(	MLClassPtr	_class1,
		MLClassPtr	_class2,
		const svm_parameter &	_param,
		FeatureNumListConstPtr	_features,
		float	_weight
	)

Parameters

_class1	First of two classes that is being added to this model.
_class2	Second of two classes that is being added to this model.
_param	Parameters that are to be used by two-class classifier.
_features	makes own copy; caller will retain ownership status.
_weight	You can specify the weight that you want to give to this binary-class SVM when voting or computing probability.

Definition at line 721 of file SVMparam.cpp.

References AddBinaryClassParms(), KKMLL::BinaryClassParmsList::LookUp(), KKMLL::BinaryClassParms::Param(), KKMLL::BinaryClassParms::SelectedFeatures(), and KKMLL::BinaryClassParms::Weight().

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

{
  if  (!binaryParmsList)
  {
    AddBinaryClassParms (_class1, _class2, _param, _features, _weight);
  }
  else
  {
    BinaryClassParmsPtr  binaryParms = binaryParmsList->LookUp (_class1, _class2);
    if  (binaryParms)
    {
      binaryParms->Param            (_param); 
      binaryParms->SelectedFeatures (_features);
      binaryParms->Weight           (_weight);
    }
    else
    {
      AddBinaryClassParms (_class1, _class2, _param, _features, _weight);
    }
  }
}  /* SetBinaryClassFields */

void SVMparam::SetFeatureNums

(

FeatureNumListConstPtr

_features

)

Definition at line 655 of file SVMparam.cpp.

References KKMLL::FeatureNumList::FeatureNumList().

{
  delete  selectedFeatures;
  selectedFeatures = new FeatureNumList (*_features);
}  /* SetFeatureNums */

void KKMLL::SVMparam::SetFeatureNums

(

FeatureNumListConst &

_features

)

void SVMparam::SetFeatureNums	(	MLClassPtr	_class1,
		MLClassPtr	_class2,
		FeatureNumListConstPtr	_features,
		float	_weight = -1
	)

Sets the selected Features and Weight for the binary class SVM specified by _class1 and _class2.

If this pair has not been defined yet will create a new entry and add to list of Binary-Class-Pair's.

Parameters

_class1	First of two classes to set features for.
_class2	Second of two classes to set features for.
_features	Makes own copy; caller will retain ownership status.
_weight	-1 Indicates use existing value.

Definition at line 614 of file SVMparam.cpp.

References AddBinaryClassParms(), KKMLL::BinaryClassParmsList::LookUp(), KKMLL::BinaryClassParms::SelectedFeatures(), and KKMLL::BinaryClassParms::Weight().

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

{
  if  (!binaryParmsList)
  {
    if  (_weight < 0)
      _weight = 1;
    AddBinaryClassParms (_class1, _class2, param, _features, _weight);
  }
  else
  {
    BinaryClassParmsPtr  binaryParms = binaryParmsList->LookUp (_class1, _class2);
    if  (binaryParms)
    {
      if  (_weight < 0)
        _weight = binaryParms->Weight ();
      binaryParms->SelectedFeatures (_features);
    }
    else
    {
      if  (_weight < 0)
        _weight = 1.0f;
      AddBinaryClassParms (_class1, _class2, param, _features, _weight);
    }
  }
}  /* SetFeatureNums */

KKStr SVMparam::SvmParamToString

(

const svm_parameter &

_param

)

const

Convert a svm_parameter struct to a cmdline str.

Definition at line 353 of file SVMparam.cpp.

References KKB::KKStr::Concat(), KKB::KKStr::KKStr(), and SVM233::svm_parameter::ToCmdLineStr().

Referenced by ToString().

{
  KKStr  cmdStr (300);

  cmdStr << _param.ToCmdLineStr ();

  return  cmdStr;
}  /* SvmParamToString */

KKStr SVMparam::ToString

(

)

const

Convert all parameters to a command line string.

Definition at line 368 of file SVMparam.cpp.

References KKMLL::BoostSVM, KKB::KKStr::Concat(), KKMLL::EncodingMethodToStr(), KKB::KKStr::KKStr(), KKMLL::MachineTypeToStr(), KKMLL::NoEncoding, KKB::operator+(), KKB::KKStr::operator=(), KKMLL::SelectionMethodToStr(), and SvmParamToString().

Referenced by KKMLL::ModelParamOldSVM::ToCmdLineStr(), and KKMLL::ModelParamOldSVM::WriteXML().

{
  KKStr  cmdStr (300);

  cmdStr = SvmParamToString (param);

  if  (encodingMethod != SVM_EncodingMethod::NoEncoding)
    cmdStr << "  -Encode " + EncodingMethodToStr (encodingMethod);

  cmdStr << "  -MT " << MachineTypeToStr (machineType);
  cmdStr << "  -SM " << SelectionMethodToStr (selectionMethod);

  if  (machineType == SVM_MachineType::BoostSVM)
  {
    cmdStr << "  -SamplingRate " << samplingRate;
  }

  if  (useProbabilityToBreakTies)
    cmdStr << "  -UseProbability";

  return  cmdStr;
}  /* ToString */

bool KKMLL::SVMparam::UseProbabilityToBreakTies ( ) const

inline

Definition at line 171 of file SVMparam.h.

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

{return useProbabilityToBreakTies;}

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

virtual

Definition at line 769 of file SVMparam.cpp.

References KKB::XmlElementKeyValuePairs::Add(), KKB::XmlTag::AddAtribute(), KKB::KKStr::Empty(), KKMLL::EncodingMethodToStr(), KKMLL::MachineTypeToStr(), KKMLL::SelectionMethodToStr(), KKB::XmlTag::tagEnd, KKB::XmlTag::tagStart, KKMLL::FeatureNumList::ToString(), SVM233::svm_parameter::ToTabDelStr(), KKMLL::BinaryClassParmsList::WriteXML(), KKB::XmlTag::WriteXML(), KKB::XmlElementKeyValuePairs::WriteXML(), KKB::XmlElementKeyValuePairs::XmlElementKeyValuePairs(), and KKB::XmlTag::XmlTag().

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

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

  {
    XmlElementKeyValuePairs*   headerFields = new XmlElementKeyValuePairs ();

    headerFields->Add ("EncodingMethod",             EncodingMethodToStr (encodingMethod));
    headerFields->Add ("FileName",                   fileName);
    headerFields->Add ("MachineType",                MachineTypeToStr (machineType));
    if  (selectedFeatures)
      headerFields->Add ("SelectedFeatures",         selectedFeatures->ToString ());
    headerFields->Add ("param",                      param.ToTabDelStr ());

    headerFields->Add ("samplingRate",               samplingRate);
    headerFields->Add ("selectionMethod",            SelectionMethodToStr (selectionMethod));


    headerFields->Add ("useProbabilityToBreakTies",  useProbabilityToBreakTies);


    headerFields->WriteXML ("HeaderFields", o);
    delete  headerFields;
    headerFields = NULL;
  }

  XmlElementVectorFloat::WriteXML (probClassPairs, "probClassPairs", o);

  if  (binaryParmsList)
    binaryParmsList->WriteXML ("binaryParmsList", o);

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

---

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

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