SvmWrapper.cpp File Reference

Provides an interface to the svm.cpp functions. More...

#include "FirstIncludes.h"
#include <algorithm>
#include <ctype.h>
#include "float.h"
#include <fstream>
#include <iostream>
#include <math.h>
#include <map>
#include <numeric>
#include <ostream>
#include <set>
#include <sstream>
#include <stdio.h>
#include <string>
#include <time.h>
#include <vector>
#include "MemoryDebug.h"
#include "KKBaseTypes.h"
#include "OSservices.h"
#include "SvmWrapper.h"
#include "KKMLLTypes.h"
#include "svm.h"

Go to the source code of this file.

Macros
#define	Malloc   (type,n) (type *)malloc((n)*sizeof(type))

Functions
void	ComputeProb (kkint32 numClasses, const VectorFloat &probClassPairs, vector< double > &dist, double **crossClassProbTable, kkint32 *votes, double *probabilities, kkint32 knownClassNum)
void	ComputeProbForVoting (kkint32 numClasses, float A, vector< double > &dist, double **crossClassProbTable, kkint32 *votes, double *probabilities, kkint32 knownClassNum, double confidence, double &compact)
template<class T >
kkint32	GetMaxIndex (vector< T > &vote, kkint32 voteLength, kkint32 &maxIndex2)
template<class T >
kkint32	GetMaxIndex (T *vote, kkint32 voteLength, kkint32 &maxIndex2)
bool	GreaterThan (kkint32 leftVotes, double leftProb, kkint32 rightVotes, double rightProb)
void	GreaterVotes (bool useProbability, kkint32 numClasses, kkint32 *votes, double *probabilities, kkint32 &pred1Idx, kkint32 &pred2Idx)
void	NormalizeProbabilitiesWithAMinumum (kkint32 numClasses, double *probabilities, double minProbability)
	Will normailize probabilites such that the sum of all equal 1.0 and no one probability will be less than 'minProbability'. More...
void	saveData (svm_problem ds, kkint32 begin, kkint32 end, std::string name)
void	saveData (svm_problem ds, kkint32 begin, kkint32 end, string name)

Detailed Description

Provides an interface to the svm.cpp functions.

Definition in file SvmWrapper.cpp.

Macro Definition Documentation

#define Malloc   (type,n) (type *)malloc((n)*sizeof(type))

Definition at line 53 of file SvmWrapper.cpp.

Function Documentation

void ComputeProb	(	kkint32	numClasses,
		const VectorFloat &	probClassPairs,
		vector< double > &	dist,
		double **	crossClassProbTable,
		kkint32 *	votes,
		double *	probabilities,
		kkint32	knownClassNum
	)

Definition at line 472 of file SvmWrapper.cpp.

{
  kkint32  i;
  for  (i = 0;  i < numClasses;  i++)
    votes[i] = 0;

   kkint32 distIdx = 0;
   for  (i = 0;  i < (numClasses - 1); i++)
   {
     for  (kkint32 j = i + 1;  j < numClasses;  j++)
     {
       if  (dist[distIdx] > 0)
         votes[i]++;
       else
         votes[j]++;

       double tempProb = (double)(1.0 / (1.0 + exp (-1.0 * probClassPairs[distIdx] * dist[distIdx])));
       crossClassProbTable[i][j] = tempProb;
       crossClassProbTable[j][i] = (1.0 - tempProb);
       distIdx++;
     }
   }

   double  totalProb = 0.0;
   for  (i = 0;  i < numClasses;  i++)
   {
     double  probThisClass = 1.0;
     for  (kkint32 j = 0;  j < numClasses;  j++)
     {
       if  (i != j)
         probThisClass *= crossClassProbTable [i][j];
     }

     probabilities[i] = probThisClass;
     totalProb += probThisClass;
   }

   if  (totalProb == 0.0)
   {
     // I think this happens because we are using float pfor probTable and double for dist[]
     // For now we will give each class an equal probability.
     for  (i = 0; i < numClasses; i++)
       probabilities[i] = (1.0 / double(numClasses));
   }
   else
   {
     for  (i = 0;  i < numClasses;  i++)
       probabilities[i] = probabilities[i] / totalProb;
   }

   if  ((knownClassNum >= 0) &&  (knownClassNum < numClasses))
   {
     kkint32 maxIndex1 = -1;
     kkint32 maxIndex2 = -1;
     maxIndex1 = GetMaxIndex (probabilities, numClasses, maxIndex2);
   }
   //NormalizeProbabilitiesWithAMinumum (numClasses, probabilities, 0.002);
}  /* ComputeProb */

