numo-libsvm 2.0.1 → 2.1.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 132e5e9b95db85b1897e804b3bcd22bb948c9d8200dcbf14752059b98f377199
-  data.tar.gz: 24ff1957951af9036b41017b4c34e1b06046059e1c57e5e33bc9d1554f87bee5
+  metadata.gz: 37613a10119b2974024687c3f781d271ebaa30b15ccff6100df17c32642dcd2d
+  data.tar.gz: 210e072576d4fa859364fdb522e6f02c9be12458e5ed0647fcd8bebedfdb3e84
 SHA512:
-  metadata.gz: 0a63eb30c744e3531c2de44a7b5ef229261f7fd0e50f84d4e3613701d165ee5cee17cac0026702980571ca25266d99c2d81f1c595ea1a6f215d71b50b26ba830
-  data.tar.gz: d16ec02c158f15181e37cecb554e6bbd60d02bd60d95bf16644849683073e34d6c06c60503039da9a7ecbee958915495d1241d5482a486056177047c4a13612b
+  metadata.gz: 142e15fe744460f679f7bd7978f1654e2e71a40a49ce3a414c3c0e68b507d6d9c286eec9edd37a10f5b9fc60a940079c42e59d1283ba607cd7748b80d16fa12f
+  data.tar.gz: 67909b309d9a186e77dc716cc2e8b1299d0be3baf10be7be87fc89f2bc67a47b087063827be2f8ba750378d354f745c58dec0feb072f8eea73c883c3c034a669

data/CHANGELOG.md

@@ -1,3 +1,7 @@
+# 2.1.0
+- Update bundled LIBSVM to 3.30.
+- Support for probilistic outputs of one-class SVM.
+
 # 2.0.1
 - Chnage to use memcpy to copy vector.
 - Refactor codes and configs with RuboCop.

data/ext/numo/libsvm/libsvmext.hpp

@@ -48,6 +48,8 @@ typedef struct svm_problem LibSvmProblem;
 
 void printNull(const char* s) {}
 
