#include <svm.h>

Public Member Functions
	SvmModel233 ()

	SvmModel233 (const SvmModel233 &_model)

	~SvmModel233 ()

kkint32	MemoryConsumedEstimated () const

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

KKStr	SupportVectorName (kkint32 svIDX)

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

Public Attributes
std::set< kkint32 >	BSVIndex

kkint32	dim

VectorKKStr	exampleNames

double *	featureWeight

double *	kValueTable

kkint32	l

kkint32 *	label

double *	margin

kkint32 *	nonSVIndex

kkint32	nr_class

kkint32 *	nSV

kkint32	numNonSV

svm_parameter	param

double *	rho

svm_node **	SV

double **	sv_coef

kkint32 *	SVIndex

bool	valid

double	weight

bool	weOwnXspace

svm_node *	xSpace

Detailed Description

Definition at line 135 of file svm.h.

Constructor & Destructor Documentation

SVM233::SvmModel233::SvmModel233 ( )

Definition at line 42 of file svm.cpp.

References dim, featureWeight, kValueTable, l, label, margin, nonSVIndex, nr_class, nSV, numNonSV, rho, SV, sv_coef, SVIndex, valid, weight, and weOwnXspace.

 {
   margin        = NULL;
   featureWeight = NULL;
   SVIndex       = NULL;
   nonSVIndex    = NULL;
   label         = NULL;
   nSV           = NULL;
   SV            = NULL;
   sv_coef       = NULL;
   rho           = NULL;
   kValueTable   = NULL;
   nr_class      = -1;
   l             = -1;
   numNonSV      = -1;
   weight        = -1;
   dim           = -1;
   valid         = true;
   weOwnXspace   = false;
 }

SVM233::SvmModel233::~SvmModel233 ( )

Definition at line 64 of file svm.cpp.

 {
   Dispose ();
 }

SVM233::SvmModel233::SvmModel233 ( const SvmModel233 & _model )

inline

Definition at line 177 of file svm.h.

References KKB::KKException::KKException().

   {
     throw KKException ("SvmModel233::SvmModel233 (const   SvmModel233& _model)  ***ERROR***  Not Supported");
   }

Member Function Documentation

kkint32 SVM233::SvmModel233::MemoryConsumedEstimated ( ) const

Definition at line 70 of file svm.cpp.

References dim, featureWeight, kValueTable, l, label, nr_class, nSV, rho, SV, sv_coef, weOwnXspace, and xSpace.

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

 {
   kkint32  memoryConsumedEstimated = sizeof (SvmModel233)
     +  param.MemoryConsumedEstimated ()
     +  (kkint32)exampleNames.size () * 40;
 
   if  (SV)             memoryConsumedEstimated  += sizeof (svm_node*) * l;
   if  (sv_coef)        memoryConsumedEstimated  += (nr_class - 1) * sizeof (double*) + l * (nr_class - 1) * sizeof (double);
   if  (rho)            memoryConsumedEstimated  += l * sizeof (double);
   if  (label)          memoryConsumedEstimated  += nr_class * sizeof (kkint32);
   if  (nSV)            memoryConsumedEstimated  += nr_class * sizeof (kkint32);
   if  (featureWeight)  memoryConsumedEstimated  += dim * sizeof (double);
   if  (kValueTable)    memoryConsumedEstimated  += sizeof (double) * l;
   if  ((xSpace != NULL) &&  weOwnXspace)  
     memoryConsumedEstimated  += sizeof (svm_node) * l;
 
   return  memoryConsumedEstimated;
 }

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

virtual

Definition at line 234 of file svm.cpp.

