#include <svm2.h>

Public Member Functions
	Svm_Model ()

	Svm_Model (const Svm_Model &_model, FileDescPtr _fileDesc)

	Svm_Model (FileDescPtr _fileDesc)

	Svm_Model (const svm_parameter &_param, const FeatureNumList &_selFeatures, FileDescPtr _fileDesc)

	~Svm_Model ()

void	CancelFlag (bool cancelFlag)

void	CleanUpMemory ()

double *	DecValues ()

kkint32	MemoryConsumedEstimated () const

void	NormalizeProbability ()
	Derives multi-class probability. More...

double **	PairwiseProb ()

double *	ProbEstimates ()

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

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

Public Attributes
volatile bool	cancelFlag

double *	dec_values

FileDescPtr	fileDesc

kkint32 *	label

kkint32	nr_class

kkint32 *	nSV

kkint32	numSVs

double **	pairwise_prob

svm_parameter	param

double *	prob_estimates

double *	probA

double *	probB

double *	rho

FeatureNumList	selFeatures

FeatureVectorList	SV

double **	sv_coef

bool	weOwnSupportVectors

Detailed Description

Definition at line 160 of file svm2.h.

Constructor & Destructor Documentation

SVM289_MFS::Svm_Model::Svm_Model ( )

Definition at line 4067 of file svm2.cpp.

References cancelFlag, dec_values, fileDesc, label, nr_class, nSV, numSVs, pairwise_prob, param, prob_estimates, probA, probB, rho, selFeatures, sv_coef, Svm_Model(), SVM289_MFS::svm_parameter::svm_parameter(), and weOwnSupportVectors.

Referenced by Svm_Model().

                                :
   cancelFlag          (false),
   fileDesc            (NULL),
   param               (),
   nr_class            (0),
   numSVs              (0),
   SV                  (),
   sv_coef             (NULL),
   rho                 (NULL),
   probA               (NULL),
   probB               (NULL),
   label               (NULL),
   nSV                 (NULL),     // number of SVs for each class (nSV[k])
   weOwnSupportVectors (true),
   selFeatures         (),
   dec_values          (NULL),
   pairwise_prob       (NULL),
   prob_estimates      (NULL)
 {
 }

SVM289_MFS::Svm_Model::Svm_Model	(	const Svm_Model &	_model,
		FileDescPtr	_fileDesc
	)

Definition at line 4089 of file svm2.cpp.

References cancelFlag, dec_values, KKMLL::FeatureNumList::FeatureNumList(), fileDesc, label, nr_class, nSV, numSVs, pairwise_prob, param, prob_estimates, probA, probB, rho, selFeatures, sv_coef, Svm_Model(), SVM289_MFS::svm_parameter::svm_parameter(), and weOwnSupportVectors.

Referenced by KKMLL::ModelSvmBase::ModelSvmBase(), and Svm_Model().

                                   :
   cancelFlag          (false),
   fileDesc            (_fileDesc),
   param               (_model.param),
   nr_class            (_model.nr_class),
   numSVs              (_model.numSVs),
   SV                  (),
   sv_coef             (NULL),
   rho                 (NULL),
   probA               (NULL),
   probB               (NULL),
   label               (NULL),
   nSV                 (NULL),     // number of SVs for each class (nSV[k])
   weOwnSupportVectors (_model.weOwnSupportVectors),
   selFeatures         (_model.selFeatures),
   dec_values          (NULL),
   pairwise_prob       (NULL),
   prob_estimates      (NULL)
 
 {
   kkint32  m = nr_class - 1;
   kkint32  numBinaryCombos = nr_class * (nr_class - 1) / 2;
 
   {
     // Copy over support vectors.
     FeatureVectorList::const_iterator idx;
     SV.Owner (weOwnSupportVectors);
     for  (idx = _model.SV.begin ();  idx != _model.SV.end ();  idx++)
     {
       FeatureVectorPtr fv = *idx;
       if  (weOwnSupportVectors)
         SV.push_back (new FeatureVector (*fv));
       else
         SV.push_back (fv);
     }
   }
 
   if  (_model.sv_coef)
   {
     sv_coef = new double*[m];
     for  (kkint32 j = 0;  j < m;  j++)
     {
       sv_coef[j] = new double[numSVs];
       for  (kkint32 i = 0;   i < numSVs;  ++i)
        sv_coef[j][i] = _model.sv_coef[j][i];
     }
   }
 
   if  (_model.rho)
   {
     // Copy over RHO
     rho = new double[numBinaryCombos];
     for  (kkint32 i = 0;  i < numBinaryCombos;  i++)
       rho[i] = _model.rho[i];
   }
 
   if  (_model.probA)
   {
     probA = new double[numBinaryCombos];
     for  (kkint32 i = 0;  i < numBinaryCombos;  i++)
       probA[i] = _model.probA[i];
   }
 
   if  (_model.probB)
   {
     probB = new double[numBinaryCombos];
     for  (kkint32 i = 0;  i < numBinaryCombos;  i++)
       probB[i] = _model.probB[i];
   }
 
   if  (_model.label)
   {
     label = new kkint32[nr_class];
     for  (kkint32 i = 0;  i < nr_class;  i++)
       label[i] = _model.label[i];
   }
 
   if  (_model.nSV)
   {
     nSV = new kkint32[nr_class];
     for (kkint32 i = 0;  i < nr_class;  i++)
       nSV[i] = _model.nSV[i];
   }
 }

