KKMLL::ModelDual Class Reference

Will implement the Dual Classifier Model. More...

#include <ModelDual.h>

Inheritance diagram for KKMLL::ModelDual:

Public Types
typedef ModelDual *	ModelDualPtr
Public Types inherited from KKMLL::Model
typedef Model *	ModelPtr
enum	ModelTypes : int {   ModelTypes::Null = 0, ModelTypes::OldSVM = 1, ModelTypes::SvmBase = 2, ModelTypes::KNN = 3,   ModelTypes::UsfCasCor = 4, ModelTypes::Dual = 5 }

Public Member Functions
	ModelDual ()
	ModelDual (FactoryFVProducerPtr _factoryFVProducer)
	ModelDual (const KKStr &_name, const ModelParamDual &_param, FactoryFVProducerPtr _factoryFVProducer)
	ModelDual (const ModelDual &_model)
virtual	~ModelDual ()
	Frees any memory allocated by, and owned by the ModelDual. More...
virtual KKStr	Description () const
virtual ModelDualPtr	Duplicate () const
virtual kkint32	MemoryConsumedEstimated () const
virtual ModelTypes	ModelType () const
virtual kkint32	NumOfSupportVectors () const
ModelParamDualPtr	Param ()
virtual MLClassPtr	Predict (FeatureVectorPtr example, RunLog &log)
virtual void	Predict (FeatureVectorPtr example, MLClassPtr knownClass, MLClassPtr &predClass1, MLClassPtr &predClass2, kkint32 &predClass1Votes, kkint32 &predClass2Votes, double &probOfKnownClass, double &predClass1Prob, double &predClass2Prob, kkint32 &numOfWinners, bool &knownClassOneOfTheWinners, double &breakTie, RunLog &log)
virtual ClassProbListPtr	ProbabilitiesByClass (FeatureVectorPtr example, RunLog &log)
virtual void	ProbabilitiesByClass (FeatureVectorPtr example, const MLClassList &_mlClasses, kkint32 *_votes, double *_probabilities, RunLog &log)
virtual void	ProbabilitiesByClass (FeatureVectorPtr _example, const MLClassList &_mlClasses, double *_probabilities, RunLog &_log)
	Derives predicted probabilities by class. More...
virtual void	ProbabilitiesByClassDual (FeatureVectorPtr example, KKStr &classifier1Desc, KKStr &classifier2Desc, ClassProbListPtr &classifier1Results, ClassProbListPtr &classifier2Results, RunLog &log)
	Only applied to ModelDual classifier. More...
virtual void	ReadXML (XmlStream &s, XmlTagConstPtr tag, VolConstBool &cancelFlag, RunLog &log)
	To be implemented by derived classes; the parent classes fields will be updated by the derived class calling ReadXMLModelToken. More...
virtual void	RetrieveCrossProbTable (MLClassList &classes, double **crossProbTable, RunLog &log)
TrainingProcess2Ptr	Trainer1 ()
TrainingProcess2Ptr	Trainer2 ()
virtual void	TrainModel (FeatureVectorListPtr _trainExamples, bool _alreadyNormalized, bool _takeOwnership, VolConstBool &_cancelFlag, RunLog &_log)
	Performs operations such as FeatureEncoding, and Normalization. The actual training of models occurs in the specific derived implementation of 'Model'. More...
virtual void	WriteXML (const KKStr &varName, ostream &o) const
Public Member Functions inherited from KKMLL::Model
	Model ()
	Model (FactoryFVProducerPtr _factoryFVProducer)
	Use this when you are planning on creating a empty model without parameters. More...
	Model (const KKStr &_name, const ModelParam &_param, FactoryFVProducerPtr _factoryFVProducer)
	Construct a instance of 'Model' using the parameters specified in '_param'. More...
	Model (const Model &_madel)
	Copy Constructor. More...
virtual	~Model ()
	Frees any memory allocated by, and owned by the Model. More...
bool	AlreadyNormalized () const
const FeatureEncoder2 &	Encoder () const
FactoryFVProducerPtr	FactoryFVProducer () const
virtual FeatureNumListConstPtr	GetFeatureNums () const
MLClassListPtr	MLClasses () const
MLClassListPtr	MLClassesNewInstance () const
virtual KKStr	ModelTypeStr () const
const KKStr &	Name () const
void	Name (const KKStr &_name)
virtual bool	NormalizeNominalAttributes () const
ModelParamPtr	Param () const
virtual void	PredictRaw (FeatureVectorPtr example, MLClassPtr &predClass, double &dist)
virtual FeatureVectorPtr	PrepExampleForPrediction (FeatureVectorPtr fv, bool &newExampleCreated)
	Every prediction method in every class that is inherited from this class should call this method before performing there prediction. Such things as Normalization and Feature Encoding. More...
const KKStr &	RootFileName () const
void	RootFileName (const KKStr &_rootFileName)
virtual FeatureNumListConstPtr	SelectedFeatures () const
const KKB::DateTime &	TimeSaved () const
double	TrainingTime () const
void	TrainingTimeEnd ()
	Derived classes call this method to stop the clock for 'trainingTime'. More...
void	TrainingTimeStart ()
	Derived classes call this method to start the clock for 'trainingTime'. More...
double	TrianingPrepTime () const
bool	ValidModel () const
void	WriteModelXMLFields (std::ostream &o) const
	The "WriteXML" method in Derived classes call this method to include the parents classes fields in the XML data. More...
virtual void	WriteXML (const KKStr &varName, std::ostream &o) const =0

Protected Member Functions
void	DeleteExistingClassifiers ()
MLClassPtr	ReconcilePredictions (MLClassPtr pred1, MLClassPtr pred2, RunLog &log)
void	ReconcileProbAndVotes (Classifier2Ptr classifier, MLClassPtr predClass, FeatureVectorPtr encodedExample, double &predClassProb, kkint32 &predClassVotes)
Protected Member Functions inherited from KKMLL::Model
void	AddErrorMsg (const KKStr &errMsg, kkint32 lineNum)
void	AllocatePredictionVariables ()
void	DeAllocateSpace ()
void	NormalizeProbabilitiesWithAMinumum (kkint32 numClasses, double *probabilities, double minProbability)
void	ReadXMLModelPost (RunLog &log)
XmlTokenPtr	ReadXMLModelToken (XmlTokenPtr t, RunLog &log)
	Will process any tokens that belong to 'ModelParam' and return NULL ones that are not will be passed back. More...
void	ReduceTrainExamples (RunLog &log)
	Reduces the Training Images down to the size dictated by the 'examplesPerClass' parameter. More...