References KKB::KKStr::Concat(), KKB::XmlContent::Content(), KKB::KKStr::EqualIgnoreCase(), KKB::KKStrParser::GetNextToken(), KKB::XmlStream::GetNextToken(), KKB::KKStrParser::GetNextTokenDouble(), KKB::KKStrParser::GetNextTokenInt(), SVM233::svm_node::index, KKB::KKStrParser::KKStrParser(), kValueTable, l, label, margin, KKB::KKStrParser::MoreTokens(), nr_class, nSV, rho, KKB::XmlElement::SectionName(), SV, sv_coef, KKB::XmlElement::ToInt32(), KKB::XmlToken::tokElement, KKB::XmlToken::TokenType(), KKB::KKStrParser::TrimWhiteSpace(), valid, SVM233::svm_node::value, KKB::XmlElement::VarName(), weOwnXspace, and xSpace.

 {
   exampleNames.clear ();
   kkint32 numberOfBinaryClassifiers = 0;
   kkint32 numElementsLoaded         = 0;
   kkint32 totalNumSVs               = 0;
   kkint32 totalNumOfElements        = 0;
   kkint32 numSVsLoaded              = 0;
   delete  rho;      rho     = NULL;
   delete  margin;   margin  = NULL;
   delete  nSV;      nSV     = NULL;
   delete  label;    label   = NULL;
   delete  SV;       SV      = NULL;
 
   bool  errorsFound = false;
   valid = true;
 
   XmlTokenPtr  t = NULL;
   while  ((!errorsFound)  &&  (!cancelFlag))
   {
     if  (t != NULL)
     {
       if  (typeid (*t) == typeid (XmlContent))
       {
         XmlContentPtr cp = dynamic_cast<XmlContentPtr> (t);
         delete  cp;  cp = NULL;  t = NULL;
       }
       else
       {
         delete t;
       }
     }
 
     t = s.GetNextToken (cancelFlag, log);
     if  (cancelFlag)
     {
       delete  t;
       t = NULL;
     }
     if  (!t)  break;
 
     if  (t->TokenType () == XmlToken::TokenTypes::tokElement)
     {
       XmlElementPtr  e = dynamic_cast<XmlElementPtr> (t);
       const KKStr&  varName = e->VarName ();
       const KKStr&  sectionName = e->SectionName ();
 
       if  (varName.EqualIgnoreCase ("Param")  &&  (typeid (*e) == typeid (XmlElementKKStr)))
       {
         param.ParseTabDelStr (*(dynamic_cast<XmlElementKKStrPtr> (e)->Value ()));
       }
 
       else if  (varName.EqualIgnoreCase ("nr_class"))
       {
         nr_class = e->ToInt32 ();
         numberOfBinaryClassifiers = nr_class * (nr_class - 1) / 2;
       }
 
       else if  (varName.EqualIgnoreCase ("totalNumSVs"))
       {
          totalNumSVs = e->ToInt32 ();
          l = totalNumSVs;
       }
 
       else if  (varName.EqualIgnoreCase ("rho")  &&  (typeid (*e) == typeid (XmlElementArrayDouble)))
       {
         delete  rho;  rho = NULL;
         XmlElementArrayDoublePtr rhoArray = dynamic_cast<XmlElementArrayDoublePtr> (e);
         if  (rhoArray->Count () != numberOfBinaryClassifiers)
         {
           log.Level (-1) << endl
             << "SvmModel233::ReadXML   ***ERROR***   'rho' array incorrect length: expected: " 
             << numberOfBinaryClassifiers << "  found: " << rhoArray->Count () << " elements"
             << endl <<endl;
           errorsFound = true;
         }
         else
         {
           rho = rhoArray->TakeOwnership ();
         }
       }
 
       else if  (varName.EqualIgnoreCase ("margin")  &&  (typeid (*e) == typeid (XmlElementArrayDouble)))
       {
         delete  margin;  margin = NULL;
         XmlElementArrayDoublePtr marginArray = dynamic_cast<XmlElementArrayDoublePtr> (e);
         if  (marginArray->Count () != numberOfBinaryClassifiers)
         {
           log.Level (-1) << endl
             << "SvmModel233::ReadXML   ***ERROR***   'margin' array incorrect length: expected: " 
             << numberOfBinaryClassifiers << "  found: " << marginArray->Count () << " elements"
             << endl <<endl;
           errorsFound = true;
         }
         else
         {
           margin = marginArray->TakeOwnership ();
         }
       }
 
       else if  (varName.EqualIgnoreCase ("label")  &&  (typeid (*e) == typeid (XmlElementArrayInt32)))
       {
         delete  label;  label = NULL;
         XmlElementArrayInt32Ptr labelArray = dynamic_cast<XmlElementArrayInt32Ptr> (e);
         if  (labelArray->Count () != nr_class)
         {
           log.Level (-1) << endl
             << "SvmModel233::ReadXML   ***ERROR***   'label' array incorrect length: expected: " 
             << nr_class << "  found: " << labelArray->Count () << " elements"
             << endl <<endl;
           errorsFound = true;
         }
         else
         {
           label = labelArray->TakeOwnership ();
         }
       }
 
       else if  (varName.EqualIgnoreCase ("nSV")  &&  (typeid (*e) == typeid (XmlElementArrayInt32)))
       {
         delete  nSV;  nSV = NULL;
         XmlElementArrayInt32Ptr nSVArray = dynamic_cast<XmlElementArrayInt32Ptr> (e);
         if  (nSVArray->Count () != nr_class)
         {
           log.Level (-1) << endl
             << "SvmModel233::ReadXML   ***ERROR***   'nSV' array incorrect length: expected: " 
             << nr_class << "  found: " << nSVArray->Count () << " elements"
             << endl <<endl;
           errorsFound = true;
         }
         else
         {
           nSV = nSVArray->TakeOwnership ();
         }
       }
 
       else if  (varName.EqualIgnoreCase ("totalNumOfElements"))
       {
         totalNumOfElements = e->ToInt32 ();
         if  (totalNumOfElements < 1)
         {
           log.Level (-1) << endl 
             << "SvmModel233::ReadXML   ***ERROR***   Invalid  totalNumOfElements: " << totalNumOfElements << endl
             << endl;
           errorsFound = true;
         }
         else
         {
           kkint32 m = nr_class - 1;
           // kint32 l = model->l;
         
           delete  sv_coef;
           sv_coef = new double*[l];
           for (kkint32 i = 0;  i < m;  i++)
             sv_coef[i] = new double[l];
 
           SV = new svm_node*[l];
           xSpace = new svm_node[totalNumOfElements];
           weOwnXspace = true;
         }
       }
     }
     else if  (typeid (*t) == typeid (XmlContent))
     {
       XmlContentPtr content = dynamic_cast<XmlContentPtr> (t);
       KKStrParser p (*(content->Content ()));
       p.TrimWhiteSpace (" ");
 
       KKStr  lineName = p.GetNextToken ("\t");
       if  (!lineName.EqualIgnoreCase ("SuportVectorNamed")  &&  !lineName.EqualIgnoreCase ("SuportVector"))
       {
         log.Level (-1) << endl
           << "SvmModel233::ReadXML   ***ERROR***   Invalid Content: " << lineName << endl
           << endl;
         errorsFound = true;
       }
 
       else if  (numSVsLoaded >= totalNumSVs)
       {
         log.Level (-1) << "SvmModel233::ReadXML  ***ERROR***  Exceeding expected number of Support Vectors." << endl;
       }
 
       if  (!SV)
       {
         log.Level (-1) << endl << "SvmModel233::ReadXML   ***ERROR***   'SV'  was no defined  LineNum:" << lineName << endl << endl;
         errorsFound = true;
       }
 
       if  (!errorsFound)
       {
         if  (lineName.EqualIgnoreCase ("SuportVectorNamed"))
         {
           exampleNames.push_back (p.GetNextToken ("\t"));
         }
       
         for (kkint32 j = 0;  j < nr_class - 1;  j++)
           sv_coef[j][numSVsLoaded] = p.GetNextTokenDouble ("\t");
 
         SV[numSVsLoaded] = &(xSpace[numElementsLoaded]);
 
         while  ((p.MoreTokens ())  &&  (numElementsLoaded < (totalNumOfElements - 1)))
         {
           xSpace[numElementsLoaded].index = p.GetNextTokenInt (":");
           xSpace[numElementsLoaded].value = p.GetNextTokenDouble ("\t");
           numElementsLoaded++;
         }
 
         if  (numElementsLoaded >= totalNumOfElements)
         {
           log.Level (-1) << endl
                << "SvmModel233::ReadXML   ***ERROR***   'numElementsLoaded'  is greater than what was defined by 'totalNumOfElements'." << endl
                << endl;
           errorsFound = true;
         }
         else
         {
           xSpace[numElementsLoaded].index = -1;
           xSpace[numElementsLoaded].value = 0.0;
           numElementsLoaded++;
           numSVsLoaded++;
         }
       }
     }
     else
     {
       log.Level (-1) << endl
         << "SvmModel233::ReadXML   ***ERROR***  Unexpected Token[" << t->SectionName () << "  " << t->VarName () << "]" << endl
         << endl;
       errorsFound = true;
     }
 
     delete  t;
     t = NULL;
   }
 
   if  (!errorsFound)
   {
     if  (numSVsLoaded != totalNumSVs)
     {
       log.Level (-1) << endl
         << "SvmModel233::ReadXML   ***ERROR***   numSVsLoaded[" << numSVsLoaded << "] does not match totalNumSVs[" << totalNumSVs << "]." << endl
         << endl;
       errorsFound= true;
     }
 
     else
     {
       delete  kValueTable;
       kValueTable = new double[l];
     }
   }
 
   valid = (!errorsFound)  &&  (!cancelFlag);
 }  /* ReadXML */