SVM289_MFS::Svm_Model::Svm_Model ( FileDescPtr _fileDesc )

Definition at line 4178 of file svm2.cpp.

References cancelFlag, dec_values, KKMLL::FeatureNumList::FeatureNumList(), fileDesc, label, nr_class, nSV, numSVs, pairwise_prob, param, prob_estimates, probA, probB, rho, selFeatures, sv_coef, Svm_Model(), SVM289_MFS::svm_parameter::svm_parameter(), and weOwnSupportVectors.

Referenced by Svm_Model().

                                                     :
    cancelFlag          (false),
    fileDesc            (_fileDesc),
    param               (),
    nr_class            (0),
    numSVs              (0),
    SV                  (_fileDesc, true),
    sv_coef             (NULL),
    rho                 (NULL),
    probA               (NULL),
    probB               (NULL),
    label               (NULL),
    nSV                 (NULL),     // number of SVs for each class (nSV[k])
    weOwnSupportVectors (false),
    selFeatures         (_fileDesc),
    dec_values          (NULL),
    pairwise_prob       (NULL),
    prob_estimates      (NULL)
 {
 }

SVM289_MFS::Svm_Model::Svm_Model	(	const svm_parameter &	_param,
		const FeatureNumList &	_selFeatures,
		FileDescPtr	_fileDesc
	)

Definition at line 4200 of file svm2.cpp.

References cancelFlag, dec_values, KKMLL::FeatureNumList::FeatureNumList(), fileDesc, label, nr_class, nSV, numSVs, pairwise_prob, param, prob_estimates, probA, probB, rho, selFeatures, sv_coef, Svm_Model(), SVM289_MFS::svm_parameter::svm_parameter(), and weOwnSupportVectors.

Referenced by Svm_Model(), and SVM289_MFS::svm_train().

                                   :
    cancelFlag          (false),
    fileDesc            (_fileDesc),
    param               (_param),
    nr_class            (0),
    numSVs              (0),
    SV                  (_fileDesc, true),
    sv_coef             (NULL),
    rho                 (NULL),
    probA               (NULL),
    probB               (NULL),
    label               (NULL),
    nSV                 (NULL),     // number of SVs for each class (nSV[k])
    weOwnSupportVectors (false),
    selFeatures         (_selFeatures),
    dec_values          (NULL),
    pairwise_prob       (NULL),
    prob_estimates      (NULL)
 
 {
 }

SVM289_MFS::Svm_Model::~Svm_Model ( )

Definition at line 4229 of file svm2.cpp.

References CleanUpMemory().

 {
   CleanUpMemory ();
 }

Member Function Documentation

void SVM289_MFS::Svm_Model::CancelFlag ( bool cancelFlag )

Definition at line 4277 of file svm2.cpp.