Protected Attributes
Classifier2Ptr	classifier1
Classifier2Ptr	classifier2
TrainingConfiguration2Ptr	config1
TrainingConfiguration2Ptr	config2
ModelParamDualPtr	param
TrainingProcess2Ptr	trainer1
KKStr	trainer1StatusMsg
TrainingProcess2Ptr	trainer2
KKStr	trainer2StatusMsg
Protected Attributes inherited from KKMLL::Model
bool	alreadyNormalized
MLClassListPtr	classes
MLClassIndexListPtr	classesIndex
double *	classProbs
double **	crossClassProbTable
kkint32	crossClassProbTableSize
FeatureEncoder2Ptr	encoder
VectorKKStr	errors
FactoryFVProducerPtr	factoryFVProducer
FileDescPtr	fileDesc
NormalizationParmsPtr	normParms
kkint32	numOfClasses
ModelParamPtr	param
KKStr	rootFileName
FeatureVectorListPtr	trainExamples
bool	validModel
kkint32 *	votes
bool	weOwnTrainExamples

Additional Inherited Members
Static Public Member Functions inherited from KKMLL::Model
static ModelPtr	CreateAModel (ModelTypes _modelType, const KKStr &_name, const ModelParam &_param, FactoryFVProducerPtr _factoryFVProducer, VolConstBool &_cancelFlag, RunLog &_log)
	A factory method that will instantiate the appropriate class of training model based off '_modelType'. More...
static ModelTypes	ModelTypeFromStr (const KKStr &_modelingTypeStr)
static KKStr	ModelTypeToStr (ModelTypes _modelingType)

Detailed Description

Will implement the Dual Classifier Model.

This model will actually load two different training models specified in the parameters field. It will utilize both classifiers for to make a prediction. Unknown examples will be submitted to both classifiers. The returned class will be the common part of the class hierarchy of the two predictions. If there is nothing in common between the two predictions then it will return the "Other class.

Definition at line 66 of file ModelDual.h.

Member Typedef Documentation

typedef ModelDual* KKMLL::ModelDual::ModelDualPtr

Definition at line 70 of file ModelDual.h.

Constructor & Destructor Documentation

ModelDual::ModelDual

(

)

Definition at line 39 of file ModelDual.cpp.

References classifier1, classifier2, config1, config2, KKMLL::Model::Model(), param, trainer1, and trainer2.

                     :
  Model (),
  param         (NULL),
  config1       (NULL),
  config2       (NULL),
  trainer1      (NULL),
  trainer2      (NULL),
  classifier1   (NULL),
  classifier2   (NULL)
{
}

ModelDual::ModelDual

(

FactoryFVProducerPtr

_factoryFVProducer

)

Definition at line 54 of file ModelDual.cpp.

References classifier1, classifier2, config1, config2, KKMLL::Model::Model(), param, trainer1, and trainer2.

                                                             :
  Model (_factoryFVProducer),
  param         (NULL),
  config1       (NULL),
  config2       (NULL),
  trainer1      (NULL),
  trainer2      (NULL),
  classifier1   (NULL),
  classifier2   (NULL)
{
}

ModelDual::ModelDual	(	const KKStr &	_name,
		const ModelParamDual &	_param,
		FactoryFVProducerPtr	_factoryFVProducer
	)

Definition at line 67 of file ModelDual.cpp.

References classifier1, classifier2, config1, config2, KKMLL::Model::Model(), param, KKMLL::Model::param, trainer1, and trainer2.

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

                      :
  Model (_name, _param, _factoryFVProducer),
  param         (NULL),
  config1       (NULL),
  config2       (NULL),
  trainer1      (NULL),
  trainer2      (NULL),
  classifier1   (NULL),
  classifier2   (NULL)
{
  param = dynamic_cast<ModelParamDualPtr> (Model::param);
}

ModelDual::ModelDual

(

const ModelDual &

_model

)

Definition at line 86 of file ModelDual.cpp.

References classifier1, classifier2, config1, config2, KKMLL::Model::Model(), param, KKMLL::Model::param, trainer1, and trainer2.

Referenced by Duplicate().

                                              :
  Model  (_model),
  param         (NULL),
  config1       (NULL),
  config2       (NULL),
  trainer1      (NULL),
  trainer2      (NULL),
  classifier1   (NULL),
  classifier2   (NULL)
{
  param = dynamic_cast<ModelParamDualPtr> (Model::param);
}

ModelDual::~ModelDual ( )

virtual

Frees any memory allocated by, and owned by the ModelDual.

Definition at line 106 of file ModelDual.cpp.

References classifier1, classifier2, config1, config2, DeleteExistingClassifiers(), trainer1, and trainer2.

{
  // The base class owns param,  so we do not delete it.
  DeleteExistingClassifiers ();
  delete  config1;      config1     = NULL;
  delete  config2;      config2     = NULL;
  delete  trainer1;     trainer1    = NULL;
  delete  trainer2;     trainer2    = NULL;
  delete  classifier1;  classifier1 = NULL;
  delete  classifier2;  classifier2 = NULL;

}

Member Function Documentation

void ModelDual::DeleteExistingClassifiers ( )

protected

Definition at line 164 of file ModelDual.cpp.

References classifier1, classifier2, config1, config2, trainer1, and trainer2.

Referenced by TrainModel(), and ~ModelDual().

{
  delete  config1;      config1     = NULL;
  delete  config2;      config2     = NULL;
  delete  trainer1;     trainer1    = NULL;
  delete  trainer2;     trainer2    = NULL;
  delete  classifier1;  classifier1 = NULL;
  delete  classifier2;  classifier2 = NULL;
}  /* DeleteExistingClassifiers */

KKStr ModelDual::Description ( ) const

virtual

Return short user readable description of model.

Reimplemented from KKMLL::Model.

Definition at line 133 of file ModelDual.cpp.

References KKB::KKStr::Concat(), KKMLL::TrainingProcess2::ConfigFileName(), KKMLL::TrainingProcess2::ModelTypeStr(), KKMLL::Model::Name(), KKB::KKStr::operator+(), KKB::operator+(), KKB::osGetRootName(), trainer1, and trainer2.

{
  KKStr  result = "Dual(" + Name () + ")";
  if  (trainer1)
    result << " " << trainer1->ModelTypeStr () + "(" + osGetRootName (trainer1->ConfigFileName ()) + ")";
  else if  (config1)
    result << " " << config1->ModelTypeStr  () + "(" + osGetRootName (config1->FileName ()) + ")";

  if  (trainer2)
    result << " " << trainer2->ModelTypeStr () + "(" + osGetRootName (trainer2->ConfigFileName ()) + ")";
  else if  (config1)
    result << " " << config2->ModelTypeStr  () + "(" + osGetRootName (config2->FileName ()) + ")";

  return  result;
}

ModelDualPtr ModelDual::Duplicate ( ) const

