kernel.cpp

vc环境下的支持向量机源码

      diff = att_x[pos_x++].att;
    }
    else{
      diff = -att_y[pos_y++].att;
    };
    diff *= PI;
    result *= (1-q2)/(2*(1-2*q*cos(diff)+q2));
    zeros--;
  };
  while(pos_x < length_x){
    diff = att_x[pos_x++].att;
    diff *= PI;
    result *= (1-q2)/(2*(1-2*q*cos(diff)+q2));
    zeros--;
  };
  while(pos_y < length_y){
    diff = att_y[pos_y++].att;
    diff *= PI;
    result *= (1-q2)/(2*(1-2*q*cos(diff)+q2));
    zeros--;
  };

  q2 = (1+q)/(2*(1-q));
  SVMINT i;
  for(i=0;i<zeros;i++){
    result *= q2;
  };
  return result;
};


/*
 *
 * kernel_zero_c: returns 0, dummy kernel
 *
 */
SVMFLOAT kernel_zero_c::calculate_K(const svm_example x, const svm_example y){
  return 0;
};


void kernel_zero_c::input(istream& data_stream){
  // read comments and parameters until next @
  char next = data_stream.peek();
  if(next == EOF){ 
    // set stream to eof
    next = data_stream.get(); 
  };
  char* s = new char[MAXCHAR];
  while((! data_stream.eof()) && (next != '@')){
    // ignore all lines
    data_stream.getline(s,MAXCHAR);
    next = data_stream.peek();
    if(next == EOF){ 
      // set stream to eof
      next = data_stream.get(); 
    };
  };
  delete []s;
};


void kernel_zero_c::output(ostream& data_stream) const{
  data_stream<<"type zero"<<endl;
};


/*
 *
 * kernel_lintransform_c: K = a*K'+b
 *
 */
kernel_lintransform_c::kernel_lintransform_c(){
  subkernel = 0;
  a=1;
  b=0;
};


kernel_lintransform_c::~kernel_lintransform_c(){
  if(0 != subkernel){
    delete subkernel;
  };
  subkernel = 0;
};


void kernel_lintransform_c::output(ostream& data_stream)const{
  data_stream<<"type lintransform"<<endl;
  data_stream<<"a "<<a<<endl;
  data_stream<<"b "<<b<<endl;
  data_stream<<"@kernel"<<endl;
  data_stream<<"# subkernel of lintransform kernel"<<endl;
  if(0 != subkernel){
    subkernel->output(data_stream);
  }
  else{
    data_stream<<"# not defined"<<endl;
    data_stream<<"type null"<<endl;
  };
};


void kernel_lintransform_c::input(istream& data_stream){
  char next = data_stream.peek();
  if(next == EOF){ 
    // set stream to eof
    next = data_stream.get(); 
  };
  char* s = new char[MAXCHAR];
  while((! data_stream.eof()) && (next != '@')){
    if('#' == next){
      // ignore comment
      data_stream.getline(s,MAXCHAR);
    }
    else if(('\n' == next) ||
	    (' ' == next) ||
	    ('\r' == next) ||
	    ('\f' == next) ||
	    ('\t' == next)){
      // ignore line-end
      next = data_stream.get();
    }
    else{
      // trying to read in parameter
      data_stream >> s;
      if(0 == strcmp("a",s)){
	data_stream >> a;
	if(a<0){
	  throw read_exception("Invalid value for parameter 'a'.");
	};
      }
      else if(0 == strcmp("b",s)){
	data_stream >> b;
      }
      else{
	throw read_exception("Unknown parameter in lintransform kernel.");
      };
      data_stream.getline(s,MAXCHAR); // ignore rest of line
    };
    next = data_stream.peek();
    if(next == EOF){ 
      // set stream to eof
      next = data_stream.get(); 
    };
  };
  if(!data_stream.eof()){
    kernel_container_c cont;
    // next line should be "@kernel"
    data_stream >> s;
    if(0==strcmp("@kernel",s)){
      data_stream.getline(s,MAXCHAR); // ignore rest of line
      data_stream >> cont;
      subkernel = cont.get_kernel();
      cont.clear();
    }
    else{
      throw read_exception("Could not find subkernel for lintransform kernel.");
    };
  };
  delete []s;
};


SVMFLOAT kernel_lintransform_c::calculate_K(const svm_example x, const svm_example y){
  return (subkernel->calculate_K(x,y)*a+b);
};


/*
 *
 * kernel_regularized_c: regularize other kernel
 *
 */

kernel_regularized_c::kernel_regularized_c(){
  inner_kernel=0;
  cache=0;
};


kernel_regularized_c::~kernel_regularized_c(){
  if(inner_kernel){
    delete inner_kernel;
    inner_kernel=0;
  };
  if(cache){
    delete []cache;
    cache=0;
  };
};