KKStr SVM233::SvmModel233::SupportVectorName ( kkint32 svIDX )

Definition at line 134 of file svm.cpp.

Referenced by KKMLL::SVMModel::FindWorstSupportVectors(), KKMLL::SVMModel::FindWorstSupportVectors2(), and KKMLL::SVMModel::SupportVectorNames().

 {
   if  (svIDX < (kkint32)exampleNames.size ())
     return  exampleNames[svIDX];
   else
     return  "SV" + StrFormatInt (svIDX, "ZZZ#");
 }

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

virtual

Definition at line 144 of file svm.cpp.

References KKB::XmlTag::AddAtribute(), KKB::KKStr::Empty(), SVM233::svm_node::index, l, label, margin, nr_class, nSV, param, rho, SV, KKB::XmlTag::tagEnd, KKB::XmlTag::tagStart, SVM233::svm_parameter::ToTabDelStr(), KKB::XmlTag::WriteXML(), KKB::KKStr::WriteXML(), and KKB::XmlTag::XmlTag().

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

 {
   XmlTag  startTag ("SvmModel233",  XmlTag::TagTypes::tagStart);
   if  (!varName.Empty ())
     startTag.AddAtribute ("VarName", varName);
   startTag.WriteXML (o);
   o << endl;
 
   kkint32 numberOfBinaryClassifiers = nr_class * (nr_class - 1) / 2;
 
   kkint32  origPrecision = (kkint32)o.precision ();
   o.precision (14);
 
   param.ToTabDelStr ().WriteXML ("Param", o);
 
   XmlElementInt32::WriteXML (nr_class, "nr_class", o);
 
   kkint32 totalNumSVs = l;
 
   XmlElementInt32::WriteXML (totalNumSVs, "totalNumSVs", o);
 
   XmlElementArrayDouble::WriteXML (numberOfBinaryClassifiers, rho, "rho", o);
 
   if  (margin)
   {
     kkint32  oldPrecision = (kkint32)o.precision ();
     o.precision (9);
     XmlElementArrayDouble::WriteXML (numberOfBinaryClassifiers, margin, "margin", o);
     o.precision (oldPrecision);
   }
 
   if (label)
     XmlElementArrayInt32::WriteXML (nr_class, label, "label", o);
 
   if  (nSV)
     XmlElementArrayInt32::WriteXML (nr_class, nSV, "nSV", o);
 
   {
     // Determine total number of elements
     kkint32  totalNumOfElements = 0;
     for  (kkint32 i = 0;  i < totalNumSVs;  i++)
     {
       const svm_node *p = SV[i];
       while  (p->index != -1)
       {
         totalNumOfElements++;
         p++;
       }
 
       totalNumOfElements++;  // Add one for terminating node
     }
 
     XmlElementInt32::WriteXML (totalNumOfElements, "totalNumOfElements", o);
   }
 
   // The Support Vector Information will be written in the Contents portion of SvmModel233
   for  (kkint32 i = 0;  i < totalNumSVs;  i++)
   {
     if  ((kkint32)exampleNames.size () > i)
       o << "SuportVectorNamed"  << "\t" << exampleNames[i];
     else
       o << "SuportVector";
 
     o.precision (16);
     for (kkint32 j = 0;  j < nr_class - 1;  j++)
       o << "\t" << sv_coef[j][i];
 
     const svm_node *p = SV[i];
     while  (p->index != -1)
     {
       o << "\t" << p->index << ":" << p->value;
       p++;
     }
 
     o << endl;
   }
 
    o.precision (origPrecision);
 
   XmlTag  endTag ("SvmModel233", XmlTag::TagTypes::tagEnd);
   endTag.WriteXML (o);
   o << endl;
 }  /* WriteXML */