virtual

Implements KKMLL::Model.

Definition at line 151 of file ModelDual.cpp.

References ModelDual().

{
  return new ModelDual (*this);
}

kkint32 ModelDual::MemoryConsumedEstimated ( ) const

virtual

Reimplemented from KKMLL::Model.

Definition at line 120 of file ModelDual.cpp.

References classifier1, classifier2, KKMLL::Classifier2::MemoryConsumedEstimated(), KKMLL::Model::MemoryConsumedEstimated(), KKMLL::TrainingProcess2::MemoryConsumedEstimated(), trainer1, and trainer2.

{
  kkint32 memoryConsumedEstimated = Model::MemoryConsumedEstimated ();
  if  (trainer1)    memoryConsumedEstimated += trainer1->MemoryConsumedEstimated ();
  if  (trainer2)    memoryConsumedEstimated += trainer2->MemoryConsumedEstimated ();
  if  (classifier1) memoryConsumedEstimated += classifier1->MemoryConsumedEstimated ();
  if  (classifier2) memoryConsumedEstimated += classifier2->MemoryConsumedEstimated ();
  return  memoryConsumedEstimated;
}

virtual ModelTypes KKMLL::ModelDual::ModelType ( ) const

inlinevirtual

Implements KKMLL::Model.

Definition at line 93 of file ModelDual.h.

References KKMLL::Model::Dual.

{return ModelTypes::Dual;}

kkint32 ModelDual::NumOfSupportVectors ( ) const

virtual

Definition at line 847 of file ModelDual.cpp.

References KKMLL::TrainingProcess2::NumOfSupportVectors(), trainer1, and trainer2.

{
  float  totalSVs = 0.0;
  kkuint32 count = 0;

  if  (trainer1)
  {
    totalSVs += (float)(trainer1->NumOfSupportVectors ());
    ++count;
  }

  if  (trainer2)
  {
    totalSVs += (float)(trainer2->NumOfSupportVectors ());
    ++count;
  }

  if  (count > 0)
    return  (kkint32)(0.5f + totalSVs / (float)count);
  else
    return 0;

}  /* NumOfSupportVectors */

ModelParamDualPtr ModelDual::Param

(

)

Definition at line 158 of file ModelDual.cpp.

References param.

{
  return param;
}

MLClassPtr ModelDual::Predict ( FeatureVectorPtr  example, RunLog &  log  )

virtual

Todo:

ModelDual::Predict Make sure that the call to the first classifier does not modify the encodedExample.

Implements KKMLL::Model.

Definition at line 430 of file ModelDual.cpp.

References classifier1, classifier2, KKMLL::Classifier2::ClassifyAExample(), KKMLL::Model::PrepExampleForPrediction(), and ReconcilePredictions().

{
  if  ((!classifier1)  ||  (!classifier2))
  {
    log.Level (-1) << endl << endl << "ModelDual::Predict   ***ERROR***      Both Classifiers are not defined." << endl << endl;
    return NULL;
  }

  bool  newExampleCreated = false;

  MLClassPtr      pred1 = NULL;
  MLClassPtr      pred2 = NULL;

  /**@todo   ModelDual::Predict    Make sure that the call to the first classifier does not modify the encodedExample. */
  FeatureVectorPtr  encodedExample = PrepExampleForPrediction (example, newExampleCreated);
  pred1 = classifier1->ClassifyAExample (*encodedExample);
  pred2 = classifier2->ClassifyAExample (*encodedExample);

  if  (newExampleCreated)
  {
    delete  encodedExample;
    encodedExample = NULL;
  }

  return  ReconcilePredictions (pred1, pred2, log);
}  /* Predict */

void ModelDual::Predict ( FeatureVectorPtr  example, MLClassPtr  knownClass, MLClassPtr &  predClass1, MLClassPtr &  predClass2, kkint32 &  predClass1Votes, kkint32 &  predClass2Votes, double &  probOfKnownClass, double &  predClass1Prob, double &  predClass2Prob, kkint32 &  numOfWinners, bool &  knownClassOneOfTheWinners, double &  breakTie, RunLog &  log  )

virtual

Todo:

Make sure that 'classifier1->ClassifyAExample' does not modify the feature data.

Implements KKMLL::Model.

Definition at line 462 of file ModelDual.cpp.

References classifier1, classifier2, KKMLL::Classifier2::ClassifyAExample(), KKMLL::Model::PrepExampleForPrediction(), ReconcilePredictions(), and ReconcileProbAndVotes().

{
  if  ((!classifier1)  ||  (!classifier2))
  {
    predClass1 = predClass2 = NULL;
    log.Level (-1) << endl << endl << "ModelDual::Predict   ***ERROR***      Both Classifiers are not defined." << endl << endl;
    return;
  }

  MLClassPtr       predClass1C1       = NULL;
  MLClassPtr       predClass2C1       = NULL;
  kkint32          predClass1VotesC1  = 0;
  kkint32          predClass2VotesC1  = 0;
  double           probOfKnownClassC1 = 0.0;
  double           predClass1ProbC1   = 0.0;
  double           predClass2ProbC1   = 0.0;
  kkint32          numOfWinnersC1     = 0;
  bool             knownClassOneOfTheWinnersC1 = false;
  double           breakTieC1         = 0.0;

  MLClassPtr       predClass1C2       = NULL;
  MLClassPtr       predClass2C2       = NULL;
  kkint32          predClass1VotesC2  = 0;
  kkint32          predClass2VotesC2  = 0;
  double           probOfKnownClassC2 = 0.0;
  double           predClass1ProbC2   = 0.0;
  double           predClass2ProbC2   = 0.0;
  kkint32          numOfWinnersC2     = 0;
  bool             knownClassOneOfTheWinnersC2 = false;
  double           breakTieC2         = 0.0;

  bool  newExampleCreated = false;
  FeatureVectorPtr  encodedExample = PrepExampleForPrediction (example, newExampleCreated);

  /**@todo   Make sure that 'classifier1->ClassifyAExample' does not modify the feature data. */

  classifier1->ClassifyAExample (*encodedExample, 
                               predClass1C1,       predClass2C1, 
                               predClass1VotesC1,  predClass2VotesC1,
                               probOfKnownClassC1,
                               predClass1ProbC1,   predClass2ProbC1,
                               numOfWinnersC1,
                               breakTieC1
                              );

  classifier2->ClassifyAExample (*encodedExample, 
                               predClass1C2,       predClass2C2, 
                               predClass1VotesC2,  predClass2VotesC2,
                               probOfKnownClassC2,
                               predClass1ProbC2,   predClass2ProbC2,
                               numOfWinnersC2,
                               breakTieC2
                              );

  predClass1 = ReconcilePredictions (predClass1C1, predClass1C2, log);
  predClass2 = ReconcilePredictions (predClass2C1, predClass2C2, log);

  if  (predClass1C1 != predClass1C2)
  {
    ReconcileProbAndVotes (classifier1,
                           predClass1,
                           encodedExample, 
                           predClass1ProbC1,
                           predClass1VotesC1
                          );

    ReconcileProbAndVotes (classifier2,
                           predClass1,
                           encodedExample, 
                           predClass1ProbC2,
                           predClass1VotesC2
                          );
  }


  if  (predClass2C1 != predClass2C2)
  {
    ReconcileProbAndVotes (classifier1,
                           predClass2,
                           encodedExample, 
                           predClass2ProbC1,
                           predClass2VotesC1
                          );

    ReconcileProbAndVotes (classifier2,
                           predClass2,
                           encodedExample, 
                           predClass2ProbC2,
                           predClass2VotesC2
                          );
  }

  predClass1Prob  = (predClass1ProbC1 + predClass1ProbC2) / 2.0;
  predClass2Prob  = (predClass2ProbC1 + predClass2ProbC2) / 2.0;
  predClass1Votes   = (kkint32)((0.5f + predClass1VotesC1 + predClass1VotesC2) / 2.0f);
  predClass2Votes   = (kkint32)((0.5f + predClass2VotesC1 + predClass2VotesC2) / 2.0f);
  

  probOfKnownClass  = (probOfKnownClassC1 + probOfKnownClassC2) / 2.0;
  breakTie          = (breakTieC1         + breakTieC2)         / 2.0;
  numOfWinners      = (numOfWinnersC1     + numOfWinnersC2)     / 2;
  knownClassOneOfTheWinners = (knownClass == predClass1C1)  ||  (knownClass == predClass1C2);

  if  (newExampleCreated)
  {
    delete  encodedExample;
    encodedExample = NULL;
  }

  return;
}  /* Predict */