void kernel_regularized_c::input(istream& data_stream){
  // read comments and parameters until next @
  // WARNING: no checks of the input values are performed
  char next = data_stream.peek();
  if(next == EOF){ 
    // set stream to eof
    next = data_stream.get(); 
  };
  char* s = new char[MAXCHAR];
  while((! data_stream.eof()) && (next != '@')){
    if('#' == next){
      // ignore comment
      data_stream.getline(s,MAXCHAR);
    }
    else if(('\n' == next) ||
	    (' ' == next) ||
	    ('\r' == next) ||
	    ('\f' == next) ||
	    ('\t' == next)){
      // ignore line-end
      next = data_stream.get();
    }
    else{
      throw read_exception("Unknown parameter in regularized kernel.");
      data_stream.getline(s,MAXCHAR); // ignore rest of line
    };
    next = data_stream.peek();
    if(next == EOF){ 
      // set stream to eof
      next = data_stream.get(); 
    };
  };
  if(!data_stream.eof()){
    kernel_container_c cont;
    // next line should be "@kernel"
    data_stream >> s;
    if(0==strcmp("@kernel",s)){
      data_stream.getline(s,MAXCHAR); // ignore rest of line
      data_stream >> cont;
      inner_kernel = cont.get_kernel();
      cont.clear();
    }
    else{
      throw read_exception("Could not find inner kernel for regularized kernel.");
    };
  };
  delete []s;
};


void kernel_regularized_c::output(ostream& data_stream)const{
  data_stream<<"type regularized"<<endl;
  data_stream<<"@kernel"<<endl
	     <<"# inner kernel of regularized kernel"<<endl;
  inner_kernel->output(data_stream);
};


void kernel_regularized_c::init(SVMINT new_cache_MB,example_set_c* new_examples){
  kernel_c::init(new_cache_MB,new_examples);
  inner_kernel->init(0,new_examples);
  inner_kernel->dim = dim;
  if(cache){ delete []cache; };
  cache = new SVMFLOAT[examples_size];
  SVMINT i;
  svm_example x;
  for(i=0;i<examples_size;i++){
    x = the_examples->get_example(i);
    cache[i] = inner_kernel->calculate_K(x,x);
    if(cache[i] > 0){
      cache[i] = sqrt(cache[i]);
    }
    else{
      cache[i] = 0;
    };
  };
};


void kernel_regularized_c::compute_row(const SVMINT i, SVMFLOAT* myrow){
  // place row i in row
  svm_example x;
  svm_example y;
  SVMFLOAT res = cache[i];
  SVMFLOAT res2;
  SVMINT k;
  if(res <= 0){
    for(k=0;k<examples_size;k++){
      myrow[k] = 0;
    };
  }
  else{
    x = the_examples->get_example(i);
    for(k=0;k<examples_size;k++){
      if(k == i){
	myrow[k] = 1;
      }
      else{
	res2 = cache[k];
	if(res2 <= 0){
	  myrow[k] = 0;
	}
	else{
	  y = the_examples->get_example(k);
	  myrow[k] = inner_kernel->calculate_K(x, y)/(res*res2);
	};
      };
    };
  };
};


void kernel_regularized_c::overwrite(const SVMINT i, const SVMINT j){
  kernel_c::overwrite(i,j);
  SVMFLOAT tmp = cache[i];
  cache[i] = cache[j];
  cache[j] = tmp;
};


SVMFLOAT kernel_regularized_c::calculate_K(const svm_example x, const svm_example y){
  // use caching here!!!
  SVMFLOAT res = inner_kernel->calculate_K(x,x)*inner_kernel->calculate_K(y,y);
  if(res > 0){
    res = inner_kernel->calculate_K(x,y)/sqrt(res);
  }
  else{
    res=0;
  };
  return res;
};


/*
 *
 * kernel_user_c: Enter your own kernel code here
 *
 */ 
kernel_user_c::kernel_user_c(){
  param_i_1 = 0;
  param_i_2 = 0;
  param_i_3 = 0;
  param_i_4 = 0;
  param_i_5 = 0;
  param_f_1 = 0;
  param_f_2 = 0;
  param_f_3 = 0;
  param_f_4 = 0;
  param_f_5 = 0;
};


SVMFLOAT kernel_user_c::calculate_K(const svm_example x, const svm_example y){
  SVMFLOAT result=0;
  // this is where you can insert your own kernel calculation
  // you can use the SVMINT parameters param_i_1 ... param_i_5
  // and the SVMFLOAT parameters param_f_1 ... param_f_5

  // begin user defined kernel

  result = innerproduct(x,y);

  // end user defined kernel

  return result;
};

