name: SupportVectorMachine

synopsis:


g++ [flags ...] file ... -l /isip/tools/lib/$ISIP_BINARY/lib_pr.a

#include <SupportVectorMachine.h>

ALGORITHM getAlgorithm();
boolean setAlgorithm(ALGORITHM arg);
IMPLEMENTATION getImplementation();
boolean setImplementation(IMPLEMENTATION arg);
boolean setPenalty(float arg);
boolean setEpsilon(float arg);
boolean setTolerance (float arg);
boolean setDegree(float arg);
boolean setKappa(float arg);
boolean setDelta(float arg);
boolean setGamma(float arg);
boolean setVerbosity(Integral::DEBUG verbosity);
boolean setOutputFile(Filename& arg);
boolean setOutputType(TYPE arg);
boolean init();
boolean loadRawFeatures(Filename& arg);
boolean loadFeatures(Sdb& in_sdb, Sdb& out_sdb);
boolean train();
boolean writeModel();

quick start:


Sdb pos_sdb;
Sdb neg_sdb;

svm.loadFeatures(pos_sdb, neg_sdb);
svm.train();
svm.writeModel();

description:

This class computes the support vectors give a list of in-class and out-of-class observation using the Sequential Minimization Optimization (SMO) algorithm.

References:

[1] V. N. Vapnik, "The Nature of Statistical Learning Theory", Springer-Verlag, New York, 1995.

[2] J. C. Platt, "Fast Training of Support Vector Machines using Sequential Minimal Optimization". In B. Scholkopf, C. J. C. Burges and A. J. Smola, editors, "Advances in Kernel Methods - Support Vector Learning", pp 185-208, MIT Press, 1998.

[3] N. Cristianini, J. Shawe-Taylor, "An Introduction to Support Vector Machines", Cambridge Press, 2000.

[4] C. J. C. Burges, "A Tutorial on Support Vector Machines for Pattern Recognition". Available on-line at (Microsoft Research): http://www.research.microsoft.com/

dependencies:

public constants:

define algorithm and implementation choices:

enum ALGORITHM { SEQUENTIAL_MINIMAL_OPTIMIZATION = 0, DEF_ALGORITHM = SEQUENTIAL_MINIMAL_OPTIMIZATION };

enum IMPLEMENTATION { LINEAR = 0, POLYNOMIAL, RBF, SIGMOID, DEF_IMPLEMENTATION = LINEAR };

enum TYPE { TEXT = 0, BINARY, DEF_TYPE = BINARY };

define name maps:

static const String CLASS_NAME;

static const NameMap IMPL_MAP;

static const NameMap ALGO_MAP;

static const NameMap TYPE_MAP;

define i/o parameters:

static const String DEF_PARAM;

static const String DEF_COMMENT_TAG;

static const String PARAM_OUTPUT_TYPE;

static const String PARAM_OUTPUT_FILE;

static const String PARAM_AUDIO_DB;

static const String PARAM_PENALTY;

static const String PARAM_EPSILON;

static const String PARAM_TOLERANCE;

static const String PARAM_POLYNOMIAL_DEGREE;

static const String PARAM_RBF_GAMMA;

static const String PARAM_SIGMOID_KAPPA;

static const String PARAM_SIGMOID_DELTA;

static const String PARAM_ALGORITHM;

static const String PARAM_IMPLEMENTATION;

define public constants:

static const long DEF_MAX_POINTS = 0;

static const long DEF_CAPACITY = 1000;

static const float DEF_BIAS = 0.0;

static const float DEF_PENALTY = 0.05;

static const float DEF_EPSILON = 0.001;

static const float DEF_TOLERANCE = 0.001;

static const float DEF_POLYNOMIAL_DEGREE = 3.0;

static const float DEF_RBF_GAMMA = 0.5;

static const float DEF_SIGMOID_KAPPA = 1.0;

static const float DEF_SIGMOID_DELTA = 1.0;

error codes:

error codes indicating general errors:

protected data:

algorithm name:

ALGORITHM algorithm_d;

implementation name:

IMPLEMENTATION implementation_d;

output type:

TYPE output_type_d;

output file:

Filename output_file_d;

audio database file:

Filename audio_db_file_d;

audio database:

AudioDatabase audio_db_d;

kernel function: we assume that the same kernel is used for all training points. this only makes sense though since anything else would mean different training points operating in different spaces.:

Kernel kernel_d;

default polynomial degree:

Float polynomial_degree_d;

default rbf gamma:

Float rbf_gamma_d;

default sigmoid kappa:

Float sigmoid_kappa_d;

default sigmoid delta:

Float sigmoid_delta_d;

lagrange multipliers:

VectorFloat alpha_d;

maximum penalty for an error:

Float penalty_d;

default tolearnce parameter:

Float tol_d;

default epsilon parameter:

Float eps_d;

maximum number of points:

Long max_points_d;

default bias parameter:

Float bias_d;

error cache parameter:

VectorFloat error_cache_d;

input observations and their labels:

Vector<VectorFloat> points_d;

VectorFloat target_d;

verbosity:

static Integral::DEBUG verbosity_d;

declare the debugging parameters:
```
static Integral::DEBUG debug_level_d;
```
declare the memory manager:
```
static MemoryManager mgr_d;
```

required public methods:

static methods:
```
static const String& name();
```

debug methods:

static boolean diagnose(Integral::DEBUG debug_level);

static boolean setDebug(Integral::DEBUG level);

boolean debug(const unichar* msg) const;

destructor/constructor(s):

~SupportVectorMachine();

SupportVectorMachine();

SupportVectorMachine(const SupportVectorMachine& arg);

assign methods:

boolean assign(const SupportVectorMachine& copy_node);

operator= method:

SupportVectorMachine& operator= (const SupportVectorMachine& arg);

i/o methods:

long sofSize() const;

boolean read(Sof& sof, long tag, const String& name = CLASS_NAME);

boolean write(Sof& sof, long tag, const String& name = CLASS_NAME) const;

boolean readData(Sof& sof, const String& pname = DEF_PARAM, long size = SofParser::FULL_OBJECT, boolean param = true, boolean nested = false);

boolean writeData(Sof& sof, const String& pname = DEF_PARAM) const;

equality methods:

boolean eq(const SupportVectorMachine& arg) const;

memory management methods:

static void* operator new(size_t size);

static void* operator new[](size_t size);

static void operator delete(void* ptr);

static void operator delete[](void* ptr);

static boolean setGrowSize(long grow_size);

boolean clear(Integral::CMODE cmode = Integral::DEF_CMODE);

class-specific public methods:

declare class specific methods:

ALGORITHM getAlgorithm();

boolean setAlgorithm(ALGORITHM arg);

IMPLEMENTATION getImplementation();

boolean setImplementation(IMPLEMENTATION arg);

boolean setPenalty(float arg);

boolean setEpsilon(float arg);

boolean setTolerance (float arg);

boolean setDegree(float arg);

boolean setKappa(float arg);

boolean setDelta(float arg);

boolean setGamma(float arg);

boolean setVerbosity(Integral::DEBUG verbosity);

boolean setOutputFile(Filename& arg);

boolean setOutputType(TYPE arg);

boolean init();

boolean loadRawFeatures(Filename& arg);

boolean loadFeatures(Sdb& in_sdb, Sdb& out_sdb);

boolean train();

boolean writeModel();

private methods:

declare private methods:

boolean sequentialMinimalOptimization();

float evaluateOutput(VectorFloat& point);

int takeStep(int i1, int i2);

int examineExample(int i2);

examples:

  
  // open the positive examples file
  //  
  Sof pos_sof;
  if (!pos_sof.open(L"positive_examples_list.sof", File::READ_ONLY)) {
    output.assign(L"\ncannot open file: ");
    output.concat(pos_example_list);
    output.concat(L", bailing out...");
    Console::put(output);
    Integral::exit();
  }

  // read the list of positive examples
  //
  Sdb pos_sdb;
  if (!pos_sdb.read(pos_sof, (long)0)) {
    output.assign(L"\ncannot read file: ");
    output.concat(pos_example_list);
    output.concat(L", bailing out...");
    Console::put(output);
    Integral::exit();
  }
  
  // open the negative examples file
  //  
  Sof neg_sof;
  if (!neg_sof.open(L"negative_examples_list.sof", File::READ_ONLY)) {
    output.assign(L"\ncannot open file: ");
    output.concat(neg_example_list);
    output.concat(L", bailing out...");
    Console::put(output);
    Integral::exit();
  }

  // read the list of positive examples
  //
  Sdb neg_sdb;
  if (!neg_sdb.read(neg_sof, (long)0)) {
    output.assign(L"\ncannot read file: ");
    output.concat(neg_example_list);
    output.concat(L", bailing out...");
    Console::put(output);
    Integral::exit();
  }

  // open the support vector parameter file
  //  
  if (verbosity >= Integral::BRIEF) {
    Console::increaseIndention();    
    output.assign(L"\nloading parameter file: ");
    output.concat(params_file);
    Console::put(output);
    Console::decreaseIndention();    
  }
  
  Sof param_sof;
  if (!param_sof.open(params_file, File::READ_ONLY)) {
    output.assign(L"\ncannot open file: ");
    output.concat(params_file);
    output.concat(L", bailing out...");
    Console::put(output);
    Integral::exit();
  }

  // read the support vector parameters
  //      
  if (!svm.read(param_sof, (long)0)) {
    output.assign(L"\nerror reading parameter file: ");
    output.concat(params_file);
    output.concat(L", bailing out...");
    Console::put(output);
    Integral::exit();    
  }
  
  // load the features from file
  //
  svm.loadFeatures(pos_sdb, neg_sdb);
    
  // start training
  //
  svm.train();
  
  // write the support vector model
  //
  svm.writeModel();

notes:

The support vector machine trainer is also employed by the isip_svm_learn to compute the support vector model.