References cancelFlag.

 {
   cancelFlag = _cancelFlag;
 }

void SVM289_MFS::Svm_Model::CleanUpMemory ( )

Definition at line 4235 of file svm2.cpp.

References dec_values, label, nr_class, nSV, pairwise_prob, prob_estimates, probA, probB, rho, and sv_coef.

Referenced by ReadXML(), and ~Svm_Model().

 {
   if  (weOwnSupportVectors)
     SV.Owner (true);
   else
     SV.Owner (false);
 
   kkint32  i;
 
   if  (sv_coef)
   {
     for  (i = 0;  i < (nr_class - 1);  i++)
       delete sv_coef[i];
     delete  sv_coef;
     sv_coef = NULL;
   }
 
   delete  rho;     rho   = NULL;
   delete  probA;   probA = NULL;
   delete  probB;   probB = NULL;
   delete  label;   label = NULL;
   delete  nSV;     nSV   = NULL;
 
   if  (pairwise_prob)
   {
     for  (i = 0;  i < nr_class;  i++)
     {
       delete  pairwise_prob[i];
       pairwise_prob[i] = NULL;
     }
     delete  pairwise_prob;
     pairwise_prob = NULL;
   }
 
   delete  dec_values;
   dec_values = NULL;
   delete  prob_estimates;
   prob_estimates = NULL;
 }  /* CleanUpMemory */

double * SVM289_MFS::Svm_Model::DecValues ( )

Definition at line 4303 of file svm2.cpp.

References dec_values, and nr_class.

Referenced by SVM289_MFS::svm_predict_probability().

 {
   if  (!dec_values)
     dec_values = new double[nr_class * (nr_class - 1) / 2];
   return  dec_values;
 }

kkint32 SVM289_MFS::Svm_Model::MemoryConsumedEstimated ( ) const

Definition at line 4284 of file svm2.cpp.

References dec_values, label, nr_class, nSV, numSVs, pairwise_prob, prob_estimates, probA, probB, rho, and sv_coef.

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

 {
   kkint32  numBinaryClassCombos = nr_class * (nr_class - 1) / 2;
   kkint32  memoryConsumedEstimated = sizeof (*this) + SV.MemoryConsumedEstimated ();
 
   if  (sv_coef)         memoryConsumedEstimated += sizeof (double)  * (nr_class - 1) * numSVs;    // sv_coef
   if  (rho)             memoryConsumedEstimated += sizeof (double)  * numBinaryClassCombos;  // rho
   if  (probA)           memoryConsumedEstimated += sizeof (double)  * numBinaryClassCombos;  // probA
   if  (probB)           memoryConsumedEstimated += sizeof (double)  * numBinaryClassCombos;  // probB
   if  (label)           memoryConsumedEstimated += sizeof (kkint32) * nr_class;
   if  (nSV)             memoryConsumedEstimated += sizeof (kkint32) * nr_class;
   if  (pairwise_prob)   memoryConsumedEstimated += sizeof (double*) * nr_class + sizeof (double) * nr_class * nr_class;
   if  (dec_values)      memoryConsumedEstimated += sizeof (double)  * numBinaryClassCombos;
   if  (prob_estimates)  memoryConsumedEstimated += sizeof (double)  * nr_class;
   return  memoryConsumedEstimated;
 }  /* Svm_Model::MemoryConsumedEstimated */

void SVM289_MFS::Svm_Model::NormalizeProbability ( )

Derives multi-class probability.

Definition at line 4581 of file svm2.cpp.

References nr_class, pairwise_prob, prob_estimates, and ProbEstimates().

Referenced by SVM289_MFS::svm_predict_probability().

 {
   // Make sure that the ProbEstimates array exists.
   ProbEstimates ();
 
   if  (pairwise_prob == NULL)
     return;
 
   kkint32  x = 0;
   kkint32  y = 0;
   double  totalProb = 0.0;
 
   for  (x = 0;  x < nr_class;  x++)
   {
     prob_estimates[x] = 1.0;
     for  (y = 0;  y < nr_class;  y++)
     {
       if  (x != y)
         prob_estimates[x] *= pairwise_prob[x][y];
     }
 
     totalProb += prob_estimates[x];
   }
 
   for  (x = 0;  x < nr_class;  x++)
     prob_estimates[x] /= totalProb;
 }  /* NormalizeProbability */

