svm_c.h

支持向量机(SVM)的VC源代码

#ifndef svm_c_h
#define svm_c_h 1

#include <stdlib.h>
#include <math.h>
#include "parameters.h"
#include "kernel.h"
#include "example_set.h"
#include "globals.h"
#include "smo.h"

/**
 * base class for SVMs
 *
 * @author Stefan Rueping <[e-mail]>
 * @version 0.1
 **/


class svm_c {
 protected:
  smo_c smo;
  SVMFLOAT* all_alphas;
  SVMFLOAT* all_ys;

  SVMINT examples_total;
  SVMINT working_set_size;
  SVMINT shrink_const; // a lagrangian multiplier is fixed if it is at bound more than this number of times
  SVMINT to_shrink;
  SVMFLOAT is_zero;
  SVMFLOAT Cpos, Cneg; // C and C*
  SVMFLOAT epsilon_pos, epsilon_neg;
  SVMFLOAT lambda_threshold;
  SVMFLOAT lambda_factor;
  SVMFLOAT lambda_eq; // lagrangian multiplier of equality contraint
  SVMFLOAT lambda_WS; // lagrangian multiplier on working set
  SVMINT target_count; // how long no descend in WS?
  SVMFLOAT sum_alpha;

  example_set_c* examples;
  example_set_c* test_set;
  kernel_c* kernel;
  parameters_c* parameters;

  // ex_i, op_i and ws_i are used as indices.
  // ex_i: index in examples, ex_i = index[op_i], ws_i
  // op_i: index of sorted examples
  // ws_i: index in working set, i.e. index in op_i if fixed values are omitted

  // The following arrays range over the example set
  SVMFLOAT* sum; // sum_i = sum_{j=1}^n (alpha_j^*-alpha_j) K(i,j)
                 // i=ex_i= 1..examples_total
  SVMINT* which_alpha; // -1 if alpha_i in WS, 1 if alpha_i^*, 0 otherwise
                       // i.e. which_alpha[i]*alpha[i] = examples->get_alpha(i)
                       // i=ex_i= 1..examples_total
  SVMINT* at_bound; // how many it. has var been at bound
  quadratic_program qp;

  SVMFLOAT* primal; // workspace for primal variables

  SVMINT* working_set;
  SVMFLOAT* working_set_values;
  // LOQO-parameters:
  SVMFLOAT init_margin;
  SVMFLOAT init_bound;
  SVMFLOAT sigfig_max;

  int init_counter_max;
  int is_pattern;
  SVMFLOAT convergence_epsilon;
  SVMFLOAT feasible_epsilon;

  /*
   * check time usage
   */
  long time_init;
  long time_optimize;
  long time_convergence;
  long time_update;
  long time_calc;
  long time_all;

  virtual int feasible(const SVMINT i); // feasible variable?
  virtual int feasible(const SVMINT i, SVMFLOAT* the_nabla, SVMFLOAT* the_lambda, int* atbound); // feasible variable?
  virtual SVMFLOAT nabla(const SVMINT i); // gradient
  virtual SVMFLOAT lambda(const SVMINT i); // lagrangian multiplier
  virtual int is_alpha_neg(const SVMINT i); // alpha or alpha* ?

  virtual void calculate_working_set();
  void heapify(int minheap, SVMINT start, SVMINT size);
  /**
   * Call actual optimizer
   **/
  virtual void optimize();
  void exit_optimizer();
  virtual int convergence();
  virtual void init_working_set();
  virtual void update_working_set();
  void put_optimizer_values();
  virtual void shrink();
  virtual void reset_shrinked();
  virtual void project_to_constraint();

  SVMFLOAT loss(SVMFLOAT prediction, SVMFLOAT value); // the actual loss-function
  SVMFLOAT loss(SVMINT i); // loss of example i
  SVMFLOAT predict(svm_example example); // calculate (regression-)prediction for one example
  SVMFLOAT predict(SVMINT i); // predict example i
  virtual void print_special_statistics();  // print statistics related to some subtype of SVM
 protected:
  virtual void init_optimizer();
 public:
  svm_c();
  /**
   * initialise kernel and parameters
   */
  virtual void init(kernel_c* new_kernel, parameters_c* new_parameters);
  /**
   * Train the SVM 
   **/
  svm_result train(example_set_c* training_examples);
  /**
   * Test svm on test set
   */
  svm_result test(example_set_c* training_examples, int verbose);
  /*
   * Predict values for exmaples in test set
   **/
  void predict(example_set_c* training_examples);
  /**
   * Init examples for testing or predicting
   **/
  void set_svs(example_set_c* training_examples);
  /*
   * print information about test set
   **/
  svm_result print_statistics();
};


class svm_pattern_c : public svm_c {
 public:
  svm_pattern_c() : svm_c() {};
  virtual int feasible(const SVMINT i); // feasible variable?
  virtual int feasible(const SVMINT i, SVMFLOAT* the_nabla, SVMFLOAT* the_lambda, int* atbound); // feasible variable?
  virtual SVMFLOAT nabla(const SVMINT i); // gradient
  virtual SVMFLOAT lambda(const SVMINT i); // lagrangian multiplier
  virtual int is_alpha_neg(const SVMINT i); // alpha or alpha* ?
 protected:
  virtual void init_optimizer();
};


class svm_regression_c : public svm_c {
 public:
  svm_regression_c() : svm_c() {};
  virtual int feasible(const SVMINT i); // feasible variable?
  virtual int feasible(const SVMINT i, SVMFLOAT* the_nabla, SVMFLOAT* the_lambda, int* atbound); // feasible variable?
  virtual SVMFLOAT nabla(const SVMINT i); // gradient
  virtual SVMFLOAT lambda(const SVMINT i); // lagrangian multiplier
  virtual int is_alpha_neg(const SVMINT i); // alpha or alpha* ?
};


#endif