VLFeat.org

Documentation - C API

• Home
• Download
• Documentation
  • Matlab API
  • C API
  • Man pages
• Tutorials
• Applications

pegasos.c

Go to the documentation of this file.

/* AUTORIGHTS
 Copyright (C) 2007-10 Andrea Vedaldi and Brian Fulkerson

 This file is part of VLFeat, available under the terms of the
 GNU GPLv2, or (at your option) any later version.
 */

#ifndef VL_PEGASOS_INSTANTIATING

#include "pegasos.h"
#include "mathop.h"
#include <math.h>

#define FLT VL_TYPE_FLOAT
#define VL_PEGASOS_INSTANTIATING
#include "pegasos.c"

#define FLT VL_TYPE_DOUBLE
#define VL_PEGASOS_INSTANTIATING
#include "pegasos.c"

/* VL_PEGAOS_INSTANTIATING */
#else

#include "float.th"

VL_EXPORT void
VL_XCAT(vl_pegasos_train_binary_svm_,SFX)(T *  model,
                                          T const * data,
                                          vl_size dimension,
                                          vl_size numSamples,
                                          vl_int8 const * labels,
                                          double regularizer,
                                          double biasMultiplier,
                                          vl_uindex startingIteration,
                                          vl_size numIterations,
                                          VlRand * randomGenerator)
{
  vl_uindex iteration ;
  vl_uindex i ;
  T const * x ;
  T acc, eta, y, scale = 1 ;
  double lambda = regularizer ;
  double sqrtLambda = sqrt(lambda) ;


#if (FLT == VL_TYPE_FLOAT)
  VlFloatVectorComparisonFunction dotFn =
#else
  VlDoubleVectorComparisonFunction dotFn =
#endif
  VL_XCAT(vl_get_vector_comparison_function_,SFX)(VlKernelL2) ;

  if (randomGenerator == NULL) randomGenerator = vl_get_rand() ;

  assert(startingIteration >= 1) ;

  /*
     The model is stored as scale*model[]. When a sample does not violate
     the margin, only scale needs to be updated.
   */

  for (iteration = startingIteration ;
       iteration < startingIteration + numIterations ;
       ++ iteration) {
    /* pick a sample  */
    vl_uindex k = vl_rand_uindex(randomGenerator, numSamples) ;
    x = data + dimension * k ;
    y = labels[k] ;

    /* project on the weight vector */
    acc = dotFn(dimension, x, model) ;
    if (biasMultiplier) acc += biasMultiplier * model[dimension] ;
    acc *= scale ;

    /* learning rate */
    eta = 1.0 / (iteration * lambda) ;

    if (y * acc < (T) 1.0) {
      /* margin violated */
      T a = scale * (1 - eta * lambda)  ;
      T b = y * eta ;

      acc = 0 ;
      for (i = 0 ; i < dimension ; ++i) {
        model[i] = a * model[i] + b * x[i] ;
        acc += model[i] * model[i] ;
      }
      if (biasMultiplier) {
        model[dimension] = a * model[dimension] + b * biasMultiplier ;
        acc += model[dimension] * model[dimension] ;
      }
      scale = VL_MIN((T)1.0 / (sqrtLambda * sqrt(acc + VL_EPSILON_D)), (T)1.0) ;
    } else {
      /* margin not violated */
      scale *= 1 - eta * lambda ;
    }
  }

  /* denormalize representation */
  for (i = 0 ; i < dimension + (biasMultiplier ? 1 : 0) ; ++i) {
    model[i] *= scale ;
  }
}

/* VL_PEGAOS_INSTANTIATING */
#undef FLT
#undef VL_PEGAOS_INSTANTIATING
#endif

 

© 2005-10 Andrea Vedaldi and Brian Fulkerson