ClassProbListPtr ModelDual::ProbabilitiesByClass ( FeatureVectorPtr  example, RunLog &  log  )

virtual

Implements KKMLL::Model.

Definition at line 591 of file ModelDual.cpp.

References classifier1, classifier2, KKMLL::ClassProbList::MergeIn(), KKMLL::ClassProbList::NormalizeToOne(), and KKMLL::Classifier2::ProbabilitiesByClass().

{
  if  ((!classifier1)  ||  (!classifier2))
  {
    log.Level (-1) << endl << endl << "ModelDual::ProbabilitiesByClass   ***ERROR***      Both Classifiers are not defined." << endl << endl;
    return NULL;
  }

  ClassProbListPtr  predictions1 = classifier1->ProbabilitiesByClass (example);
  ClassProbListPtr  predictions2 = classifier1->ProbabilitiesByClass (example);

  if  (predictions1 == NULL)
    return predictions2;

  else if  (predictions2 == NULL)
    return predictions1;

  ClassProbList::iterator  idx;
  for  (idx = predictions2->begin ();  idx != predictions2->end ();  ++idx)
  {
    ClassProbPtr  cp = *idx;
    predictions1->MergeIn (cp);
  }
  delete  predictions2;
  predictions2 = NULL;

  predictions1->NormalizeToOne ();

  return  predictions1;
}  /* ProbabilitiesByClass */

void ModelDual::ProbabilitiesByClass ( FeatureVectorPtr  example, const MLClassList &  _mlClasses, kkint32 *  _votes, double *  _probabilities, RunLog &  log  )

virtual

Implements KKMLL::Model.

Definition at line 676 of file ModelDual.cpp.

References KKMLL::ClassProbList::AddIn(), classifier1, classifier2, KKMLL::ClassProbList::LookUp(), KKMLL::ClassProbList::NormalizeToOne(), KKMLL::Classifier2::ProbabilitiesByClass(), KKMLL::ClassProb::probability, and KKMLL::ClassProb::votes.

{
  kkint32  numClasses = _mlClasses.QueueSize ();
  for  (kkint32 idx = 0;  idx < numClasses;  idx++)
  {
    _probabilities[idx] = 0.0;
    _votes        [idx] = 0;
  }

  if  ((!classifier1)  ||  (!classifier2))
  {
    _log.Level (-1) << endl << "ModelDual::ProbabilitiesByClass   ***ERROR***      Both Classifiers are not defined." << endl << endl;
    return;
  }

  ClassProbListPtr  predictions1 = classifier1->ProbabilitiesByClass (example);
  ClassProbListPtr  predictions2 = classifier2->ProbabilitiesByClass (example);

  if  (predictions1 == NULL)
  {
    predictions1 = predictions2;
    predictions2 = NULL;
  }

  else if  (predictions2 == NULL)
  {
    // 'predictions1' already has the total of both.
  }

  else
  {
    predictions1->AddIn (predictions2);
    delete  predictions2;
    predictions2 = NULL;
  }

  kkuint32 x = 0;
  predictions1->NormalizeToOne ();
  MLClassList::const_iterator  idx2;
  for  (idx2 = _mlClasses.begin (), x = 0;  idx2 != _mlClasses.end ();  ++idx2, ++x)
  {
    MLClassPtr      c =*idx2;
    ClassProbPtr  cp = predictions1->LookUp (c);
    if  (cp)
    {
      _votes        [x] = (kkint32)(0.5f + cp->votes);
      _probabilities[x] = cp->probability;
    }
  }

  delete  predictions1;
  predictions1 = NULL;

  return;
}  /* ProbabilitiesByClass */

void ModelDual::ProbabilitiesByClass ( FeatureVectorPtr  _example, const MLClassList &  _mlClasses, double *  _probabilities, RunLog &  _log  )

virtual

Derives predicted probabilities by class.

Will get the probabilities assigned to each class by the classifier. The '_mlClasses' parameter dictates the order of the classes. That is the probabilities for any given index in '_probabilities' will be for the class specified in the same index in '_mlClasses'.

Parameters

[in]	_example	FeatureVector object to calculate predicted probabilities for.
[in]	_mlClasses	List of classes that caller is aware of. This should be the same list that was used when constructing this Model object. The list must be the same but not necessarily in the same order as when Model was 1st constructed.
[out]	_probabilities	An array that must be as big as the number of classes as in mlClasses. The probability of class in mlClasses[x] will be returned in probabilities[x].

Implements KKMLL::Model.

Definition at line 741 of file ModelDual.cpp.

References KKMLL::ClassProbList::AddIn(), classifier1, classifier2, KKMLL::ClassProbList::LookUp(), KKMLL::ClassProbList::NormalizeToOne(), KKMLL::Classifier2::ProbabilitiesByClass(), and KKMLL::ClassProb::probability.