void ComputeProbForVoting	(	kkint32	numClasses,
		float	A,
		vector< double > &	dist,
		double **	crossClassProbTable,
		kkint32 *	votes,
		double *	probabilities,
		kkint32	knownClassNum,
		double	confidence,
		double &	compact
	)

Parameters

numClasses	Number of Classes.
A	probability parameter
dist	Distances for each binary classifier from decision boundary.
crossClassProbTable	Two dimensional array that is 'numClass' by 'numClass'; will receive the probabilities between classes.
votes	Array 'numClasses' in length that will receive the number of Votes each class won.
probabilities	Array 'numClasses' in length that will receive the computed Probability for Each Class
knownClassNum	The Class that we know the example to be.
confidence	Used for calculating 'compact' probability must exceed this.
compact	'knownClassNum' and 'confidence' need to be provided.

Definition at line 287 of file SvmWrapper.cpp.

{
  compact = 0.0;

  kkint32 i;
  for  (i = 0;  i < numClasses;  i++)
    votes[i] = 0;

   kkint32 distIdx = 0;
   for  (i = 0;  i < (numClasses - 1); i++)
   {
     for  (kkint32 j = i + 1;  j < numClasses;  j++)
     {
       if  (dist[distIdx] > 0)
         votes[i]++;
       else
         votes[j]++;

       crossClassProbTable[i][j] = 0.0;
       crossClassProbTable[j][i] = 0.0;

       distIdx++;
     }
   }

   int  win1 = -1;
   int  win2 = -1;
   int  win3 = -1;
   int  win4 = -1;

   int  win1Idx = 0;
   int  win2Idx = 0;
   int  win3Idx = 0;
   int  win4Idx = 0;

   for  (i = 0;  i < numClasses;  ++i)
   {
     int  zed = votes[i];
     if  (zed >= win4)
     {
       win4 = zed;
       win4Idx = i;

       if  (win4 >= win3)
       {
         win4 = win3;
         win4Idx = win3Idx;
         win3 = zed;
         win3Idx = i;

         if  (win3 >= win2)
         {
           win3 = win2;
           win3Idx = win2Idx;
           win2 = zed;
           win2Idx = i;

           if  (win2 >= win1)
           {
             win2 = win1;
             win2Idx = win1Idx;
             win1 = zed;
             win1Idx = i;
           }
         }
       }
     }
   }

   if  (win1 == win2)
   {
     if  (win1 == win3)
     {
       if  (win1 == win4)
       {
         probabilities[win1Idx] = 0.25;
         probabilities[win2Idx] = 0.25;
         probabilities[win3Idx] = 0.25;
         probabilities[win4Idx] = 0.25;
       }
       else
       {
         probabilities[win1Idx] = 0.95 / 3.0;
         probabilities[win2Idx] = 0.95 / 3.0;
         probabilities[win3Idx] = 0.95 / 3.0;
         probabilities[win4Idx] = 0.05;
       }
     }
     else
     {
       probabilities[win1Idx] = 0.85 / 2.0;
       probabilities[win2Idx] = 0.85 / 2.0;
       probabilities[win3Idx] = 0.10;
       probabilities[win4Idx] = 0.05;
     }
   }

   else 
   {
     probabilities[win1Idx] = 0.65;
     if  (win2 == win3)
     {
       if  (win2 == win4)
       {
         probabilities[win2Idx] = 0.30 / 3.0;
         probabilities[win3Idx] = 0.30 / 3.0;
         probabilities[win4Idx] = 0.30 / 3.0;
       }
       else
       {
         probabilities[win2Idx] = 0.30 / 2.0;
         probabilities[win3Idx] = 0.30 / 2.0;
         probabilities[win4Idx] = 0.05;
       }
     }

     else
     {
       probabilities[win2Idx] = 0.20;
       if  (win3 == win4)
       {
         probabilities[win3Idx] = 0.15 / 2.0;
         probabilities[win4Idx] = 0.15 / 2.0;
       }
       else
       {
         probabilities[win3Idx] = 0.10;
         probabilities[win4Idx] = 0.05;
       }
     }
   }

   //NormalizeProbabilitiesWithAMinumum (numClasses, probabilities, 0.001);

   for  (i = 0;  i < numClasses;  ++i)
   {
     crossClassProbTable [win1Idx][i] = probabilities[win1Idx];
     crossClassProbTable [i][win1Idx] = 1.0 - probabilities[win1Idx];
     if  (i != win1Idx)
     {
       crossClassProbTable [win2Idx][i] = probabilities[win2Idx];
       crossClassProbTable [i][win2Idx] = 1.0 - probabilities[win2Idx];
       if  (i != win2Idx)
       {
         crossClassProbTable [win3Idx][i] = probabilities[win3Idx];
         crossClassProbTable [i][win3Idx] = 1.0 - probabilities[win3Idx];
         if  (i != win3Idx)
         {
           crossClassProbTable [win4Idx][i] = probabilities[win4Idx];
           crossClassProbTable [i][win4Idx] = 1.0 - probabilities[win4Idx];
         }
       }
     }
   }

   if  ((knownClassNum >= 0) &&  (knownClassNum < numClasses))
   {
     kkint32 maxIndex1 = -1;
     kkint32 maxIndex2 = -1;
     maxIndex1 = GetMaxIndex (probabilities, numClasses, maxIndex2);

     if  (probabilities[maxIndex1] >= confidence)
     {
       if  ((probabilities[knownClassNum] < 1.0f)  &&  (probabilities[knownClassNum] > 0.0f))
       {
         compact = -log ((double)probabilities[knownClassNum]);
       }
     }
   }
}  /* ComputeProbForVoting */