void kernel_user_c::input(istream& data_stream){
  // read comments and parameters until next @
  // WARNING: no checks of the input values are performed
  char next = data_stream.peek();
  if(next == EOF){ 
    // set stream to eof
    next = data_stream.get(); 
  };
  char* s = new char[MAXCHAR];
  while((! data_stream.eof()) && (next != '@')){
    if('#' == next){
      // ignore comment
      data_stream.getline(s,MAXCHAR);
    }
    else if(('\n' == next) ||
	    ('\t' == next) ||
	    ('\r' == next) ||
	    ('\f' == next) ||
	    (' ' == next)){
      // ignore line-end
      next = data_stream.get();
    }
    else{
      // trying to read in parameter
      data_stream >> s;
      if(0 == strcmp("param_i_1",s)){
	data_stream >> param_i_1;
      }
      else if(0 == strcmp("param_i_2",s)){
	data_stream >> param_i_2;
      }
      else if(0 == strcmp("param_i_3",s)){
	data_stream >> param_i_3;
      }
      else if(0 == strcmp("param_i_4",s)){
	data_stream >> param_i_4;
      }
      else if(0 == strcmp("param_i_5",s)){
	data_stream >> param_i_5;
      }
      else if(0 == strcmp("param_f_1",s)){
	data_stream >> param_f_1;
      }
      else if(0 == strcmp("param_f_2",s)){
	data_stream >> param_f_2;
      }
      else if(0 == strcmp("param_f_3",s)){
	data_stream >> param_f_3;
      }
      else if(0 == strcmp("param_f_4",s)){
	data_stream >> param_f_4;
      }
      else if(0 == strcmp("param_f_5",s)){
	data_stream >> param_f_5;
      }
      else{
	cout<<"Ignoring unknown parameter: "<<s<<endl;
      };
      data_stream.getline(s,MAXCHAR);
    };
    next = data_stream.peek();
    if(next == EOF){ 
      // set stream to eof
      next = data_stream.get(); 
    };
  };
  delete []s;
};

void kernel_user_c::output(ostream& data_stream) const{
  data_stream<<"type user"<<endl;
  data_stream<<"param_i_1 "<<param_i_1<<endl;
  data_stream<<"param_i_2 "<<param_i_2<<endl;
  data_stream<<"param_i_3 "<<param_i_3<<endl;
  data_stream<<"param_i_4 "<<param_i_4<<endl;
  data_stream<<"param_i_5 "<<param_i_5<<endl;
  data_stream<<"param_f_1 "<<param_f_1<<endl;
  data_stream<<"param_f_2 "<<param_f_2<<endl;
  data_stream<<"param_f_3 "<<param_f_3<<endl;
  data_stream<<"param_f_4 "<<param_f_4<<endl;
  data_stream<<"param_f_5 "<<param_f_5<<endl;
};

/*
 *
 * kernel_user2_c: Enter your own kernel code here
 *
 */
kernel_user2_c::kernel_user2_c(){
  number_param = 100;
  param_i = new SVMINT[number_param];
  param_f = new SVMFLOAT[number_param];
}


kernel_user2_c::~kernel_user2_c(){
  if(param_i != 0) delete param_i;
  if(param_f != 0) delete param_f;
};


SVMFLOAT kernel_user2_c::calculate_K(const svm_example x, const svm_example y){
  SVMFLOAT result=0;
  // this is where you can insert your own kernel calculation
  // you can use the SVMINT parameters param_i[0] ... param_i[number_param-1]
  // and the SVMFLOAT parameters param_f[0] ... param_f[number_param-1]
  // number_param is defined in the class constructor

  // begin user defined kernel

  result = norm2(x,y);

  // end user defined kernel

  return result;
};

void kernel_user2_c::input(istream& data_stream){
  // read comments and parameters until next @
  // WARNING: no checks of the input values are performed
  char next = data_stream.peek();
  if(next == EOF){ 
    // set stream to eof
    next = data_stream.get(); 
  };
  SVMINT pos;
  char* s = new char[MAXCHAR];
  while((! data_stream.eof()) && (next != '@')){
    if('#' == next){
      // ignore comment
      data_stream.getline(s,MAXCHAR);
    }
    else if(('\n' == next) ||
	    ('\t' == next) ||
	    ('\r' == next) ||
	    ('\f' == next) ||
	    (' ' == next)){
      // ignore line-end
      next = data_stream.get();
    }
    else{
      // trying to read in parameter
      data_stream >> s;
      if(0 == strcmp("param_i",s)){
	data_stream >> pos;
	if((pos >= 0) && (pos<number_param)){
	  data_stream >> param_i[pos];
	}
	else{
	  throw read_exception("Illegal parameter index for param_i.");
	};
      }
      else if(0==strcmp("param_f",s)){
	data_stream >> pos;
	if((pos >= 0) && (pos<number_param)){
	  data_stream >> param_f[pos];
	}
	else{
	  throw read_exception("Illegal parameter index for param_f.");
	};
      }
      else{
	cout<<"Ignoring unknown parameter: "<<s<<endl;
      };
      data_stream.getline(s,MAXCHAR);
    };
    next = data_stream.peek();
    if(next == EOF){ 
      // set stream to eof
      next = data_stream.get(); 
    };
  };
  delete []s;
};

void kernel_user2_c::output(ostream& data_stream) const{
  data_stream<<"type user"<<endl;
  SVMINT i;
  for(i=0;i<number_param;i++){
    data_stream<<"param_i "<<i<<" "<<param_i[i]<<endl;
  };
  for(i=0;i<number_param;i++){
    data_stream<<"param_f "<<i<<" "<<param_f[i]<<endl;
  };
};