{
  kkint32  numClasses = _mlClasses.QueueSize ();
  for  (kkint32 idx = 0;  idx < numClasses;  idx++)
  {
    _probabilities[idx] = 0.0;
  }

  if  ((!classifier1)  ||  (!classifier2))
  {
    _log.Level (-1) << endl << "ModelDual::ProbabilitiesByClass   ***ERROR***      Both Classifiers are not defined." << endl << endl;
    return;
  }

  ClassProbListPtr  predictions1 = classifier1->ProbabilitiesByClass (_example);
  ClassProbListPtr  predictions2 = classifier2->ProbabilitiesByClass (_example);

  if  (predictions1 == NULL)
  {
    predictions1 = predictions2;
    predictions2 = NULL;
  }

  else if  (predictions2 == NULL)
  {
    // 'predictions1' already has the total of both.
  }

  else
  {
    predictions1->AddIn (predictions2);
    delete  predictions2;
    predictions2 = NULL;
  }

  kkuint32 x = 0;
  predictions1->NormalizeToOne ();
  MLClassList::const_iterator  idx2;
  for  (idx2 = _mlClasses.begin (), x = 0;  idx2 != _mlClasses.end ();  ++idx2, ++x)
  {
    MLClassPtr      c =*idx2;
    ClassProbPtr  cp = predictions1->LookUp (c);
    if  (cp)
      _probabilities[x] = cp->probability;
  }

  delete  predictions1;
  predictions1 = NULL;

  return;
}  /* ProbabilitiesByClass */

void ModelDual::ProbabilitiesByClassDual ( FeatureVectorPtr  example, KKStr &  classifier1Desc, KKStr &  classifier2Desc, ClassProbListPtr &  classifier1Results, ClassProbListPtr &  classifier2Results, RunLog &  log  )

virtual

Only applied to ModelDual classifier.

Reimplemented from KKMLL::Model.

Definition at line 628 of file ModelDual.cpp.

References classifier1, classifier2, KKMLL::TrainingProcess2::ModelDescription(), KKB::KKStr::operator=(), KKMLL::Model::PrepExampleForPrediction(), KKMLL::Classifier2::ProbabilitiesByClass(), trainer1, and trainer2.

{
  delete  classifier1Results;  classifier1Results = NULL;
  delete  classifier2Results;  classifier2Results = NULL;

  if  ((!classifier1)  ||  (!classifier2))
  {
    log.Level (-1) << endl << endl << "ModelDual::ProbabilitiesByClassDual   ***ERROR***      Both Classifiers are not defined." << endl << endl;
    return;
  }

  classifier1Desc = trainer1->ModelDescription ();
  classifier2Desc = trainer2->ModelDescription ();

  {
    bool  newExampleCreated = false;
    FeatureVectorPtr  encodedExample = PrepExampleForPrediction (example, newExampleCreated);
    classifier1Results = classifier1->ProbabilitiesByClass (encodedExample);
    if  (newExampleCreated)
    {
      delete encodedExample;
      encodedExample = NULL;
    }
  }

  {
    bool  newExampleCreated = false;
    FeatureVectorPtr  encodedExample = PrepExampleForPrediction (example, newExampleCreated);
    classifier2Results = classifier2->ProbabilitiesByClass (encodedExample);
    if  (newExampleCreated)
    {
      delete encodedExample;
      encodedExample = NULL;
    }
  }

  return;
}  /* ProbabilitiesByClass */

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

virtual

To be implemented by derived classes; the parent classes fields will be updated by the derived class calling ReadXMLModelToken.

Todo:

I need the Config1 configuration read from the XML file to be correct; but to deal with this problem for now; will reload the original.

Todo:

I need the Config1 configuration read from the XML file to be correct; but to deal with this problem for now; will reload the original.

Implements KKMLL::Model.

Definition at line 902 of file ModelDual.cpp.

References KKMLL::Model::AddErrorMsg(), classifier1, KKMLL::Classifier2::Classifier2(), classifier2, KKB::KKStr::Concat(), config1, config2, KKB::XmlStream::GetNextToken(), KKB::KKStr::KKStr(), KKMLL::ModelParam::ModelParamTypeStr(), param, KKMLL::Model::param, KKMLL::Model::ReadXMLModelPost(), KKMLL::Model::ReadXMLModelToken(), KKB::XmlToken::SectionName(), KKB::XmlElement::SectionName(), KKB::XmlToken::tokElement, KKB::XmlToken::TokenType(), trainer1, trainer2, KKMLL::Model::validModel, KKB::XmlToken::VarName(), and KKB::XmlElement::VarName().

