kernel.cpp

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

  data_stream<<"degree "<<degree<<endl;
};


/*
 *
 *
 * kernel_aggregation_c : kernels, that consist of some other kernels
 *
 */

kernel_aggregation_c::kernel_aggregation_c(){
  number_elements = 0;
  elements = 0;
  from = 0;
  to = 0;
};


kernel_aggregation_c::~kernel_aggregation_c(){
  if(number_elements > 0){
    delete []elements;
    elements = 0;
    delete []from;
    from = 0;
    delete[] to;
    to = 0;
    number_elements = 0;
  };
};


void kernel_aggregation_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();
  char* s = new char[MAXCHAR];
  SVMINT parts_read=0;
  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("number_parts",s)){
	if(number_elements>0){
	  throw read_exception("Parameter 'number_parts' cannot be defined twice.");
	};
	data_stream >> number_elements;
	if(number_elements<=0){
	  throw read_exception("Invalid value for parameter 'number_parts'.");
	};
	elements = new kernel_c*[number_elements];
	from = new SVMINT[number_elements];
	to = new SVMINT[number_elements];
      }
      else if(0==strcmp("range",s)){
	if(parts_read<number_elements){
	  data_stream >> from[parts_read];
	  from[parts_read]--;
	  data_stream >> to[parts_read];
	  parts_read++;
	}
	else{
	  throw read_exception("too much ranges defined in aggregation kernel or 'number_parts' not given.");
	};
      }
      else{
	throw read_exception("Unknown parameter in aggregation kernel.");
      };
      data_stream.getline(s,MAXCHAR); // ignore rest of line
    };
    next = data_stream.peek();
  };
  if(!data_stream.eof()){
    kernel_container_c cont;
    for(SVMINT i=0;i<number_elements;i++){
      // 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;
	elements[i] = cont.get_kernel();
	cont.clear();
      }
      else{
	throw read_exception("Could not find enough kernel parts for aggregation kernel.");
      };
    };
  };
  delete []s;
};


void kernel_aggregation_c::output_aggregation(ostream& data_stream) const{
  SVMINT i;
  data_stream<<"number_parts "<<number_elements<<endl;
  for(i=0;i<number_elements;i++){
    data_stream<<"range "
	       <<(from[i]+1)  // inner format: [from,to[, starting at 0
                              // io format:    [from,to], starting at 1
	       <<" "<<to[i]<<endl;
  };
  for(i=0;i<number_elements;i++){
    data_stream<<"@kernel"<<endl
	       <<"# "<<(i+1)<<". part of aggregation kernel"<<endl;
    (elements[i])->output(data_stream);
  };
};


void kernel_aggregation_c::output(ostream& data_stream)const{
  data_stream<<"type aggregation"<<endl;
  output_aggregation(data_stream);
};


SVMFLOAT kernel_aggregation_c::calculate_K(const svm_example x, const svm_example y){
  SVMFLOAT result=0;
  svm_example new_x = x;
  svm_example new_y = y;
  SVMINT start;
  SVMINT stop;
  for(SVMINT i=0;i<number_elements;i++){
    // find matching part of x and y
    start=0;
    while((start<x.length) && (((x.example)[start]).index < from[i])){
      start++;
    };
    new_x.example = x.example + start;
    stop=start;
    while((stop<x.length) && (((x.example)[stop]).index < to[i])){
      stop++;
    };
    new_x.length = stop-start;
    start=0;
    while((start<y.length) && (((y.example)[start]).index < from[i])){
      start++;
    };
    new_y.example = y.example + start;
    stop=start;
    while((stop<y.length) && (((y.example)[stop]).index < to[i])){
      stop++;
    };
    new_y.length = stop-start;

    // default ist sum-kernel
    result += (elements[i])->calculate_K(new_x,new_y);

  };
  return result;
};

/*
 *
 *
 * kernel_prod_aggregation_c : kernel, that consist of the 
 *                             prodcut of some other kernels
 *
 */

kernel_prod_aggregation_c::kernel_prod_aggregation_c(){
  number_elements = 0;
  elements = 0;
  from = 0;
  to = 0;
};


kernel_prod_aggregation_c::~kernel_prod_aggregation_c(){
  if(number_elements > 0){
    delete []elements;
    elements = 0;
    delete []from;
    from = 0;
    delete[] to;
    to = 0;
    number_elements = 0;
  };
};


void kernel_prod_aggregation_c::output(ostream& data_stream)const{
  data_stream<<"type prod_aggregation"<<endl;
  output_aggregation(data_stream);
};


SVMFLOAT kernel_prod_aggregation_c::calculate_K(const svm_example x, const svm_example y){
  SVMFLOAT result=1;
  svm_example new_x = x;
  svm_example new_y = y;
  SVMINT start;
  SVMINT stop;

  for(SVMINT i=0;i<number_elements;i++){
    // find matching part of x and y
    start=0;
    while((start<x.length) && (((x.example)[start]).index < from[i])){
      start++;
    };
    new_x.example = x.example + start;
    stop=start;
    while((stop<x.length) && (((x.example)[stop]).index < to[i])){
      stop++;
    };
    new_x.length = stop-start;
    start=0;
    while((start<y.length) && (((y.example)[start]).index < from[i])){
      start++;
    };
    new_y.example = y.example + start;
    stop=start;
    while((stop<y.length) && (((y.example)[stop]).index < to[i])){
      stop++;
    };
    new_y.length = stop-start;

    // default ist sum-kernel
    result *= (elements[i])->calculate_K(new_x,new_y);

  };
  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();
  char* s = new char[MAXCHAR];
  while((! data_stream.eof()) && (next != '@')){
    // ignore all lines
    data_stream.getline(s,MAXCHAR);
    next = data_stream.peek();
  };
  delete []s;
};


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


/*
 *
 * 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();
  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_i_1",s)){
	data_stream >> param_f_1;
      }
      else if(0 == strcmp("param_i_2",s)){
	data_stream >> param_f_2;
      }
      else if(0 == strcmp("param_i_3",s)){
	data_stream >> param_f_3;
      }
      else if(0 == strcmp("param_i_4",s)){
	data_stream >> param_f_4;
      }
      else if(0 == strcmp("param_i_5",s)){
	data_stream >> param_f_5;
      }
      else{
	cout<<"Ignoring unknown parameter: "<<s<<endl;
      };
      data_stream.getline(s,MAXCHAR);
    };
    next = data_stream.peek();
  };
  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();
  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();
  };
  delete []s;
};

void kernel_user2_c::output(ostream& data_stream) const{
  SVMINT i;
  data_stream<<"type user"<<endl;
  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;
  };
};