template<class T >

kkint32 GetMaxIndex	(	vector< T > &	vote,
		kkint32	voteLength,
		kkint32 &	maxIndex2
	)

Definition at line 67 of file SvmWrapper.cpp.

{
  T max=vote[0];
  kkint32 maxIndex=0;

  T  max2 = 0;
  maxIndex2 = -1;

  for  (kkint32 i = 1;  i < voteLength;  i++)
  {
    if  (vote[i]> max)
    {
      max2      = max;
      maxIndex2 = maxIndex;
      max       = vote[i];
      maxIndex  = i;
    }

    else if  (maxIndex2 < 0)
    {
      max2      = vote[i];
      maxIndex2 = i;
    }

    else if  (vote[i] > max2)
    {
      max2 = vote[i];
      maxIndex2 = i;
    }
  }

  return maxIndex;
}  /* GetMaxIndex */

template<class T >

kkint32 GetMaxIndex	(	T *	vote,
		kkint32	voteLength,
		kkint32 &	maxIndex2
	)

Definition at line 108 of file SvmWrapper.cpp.

{
  T max=vote[0];
  kkint32 maxIndex=0;

  T  max2 = 0;
  maxIndex2 = -1;

  for  (kkint32 i = 1;  i < voteLength;  i++)
  {
    if  (vote[i]> max)
    {
      max2      = max;
      maxIndex2 = maxIndex;
      max       = vote[i];
      maxIndex  = i;
    }

    else if  (maxIndex2 < 0)
    {
      max2      = vote[i];
      maxIndex2 = i;
    }

    else if  (vote[i] > max2)
    {
      max2 = vote[i];
      maxIndex2 = i;
    }
  }

  return maxIndex;
}  /* GetMaxIndex */