{
  delete  config1;  config1 = NULL;
  delete  config2;  config2 = NULL;

  KKStr  config1Name = "";
  KKStr  config2Name = "";

  XmlTokenPtr  t = s.GetNextToken (cancelFlag, log);
  while  (t  &&  (!cancelFlag))
  {
    t = ReadXMLModelToken (t, log);
    bool tokenFound = true;
    if  ((t != NULL)  &&  (t->TokenType () == XmlToken::TokenTypes::tokElement))
    {
      XmlElementPtr e = dynamic_cast<XmlElementPtr> (t);
      if  (!e)
      {
        tokenFound = false;
      }
      else
      {
        const KKStr&  varName     = e->VarName();
        const KKStr&  sectionName = e->SectionName ();

        if  ((varName.EqualIgnoreCase ("config1"))  &&  (typeid (*e) == typeid (XmlElementTrainingConfiguration2)))
        {
          delete config1;
          config1 = dynamic_cast<XmlElementTrainingConfiguration2Ptr>(e)->TakeOwnership ();
          config1Name = config1->ConfigRootName ();

          /**@todo   I need the Config1 configuration read from the XML file to be correct;  but to deal with this problem for now; will reload the original. */
          delete  config1;
          config1 = new TrainingConfiguration2 ();
          config1 ->Load (config1Name, false, log);
        }

        else if  ((varName.EqualIgnoreCase ("config2"))  &&  (typeid (*e) == typeid (XmlElementTrainingConfiguration2)))
        {
          delete config2;
          config2 = dynamic_cast<XmlElementTrainingConfiguration2Ptr>(e)->TakeOwnership ();
          config2Name = config1->ConfigRootName ();
          /**@todo   I need the Config1 configuration read from the XML file to be correct;  but to deal with this problem for now; will reload the original. */
          delete  config2;
          config2 = new TrainingConfiguration2 ();
          config2 ->Load (config2Name, false, log);
        }
      
        else if  ((varName.EqualIgnoreCase ("trainer1"))  &&  (typeid (*e) == typeid (XmlElementTrainingProcess2)))
        {
          delete trainer1;
          trainer1 = dynamic_cast<XmlElementTrainingProcess2Ptr>(e)->TakeOwnership ();
        }
      
        else if  ((varName.EqualIgnoreCase ("trainer2"))  &&  (typeid (*e) == typeid (XmlElementTrainingProcess2)))
        {
          delete trainer2;
          trainer2 = dynamic_cast<XmlElementTrainingProcess2Ptr>(e)->TakeOwnership ();
        }
        else
        {
          tokenFound = false;
        }
      }
    }
    if  (!tokenFound)
    {
      KKStr  errMsg (128);
      errMsg << "ModelDual::ReadXML   ***ERROR***   Unexpected Element: Section: " << t->SectionName () << " VarName:" << t->VarName ();
      log.Level (-1) << endl << errMsg << endl << endl;
      AddErrorMsg (errMsg, 0);
    }

    delete  t;
    t = s.GetNextToken (cancelFlag, log);
  }

  delete  t;
  t = NULL;

  if  (cancelFlag)
    validModel = false;

  if  (validModel)
  {
    if  (!trainer1)
    {
      validModel = false;
      KKStr  errMsg = "ModelDual::ReadXML   ***ERROR***   trainer1 not loaded!!!";
      log.Level (-1) << endl << errMsg << endl << endl;
      AddErrorMsg (errMsg, 0);
    }

    if  (!trainer2)
    {
      validModel = false;
      KKStr  errMsg = "ModelDual::ReadXML   ***ERROR***   trainer2 not loaded!!!";
      log.Level (-1) << endl << errMsg << endl << endl;
      AddErrorMsg (errMsg, 0);
    }

    if  (validModel)
    {
      delete  classifier1;   classifier1 = new Classifier2 (trainer1, log);
      delete  classifier2;   classifier2 = new Classifier2 (trainer2, log);
    }
  }

  if  (!param)
    param = dynamic_cast<ModelParamDualPtr> (Model::param);

  if  (Model::param == NULL)
  {
    KKStr errMsg (128);
    errMsg << "ModelDual::ReadXML  ***ERROR***  Base class 'Model' does not have 'param' defined.";
    AddErrorMsg (errMsg, 0);
    log.Level (-1) << endl << errMsg << endl << endl;
  }

  else if  (typeid (*Model::param) != typeid(ModelParamDual))
  {
    KKStr errMsg (128);
    errMsg << "ModelDual::ReadXML  ***ERROR***  Base class 'Model' param parameter is of the wrong type;  found: " << Model::param->ModelParamTypeStr ();
    AddErrorMsg (errMsg, 0);
    log.Level (-1) << endl << errMsg << endl << endl;
  }

  else
  {
    param = dynamic_cast<ModelParamDualPtr> (Model::param);
  }

  ReadXMLModelPost (log);
}  /* ReadXML */

MLClassPtr ModelDual::ReconcilePredictions ( MLClassPtr  pred1, MLClassPtr  pred2, RunLog &  log  )

protected

Definition at line 320 of file ModelDual.cpp.

References KKB::KKStr::Append(), KKB::KKStr::Concat(), KKMLL::MLClass::CreateNewMLClass(), KKB::KKStr::Empty(), KKB::KKStr::ExtractToken2(), KKMLL::ModelParamDual::FullHierarchyMustMatch(), KKB::KKStr::KKStr(), KKB::KKStr::Len(), KKMLL::MLClass::Name(), KKB::KKStr::operator+=(), KKB::KKStr::operator==(), KKMLL::ModelParamDual::OtherClass(), and param.

Referenced by Predict().

{
  if  (pred1 == pred2)
    return pred1;

  else if  (param->FullHierarchyMustMatch ())
  {
    if  (param->OtherClass ())
      return param->OtherClass ();
    else
      return MLClass::CreateNewMLClass ("NoAgreement");
  }

  if  (!pred1)
  {
    if  (!pred2)
    {
      log.Level (-1) << "ModelDual::ReconcilePredictions ***WARNING***  Classifier[" << param->ConfigFileName1 () << "] nor Classifier[" << param->ConfigFileName2 () << "]  return predictions." << endl;
      return  NULL;
    }
    else
    {
      log.Level (-1) << "ModelDual::ReconcilePredictions  ***WARNING***  Classifier[" << param->ConfigFileName1 () << "] did not return a prediction." << endl;
      return pred2;
    }
  }
  else
  {
    if  (!pred2)
    {
      log.Level (-1) << "ModelDual::ReconcilePredictions  ***WARNING***  Classifier[" << param->ConfigFileName2 () << "] did not return a prediction." << endl;
      return  pred1;
    }
  }

  // We need to find the common part of the predictions.
  KKStr  name1 = pred1->Name ();
  KKStr  name2 = pred2->Name ();
  kkint32 maxLen = Min (name1.Len (), name2.Len ());
  KKStr  commonPart (maxLen + 1);

  while  ((!name1.Empty ())  &&  (!name2.Empty ()))
  {
    KKStr  name1Token = name1.ExtractToken2 ("_");
    KKStr  name2Token = name2.ExtractToken2 ("_");
    if  (name1Token == name2Token)
    {
      if  (!commonPart.Empty ())
        commonPart.Append ('_');
      commonPart += name1Token;
    }
    else
    {
      break;
    }
  }

  if  (commonPart.Len () < 1)
  {
    if  (param->OtherClass ())
      return param->OtherClass ();
    else
      return MLClass::CreateNewMLClass ("NoAgreement");
  }
  else
  {
    return  MLClass::CreateNewMLClass (commonPart);
  }
}  /* ReconcilePredictions */

void ModelDual::ReconcileProbAndVotes ( Classifier2Ptr  classifier, MLClassPtr  predClass, FeatureVectorPtr  encodedExample, double &  predClassProb, kkint32 &  predClassVotes  )

protected

Definition at line 396 of file ModelDual.cpp.

References KKMLL::ClassProb::classLabel, KKB::KKStr::Concat(), KKMLL::MLClass::Name(), KKMLL::Classifier2::ProbabilitiesByClass(), KKMLL::ClassProb::probability, KKB::KKStr::StartsWith(), and KKMLL::ClassProb::votes.

Referenced by Predict().

{
  const KKStr&  name = predClass->Name ();

  predClassProb = 0.0;
  predClassVotes = 0;

  ClassProbListPtr  predictions = classifier->ProbabilitiesByClass (encodedExample);
  ClassProbList::iterator  idx;
  for  (idx = predictions->begin ();  idx != predictions->end ();  ++idx)
  {
    ClassProbPtr p = *idx;
    if  (p->classLabel->Name ().StartsWith (name))
    {
      predClassProb  += p->probability;
      predClassVotes += (kkint32)(p->votes);
    }
  }

  delete  predictions;
  predictions =  NULL;

  return;
}  /* ReconcileProbAndVotes */