double ** SVM289_MFS::Svm_Model::PairwiseProb ( )

Definition at line 4319 of file svm2.cpp.

References nr_class, and pairwise_prob.

Referenced by KKMLL::ModelSvmBase::RetrieveCrossProbTable(), and SVM289_MFS::svm_predict_probability().

 {
   if  (!pairwise_prob)
   {
     pairwise_prob = new double*[nr_class];
     for  (kkint32 x = 0;  x < nr_class;  x++)
       pairwise_prob[x] = new double[nr_class];
   }
   return  pairwise_prob;
 }

double * SVM289_MFS::Svm_Model::ProbEstimates ( )

Definition at line 4311 of file svm2.cpp.

References nr_class, and prob_estimates.

Referenced by NormalizeProbability(), and SVM289_MFS::svm_predict_probability().

 {
   if  (!prob_estimates)
     prob_estimates = new double[nr_class];
   return  prob_estimates;
 }

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

virtual

Reading in all the info needed to build the Svm_Model data structure including allocating needed memory.

Definition at line 4417 of file svm2.cpp.

References CleanUpMemory(), SVM289_MFS::svm_parameter::coef0, KKB::KKStr::Concat(), SVM289_MFS::svm_parameter::degree, KKB::KKStr::EqualIgnoreCase(), fileDesc, SVM289_MFS::svm_parameter::gamma, KKB::XmlStream::GetNextToken(), SVM289_MFS::svm_parameter::kernel_type, SVM289_MFS::Kernel_Type_FromStr(), label, nr_class, nSV, numSVs, param, probA, probB, rho, sv_coef, SVM289_MFS::svm_parameter::svm_type, SVM289_MFS::SVM_Type_FromStr(), KKB::XmlToken::tokElement, KKB::XmlToken::TokenType(), KKMLL::XmlElementFileDesc::Value(), KKB::XmlToken::VarName(), and weOwnSupportVectors.

 {
   CleanUpMemory ();
   SV.Owner (true);
   weOwnSupportVectors = true;
 
   kkint32  numBinaryCombos = 0;
 
   KKStr  svmParametersStr;
   XmlTokenPtr  t = s.GetNextToken (cancelFlag, log);
   while  (t  &&  (!cancelFlag))
   {
     const KKStr& varName = t->VarName ();
     if  (t->TokenType () == XmlToken::TokenTypes::tokElement)
     {
       XmlElementPtr e = dynamic_cast<XmlElementPtr> (t);
       if  (e)
       {
         KKStr  valueStr;
         double  valueDouble = 0.0;
         kkint32  valueInt32 = 0;
 
         if  (typeid(*e) == typeid(XmlElementKKStr))
           valueStr = *(dynamic_cast<XmlElementKKStrPtr> (e)->Value ());
 
         else if  (typeid(*e) == typeid(XmlElementInt32))
           valueInt32 = dynamic_cast<XmlElementInt32Ptr> (e)->Value ();
 
         else if  (typeid(*e) == typeid(XmlElementDouble))
           valueDouble = dynamic_cast<XmlElementDoublePtr> (e)->Value ();
 
         if  (varName.EqualIgnoreCase ("FileDesc"))
         {
           fileDesc = dynamic_cast<XmlElementFileDescPtr> (e)->Value ();
           SV.ResetFileDesc (fileDesc);
         }
 
         else if  (varName.EqualIgnoreCase ("svm_type"))
           param.svm_type = SVM_Type_FromStr (valueStr);
 
         else if  (varName.EqualIgnoreCase ("kernel_type"))
           param.kernel_type = Kernel_Type_FromStr (valueStr);
 
         else if  (varName.EqualIgnoreCase ("degree"))
           param.degree = valueInt32;
 
         else if  (varName.EqualIgnoreCase ("gamma"))
           param.gamma = valueDouble;
 
         else if  (varName.EqualIgnoreCase ("coef0"))
           param.coef0 = valueDouble;
 
         else if  (varName.EqualIgnoreCase ("selFeatures"))
           selFeatures = *(dynamic_cast<XmlElementFeatureNumListPtr> (e)->Value ());
 
         else if  (varName.EqualIgnoreCase ("nr_class"))
         {
           nr_class = valueInt32;
           numBinaryCombos = nr_class * (nr_class - 1) / 2;
         }
 
         else if  (varName.EqualIgnoreCase ("numSVs"))
           numSVs = valueInt32;
 
         else if  (varName.EqualIgnoreCase ("rho"))
         {
           delete  rho;
           rho = dynamic_cast<XmlElementArrayDoublePtr> (e)->TakeOwnership ();
           numSVs = valueInt32;
         }
 
         else if  (varName.EqualIgnoreCase ("label"))
         {
           delete  label;
           label = dynamic_cast<XmlElementArrayInt32Ptr> (e)->TakeOwnership ();
         }
 
         else if  (varName.EqualIgnoreCase ("probA"))
         {
           delete  probA;
           probA = dynamic_cast<XmlElementArrayDoublePtr> (e)->TakeOwnership ();   // numBinaryCombos
         }  
 
         else if  (varName.EqualIgnoreCase ("probB"))
         {
           delete  probB;
           probB = dynamic_cast<XmlElementArrayDoublePtr> (e)->TakeOwnership ();   // numBinaryCombos
         }
 
         else if  (varName.EqualIgnoreCase ("nSV"))
         {
           delete nSV;
           nSV = dynamic_cast<XmlElementArrayInt32Ptr> (e)->TakeOwnership ();   // numBinaryCombos
         }
 
         else if  (varName.EqualIgnoreCase ("SupportVector"))
         {
           kkint32 m = nr_class - 1;
           kkint32 i = 0, j = 0;
 
           if  (!sv_coef)
           {
             sv_coef = new double*[m];
             for  (i = 0;  i < m;  i++)
             {
               sv_coef[i] = new double[numSVs];
               for  (j = 0;  j < numSVs;  j++)
                 sv_coef[i][j] = 0.0;
             }
           }
 
           if  (SV.QueueSize () >= numSVs)
           {
             KKStr errorMsg = "SVM289_MFS::Svm_Model::Read   ***ERROR***  To many Support Vector's Defined.";
             log.Level (-1) << endl << errorMsg << endl << endl;
           }
           else
           {
             KKStrParser p (valueStr);
             p.TrimWhiteSpace (" ");
             KKStr    imageFileName = p.GetNextToken ("\t");
             kkint32  numOffeatures  = p.GetNextTokenInt ("\t");
 
             FeatureVectorPtr  fv = new FeatureVector (numOffeatures);
 
             for  (kkint32  j = 0;  (j < (nr_class - 1))  &&  p.MoreTokens ();  ++j)
               sv_coef[j][i] = p.GetNextTokenDouble ("\t");
 
             if  (param.kernel_type == Kernel_Type::PRECOMPUTED)
             {
               log.Level (-1) << endl << endl
                              << "SVM289_MFS::Svm_Model::Read  ***ERROR***    PRECOMPUTED   Can not Handle." << endl
                              << endl;
             }
             else
             {
               for  (kkint32 zed = 0;  (zed < numOffeatures)  &&  (p.MoreTokens ());  ++zed)
               {
                 KKStr  featureField = p.GetNextToken ("\t");
                 kkint32 featureNumber = featureField.ExtractTokenInt (":");
                 double  featureValue = featureField.ExtractTokenDouble ("\t");
                 fv->FeatureData (featureNumber, (float)featureValue);
               }
             }
             SV.PushOnBack (fv);
           }
         }
       }
     }
     delete  t;
     t = s.GetNextToken (cancelFlag, log);
   }
   delete  t;
   t = NULL;
 }  /* ReadXML */

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