bool GreaterThan	(	kkint32	leftVotes,
		double	leftProb,
		kkint32	rightVotes,
		double	rightProb
	)

Definition at line 151 of file SvmWrapper.cpp.

Referenced by GreaterVotes().

{
  if  (leftVotes < rightVotes)
    return false;

  else if  (leftVotes > rightVotes)
    return true;

  else if  (leftProb < rightProb)
    return false;
  
  else if  (leftProb > rightProb)
    return  true;
  
  else
    return  false;
}  /* GreaterThan */

void GreaterVotes	(	bool	useProbability,
		kkint32	numClasses,
		kkint32 *	votes,
		double *	probabilities,
		kkint32 &	pred1Idx,
		kkint32 &	pred2Idx
	)

Definition at line 175 of file SvmWrapper.cpp.

References GreaterThan().

Referenced by KKMLL::SvmPredictClass().

{
  if  (useProbability)
  {
    pred1Idx = GetMaxIndex (probabilities, numClasses, pred2Idx);
    return;
  }

  kkint32 max1Votes = votes[0];
  double  max1Prob  = probabilities[0];
  pred1Idx = 0;

  kkint32 max2Votes = -1;
  double  max2Prob  = -1.0f;
  pred2Idx = -1;

  for  (kkint32 x = 1;  x < numClasses;  x++)
  {
    if  (GreaterThan (votes[x], probabilities[x], max1Votes, max1Prob))
    {
      max2Votes = max1Votes;
      max2Prob  = max1Prob;
      pred2Idx  = pred1Idx;
      max1Votes = votes[x];
      max1Prob  = probabilities[x];
      pred1Idx = x;
    }
    else if  ((pred2Idx < 0)  ||  GreaterThan (votes[x], probabilities[x], max2Votes, max2Prob))
    {
      max2Votes = votes[x];
      max2Prob  = probabilities[x];
      pred2Idx = x;
    }
  }
} /* GreaterVotes*/

void NormalizeProbabilitiesWithAMinumum	(	kkint32	numClasses,
		double *	probabilities,
		double	minProbability
	)

Will normailize probabilites such that the sum of all equal 1.0 and no one probability will be less than 'minProbability'.

Parameters

[in]	numClasses	Number of classes represented in array 'probabilities'.
[in,out]	probabilities	Probabilites that are to be adjusted.
[in]	minProbability	Smallest probablity that any one class can have assigned to it.

Definition at line 255 of file SvmWrapper.cpp.

{
  double  sumGreaterOrEqualMin = 0.0;
  kkint32 numLessThanMin = 0;

  kkint32 x = 0;
  for  (x = 0;  x < numClasses;  ++x)
  {
    if  (probabilities[x] < minProbability)
      ++numLessThanMin;
    else
      sumGreaterOrEqualMin += probabilities[x];
  }

  double probLessMinTotal = numLessThanMin * minProbability;
  double probLeftToAllocate  = 1.0 - probLessMinTotal;  

  for  (x = 0;  x < numClasses;  ++x)
  {
    if  (probabilities[x] < minProbability)
      probabilities[x] = minProbability;
    else
      probabilities[x] = (probabilities[x] / sumGreaterOrEqualMin) * probLeftToAllocate;
  }
}  /* NormalizeProbabilitiesWithAMinumum */

void saveData	(	svm_problem	ds,
		kkint32	begin,
		kkint32	end,
		std::string	name
	)

void saveData	(	svm_problem	ds,
		kkint32	begin,
		kkint32	end,
		string	name
	)

Definition at line 223 of file SvmWrapper.cpp.

References SVM233::svm_node::index, and SVM233::svm_problem::x.

{
  ofstream out(name.c_str());
  if(!out.good())
  {
    cout << " cannot open " << name << endl;
    exit(-1);
  }
  for(kkint32 i=begin; i<end; i++)
  {
    svm_node* temp=ds.x[i];
    while(temp->index!=-1)
    {
      out << temp->value << ",";
      temp++;
    }
    out << ds.y[i] << endl;
  }
  out.close();
}