void ModelDual::RetrieveCrossProbTable ( MLClassList &  classes, double **  crossProbTable, RunLog &  log  )

virtual

Parameters

crossProbTable

two dimension matrix that needs to be classes.QueueSize () squared.

Reimplemented from KKMLL::Model.

Definition at line 800 of file ModelDual.cpp.

References classifier1, classifier2, and KKMLL::Classifier2::RetrieveCrossProbTable().

{
  if  ((!classifier1)  ||  (!classifier2))
  {
    _log.Level (-1) << endl << "ModelDual::RetrieveCrossProbTable   ***ERROR***      Both Classifiers are not defined." << endl << endl;
    return;
  }

  kkint32 x = 0, y = 0;

  kkint32 numClasses = _classes.QueueSize ();

  double**  crossProbTableC1 = new double*[numClasses];
  double**  crossProbTableC2 = new double*[numClasses];

  for  (x = 0;  x < numClasses;  ++x)
  {
    crossProbTableC1[x] = new double[numClasses];
    crossProbTableC2[x] = new double[numClasses];
  }

  classifier1->RetrieveCrossProbTable (_classes, crossProbTableC1);
  classifier2->RetrieveCrossProbTable (_classes, crossProbTableC2);

  for  (x = 0;  x < numClasses;  ++x)
  {
    for  (y = 0;  y < numClasses;  ++y)
      _crossProbTable[x][y] = (crossProbTableC1[x][y] + crossProbTableC2[x][y]) / 2.0;
  }

  for  (x = 0;  x < numClasses;  ++x)
  {
    delete  crossProbTableC1[x];  crossProbTableC1[x] = NULL;
    delete  crossProbTableC2[x];  crossProbTableC2[x] = NULL;
  }

  delete[]  crossProbTableC1;  crossProbTableC1 = NULL;
  delete[]  crossProbTableC2;  crossProbTableC2 = NULL;

}  /* RetrieveCrossProbTable */

TrainingProcess2Ptr KKMLL::ModelDual::Trainer1 ( )

inline

Definition at line 98 of file ModelDual.h.

References trainer1.

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

{return trainer1;}

TrainingProcess2Ptr KKMLL::ModelDual::Trainer2 ( )

inline

Definition at line 100 of file ModelDual.h.

References trainer2.

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

{return trainer2;}

void ModelDual::TrainModel ( FeatureVectorListPtr  _trainExamples, bool  _alreadyNormalized, bool  _takeOwnership, VolConstBool &  _cancelFlag, RunLog &  _log  )

virtual

Performs operations such as FeatureEncoding, and Normalization. The actual training of models occurs in the specific derived implementation of 'Model'.

Performs operations such as FeatureEncoding, and Normalization; the actual training of models occurs in the specific implementation of 'Model'.

Parameters

[in]	_trainExamples	Training data that classifier will be built from. If the examples need to be normalized or encoded and we are not taking ownership then a duplicate list of examples will be created that this method and class will be free to modify.
[in]	_alreadyNormalized	Indicates if contents of '_trainExamples' are normalized already; if not they will be normalized.
[in]	_takeOwnership	This instance of Model will take ownership of '_examples' and is free to modify its contents.

< false = DON'T take ownership of 'trainExamples'.

< true = Features are already normalized.

< false = DON'T take ownership of 'trainExamples'.

< true = Features are already normalized.

Parameters

_takeOwnership

Model will take ownership of these examples

Reimplemented from KKMLL::Model.

Definition at line 177 of file ModelDual.cpp.

References KKMLL::TrainingProcess2::Abort(), classifier1, KKMLL::Classifier2::Classifier2(), classifier2, KKB::KKStr::Concat(), config1, config2, KKMLL::TrainingConfiguration2::ConfigFileExists(), KKMLL::ModelParamDual::ConfigFileName1(), KKMLL::ModelParamDual::ConfigFileName2(), KKMLL::TrainingProcess2::CreateTrainingProcessFromTrainingExamples(), DeleteExistingClassifiers(), KKMLL::Model::factoryFVProducer, KKB::KKException::KKException(), KKMLL::TrainingConfiguration2::Load(), KKMLL::FactoryFVProducer::ManufacturTrainingConfiguration(), KKB::KKStr::operator+(), KKB::operator+(), param, trainer1, trainer2, KKMLL::Model::trainExamples, KKMLL::Model::TrainingTimeEnd(), KKMLL::Model::TrainingTimeStart(), KKMLL::Model::TrainModel(), and KKMLL::Model::validModel.