virtual

Definition at line 4332 of file svm2.cpp.

References KKB::XmlTag::AddAtribute(), SVM289_MFS::svm_parameter::coef0, KKB::KKStr::Concat(), SVM289_MFS::svm_parameter::degree, KKB::KKStr::Empty(), KKMLL::FeatureVector::ExampleFileName(), KKMLL::FeatureVector::FeatureData(), fileDesc, SVM289_MFS::svm_parameter::gamma, SVM289_MFS::svm_parameter::kernel_type, SVM289_MFS::Kernel_Type_ToStr(), KKB::KKStr::KKStr(), label, nr_class, nSV, KKMLL::FeatureVector::NumOfFeatures(), numSVs, param, SVM289_MFS::POLY, SVM289_MFS::PRECOMPUTED, probA, probB, SVM289_MFS::RBF, rho, selFeatures, SVM289_MFS::SIGMOID, KKB::SPRINTF(), sv_coef, SVM289_MFS::svm_parameter::svm_type, SVM289_MFS::SVM_Type_ToStr(), KKB::XmlTag::tagEnd, KKB::XmlTag::tagStart, KKMLL::FeatureNumList::WriteXML(), KKB::XmlTag::WriteXML(), KKMLL::FileDesc::WriteXML(), KKB::KKStr::WriteXML(), and KKB::XmlTag::XmlTag().

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

 {
   XmlTag  startTag ("Svm_Model",  XmlTag::TagTypes::tagStart);
   if  (!varName.Empty ())
     startTag.AddAtribute ("VarName", varName);
   startTag.WriteXML (o);
   o << endl;
 
   fileDesc->WriteXML ("FileDesc", o);
 
   SVM_Type_ToStr (param.svm_type).WriteXML ("svm_type", o);
 
   Kernel_Type_ToStr (param.kernel_type).WriteXML ("kernel_type", o);
 
   if  (param.kernel_type == Kernel_Type::POLY)
     XmlElementInt32::WriteXML (param.degree, "degree", o);
 
   if  (param.kernel_type == Kernel_Type::POLY || param.kernel_type == Kernel_Type::RBF || param.kernel_type == Kernel_Type::SIGMOID)
     XmlElementDouble::WriteXML (param.gamma, "gamma", o);
 
   if  (param.kernel_type == Kernel_Type::POLY || param.kernel_type == Kernel_Type::SIGMOID)
     XmlElementDouble::WriteXML (param.coef0, "coef0", o);
 
   selFeatures.WriteXML ("selFeatures", o);
 
   XmlElementInt32::WriteXML (nr_class, "nr_class", o);
 
   kkint32  numBinaryCombos = nr_class * (nr_class - 1) / 2;
 
   XmlElementInt32::WriteXML (numSVs, "numSVs", o);
   
   XmlElementArrayDouble::WriteXML (numBinaryCombos, rho, "rho", o);
   
   XmlElementArrayInt32::WriteXML (nr_class, label, "label", o);
 
   if  (probA) // regression has probA only
      XmlElementArrayDouble::WriteXML (numBinaryCombos, probA, "probA", o);
 
   if  (probB)
      XmlElementArrayDouble::WriteXML (numBinaryCombos, probB, "probB", o);
 
   if  (nSV)
       XmlElementArrayInt32::WriteXML (nr_class, nSV, "nSV", o);
 
   char buff[128];
 
   for  (kkint32 i = 0;  i < numSVs;  ++i)
   {
     const  FeatureVector&  p = SV[i];
 
     KKStr  svStr (512);
     svStr << p.ExampleFileName () << "\t" << p.NumOfFeatures ();
     for  (kkint32 j = 0;  j < nr_class - 1;  j++)
     {
       SPRINTF (buff, sizeof (buff), "%0.15g", sv_coef[j][i]);
       svStr << "\t" << buff;
     }
 
     if  (param.kernel_type == Kernel_Type::PRECOMPUTED)
     {
       svStr << "\t" << p.FeatureData (0);
     }
     else
     {
       for  (kkint32 zed = 0;  zed < p.NumOfFeatures ();  zed++)
         svStr << "\t" << zed << ":" << p.FeatureData (zed);
     }
 
     svStr.WriteXML ("SupportVector", o);
   }
 
   XmlTag  endTag ("Svm_Model", XmlTag::TagTypes::tagEnd);
   endTag.WriteXML (o);
   o << endl;
 }  /* WriteXML */