liblinear-ruby 1.0.2 → 1.0.3

data/ext/linear.h

@@ -1,7 +1,7 @@
 #ifndef _LIBLINEAR_H
 #define _LIBLINEAR_H
 
-#define LIBLINEAR_VERSION 211
+#define LIBLINEAR_VERSION 230
 
 #ifdef __cplusplus
 extern "C" {
@@ -51,7 +51,7 @@ struct model
 
 struct model* train(const struct problem *prob, const struct parameter *param);
 void cross_validation(const struct problem *prob, const struct parameter *param, int nr_fold, double *target);
-void find_parameter_C(const struct problem *prob, const struct parameter *param, int nr_fold, double start_C, double max_C, double *best_C, double *best_rate);
+void find_parameters(const struct problem *prob, const struct parameter *param, int nr_fold, double start_C, double start_p, double *best_C, double *best_p, double *best_score);
 
 double predict_values(const struct model *model_, const struct feature_node *x, double* dec_values);
 double predict(const struct model *model_, const struct feature_node *x);

data/ext/tron.cpp

@@ -31,6 +31,19 @@ static void default_print(const char *buf)
 	fflush(stdout);
 }
 
+static double uTMv(int n, double *u, double *M, double *v)
+{
+	const int m = n-4;
+	double res = 0;
+	int i;
+	for (i=0; i<m; i+=5)
+		res += u[i]*M[i]*v[i]+u[i+1]*M[i+1]*v[i+1]+u[i+2]*M[i+2]*v[i+2]+
+			u[i+3]*M[i+3]*v[i+3]+u[i+4]*M[i+4]*v[i+4];
+	for (; i<n; i++)
+		res += u[i]*M[i]*v[i];
+	return res;
+}
+
 void TRON::info(const char *fmt,...)
 {
 	char buf[BUFSIZ];
@@ -64,13 +77,16 @@ void TRON::tron(double *w)
 
 	int n = fun_obj->get_nr_variable();
 	int i, cg_iter;
-	double delta, snorm, one=1.0;
+	double delta=0, sMnorm, one=1.0;
 	double alpha, f, fnew, prered, actred, gs;
 	int search = 1, iter = 1, inc = 1;
 	double *s = new double[n];
 	double *r = new double[n];
 	double *g = new double[n];
 
+	const double alpha_pcg = 0.01;
+	double *M = new double[n];
+
 	// calculate gradient norm at w=0 for stopping condition.
 	double *w0 = new double[n];
 	for (i=0; i<n; i++)
@@ -82,19 +98,22 @@ void TRON::tron(double *w)
 
 	f = fun_obj->fun(w);
 	fun_obj->grad(w, g);
-	delta = dnrm2_(&n, g, &inc);
-	double gnorm = delta;
+	double gnorm = dnrm2_(&n, g, &inc);
 
 	if (gnorm <= eps*gnorm0)
 		search = 0;
 
-	iter = 1;
+	fun_obj->get_diag_preconditioner(M);
+	for(i=0; i<n; i++)
+		M[i] = (1-alpha_pcg) + alpha_pcg*M[i];
+	delta = sqrt(uTMv(n, g, M, g));
 
 	double *w_new = new double[n];
 	bool reach_boundary;
+	bool delta_adjusted = false;
 	while (iter <= max_iter && search)
 	{
-		cg_iter = trcg(delta, g, s, r, &reach_boundary);
+		cg_iter = trpcg(delta, g, M, s, r, &reach_boundary);
 
 		memcpy(w_new, w, sizeof(double)*n);
 		daxpy_(&n, &one, s, &inc, w_new, &inc);
@@ -107,11 +126,14 @@ void TRON::tron(double *w)
 		actred = f - fnew;
 
 		// On the first iteration, adjust the initial step bound.
-		snorm = dnrm2_(&n, s, &inc);
-		if (iter == 1)
-			delta = min(delta, snorm);
+		sMnorm = sqrt(uTMv(n, s, M, s));
+		if (iter == 1 && !delta_adjusted)
+		{
+			delta = min(delta, sMnorm);
+			delta_adjusted = true;
+		}
 
-		// Compute prediction alpha*snorm of the step.
+		// Compute prediction alpha*sMnorm of the step.
 		if (fnew - f - gs <= 0)
 			alpha = sigma3;
 		else
@@ -119,17 +141,17 @@ void TRON::tron(double *w)
 
 		// Update the trust region bound according to the ratio of actual to predicted reduction.
 		if (actred < eta0*prered)
-			delta = min(max(alpha, sigma1)*snorm, sigma2*delta);
+			delta = min(alpha*sMnorm, sigma2*delta);
 		else if (actred < eta1*prered)
-			delta = max(sigma1*delta, min(alpha*snorm, sigma2*delta));
+			delta = max(sigma1*delta, min(alpha*sMnorm, sigma2*delta));
 		else if (actred < eta2*prered)
-			delta = max(sigma1*delta, min(alpha*snorm, sigma3*delta));
+			delta = max(sigma1*delta, min(alpha*sMnorm, sigma3*delta));
 		else
 		{
 			if (reach_boundary)
 				delta = sigma3*delta;
 			else
-				delta = max(delta, min(alpha*snorm, sigma3*delta));
+				delta = max(delta, min(alpha*sMnorm, sigma3*delta));
 		}
 
 		info("iter %2d act %5.3e pre %5.3e delta %5.3e f %5.3e |g| %5.3e CG %3d\n", iter, actred, prered, delta, f, gnorm, cg_iter);
@@ -140,6 +162,9 @@ void TRON::tron(double *w)
 			memcpy(w, w_new, sizeof(double)*n);
 			f = fnew;
 			fun_obj->grad(w, g);
+			fun_obj->get_diag_preconditioner(M);
+			for(i=0; i<n; i++)
+				M[i] = (1-alpha_pcg) + alpha_pcg*M[i];
 
 			gnorm = dnrm2_(&n, g, &inc);
 			if (gnorm <= eps*gnorm0)
@@ -167,53 +192,60 @@ void TRON::tron(double *w)
 	delete[] r;
 	delete[] w_new;
 	delete[] s;
+	delete[] M;
 }
 
-int TRON::trcg(double delta, double *g, double *s, double *r, bool *reach_boundary)
+int TRON::trpcg(double delta, double *g, double *M, double *s, double *r, bool *reach_boundary)
 {
 	int i, inc = 1;
 	int n = fun_obj->get_nr_variable();
 	double one = 1;
 	double *d = new double[n];
 	double *Hd = new double[n];
-	double rTr, rnewTrnew, alpha, beta, cgtol;
+	double zTr, znewTrnew, alpha, beta, cgtol;
+	double *z = new double[n];
 
 	*reach_boundary = false;
 	for (i=0; i<n; i++)
 	{
 		s[i] = 0;
 		r[i] = -g[i];
-		d[i] = r[i];
+		z[i] = r[i] / M[i];
+		d[i] = z[i];
 	}
-	cgtol = eps_cg*dnrm2_(&n, g, &inc);
 
+	zTr = ddot_(&n, z, &inc, r, &inc);
+	cgtol = eps_cg*sqrt(zTr);
 	int cg_iter = 0;
-	rTr = ddot_(&n, r, &inc, r, &inc);
-	while (1)
+	int max_cg_iter = max(n, 5);
+
+	while (cg_iter < max_cg_iter)
 	{
-		if (dnrm2_(&n, r, &inc) <= cgtol)
+		if (sqrt(zTr) <= cgtol)
 			break;
 		cg_iter++;
 		fun_obj->Hv(d, Hd);
 
-		alpha = rTr/ddot_(&n, d, &inc, Hd, &inc);
+		alpha = zTr/ddot_(&n, d, &inc, Hd, &inc);
 		daxpy_(&n, &alpha, d, &inc, s, &inc);
-		if (dnrm2_(&n, s, &inc) > delta)
+
+		double sMnorm = sqrt(uTMv(n, s, M, s));
+		if (sMnorm > delta)
 		{
 			info("cg reaches trust region boundary\n");
 			*reach_boundary = true;
 			alpha = -alpha;
 			daxpy_(&n, &alpha, d, &inc, s, &inc);
 
-			double std = ddot_(&n, s, &inc, d, &inc);
-			double sts = ddot_(&n, s, &inc, s, &inc);
-			double dtd = ddot_(&n, d, &inc, d, &inc);
+			double sTMd = uTMv(n, s, M, d);
+			double sTMs = uTMv(n, s, M, s);
+			double dTMd = uTMv(n, d, M, d);
 			double dsq = delta*delta;
-			double rad = sqrt(std*std + dtd*(dsq-sts));
-			if (std >= 0)
-				alpha = (dsq - sts)/(std + rad);
+			double rad = sqrt(sTMd*sTMd + dTMd*(dsq-sTMs));
+			if (sTMd >= 0)
+				alpha = (dsq - sTMs)/(sTMd + rad);
 			else
-				alpha = (rad - std)/dtd;
+				alpha = (rad - sTMd)/dTMd;
 			daxpy_(&n, &alpha, d, &inc, s, &inc);
 			alpha = -alpha;
 			daxpy_(&n, &alpha, Hd, &inc, r, &inc);
@@ -221,15 +253,22 @@ int TRON::trcg(double delta, double *g, double *s, double *r, bool *reach_bounda
 		}
 		alpha = -alpha;
 		daxpy_(&n, &alpha, Hd, &inc, r, &inc);
-		rnewTrnew = ddot_(&n, r, &inc, r, &inc);
-		beta = rnewTrnew/rTr;
+
+		for (i=0; i<n; i++)
+			z[i] = r[i] / M[i];
+		znewTrnew = ddot_(&n, z, &inc, r, &inc);
+		beta = znewTrnew/zTr;
 		dscal_(&n, &beta, d, &inc);
-		daxpy_(&n, &one, r, &inc, d, &inc);
-		rTr = rnewTrnew;
+		daxpy_(&n, &one, z, &inc, d, &inc);
+		zTr = znewTrnew;
 	}
 
+	if (cg_iter == max_cg_iter)
+		info("WARNING: reaching maximal number of CG steps\n");
+	
 	delete[] d;
 	delete[] Hd;
+	delete[] z;
 
 	return(cg_iter);
 }

data/ext/tron.h

@@ -9,6 +9,7 @@ public:
 	virtual void Hv(double *s, double *Hs) = 0 ;
 
 	virtual int get_nr_variable(void) = 0 ;
+	virtual void get_diag_preconditioner(double *M) = 0 ;
 	virtual ~function(void){}
 };
 
@@ -22,7 +23,7 @@ public:
 	void set_print_string(void (*i_print) (const char *buf));
 
 private:
-	int trcg(double delta, double *g, double *s, double *r, bool *reach_boundary);
+	int trpcg(double delta, double *g, double *M, double *s, double *r, bool *reach_boundary);
 	double norm_inf(int n, double *x);
 
 	double eps;

data/lib/liblinear/parameter.rb

@@ -21,7 +21,7 @@ class Liblinear
         when Liblinear::L2R_LR_DUAL         then
           0.1
         when Liblinear::L2R_L2LOSS_SVR      then
-          0.001
+          0.0001
         when Liblinear::L2R_L2LOSS_SVR_DUAL then
           0.1
         when Liblinear::L2R_L1LOSS_SVR_DUAL then

data/lib/liblinear/version.rb

@@ -1,3 +1,3 @@
 class Liblinear
-  VERSION = '1.0.2'
+  VERSION = '1.0.3'
 end

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: liblinear-ruby
 version: !ruby/object:Gem::Version
-  version: 1.0.2
+  version: 1.0.3
 platform: ruby
 authors:
 - Kei Tsuchiya
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2017-05-22 00:00:00.000000000 Z
+date: 2019-03-29 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: bundler
@@ -104,8 +104,7 @@ required_rubygems_version: !ruby/object:Gem::Requirement
     - !ruby/object:Gem::Version
       version: '0'
 requirements: []
-rubyforge_project: 
-rubygems_version: 2.5.1
+rubygems_version: 3.0.1
 signing_key: 
 specification_version: 4
 summary: Ruby wrapper of LIBLINEAR using SWIG