{
  _log.Level (10) << "ModelDual::TrainModel  Model[" << param->FileName () << "]  _trainExamples->size()[" << _trainExamples->size() << "]" << endl;

  if  (param == NULL)
  {
    validModel = false;
    KKStr  errMsg = "ModelDual::TrainModel   (param == NULL)";
    _log.Level (-1) << endl << errMsg << endl << endl;
    throw KKException (errMsg);
  }

  DeleteExistingClassifiers ();

  try 
  {
    Model::TrainModel (_trainExamples, _alreadyNormalized, _takeOwnership, _cancelFlag, _log);
  }
  catch (const KKException&  e)
  {
    validModel = false;
    KKStr  errMsg = "ModelDual::TrainModel  ***ERROR*** Exception occurred calling 'Model::TrainModel'.";
    _log.Level (-1) << endl << errMsg << endl << e.ToString () << endl << endl;
    throw  KKException (errMsg, e);
  }
  catch (const exception& e2)
  {
    validModel = false;
    KKStr errMsg = "ModelDual::TrainModel  ***ERROR*** Exception occurred calling 'Model::TrainModel'.";
    _log.Level (-1) << endl << errMsg << endl << e2.what () << endl << endl;
    throw KKException (errMsg, e2);
  }
  catch (...)
  {
    validModel = false;
    KKStr errMsg = "ModelDual::TrainModel  ***ERROR*** Exception occurred calling 'Model::TrainModel'.";
    _log.Level (-1) << endl << errMsg << endl << endl;
    throw KKException (errMsg);
  }
    
  // 'Model::TrainModel'  Will have performed any BitReduction and Feature Encoding 
  // that needed to be done.  
  // Also the data structures 'classes', 'encoder', and 'fileDesc' will have been built.
  // 'classes' will already be sorted in name order.
  // The Prediction variables 'probabilities', 'votes', and 'crossClassProbTable' will
  // have been built.

  {
    // Make sure that the configuration files actually exist.
    if  (!TrainingConfiguration2::ConfigFileExists (param->ConfigFileName1 ()))
    {
      validModel = false;
      KKStr errMsg = "ModelDual::TrainModel  ***ERROR***  Could not find Configuration[" + param->ConfigFileName1 () + "].";
      _log.Level (-1) << endl << errMsg << endl << endl;
      throw KKException (errMsg);
    }

    if  (!TrainingConfiguration2::ConfigFileExists (param->ConfigFileName2 ()))
    {
      validModel = false;
      KKStr errMsg = "ModelDual::TrainModel  ***ERROR***  Could not find Configuration[" + param->ConfigFileName2 () + "].";
      _log.Level (-1) << endl << errMsg << endl << endl;
      throw KKException (errMsg);
    }
  }

  config1 = factoryFVProducer->ManufacturTrainingConfiguration ();
  config1->Load (param->ConfigFileName1 (),
                 false,  // false = Do NOT validate directories.
                 _log
                );
  if  (!config1->FormatGood ())
  {
    validModel = false;
    KKStr errMsg = "ModelDual::TrainModel  ***ERROR***  Configuration[" + param->ConfigFileName1 () + "] is not valid.";
    _log.Level (-1) << endl << errMsg << endl << endl;
    throw KKException (errMsg);
  }

  config2 = factoryFVProducer->ManufacturTrainingConfiguration ();
  config2->Load (param->ConfigFileName2 (), 
                 false,  // false = Do NOT validate directories.
                 _log
                );
  if  (!config2->FormatGood ())
  {
    validModel = false;
    KKStr errMsg = "ModelDual::TrainModel  ***ERROR***  Configuration[" + param->ConfigFileName2 () + "] is not valid.";
    _log.Level (-1) << endl << errMsg << endl << endl;
    throw KKException (errMsg);
  }

  KKStr  statusMsg;

  TrainingTimeStart ();
  trainer1 = TrainingProcess2::CreateTrainingProcessFromTrainingExamples 
                          (config1, 
                           trainExamples, 
                           false,         /**< false = DON'T take ownership of 'trainExamples'. */
                           true,          /**< true = Features are already normalized.  */
                           _cancelFlag,
                           _log
                          );
  TrainingTimeEnd ();

  if  ((!trainer1)  ||  trainer1->Abort ())
  {
    validModel = false;
    KKStr errMsg = "ModelDual::TrainModel  ***ERROR***  Error building TrainingProcess for [" + param->ConfigFileName1 () + "].";
    _log.Level (-1) << endl << errMsg << endl << endl;
    throw KKException (errMsg);
  }

  TrainingTimeStart ();
  trainer2 = TrainingProcess2::CreateTrainingProcessFromTrainingExamples 
                          (config2, 
                           trainExamples, 
                           false,         /**< false = DON'T take ownership of 'trainExamples'. */
                           true,          /**< true = Features are already normalized.  */
                           _cancelFlag,
                           _log
                          );
  TrainingTimeEnd ();

  if  ((!trainer2)  ||  trainer2->Abort ())
  {
    validModel = false;
    KKStr errMsg = "ModelDual::TrainModel  ***ERROR***  Error building TrainingProcess for [" + param->ConfigFileName1 () + "].";
    _log.Level (-1) << endl << errMsg << endl << endl;
    throw KKException (errMsg);
  }

  classifier1 = new Classifier2 (trainer1, _log);
  classifier2 = new Classifier2 (trainer2, _log);
}  /* TrainModel */

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

virtual

Definition at line 875 of file ModelDual.cpp.

References KKB::XmlTag::AddAtribute(), config1, config2, KKB::KKStr::Empty(), KKB::XmlTag::tagEnd, KKB::XmlTag::tagStart, trainer1, trainer2, KKMLL::Model::WriteModelXMLFields(), KKB::XmlTag::WriteXML(), KKMLL::TrainingProcess2::WriteXML(), KKMLL::TrainingConfiguration2::WriteXML(), and KKB::XmlTag::XmlTag().

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

  WriteModelXMLFields (o);  // Write the base class data fields 1st.

  config1->WriteXML ("config1", o);
  config2->WriteXML ("config2", o);

  trainer1->WriteXML ("trainer1", o);
  trainer2->WriteXML ("trainer2", o);

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

Member Data Documentation

Classifier2Ptr KKMLL::ModelDual::classifier1

protected

Definition at line 223 of file ModelDual.h.

Referenced by DeleteExistingClassifiers(), MemoryConsumedEstimated(), ModelDual(), Predict(), ProbabilitiesByClass(), ProbabilitiesByClassDual(), ReadXML(), RetrieveCrossProbTable(), TrainModel(), and ~ModelDual().

Classifier2Ptr KKMLL::ModelDual::classifier2

protected

Definition at line 224 of file ModelDual.h.

Referenced by DeleteExistingClassifiers(), MemoryConsumedEstimated(), ModelDual(), Predict(), ProbabilitiesByClass(), ProbabilitiesByClassDual(), ReadXML(), RetrieveCrossProbTable(), TrainModel(), and ~ModelDual().

TrainingConfiguration2Ptr KKMLL::ModelDual::config1

protected

Definition at line 217 of file ModelDual.h.

Referenced by DeleteExistingClassifiers(), ModelDual(), ReadXML(), TrainModel(), WriteXML(), and ~ModelDual().

TrainingConfiguration2Ptr KKMLL::ModelDual::config2

protected

Definition at line 218 of file ModelDual.h.

Referenced by DeleteExistingClassifiers(), ModelDual(), ReadXML(), TrainModel(), WriteXML(), and ~ModelDual().

ModelParamDualPtr KKMLL::ModelDual::param

protected

We will NOT own this instance. It will point to same instance defined in parent class Model.

Definition at line 229 of file ModelDual.h.

Referenced by ModelDual(), Param(), ReadXML(), ReconcilePredictions(), and TrainModel().

TrainingProcess2Ptr KKMLL::ModelDual::trainer1

protected

Definition at line 220 of file ModelDual.h.

Referenced by DeleteExistingClassifiers(), Description(), MemoryConsumedEstimated(), ModelDual(), NumOfSupportVectors(), ProbabilitiesByClassDual(), ReadXML(), Trainer1(), TrainModel(), WriteXML(), and ~ModelDual().

KKStr KKMLL::ModelDual::trainer1StatusMsg

protected

Definition at line 226 of file ModelDual.h.

TrainingProcess2Ptr KKMLL::ModelDual::trainer2

protected

Definition at line 221 of file ModelDual.h.

Referenced by DeleteExistingClassifiers(), Description(), MemoryConsumedEstimated(), ModelDual(), NumOfSupportVectors(), ProbabilitiesByClassDual(), ReadXML(), Trainer2(), TrainModel(), WriteXML(), and ~ModelDual().

KKStr KKMLL::ModelDual::trainer2StatusMsg

protected

Definition at line 227 of file ModelDual.h.

---

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

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