+#define NR_MARKS 10
+
 /** CONVERTERS */
 VALUE convertVectorXiToNArray(const int* const arr, const int size) {
   size_t shape[1] = {(size_t)size};
@@ -215,6 +217,8 @@ LibSvmModel* convertHashToLibSvmModel(VALUE model_hash) {
   model->probA = convertNArrayToVectorXd(el);
   el = rb_hash_aref(model_hash, ID2SYM(rb_intern("probB")));
   model->probB = convertNArrayToVectorXd(el);
+  el = rb_hash_aref(model_hash, ID2SYM(rb_intern("prob_density_marks")));
+  model->prob_density_marks = convertNArrayToVectorXd(el);
   el = rb_hash_aref(model_hash, ID2SYM(rb_intern("sv_indices")));
   model->sv_indices = convertNArrayToVectorXi(el);
   el = rb_hash_aref(model_hash, ID2SYM(rb_intern("label")));
@@ -234,6 +238,7 @@ VALUE convertLibSvmModelToHash(const LibSvmModel* const model) {
   VALUE intercepts = model->rho ? convertVectorXdToNArray(model->rho, n_classes * (n_classes - 1) / 2) : Qnil;
   VALUE prob_alpha = model->probA ? convertVectorXdToNArray(model->probA, n_classes * (n_classes - 1) / 2) : Qnil;
   VALUE prob_beta = model->probB ? convertVectorXdToNArray(model->probB, n_classes * (n_classes - 1) / 2) : Qnil;
+  VALUE prob_density_marks = model->prob_density_marks ? convertVectorXdToNArray(model->prob_density_marks, NR_MARKS) : Qnil;
   VALUE sv_indices = model->sv_indices ? convertVectorXiToNArray(model->sv_indices, n_support_vecs) : Qnil;
   VALUE labels = model->label ? convertVectorXiToNArray(model->label, n_classes) : Qnil;
   VALUE n_support_vecs_each_class = model->nSV ? convertVectorXiToNArray(model->nSV, n_classes) : Qnil;
@@ -245,6 +250,7 @@ VALUE convertLibSvmModelToHash(const LibSvmModel* const model) {
   rb_hash_aset(model_hash, ID2SYM(rb_intern("rho")), intercepts);
   rb_hash_aset(model_hash, ID2SYM(rb_intern("probA")), prob_alpha);
   rb_hash_aset(model_hash, ID2SYM(rb_intern("probB")), prob_beta);
+  rb_hash_aset(model_hash, ID2SYM(rb_intern("prob_density_marks")), prob_density_marks);
   rb_hash_aset(model_hash, ID2SYM(rb_intern("sv_indices")), sv_indices);
   rb_hash_aset(model_hash, ID2SYM(rb_intern("label")), labels);
   rb_hash_aset(model_hash, ID2SYM(rb_intern("nSV")), n_support_vecs_each_class);
@@ -377,9 +383,7 @@ bool isSignleOutputModel(LibSvmModel* model) {
   return (model->param.svm_type == ONE_CLASS || model->param.svm_type == EPSILON_SVR || model->param.svm_type == NU_SVR);
 }
 
-bool isProbabilisticModel(LibSvmModel* model) {
-  return ((model->param.svm_type == C_SVC || model->param.svm_type == NU_SVC) && model->probA != NULL && model->probB != NULL);
-}
+bool isProbabilisticModel(LibSvmModel* model) { return svm_check_probability_model(model) != 0; }
 
 void deleteLibSvmModel(LibSvmModel* model) {
   if (model) {
@@ -399,6 +403,8 @@ void deleteLibSvmModel(LibSvmModel* model) {
     model->probA = NULL;
     xfree(model->probB);
     model->probB = NULL;
+    xfree(model->prob_density_marks);
+    model->prob_density_marks = NULL;
     xfree(model->sv_indices);
     model->sv_indices = NULL;
     xfree(model->label);

data/ext/numo/libsvm/src/svm.cpp

@@ -1825,7 +1825,7 @@ static double sigmoid_predict(double decision_value, double A, double B)
 		return 1.0/(1+exp(fApB)) ;
 }
 
-// Method 2 from the multiclass_prob paper by Wu, Lin, and Weng
+// Method 2 from the multiclass_prob paper by Wu, Lin, and Weng to predict probabilities
 static void multiclass_probability(int k, double **r, double *p)
 {
 	int t,j;
@@ -1889,7 +1889,7 @@ static void multiclass_probability(int k, double **r, double *p)
 	free(Qp);
 }
 
-// Cross-validation decision values for probability estimates
+// Using cross-validation decision values to get parameters for SVC probability estimates
 static void svm_binary_svc_probability(
 	const svm_problem *prob, const svm_parameter *param,
 	double Cp, double Cn, double& probA, double& probB)
@@ -1976,6 +1976,83 @@ static void svm_binary_svc_probability(
 	free(perm);
 }
 
+// Binning method from the oneclass_prob paper by Que and Lin to predict the probability as a normal instance (i.e., not an outlier)
+static double predict_one_class_probability(const svm_model *model, double dec_value)
+{
+	double prob_estimate = 0.0;
+	int nr_marks = 10;
+
+	if(dec_value < model->prob_density_marks[0])
+		prob_estimate = 0.001;
+	else if(dec_value > model->prob_density_marks[nr_marks-1])
+		prob_estimate = 0.999;
+	else
+	{
+		for(int i=1;i<nr_marks;i++)
+			if(dec_value < model->prob_density_marks[i])
+			{
+				prob_estimate = (double)i/nr_marks;
+				break;
+			}
+	}
+	return prob_estimate;
+}
+
+static int compare_double(const void *a, const void *b)
+{
+	if(*(double *)a > *(double *)b)
+		return 1;
+	else if(*(double *)a < *(double *)b)
+		return -1;
+	return 0;
+}
+
+// Get parameters for one-class SVM probability estimates
+static int svm_one_class_probability(const svm_problem *prob, const svm_model *model, double *prob_density_marks)
+{
+	double *dec_values = Malloc(double,prob->l);
+	double *pred_results = Malloc(double,prob->l);
+	int ret = 0;
+	int nr_marks = 10;
+
+	for(int i=0;i<prob->l;i++)
+		pred_results[i] = svm_predict_values(model,prob->x[i],&dec_values[i]);
+	qsort(dec_values,prob->l,sizeof(double),compare_double);
+
+	int neg_counter=0;
+	for(int i=0;i<prob->l;i++)
+		if(dec_values[i]>=0)
+		{
+			neg_counter = i;
+			break;
+		}
+
+	int pos_counter = prob->l-neg_counter;
+	if(neg_counter<nr_marks/2 || pos_counter<nr_marks/2)
+	{
+		fprintf(stderr,"WARNING: number of positive or negative decision values <%d; too few to do a probability estimation.\n",nr_marks/2);
+		ret = -1;
+	}
+	else
+	{
+		// Binning by density
+		double *tmp_marks = Malloc(double,nr_marks+1);
+		int mid = nr_marks/2;
+		for(int i=0;i<mid;i++)
+			tmp_marks[i] = dec_values[i*neg_counter/mid];
+		tmp_marks[mid] = 0;
+		for(int i=mid+1;i<nr_marks+1;i++)
+			tmp_marks[i] = dec_values[neg_counter-1+(i-mid)*pos_counter/mid];
+
+		for(int i=0;i<nr_marks;i++)
+			prob_density_marks[i] = (tmp_marks[i]+tmp_marks[i+1])/2;
+		free(tmp_marks);
+	}
+	free(dec_values);
+	free(pred_results);
+	return ret;
+}
+
 // Return parameter of a Laplace distribution
 static double svm_svr_probability(
 	const svm_problem *prob, const svm_parameter *param)
@@ -2104,16 +2181,9 @@ svm_model *svm_train(const svm_problem *prob, const svm_parameter *param)
 		model->label = NULL;
 		model->nSV = NULL;
 		model->probA = NULL; model->probB = NULL;
+		model->prob_density_marks = NULL;
 		model->sv_coef = Malloc(double *,1);
 
-		if(param->probability &&
-		   (param->svm_type == EPSILON_SVR ||
-		    param->svm_type == NU_SVR))
-		{
-			model->probA = Malloc(double,1);
-			model->probA[0] = svm_svr_probability(prob,param);
-		}
-
 		decision_function f = svm_train_one(prob,param,0,0);
 		model->rho = Malloc(double,1);
 		model->rho[0] = f.rho;
@@ -2136,6 +2206,26 @@ svm_model *svm_train(const svm_problem *prob, const svm_parameter *param)
 				++j;
 			}
 
+		if(param->probability &&
+		   (param->svm_type == EPSILON_SVR ||
+		    param->svm_type == NU_SVR))
+		{
+			model->probA = Malloc(double,1);
+			model->probA[0] = svm_svr_probability(prob,param);
+		}
+		else if(param->probability && param->svm_type == ONE_CLASS)
+		{
+			int nr_marks = 10;
+			double *prob_density_marks = Malloc(double,nr_marks);
+
+			if(svm_one_class_probability(prob,model,prob_density_marks) == 0)
+			{
+				model->prob_density_marks = Malloc(double,nr_marks);
+				for(i=0;i<nr_marks;i++)
+					model->prob_density_marks[i] = prob_density_marks[i];
+			}
+		}
+
 		free(f.alpha);
 	}
 	else
@@ -2253,6 +2343,7 @@ svm_model *svm_train(const svm_problem *prob, const svm_parameter *param)
 			model->probA=NULL;
 			model->probB=NULL;
 		}
+		model->prob_density_marks=NULL;	// for one-class SVM probabilistic outputs only
 
 		int total_sv = 0;
 		int *nz_count = Malloc(int,nr_class);
@@ -2630,6 +2721,14 @@ double svm_predict_probability(
 		free(pairwise_prob);
 		return model->label[prob_max_idx];
 	}
+	else if(model->param.svm_type == ONE_CLASS && model->prob_density_marks!=NULL)
+	{
+		double dec_value;
+		double pred_result = svm_predict_values(model,x,&dec_value);
+		prob_estimates[0] = predict_one_class_probability(model,dec_value);
+		prob_estimates[1] = 1-prob_estimates[0];
+		return pred_result;
+	}
 	else
 		return svm_predict(model, x);
 }
@@ -2703,6 +2802,14 @@ int svm_save_model(const char *model_file_name, const svm_model *model)
 			fprintf(fp," %.17g",model->probB[i]);
 		fprintf(fp, "\n");
 	}
+	if(model->prob_density_marks)
+	{
+		fprintf(fp, "prob_density_marks");
+		int nr_marks=10;
+		for(int i=0;i<nr_marks;i++)
+			fprintf(fp," %.17g",model->prob_density_marks[i]);
+		fprintf(fp, "\n");
+	}
 
 	if(model->nSV)
 	{
@@ -2857,6 +2964,13 @@ bool read_model_header(FILE *fp, svm_model* model)
 			for(int i=0;i<n;i++)
 				FSCANF(fp,"%lf",&model->probB[i]);
 		}
+		else if(strcmp(cmd,"prob_density_marks")==0)
+		{
+			int n = 10;	// nr_marks
+			model->prob_density_marks = Malloc(double,n);
+			for(int i=0;i<n;i++)
+				FSCANF(fp,"%lf",&model->prob_density_marks[i]);
+		}
 		else if(strcmp(cmd,"nr_sv")==0)
 		{
 			int n = model->nr_class;
@@ -2901,6 +3015,7 @@ svm_model *svm_load_model(const char *model_file_name)
 	model->rho = NULL;
 	model->probA = NULL;
 	model->probB = NULL;
+	model->prob_density_marks = NULL;
 	model->sv_indices = NULL;
 	model->label = NULL;
 	model->nSV = NULL;
@@ -3012,13 +3127,16 @@ void svm_free_model_content(svm_model* model_ptr)
 	model_ptr->rho = NULL;
 
 	free(model_ptr->label);
-	model_ptr->label= NULL;
+	model_ptr->label = NULL;
 
 	free(model_ptr->probA);
 	model_ptr->probA = NULL;
 
 	free(model_ptr->probB);
-	model_ptr->probB= NULL;
+	model_ptr->probB = NULL;
+
+	free(model_ptr->prob_density_marks);
+	model_ptr->prob_density_marks = NULL;
 
 	free(model_ptr->sv_indices);
 	model_ptr->sv_indices = NULL;
@@ -3104,10 +3222,6 @@ const char *svm_check_parameter(const svm_problem *prob, const svm_parameter *pa
 	   param->probability != 1)
 		return "probability != 0 and probability != 1";
 
-	if(param->probability == 1 &&
-	   svm_type == ONE_CLASS)
-		return "one-class SVM probability output not supported yet";
-
 
 	// check whether nu-svc is feasible
 
@@ -3167,8 +3281,10 @@ const char *svm_check_parameter(const svm_problem *prob, const svm_parameter *pa
 
 int svm_check_probability_model(const svm_model *model)
 {
-	return ((model->param.svm_type == C_SVC || model->param.svm_type == NU_SVC) &&
-		model->probA!=NULL && model->probB!=NULL) ||
+	return
+		((model->param.svm_type == C_SVC || model->param.svm_type == NU_SVC) &&
+		 model->probA!=NULL && model->probB!=NULL) ||
+		(model->param.svm_type == ONE_CLASS && model->prob_density_marks!=NULL) ||
 		((model->param.svm_type == EPSILON_SVR || model->param.svm_type == NU_SVR) &&
 		 model->probA!=NULL);
 }

data/ext/numo/libsvm/src/svm.h

@@ -1,7 +1,7 @@
 #ifndef _LIBSVM_H
 #define _LIBSVM_H
 
-#define LIBSVM_VERSION 324
+#define LIBSVM_VERSION 330
 
 #ifdef __cplusplus
 extern "C" {
@@ -59,6 +59,7 @@ struct svm_model
 	double *rho;		/* constants in decision functions (rho[k*(k-1)/2]) */
 	double *probA;		/* pariwise probability information */
 	double *probB;
+	double *prob_density_marks;	/* probability information for ONE_CLASS */
 	int *sv_indices;        /* sv_indices[0,...,nSV-1] are values in [1,...,num_traning_data] to indicate SVs in the training set */
 
 	/* for classification only */

data/lib/numo/libsvm/version.rb

@@ -3,6 +3,6 @@
 module Numo
   module Libsvm
     # The version of Numo::Libsvm you are using.
-    VERSION = '2.0.1'
+    VERSION = '2.1.0'
   end
 end

data/sig/numo/libsvm.rbs

@@ -27,6 +27,7 @@ module Numo
       rho: Numo::DFloat,
       probA: Numo::DFloat,
       probB: Numo::DFloat,
+      prob_density_marks: Numo::DFloat,
       sv_indices: Numo::Int32,
       label: Numo::Int32,
       nSV: Numo::Int32,

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: numo-libsvm
 version: !ruby/object:Gem::Version
-  version: 2.0.1
+  version: 2.1.0
 platform: ruby
 authors:
 - yoshoku
 autorequire:
 bindir: exe
 cert_chain: []
-date: 2022-07-18 00:00:00.000000000 Z
+date: 2022-09-03 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: numo-narray