svmsgd_alg.cpp

Go to the documentation of this file.

#include "svmsgd_alg.h"

SvmsgdAlgorithm::SvmsgdAlgorithm(void) // loss, d, C1, num_iters, use_bias, use_reg_bias, wscale
{
  this->loss_type=LOGLOSS; //default values for now
  this->bias=0;
  this->wscale=1.0;
  this->num_iters=100;
  double C1=1.0;

  this->lambda=1.0/(C1*this->num_iters);
  this->use_bias=1;
  this->use_reg_bias=0;
  
  double maxw=1.0/sqrt(lambda);
  double typw=sqrt(maxw);
  double l=this->dloss(-typw);
  l=1.0>l?1.0:l;
  double eta0=typw / l;
  this->t=1.0/(eta0*this->lambda);
  this->calibrated=false;
}

SvmsgdAlgorithm::~SvmsgdAlgorithm(void)
{
  delete [] this->w;
}

void SvmsgdAlgorithm::config_update(Config& new_cfg, uint32_t level)
{
  this->lock();

  // save the current configuration
  this->config_=new_cfg;
  
  this->unlock();
}

double SvmsgdAlgorithm::dloss(double z)
{
  double ez;
  switch(this->loss_type)
  {
  case LOGLOSS:
    if (z < 0) return 1 / (exp(z) + 1);
    ez = exp(-z);
    return ez / (ez + 1);
  case LOGLOSSMARGIN:
    if (z < 1) return 1 / (exp(z-1) + 1);
    ez = exp(1-z);
    return ez / (ez + 1);
  case SMOOTHHINGELOSS:
    if (z < 0) return 1;
    if (z < 1) return 1-z;
    return 0;
  case SQUAREDHINGELOSS:
    if (z < 1) return (1 - z);
    return 0;
  default:
    if (z < 1) return 1;
    return 0;
  }
  return 0;
}

double SvmsgdAlgorithm::loss(double z)
{
  switch(this->loss_type)
  {
  case LOGLOSS:
    if (z >= 0) return log(1+exp(-z));
    else return -z + log(1+exp(z));
  case LOGLOSSMARGIN:
    if (z >= 1) return log(1+exp(1-z));
    else return 1-z + log(1+exp(z-1));
  case SMOOTHHINGELOSS:
    if (z < 0) return 0.5 - z;
    if (z < 1) return 0.5 * (1-z) * (1-z);
    return 0;
  case SQUAREDHINGELOSS:
    if (z < 1) return 0.5 * (1 - z) * (1 - z);
    return 0;
  case HINGELOSS:
    if (z < 1) return 1 - z;
    return 0;
  default:
    ROS_ERROR("SVMSGD ERROR: Unknown loss\n");
    exit(-1);
  }
}

void SvmsgdAlgorithm::calibrate(const std::vector<iri_svmsgd::learn_example> &train_matrix)
{
  if(train_matrix.size()==0)
  {
    ROS_ERROR("Empty calibration matrix!\n");
    exit(-1);
  }
  if(this->calibrated==true)
  {
    ROS_INFO("SVMSGD already calibrated, re-initializing and re-calibrating\n");
    delete [] this->w;
    this->bias=0;
  }
  this->d=train_matrix[0].feature_vector.size();
  this->w=new double[this->d];
  
  int j;
  int num_vec=train_matrix.size();
  double* c=(double*)malloc(sizeof(double)*this->d);
  memset(c, 0, this->d*sizeof(double));

  ROS_INFO("Estimating sparsity and bscale num_vec=%d num_feat=%d.\n", num_vec, this->d);

  /* compute average gradient size*/
  int n = 0;
  int k = 0;
  double m = 0;
  double r = 0;

  for (j=0; j<num_vec && m<=1000; j++, n++)
  {
    n++;
    r += this->d ;
    /* r += get_nnz_features_for_vector(train_matrix, j);  //overestimating*/
    add_to_dense_vec_abs(train_matrix[j].feature_vector, 1.0, c);

    /*waste cpu cycles for readability*/
    /*(only changed dims need checking)*/
    for(k=0; k<this->d; k++)
      m = c[k]>m?c[k]:m;
  }

  /* bias update scaling*/
  this->bscale = m/n;

  /* compute weight decay skip*/
  this->skip = (int) ((8 * n * this->d) / r);
  ROS_INFO("using %d examples. skip=%d  bscale=%.6f\n", n, this->skip, this->bscale);

  free(c);
  this->calibrated=true;
  this->count=this->skip;
}

// SvmsgdAlgorithm Public API

void SvmsgdAlgorithm::process_new_example(std::vector<float> &new_example, double y)
{
  double eta = 1.0 / (this->lambda * this->t);
  double z = y * (dot(new_example, this->w, this->d) + this->bias);

  if ( (z < 1) || (this->loss_type >= LOGLOSS) ) {
    double etd = eta * this->dloss(z);
    this->add_to_dense_vec(new_example, etd * y / this->wscale, this->w);

    if (this->use_bias) {
      if (this->use_reg_bias)
        this->bias *= 1 - eta * this->lambda * this->bscale;
      this->bias += etd * y * this->bscale;
    }
  }

  if (--this->count <= 0) {
    double r = 1 - eta * this->lambda * this->skip;
    if (r < 0.8)
      r = pow(1 - eta * this->lambda, this->skip);

    for (int i_scale=0; i_scale < this->d; i_scale++)
      this->w[i_scale]*=r;
    this->count = this->skip;
  }
  this->t++;
}