numo-liblinear 1.0.0 → 1.1.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
-SHA1:
-  metadata.gz: e97d55247e6ea6bb0e6c98c5ad93445adc0f37fa
-  data.tar.gz: c164048e2db697e01269f48e816c4e6adac2ecfb
+SHA256:
+  metadata.gz: 4e69ca89df0a86fdc4be7d1a3074a4722ead3997a6f7ba2fff84b48c6d1c36ea
+  data.tar.gz: 992d8f8606dbf272ac18c1f6502e923d69ce3242d6cb35a460b3856cace29671
 SHA512:
-  metadata.gz: 4240c57da4b083bc433293ec2c9b0716893f2523ab4180d8cf41f3bdd6d769173abc45ba0ce08607615b4de34849949527b1a97ce43cfaa5dd4a1f21a0a0e67c
-  data.tar.gz: ba830acf8df33fec1efffb35a041bf6f08bf65f368b4d03fa6fc086e5d8e6a046b99629e313126100cea57ae7b655410871f85e8e63a6ba1c6234e03a1d62a2f
+  metadata.gz: 46f453f5b9ee23640a7131d92d3f666806e182265654cec321ebae22c97ae6af06a5b35726e4ab0cfde96407d0fb828391a2c5578c3e27644c487df66432cce8
+  data.tar.gz: d1e0fc15d4227491823fe4ed8f631c491e6cd4c8fb9c078ccf230785e2881fa12134dbfca9e84069bd8d995c140523bfc0572cbaa38761b114d162015dea5be1

data/.travis.yml

@@ -8,6 +8,7 @@ rvm:
   - '2.4'
   - '2.5'
   - '2.6'
+  - '2.7'
 
 before_install:
   - gem install bundler -v 2.0.2

data/CHANGELOG.md

@@ -1,3 +1,7 @@
+# 1.1.0
+- Update bundled LIBLINEAR version to 2.4.1.
+- Support one-class SVM implemented on LIBLINEAR ver. 2.4.0.
+
 # 1.0.0
 ## Breaking change
 - For easy installation, Numo::LIBLINEAR bundles LIBLINEAR codes.

data/LICENSE.txt

@@ -1,4 +1,4 @@
-Copyright (c) 2019 Atsushi Tatsuma
+Copyright (c) 2019-2020 Atsushi Tatsuma
 All rights reserved.
 
 Redistribution and use in source and binary forms, with or without

data/README.md

@@ -3,7 +3,7 @@
 [![Build Status](https://travis-ci.org/yoshoku/numo-liblinear.svg?branch=master)](https://travis-ci.org/yoshoku/numo-liblinear)
 [![Gem Version](https://badge.fury.io/rb/numo-liblinear.svg)](https://badge.fury.io/rb/numo-liblinear)
 [![BSD 3-Clause License](https://img.shields.io/badge/License-BSD%203--Clause-orange.svg)](https://github.com/yoshoku/numo-liblinear/blob/master/LICENSE.txt)
-[![Documentation](http://img.shields.io/badge/docs-rdoc.info-blue.svg)](https://www.rubydoc.info/gems/numo-liblinear/0.4.0)
+[![Documentation](http://img.shields.io/badge/docs-rdoc.info-blue.svg)](https://yoshoku.github.io/numo-liblinear/doc/)
 
 Numo::Liblinear is a Ruby gem binding to the [LIBLINEAR](https://www.csie.ntu.edu.tw/~cjlin/liblinear/) library.
 LIBLINEAR is one of the famous libraries for large-scale regularized linear classification and regression.

data/ext/numo/liblinear/extconf.rb

@@ -29,7 +29,7 @@ end
 $LDFLAGS << ' -lstdc++ '
 
 $srcs = Dir.glob("#{$srcdir}/*.c").map { |path| File.basename(path) }
-$srcs.concat(%w[linear.cpp tron.cpp daxpy.c ddot.c dnrm2.c dscal.c])
+$srcs.concat(%w[linear.cpp newton.cpp daxpy.c ddot.c dnrm2.c dscal.c])
 
 $INCFLAGS << " -I$(srcdir)/liblinear"
 $VPATH << "$(srcdir)/liblinear"

data/ext/numo/liblinear/liblinear/linear.cpp

@@ -5,7 +5,7 @@
 #include <stdarg.h>
 #include <locale.h>
 #include "linear.h"
-#include "tron.h"
+#include "newton.h"
 int liblinear_version = LIBLINEAR_VERSION;
 typedef signed char schar;
 template <class T> static inline void swap(T& x, T& y) { T t=x; x=y; y=t; }
@@ -70,6 +70,28 @@ public:
 		return (ret);
 	}
 
+	static double sparse_dot(const feature_node *x1, const feature_node *x2)
+	{
+		double ret = 0;
+		while(x1->index != -1 && x2->index != -1)
+		{
+			if(x1->index == x2->index)
+			{
+				ret += x1->value * x2->value;
+				++x1;
+				++x2;
+			}
+			else
+			{
+				if(x1->index > x2->index)
+					++x2;
+				else
+					++x1;
+			}
+		}
+		return (ret);
+	}
+
 	static void axpy(const double a, const feature_node *x, double *y)
 	{
 		while(x->index != -1)
@@ -80,70 +102,195 @@ public:
 	}
 };
 
-class l2r_lr_fun: public function
+// L2-regularized empirical risk minimization
+// min_w w^Tw/2 + \sum C_i \xi(w^Tx_i), where \xi() is the loss
+
+class l2r_erm_fun: public function
 {
 public:
-	l2r_lr_fun(const problem *prob, double *C);
-	~l2r_lr_fun();
+	l2r_erm_fun(const problem *prob, const parameter *param, double *C);
+	~l2r_erm_fun();
 
 	double fun(double *w);
-	void grad(double *w, double *g);
-	void Hv(double *s, double *Hs);
-
+	double linesearch_and_update(double *w, double *d, double *f, double *g, double alpha);
 	int get_nr_variable(void);
-	void get_diag_preconditioner(double *M);
 
-private:
+protected:
+	virtual double C_times_loss(int i, double wx_i) = 0;
 	void Xv(double *v, double *Xv);
 	void XTv(double *v, double *XTv);
 
 	double *C;
-	double *z;
-	double *D;
 	const problem *prob;
+	double *wx;
+	double *tmp; // a working array
+	double wTw;
+	int regularize_bias;
 };
 
-l2r_lr_fun::l2r_lr_fun(const problem *prob, double *C)
+l2r_erm_fun::l2r_erm_fun(const problem *prob, const parameter *param, double *C)
 {
 	int l=prob->l;
 
 	this->prob = prob;
 
-	z = new double[l];
-	D = new double[l];
+	wx = new double[l];
+	tmp = new double[l];
 	this->C = C;
+	this->regularize_bias = param->regularize_bias;
 }
 
-l2r_lr_fun::~l2r_lr_fun()
+l2r_erm_fun::~l2r_erm_fun()
 {
-	delete[] z;
-	delete[] D;
+	delete[] wx;
+	delete[] tmp;
 }
 
-
-double l2r_lr_fun::fun(double *w)
+double l2r_erm_fun::fun(double *w)
 {
 	int i;
 	double f=0;
-	double *y=prob->y;
 	int l=prob->l;
 	int w_size=get_nr_variable();
 
-	Xv(w, z);
+	wTw = 0;
+	Xv(w, wx);
 
 	for(i=0;i<w_size;i++)
-		f += w[i]*w[i];
-	f /= 2.0;
+		wTw += w[i]*w[i];
+	if(regularize_bias == 0)
+		wTw -= w[w_size-1]*w[w_size-1];
 	for(i=0;i<l;i++)
+		f += C_times_loss(i, wx[i]);
+	f = f + 0.5 * wTw;
+
+	return(f);
+}
+
+int l2r_erm_fun::get_nr_variable(void)
+{
+	return prob->n;
+}
+
+// On entry *f must be the function value of w
+// On exit w is updated and *f is the new function value
+double l2r_erm_fun::linesearch_and_update(double *w, double *s, double *f, double *g, double alpha)
+{
+	int i;
+	int l = prob->l;
+	double sTs = 0;
+	double wTs = 0;
+	double gTs = 0;
+	double eta = 0.01;
+	int w_size = get_nr_variable();
+	int max_num_linesearch = 20;
+	double fold = *f;
+	Xv(s, tmp);
+
+	for (i=0;i<w_size;i++)
+	{
+		sTs += s[i] * s[i];
+		wTs += s[i] * w[i];
+		gTs += s[i] * g[i];
+	}
+	if(regularize_bias == 0)
+	{
+		// bias not used in calculating (w + \alpha s)^T (w + \alpha s)
+		sTs -= s[w_size-1] * s[w_size-1];
+		wTs -= s[w_size-1] * w[w_size-1];
+	}
+
+	int num_linesearch = 0;
+	for(num_linesearch=0; num_linesearch < max_num_linesearch; num_linesearch++)
 	{
-		double yz = y[i]*z[i];
-		if (yz >= 0)
-			f += C[i]*log(1 + exp(-yz));
+		double loss = 0;
+		for(i=0;i<l;i++)
+		{
+			double inner_product = tmp[i] * alpha + wx[i];
+			loss += C_times_loss(i, inner_product);
+		}
+		*f = loss + (alpha * alpha * sTs + wTw) / 2.0 + alpha * wTs;
+		if (*f - fold <= eta * alpha * gTs)
+		{
+			for (i=0;i<l;i++)
+				wx[i] += alpha * tmp[i];
+			break;
+		}
 		else
-			f += C[i]*(-yz+log(1 + exp(yz)));
+			alpha *= 0.5;
 	}
 
-	return(f);
+	if (num_linesearch >= max_num_linesearch)
+	{
+		*f = fold;
+		return 0;
+	}
+	else
+		for (i=0;i<w_size;i++)
+			w[i] += alpha * s[i];
+
+	wTw += alpha * alpha * sTs + 2* alpha * wTs;
+	return alpha;
+}
+
+void l2r_erm_fun::Xv(double *v, double *Xv)
+{
+	int i;
+	int l=prob->l;
+	feature_node **x=prob->x;
+
+	for(i=0;i<l;i++)
+		Xv[i]=sparse_operator::dot(v, x[i]);
+}
+
+void l2r_erm_fun::XTv(double *v, double *XTv)
+{
+	int i;
+	int l=prob->l;
+	int w_size=get_nr_variable();
+	feature_node **x=prob->x;
+
+	for(i=0;i<w_size;i++)
+		XTv[i]=0;
+	for(i=0;i<l;i++)
+		sparse_operator::axpy(v[i], x[i], XTv);
+}
+
+class l2r_lr_fun: public l2r_erm_fun
+{
+public:
+	l2r_lr_fun(const problem *prob, const parameter *param, double *C);
+	~l2r_lr_fun();
+
+	void grad(double *w, double *g);
+	void Hv(double *s, double *Hs);
+
+	void get_diag_preconditioner(double *M);
+
+private:
+	double *D;
+	double C_times_loss(int i, double wx_i);
+};
+
+l2r_lr_fun::l2r_lr_fun(const problem *prob, const parameter *param, double *C):
+	l2r_erm_fun(prob, param, C)
+{
+	int l=prob->l;
+	D = new double[l];
+}
+
+l2r_lr_fun::~l2r_lr_fun()
+{
+	delete[] D;
+}
+
+double l2r_lr_fun::C_times_loss(int i, double wx_i)
+{
+	double ywx_i = wx_i * prob->y[i];
+	if (ywx_i >= 0)
+		return C[i]*log(1 + exp(-ywx_i));
+	else
+		return C[i]*(-ywx_i + log(1 + exp(ywx_i)));
 }
 
 void l2r_lr_fun::grad(double *w, double *g)
@@ -155,19 +302,16 @@ void l2r_lr_fun::grad(double *w, double *g)
 
 	for(i=0;i<l;i++)
 	{
-		z[i] = 1/(1 + exp(-y[i]*z[i]));
-		D[i] = z[i]*(1-z[i]);
-		z[i] = C[i]*(z[i]-1)*y[i];
+		tmp[i] = 1/(1 + exp(-y[i]*wx[i]));
+		D[i] = tmp[i]*(1-tmp[i]);
+		tmp[i] = C[i]*(tmp[i]-1)*y[i];
 	}
-	XTv(z, g);
+	XTv(tmp, g);
 
 	for(i=0;i<w_size;i++)
 		g[i] = w[i] + g[i];
-}
-
-int l2r_lr_fun::get_nr_variable(void)
-{
-	return prob->n;
+	if(regularize_bias == 0)
+		g[w_size-1] -= w[w_size-1];
 }
 
 void l2r_lr_fun::get_diag_preconditioner(double *M)
@@ -179,14 +323,16 @@ void l2r_lr_fun::get_diag_preconditioner(double *M)
 
 	for (i=0; i<w_size; i++)
 		M[i] = 1;
+	if(regularize_bias == 0)
+		M[w_size-1] = 0;
 
 	for (i=0; i<l; i++)
 	{
-		feature_node *s = x[i];
-		while (s->index!=-1)
+		feature_node *xi = x[i];
+		while (xi->index!=-1)
 		{
-			M[s->index-1] += s->value*s->value*C[i]*D[i];
-			s++;
+			M[xi->index-1] += xi->value*xi->value*C[i]*D[i];
+			xi++;
 		}
 	}
 }
@@ -211,94 +357,49 @@ void l2r_lr_fun::Hv(double *s, double *Hs)
 	}
 	for(i=0;i<w_size;i++)
 		Hs[i] = s[i] + Hs[i];
+	if(regularize_bias == 0)
+		Hs[w_size-1] -= s[w_size-1];
 }
 
-void l2r_lr_fun::Xv(double *v, double *Xv)
-{
-	int i;
-	int l=prob->l;
-	feature_node **x=prob->x;
-
-	for(i=0;i<l;i++)
-		Xv[i]=sparse_operator::dot(v, x[i]);
-}
-
-void l2r_lr_fun::XTv(double *v, double *XTv)
-{
-	int i;
-	int l=prob->l;
-	int w_size=get_nr_variable();
-	feature_node **x=prob->x;
-
-	for(i=0;i<w_size;i++)
-		XTv[i]=0;
-	for(i=0;i<l;i++)
-		sparse_operator::axpy(v[i], x[i], XTv);
-}
-
-class l2r_l2_svc_fun: public function
+class l2r_l2_svc_fun: public l2r_erm_fun
 {
 public:
-	l2r_l2_svc_fun(const problem *prob, double *C);
+	l2r_l2_svc_fun(const problem *prob, const parameter *param, double *C);
 	~l2r_l2_svc_fun();
 
-	double fun(double *w);
 	void grad(double *w, double *g);
 	void Hv(double *s, double *Hs);
 
-	int get_nr_variable(void);
 	void get_diag_preconditioner(double *M);
 
 protected:
-	void Xv(double *v, double *Xv);
 	void subXTv(double *v, double *XTv);
 
-	double *C;
-	double *z;
 	int *I;
 	int sizeI;
-	const problem *prob;
+
+private:
+	double C_times_loss(int i, double wx_i);
 };
 
-l2r_l2_svc_fun::l2r_l2_svc_fun(const problem *prob, double *C)
+l2r_l2_svc_fun::l2r_l2_svc_fun(const problem *prob, const parameter *param, double *C):
+	l2r_erm_fun(prob, param, C)
 {
-	int l=prob->l;
-
-	this->prob = prob;
-
-	z = new double[l];
-	I = new int[l];
-	this->C = C;
+	I = new int[prob->l];
 }
 
 l2r_l2_svc_fun::~l2r_l2_svc_fun()
 {
-	delete[] z;
 	delete[] I;
 }
 
-double l2r_l2_svc_fun::fun(double *w)
+double l2r_l2_svc_fun::C_times_loss(int i, double wx_i)
 {
-	int i;
-	double f=0;
-	double *y=prob->y;
-	int l=prob->l;
-	int w_size=get_nr_variable();
-
-	Xv(w, z);
-
-	for(i=0;i<w_size;i++)
-		f += w[i]*w[i];
-	f /= 2.0;
-	for(i=0;i<l;i++)
-	{
-		z[i] = y[i]*z[i];
-		double d = 1-z[i];
-		if (d > 0)
-			f += C[i]*d*d;
-	}
-
-	return(f);
+	double d = 1 - prob->y[i] * wx_i;
+	if (d > 0)
+		return C[i] * d * d;
+	else
+		return 0;
 }
 
 void l2r_l2_svc_fun::grad(double *w, double *g)
@@ -310,21 +411,21 @@ void l2r_l2_svc_fun::grad(double *w, double *g)
 
 	sizeI = 0;
 	for (i=0;i<l;i++)
-		if (z[i] < 1)
+	{
+		tmp[i] = wx[i] * y[i];
+		if (tmp[i] < 1)
 		{
-			z[sizeI] = C[i]*y[i]*(z[i]-1);
+			tmp[sizeI] = C[i]*y[i]*(tmp[i]-1);
 			I[sizeI] = i;
 			sizeI++;
 		}
-	subXTv(z, g);
+	}
+	subXTv(tmp, g);
 
 	for(i=0;i<w_size;i++)
 		g[i] = w[i] + 2*g[i];
-}
-
-int l2r_l2_svc_fun::get_nr_variable(void)
-{
-	return prob->n;
+	if(regularize_bias == 0)
+		g[w_size-1] -= w[w_size-1];
 }
 
 void l2r_l2_svc_fun::get_diag_preconditioner(double *M)
@@ -335,15 +436,17 @@ void l2r_l2_svc_fun::get_diag_preconditioner(double *M)
 
 	for (i=0; i<w_size; i++)
 		M[i] = 1;
+	if(regularize_bias == 0)
+		M[w_size-1] = 0;
 
 	for (i=0; i<sizeI; i++)
 	{
 		int idx = I[i];
-		feature_node *s = x[idx];
-		while (s->index!=-1)
+		feature_node *xi = x[idx];
+		while (xi->index!=-1)
 		{
-			M[s->index-1] += s->value*s->value*C[idx]*2;
-			s++;
+			M[xi->index-1] += xi->value*xi->value*C[idx]*2;
+			xi++;
 		}
 	}
 }
@@ -367,16 +470,8 @@ void l2r_l2_svc_fun::Hv(double *s, double *Hs)
 	}
 	for(i=0;i<w_size;i++)
 		Hs[i] = s[i] + 2*Hs[i];
-}
-
-void l2r_l2_svc_fun::Xv(double *v, double *Xv)
-{
-	int i;
-	int l=prob->l;
-	feature_node **x=prob->x;
-
-	for(i=0;i<l;i++)
-		Xv[i]=sparse_operator::dot(v, x[i]);
+	if(regularize_bias == 0)
+		Hs[w_size-1] -= s[w_size-1];
 }
 
 void l2r_l2_svc_fun::subXTv(double *v, double *XTv)
@@ -394,45 +489,30 @@ void l2r_l2_svc_fun::subXTv(double *v, double *XTv)
 class l2r_l2_svr_fun: public l2r_l2_svc_fun
 {
 public:
-	l2r_l2_svr_fun(const problem *prob, double *C, double p);
+	l2r_l2_svr_fun(const problem *prob, const parameter *param, double *C);
 
-	double fun(double *w);
 	void grad(double *w, double *g);
 
 private:
+	double C_times_loss(int i, double wx_i);
 	double p;
 };
 
-l2r_l2_svr_fun::l2r_l2_svr_fun(const problem *prob, double *C, double p):
-	l2r_l2_svc_fun(prob, C)
+l2r_l2_svr_fun::l2r_l2_svr_fun(const problem *prob, const parameter *param, double *C):
+	l2r_l2_svc_fun(prob, param, C)
 {
-	this->p = p;
+	this->p = param->p;
+	this->regularize_bias = param->regularize_bias;
 }
 
-double l2r_l2_svr_fun::fun(double *w)
+double l2r_l2_svr_fun::C_times_loss(int i, double wx_i)
 {
-	int i;
-	double f=0;
-	double *y=prob->y;
-	int l=prob->l;
-	int w_size=get_nr_variable();
-	double d;
-
-	Xv(w, z);
-
-	for(i=0;i<w_size;i++)
-		f += w[i]*w[i];
-	f /= 2;
-	for(i=0;i<l;i++)
-	{
-		d = z[i] - y[i];
-		if(d < -p)
-			f += C[i]*(d+p)*(d+p);
-		else if(d > p)
-			f += C[i]*(d-p)*(d-p);
-	}
-
-	return(f);
+	double d = wx_i - prob->y[i];
+	if(d < -p)
+		return C[i]*(d+p)*(d+p);
+	else if(d > p)
+		return C[i]*(d-p)*(d-p);
+	return 0;
 }
 
 void l2r_l2_svr_fun::grad(double *w, double *g)
@@ -446,27 +526,29 @@ void l2r_l2_svr_fun::grad(double *w, double *g)
 	sizeI = 0;
 	for(i=0;i<l;i++)
 	{
-		d = z[i] - y[i];
+		d = wx[i] - y[i];
 
 		// generate index set I
 		if(d < -p)
 		{
-			z[sizeI] = C[i]*(d+p);
+			tmp[sizeI] = C[i]*(d+p);
 			I[sizeI] = i;
 			sizeI++;
 		}
 		else if(d > p)
 		{
-			z[sizeI] = C[i]*(d-p);
+			tmp[sizeI] = C[i]*(d-p);
 			I[sizeI] = i;
 			sizeI++;
 		}
 
 	}
-	subXTv(z, g);
+	subXTv(tmp, g);
 
 	for(i=0;i<w_size;i++)
 		g[i] = w[i] + 2*g[i];
+	if(regularize_bias == 0)
+		g[w_size-1] -= w[w_size-1];
 }
 
 // A coordinate descent algorithm for
@@ -1378,6 +1460,9 @@ void solve_l2r_lr_dual(const problem *prob, double *w, double eps, double Cp, do
 // solution will be put in w
 //
 // See Yuan et al. (2010) and appendix of LIBLINEAR paper, Fan et al. (2008)
+//
+// To not regularize the bias (i.e., regularize_bias = 0), a constant feature = 1
+// must have been added to the original data. (see -B and -R option)
 
 #undef GETI
 #define GETI(i) (y[i]+1)
@@ -1385,7 +1470,7 @@ void solve_l2r_lr_dual(const problem *prob, double *w, double eps, double Cp, do
 
 static void solve_l1r_l2_svc(
 	problem *prob_col, double *w, double eps,
-	double Cp, double Cn)
+	double Cp, double Cn, int regularize_bias)
 {
 	int l = prob_col->l;
 	int w_size = prob_col->n;
@@ -1475,49 +1560,66 @@ static void solve_l1r_l2_svc(
 			H *= 2;
 			H = max(H, 1e-12);
 
-			double Gp = G+1;
-			double Gn = G-1;
 			double violation = 0;
-			if(w[j] == 0)
+			double Gp = 0, Gn = 0;
+			if(j == w_size-1 && regularize_bias == 0)
+				violation = fabs(G);
+			else
 			{
-				if(Gp < 0)
-					violation = -Gp;
-				else if(Gn > 0)
-					violation = Gn;
-				else if(Gp>Gmax_old/l && Gn<-Gmax_old/l)
+				Gp = G+1;
+				Gn = G-1;
+				if(w[j] == 0)
 				{
-					active_size--;
-					swap(index[s], index[active_size]);
-					s--;
-					continue;
+					if(Gp < 0)
+						violation = -Gp;
+					else if(Gn > 0)
+						violation = Gn;
+					else if(Gp>Gmax_old/l && Gn<-Gmax_old/l)
+					{
+						active_size--;
+						swap(index[s], index[active_size]);
+						s--;
+						continue;
+					}
 				}
+				else if(w[j] > 0)
+					violation = fabs(Gp);
+				else
+					violation = fabs(Gn);
 			}
-			else if(w[j] > 0)
-				violation = fabs(Gp);
-			else
-				violation = fabs(Gn);
-
 			Gmax_new = max(Gmax_new, violation);
 			Gnorm1_new += violation;
 
 			// obtain Newton direction d
-			if(Gp < H*w[j])
-				d = -Gp/H;
-			else if(Gn > H*w[j])
-				d = -Gn/H;
+			if(j == w_size-1 && regularize_bias == 0)
+				d = -G/H;
 			else
-				d = -w[j];
+			{
+				if(Gp < H*w[j])
+					d = -Gp/H;
+				else if(Gn > H*w[j])
+					d = -Gn/H;
+				else
+					d = -w[j];
+			}
 
 			if(fabs(d) < 1.0e-12)
 				continue;
 
-			double delta = fabs(w[j]+d)-fabs(w[j]) + G*d;
+			double delta;
+			if(j == w_size-1 && regularize_bias == 0)
+				delta = G*d;
+			else
+				delta = fabs(w[j]+d)-fabs(w[j]) + G*d;
 			d_old = 0;
 			int num_linesearch;
 			for(num_linesearch=0; num_linesearch < max_num_linesearch; num_linesearch++)
 			{
 				d_diff = d_old - d;
-				cond = fabs(w[j]+d)-fabs(w[j]) - sigma*delta;
+				if(j == w_size-1 && regularize_bias == 0)
+					cond = -sigma*delta;
+				else
+					cond = fabs(w[j]+d)-fabs(w[j]) - sigma*delta;
 
 				appxcond = xj_sq[j]*d*d + G_loss*d + cond;
 				if(appxcond <= 0)
@@ -1632,6 +1734,8 @@ static void solve_l1r_l2_svc(
 			nnz++;
 		}
 	}
+	if (regularize_bias == 0)
+		v -= fabs(w[w_size-1]);
 	for(j=0; j<l; j++)
 		if(b[j] > 0)
 			v += C[GETI(j)]*b[j]*b[j];
@@ -1657,6 +1761,9 @@ static void solve_l1r_l2_svc(
 // solution will be put in w
 //
 // See Yuan et al. (2011) and appendix of LIBLINEAR paper, Fan et al. (2008)
+//
+// To not regularize the bias (i.e., regularize_bias = 0), a constant feature = 1
+// must have been added to the original data. (see -B and -R option)
 
 #undef GETI
 #define GETI(i) (y[i]+1)
@@ -1664,7 +1771,7 @@ static void solve_l1r_l2_svc(
 
 static void solve_l1r_lr(
 	const problem *prob_col, double *w, double eps,
-	double Cp, double Cn)
+	double Cp, double Cn, int regularize_bias)
 {
 	int l = prob_col->l;
 	int w_size = prob_col->n;
@@ -1734,6 +1841,9 @@ static void solve_l1r_lr(
 			x++;
 		}
 	}
+	if (regularize_bias == 0)
+		w_norm -= fabs(w[w_size-1]);
+
 	for(j=0; j<l; j++)
 	{
 		exp_wTx[j] = exp(exp_wTx[j]);
@@ -1765,29 +1875,33 @@ static void solve_l1r_lr(
 			}
 			Grad[j] = -tmp + xjneg_sum[j];
 
-			double Gp = Grad[j]+1;
-			double Gn = Grad[j]-1;
 			double violation = 0;
-			if(w[j] == 0)
+			if (j == w_size-1 && regularize_bias == 0)
+				violation = fabs(Grad[j]);
+			else
 			{
-				if(Gp < 0)
-					violation = -Gp;
-				else if(Gn > 0)
-					violation = Gn;
-				//outer-level shrinking
-				else if(Gp>Gmax_old/l && Gn<-Gmax_old/l)
+				double Gp = Grad[j]+1;
+				double Gn = Grad[j]-1;
+				if(w[j] == 0)
 				{
-					active_size--;
-					swap(index[s], index[active_size]);
-					s--;
-					continue;
+					if(Gp < 0)
+						violation = -Gp;
+					else if(Gn > 0)
+						violation = Gn;
+					//outer-level shrinking
+					else if(Gp>Gmax_old/l && Gn<-Gmax_old/l)
+					{
+						active_size--;
+						swap(index[s], index[active_size]);
+						s--;
+						continue;
+					}
 				}
+				else if(w[j] > 0)
+					violation = fabs(Gp);
+				else
+					violation = fabs(Gn);
 			}
-			else if(w[j] > 0)
-				violation = fabs(Gp);
-			else
-				violation = fabs(Gn);
-
 			Gmax_new = max(Gmax_new, violation);
 			Gnorm1_new += violation;
 		}
@@ -1831,40 +1945,48 @@ static void solve_l1r_lr(
 					x++;
 				}
 
-				double Gp = G+1;
-				double Gn = G-1;
 				double violation = 0;
-				if(wpd[j] == 0)
+				if (j == w_size-1 && regularize_bias == 0)
 				{
-					if(Gp < 0)
-						violation = -Gp;
-					else if(Gn > 0)
-						violation = Gn;
-					//inner-level shrinking
-					else if(Gp>QP_Gmax_old/l && Gn<-QP_Gmax_old/l)
-					{
-						QP_active_size--;
-						swap(index[s], index[QP_active_size]);
-						s--;
-						continue;
-					}
+					// bias term not shrunken
+					violation = fabs(G);
+					z = -G/H;
 				}
-				else if(wpd[j] > 0)
-					violation = fabs(Gp);
 				else
-					violation = fabs(Gn);
+				{
+					double Gp = G+1;
+					double Gn = G-1;
+					if(wpd[j] == 0)
+					{
+						if(Gp < 0)
+							violation = -Gp;
+						else if(Gn > 0)
+							violation = Gn;
+						//inner-level shrinking
+						else if(Gp>QP_Gmax_old/l && Gn<-QP_Gmax_old/l)
+						{
+							QP_active_size--;
+							swap(index[s], index[QP_active_size]);
+							s--;
+							continue;
+						}
+					}
+					else if(wpd[j] > 0)
+						violation = fabs(Gp);
+					else
+						violation = fabs(Gn);
 
+					// obtain solution of one-variable problem
+					if(Gp < H*wpd[j])
+						z = -Gp/H;
+					else if(Gn > H*wpd[j])
+						z = -Gn/H;
+					else
+						z = -wpd[j];
+				}
 				QP_Gmax_new = max(QP_Gmax_new, violation);
 				QP_Gnorm1_new += violation;
 
-				// obtain solution of one-variable problem
-				if(Gp < H*wpd[j])
-					z = -Gp/H;
-				else if(Gn > H*wpd[j])
-					z = -Gn/H;
-				else
-					z = -wpd[j];
-
 				if(fabs(z) < 1.0e-12)
 					continue;
 				z = min(max(z,-10.0),10.0);
@@ -1905,6 +2027,8 @@ static void solve_l1r_lr(
 			if(wpd[j] != 0)
 				w_norm_new += fabs(wpd[j]);
 		}
+		if (regularize_bias == 0)
+			w_norm_new -= fabs(wpd[w_size-1]);
 		delta += (w_norm_new-w_norm);
 
 		negsum_xTd = 0;
@@ -1947,6 +2071,8 @@ static void solve_l1r_lr(
 					if(wpd[j] != 0)
 						w_norm_new += fabs(wpd[j]);
 				}
+				if (regularize_bias == 0)
+					w_norm_new -= fabs(wpd[w_size-1]);
 				delta *= 0.5;
 				negsum_xTd *= 0.5;
 				for(int i=0; i<l; i++)
@@ -1995,6 +2121,8 @@ static void solve_l1r_lr(
 			v += fabs(w[j]);
 			nnz++;
 		}
+	if (regularize_bias == 0)
+		v -= fabs(w[w_size-1]);
 	for(j=0; j<l; j++)
 		if(y[j] == 1)
 			v += C[GETI(j)]*log(1+1/exp_wTx[j]);
@@ -2017,6 +2145,342 @@ static void solve_l1r_lr(
 	delete [] D;
 }
 
+struct heap {
+	enum HEAP_TYPE { MIN, MAX };
+	int _size;
+	HEAP_TYPE _type;
+	feature_node* a;
+
+	heap(int max_size, HEAP_TYPE type)
+	{
+		_size = 0;
+		a = new feature_node[max_size];
+		_type = type;
+	}
+	~heap()
+	{
+		delete [] a;
+	}
+	bool cmp(const feature_node& left, const feature_node& right)
+	{
+		if(_type == MIN)
+			return left.value > right.value;
+		else
+			return left.value < right.value;
+	}
+	int size()
+	{
+		return _size;
+	}
+	void push(feature_node node)
+	{
+		a[_size] = node;
+		_size++;
+		int i = _size-1;
+		while(i)
+		{
+			int p = (i-1)/2;
+			if(cmp(a[p], a[i]))
+			{
+				swap(a[i], a[p]);
+				i = p;
+			}
+			else
+				break;
+		}
+	}
+	void pop()
+	{
+		_size--;
+		a[0] = a[_size];
+		int i = 0;
+		while(i*2+1 < _size)
+		{
+			int l = i*2+1;
+			int r = i*2+2;
+			if(r < _size && cmp(a[l], a[r]))
+				l = r;
+			if(cmp(a[i], a[l]))
+			{
+				swap(a[i], a[l]);
+				i = l;
+			}
+			else
+				break;
+		}
+	}
+	feature_node top()
+	{
+		return a[0];
+	}
+};
+
+// A two-level coordinate descent algorithm for
+// a scaled one-class SVM dual problem
+//
+//  min_\alpha  0.5(\alpha^T Q \alpha),
+//    s.t.      0 <= \alpha_i <= 1 and
+//              e^T \alpha = \nu l
+//
+//  where Qij = xi^T xj
+//
+// Given:
+// x, nu
+// eps is the stopping tolerance
+//
+// solution will be put in w and rho
+//
+// See Algorithm 7 in supplementary materials of Chou et al., SDM 2020.
+
+static void solve_oneclass_svm(const problem *prob, double *w, double *rho, double eps, double nu)
+{
+	int l = prob->l;
+	int w_size = prob->n;
+	int i, j, s, iter = 0;
+	double Gi, Gj;
+	double Qij, quad_coef, delta, sum;
+	double old_alpha_i;
+	double *QD = new double[l];
+	double *G = new double[l];
+	int *index = new int[l];
+	double *alpha = new double[l];
+	int max_inner_iter;
+	int max_iter = 1000;
+	int active_size = l;
+
+	double negGmax;			// max { -grad(f)_i | alpha_i < 1 }
+	double negGmin;			// min { -grad(f)_i | alpha_i > 0 }
+
+	int *most_violating_i = new int[l];
+	int *most_violating_j = new int[l];
+
+	int n = (int)(nu*l);		// # of alpha's at upper bound
+	for(i=0; i<n; i++)
+		alpha[i] = 1;
+	if (n<l)
+		alpha[i] = nu*l-n;
+	for(i=n+1; i<l; i++)
+		alpha[i] = 0;
+
+	for(i=0; i<w_size; i++)
+		w[i] = 0;
+	for(i=0; i<l; i++)
+	{
+		feature_node * const xi = prob->x[i];
+		QD[i] = sparse_operator::nrm2_sq(xi);
+		sparse_operator::axpy(alpha[i], xi, w);
+
+		index[i] = i;
+	}
+
+	while (iter < max_iter)
+	{
+		negGmax = -INF;
+		negGmin = INF;
+
+		for (s=0; s<active_size; s++)
+		{
+			i = index[s];
+			feature_node * const xi = prob->x[i];
+			G[i] = sparse_operator::dot(w, xi);
+			if (alpha[i] < 1)
+				negGmax = max(negGmax, -G[i]);
+			if (alpha[i] > 0)
+				negGmin = min(negGmin, -G[i]);
+		}
+
+		if (negGmax - negGmin < eps)
+		{
+			if (active_size == l)
+				break;
+			else
+			{
+				active_size = l;
+				info("*");
+				continue;
+			}
+		}
+
+		for(s=0; s<active_size; s++)
+		{
+			i = index[s];
+			if ((alpha[i] == 1 && -G[i] > negGmax) ||
+			    (alpha[i] == 0 && -G[i] < negGmin))
+			{
+				active_size--;
+				swap(index[s], index[active_size]);
+				s--;
+			}
+		}
+
+		max_inner_iter = max(active_size/10, 1);
+		struct heap min_heap = heap(max_inner_iter, heap::MIN);
+		struct heap max_heap = heap(max_inner_iter, heap::MAX);
+		struct feature_node node;
+		for(s=0; s<active_size; s++)
+		{
+			i = index[s];
+			node.index = i;
+			node.value = -G[i];
+
+			if (alpha[i] < 1)
+			{
+				if (min_heap.size() < max_inner_iter)
+					min_heap.push(node);
+				else if (min_heap.top().value < node.value)
+				{
+					min_heap.pop();
+					min_heap.push(node);
+				}
+			}
+
+			if (alpha[i] > 0)
+			{
+				if (max_heap.size() < max_inner_iter)
+					max_heap.push(node);
+				else if (max_heap.top().value > node.value)
+				{
+					max_heap.pop();
+					max_heap.push(node);
+				}
+			}
+		}
+		max_inner_iter = min(min_heap.size(), max_heap.size());
+		while (max_heap.size() > max_inner_iter)
+			max_heap.pop();
+		while (min_heap.size() > max_inner_iter)
+			min_heap.pop();
+
+		for (s=max_inner_iter-1; s>=0; s--)
+		{
+			most_violating_i[s] = min_heap.top().index;
+			most_violating_j[s] = max_heap.top().index;
+			min_heap.pop();
+			max_heap.pop();
+		}
+
+		for (s=0; s<max_inner_iter; s++)
+		{
+			i = most_violating_i[s];
+			j = most_violating_j[s];
+
+			if ((alpha[i] == 0 && alpha[j] == 0) ||
+			    (alpha[i] == 1 && alpha[j] == 1))
+				continue;
+
+			feature_node const * xi = prob->x[i];
+			feature_node const * xj = prob->x[j];
+
+			Gi = sparse_operator::dot(w, xi);
+			Gj = sparse_operator::dot(w, xj);
+
+			int violating_pair = 0;
+			if (alpha[i] < 1 && alpha[j] > 0 && -Gj + 1e-12 < -Gi)
+				violating_pair = 1;
+			else
+				if (alpha[i] > 0 && alpha[j] < 1 && -Gi + 1e-12 < -Gj)
+					violating_pair = 1;
+			if (violating_pair == 0)
+				continue;
+
+			Qij = sparse_operator::sparse_dot(xi, xj);
+			quad_coef = QD[i] + QD[j] - 2*Qij;
+			if(quad_coef <= 0)
+				quad_coef = 1e-12;
+			delta = (Gi - Gj) / quad_coef;
+			old_alpha_i = alpha[i];
+			sum = alpha[i] + alpha[j];
+			alpha[i] = alpha[i] - delta;
+			alpha[j] = alpha[j] + delta;
+			if (sum > 1)
+			{
+				if (alpha[i] > 1)
+				{
+					alpha[i] = 1;
+					alpha[j] = sum - 1;
+				}
+			}
+			else
+			{
+				if (alpha[j] < 0)
+				{
+					alpha[j] = 0;
+					alpha[i] = sum;
+				}
+			}
+			if (sum > 1)
+			{
+				if (alpha[j] > 1)
+				{
+					alpha[j] = 1;
+					alpha[i] = sum - 1;
+				}
+			}
+			else
+			{
+				if (alpha[i] < 0)
+				{
+					alpha[i] = 0;
+					alpha[j] = sum;
+				}
+			}
+			delta = alpha[i] - old_alpha_i;
+			sparse_operator::axpy(delta, xi, w);
+			sparse_operator::axpy(-delta, xj, w);
+		}
+		iter++;
+		if (iter % 10 == 0)
+			info(".");
+	}
+	info("\noptimization finished, #iter = %d\n",iter);
+	if (iter >= max_iter)
+		info("\nWARNING: reaching max number of iterations\n\n");
+
+	// calculate object value
+	double v = 0;
+	for(i=0; i<w_size; i++)
+		v += w[i]*w[i];
+	int nSV = 0;
+	for(i=0; i<l; i++)
+	{
+		if (alpha[i] > 0)
+			++nSV;
+	}
+	info("Objective value = %lf\n", v/2);
+	info("nSV = %d\n", nSV);
+
+	// calculate rho
+	double nr_free = 0;
+	double ub = INF, lb = -INF, sum_free = 0;
+	for(i=0; i<l; i++)
+	{
+		double G = sparse_operator::dot(w, prob->x[i]);
+		if (alpha[i] == 1)
+			lb = max(lb, G);
+		else if (alpha[i] == 0)
+			ub = min(ub, G);
+		else
+		{
+			++nr_free;
+			sum_free += G;
+		}
+	}
+
+	if (nr_free > 0)
+		*rho = sum_free/nr_free;
+	else
+		*rho = (ub + lb)/2;
+
+	info("rho = %lf\n", *rho);
+
+	delete [] QD;
+	delete [] G;
+	delete [] index;
+	delete [] alpha;
+	delete [] most_violating_i;
+	delete [] most_violating_j;
+}
+
 // transpose matrix X from row format to column format
 static void transpose(const problem *prob, feature_node **x_space_ret, problem *prob_col)
 {
@@ -2152,11 +2616,7 @@ static void group_classes(const problem *prob, int *nr_class_ret, int **label_re
 
 static void train_one(const problem *prob, const parameter *param, double *w, double Cp, double Cn)
 {
-	//inner and outer tolerances for TRON
 	double eps = param->eps;
-	double eps_cg = 0.1;
-	if(param->init_sol != NULL)
-		eps_cg = 0.5;
 
 	int pos = 0;
 	int neg = 0;
@@ -2179,10 +2639,10 @@ static void train_one(const problem *prob, const parameter *param, double *w, do
 				else
 					C[i] = Cn;
 			}
-			fun_obj=new l2r_lr_fun(prob, C);
-			TRON tron_obj(fun_obj, primal_solver_tol, eps_cg);
-			tron_obj.set_print_string(liblinear_print_string);
-			tron_obj.tron(w);
+			fun_obj=new l2r_lr_fun(prob, param, C);
+			NEWTON newton_obj(fun_obj, primal_solver_tol);
+			newton_obj.set_print_string(liblinear_print_string);
+			newton_obj.newton(w);
 			delete fun_obj;
 			delete[] C;
 			break;
@@ -2197,10 +2657,10 @@ static void train_one(const problem *prob, const parameter *param, double *w, do
 				else
 					C[i] = Cn;
 			}
-			fun_obj=new l2r_l2_svc_fun(prob, C);
-			TRON tron_obj(fun_obj, primal_solver_tol, eps_cg);
-			tron_obj.set_print_string(liblinear_print_string);
-			tron_obj.tron(w);
+			fun_obj=new l2r_l2_svc_fun(prob, param, C);
+			NEWTON newton_obj(fun_obj, primal_solver_tol);
+			newton_obj.set_print_string(liblinear_print_string);
+			newton_obj.newton(w);
 			delete fun_obj;
 			delete[] C;
 			break;
@@ -2216,7 +2676,7 @@ static void train_one(const problem *prob, const parameter *param, double *w, do
 			problem prob_col;
 			feature_node *x_space = NULL;
 			transpose(prob, &x_space ,&prob_col);
-			solve_l1r_l2_svc(&prob_col, w, primal_solver_tol, Cp, Cn);
+			solve_l1r_l2_svc(&prob_col, w, primal_solver_tol, Cp, Cn, param->regularize_bias);
 			delete [] prob_col.y;
 			delete [] prob_col.x;
 			delete [] x_space;
@@ -2227,7 +2687,7 @@ static void train_one(const problem *prob, const parameter *param, double *w, do
 			problem prob_col;
 			feature_node *x_space = NULL;
 			transpose(prob, &x_space ,&prob_col);
-			solve_l1r_lr(&prob_col, w, primal_solver_tol, Cp, Cn);
+			solve_l1r_lr(&prob_col, w, primal_solver_tol, Cp, Cn, param->regularize_bias);
 			delete [] prob_col.y;
 			delete [] prob_col.x;
 			delete [] x_space;
@@ -2242,10 +2702,10 @@ static void train_one(const problem *prob, const parameter *param, double *w, do
 			for(int i = 0; i < prob->l; i++)
 				C[i] = param->C;
 
-			fun_obj=new l2r_l2_svr_fun(prob, C, param->p);
-			TRON tron_obj(fun_obj, param->eps);
-			tron_obj.set_print_string(liblinear_print_string);
-			tron_obj.tron(w);
+			fun_obj=new l2r_l2_svr_fun(prob, param, C);
+			NEWTON newton_obj(fun_obj, param->eps);
+			newton_obj.set_print_string(liblinear_print_string);
+			newton_obj.newton(w);
 			delete fun_obj;
 			delete[] C;
 			break;
@@ -2432,7 +2892,7 @@ static void find_parameter_C(const problem *prob, parameter *param_tmp, double s
 	}
 
 	if(param_tmp->C > max_C)
-		info("warning: maximum C reached.\n");
+		info("WARNING: maximum C reached.\n");
 	free(target);
 	for(i=0; i<nr_fold; i++)
 		free(prev_w[i]);
@@ -2473,6 +2933,13 @@ model* train(const problem *prob, const parameter *param)
 		model_->label = NULL;
 		train_one(prob, param, model_->w, 0, 0);
 	}
+	else if(check_oneclass_model(model_))
+	{
+		model_->w = Malloc(double, w_size);
+		model_->nr_class = 2;
+		model_->label = NULL;
+		solve_oneclass_svm(prob, model_->w, &(model_->rho), param->eps, param->nu);
+	}
 	else
 	{
 		int nr_class;
@@ -2716,11 +3183,11 @@ void find_parameters(const problem *prob, const parameter *param, int nr_fold, d
 		if(start_C <= 0)
 			start_C = calc_start_C(prob, &param_tmp);
 		double max_C = 1024;
-		start_C = min(start_C, max_C);		
+		start_C = min(start_C, max_C);
 		double best_C_tmp, best_score_tmp;
-		
+
 		find_parameter_C(prob, &param_tmp, start_C, max_C, &best_C_tmp, &best_score_tmp, fold_start, perm, subprob, nr_fold);
-		
+
 		*best_C = best_C_tmp;
 		*best_score = best_score_tmp;
 	}
@@ -2744,9 +3211,9 @@ void find_parameters(const problem *prob, const parameter *param, int nr_fold, d
 				start_C_tmp = start_C;
 			start_C_tmp = min(start_C_tmp, max_C);
 			double best_C_tmp, best_score_tmp;
-			
+
 			find_parameter_C(prob, &param_tmp, start_C_tmp, max_C, &best_C_tmp, &best_score_tmp, fold_start, perm, subprob, nr_fold);
-			
+
 			if(best_score_tmp < *best_score)
 			{
 				*best_p = param_tmp.p;
@@ -2793,11 +3260,15 @@ double predict_values(const struct model *model_, const struct feature_node *x,
 			for(i=0;i<nr_w;i++)
 				dec_values[i] += w[(idx-1)*nr_w+i]*lx->value;
 	}
+	if(check_oneclass_model(model_))
+		dec_values[0] -= model_->rho;
 
 	if(nr_class==2)
 	{
 		if(check_regression_model(model_))
 			return dec_values[0];
+		else if(check_oneclass_model(model_))
+			return (dec_values[0]>0)?1:-1;
 		else
 			return (dec_values[0]>0)?model_->label[0]:model_->label[1];
 	}
@@ -2860,7 +3331,9 @@ static const char *solver_type_table[]=
 	"L2R_LR", "L2R_L2LOSS_SVC_DUAL", "L2R_L2LOSS_SVC", "L2R_L1LOSS_SVC_DUAL", "MCSVM_CS",
 	"L1R_L2LOSS_SVC", "L1R_LR", "L2R_LR_DUAL",
 	"", "", "",
-	"L2R_L2LOSS_SVR", "L2R_L2LOSS_SVR_DUAL", "L2R_L1LOSS_SVR_DUAL", NULL
+	"L2R_L2LOSS_SVR", "L2R_L2LOSS_SVR_DUAL", "L2R_L1LOSS_SVR_DUAL",
+	"", "", "", "", "", "", "",
+	"ONECLASS_SVM", NULL
 };
 
 int save_model(const char *model_file_name, const struct model *model_)
@@ -2906,6 +3379,9 @@ int save_model(const char *model_file_name, const struct model *model_)
 
 	fprintf(fp, "bias %.17g\n", model_->bias);
 
+	if(check_oneclass_model(model_))
+		fprintf(fp, "rho %.17g\n", model_->rho);
+
 	fprintf(fp, "w\n");
 	for(i=0; i<w_size; i++)
 	{
@@ -2956,12 +3432,13 @@ struct model *load_model(const char *model_file_name)
 	int n;
 	int nr_class;
 	double bias;
+	double rho;
 	model *model_ = Malloc(model,1);
 	parameter& param = model_->param;
 	// parameters for training only won't be assigned, but arrays are assigned as NULL for safety
 	param.nr_weight = 0;
 	param.weight_label = NULL;
-	param.weight = NULL;	
+	param.weight = NULL;
 	param.init_sol = NULL;
 
 	model_->label = NULL;
@@ -3010,6 +3487,11 @@ struct model *load_model(const char *model_file_name)
 			FSCANF(fp,"%lf",&bias);
 			model_->bias=bias;
 		}
+		else if(strcmp(cmd,"rho")==0)
+		{
+			FSCANF(fp,"%lf",&rho);
+			model_->rho=rho;
+		}
 		else if(strcmp(cmd,"w")==0)
 		{
 			break;
@@ -3082,7 +3564,7 @@ static inline double get_w_value(const struct model *model_, int idx, int label_
 
 	if(idx < 0 || idx > model_->nr_feature)
 		return 0;
-	if(check_regression_model(model_))
+	if(check_regression_model(model_) || check_oneclass_model(model_))
 		return w[idx];
 	else
 	{
@@ -3102,7 +3584,8 @@ static inline double get_w_value(const struct model *model_, int idx, int label_
 
 // feat_idx: starting from 1 to nr_feature
 // label_idx: starting from 0 to nr_class-1 for classification models;
-//            for regression models, label_idx is ignored.
+//            for regression and one-class SVM models, label_idx is
+//            ignored.
 double get_decfun_coef(const struct model *model_, int feat_idx, int label_idx)
 {
 	if(feat_idx > model_->nr_feature)
@@ -3112,6 +3595,11 @@ double get_decfun_coef(const struct model *model_, int feat_idx, int label_idx)
 
 double get_decfun_bias(const struct model *model_, int label_idx)
 {
+	if(check_oneclass_model(model_))
+	{
+		fprintf(stderr, "ERROR: get_decfun_bias can not be called for a one-class SVM model\n");
+		return 0;
+	}
 	int bias_idx = model_->nr_feature;
 	double bias = model_->bias;
 	if(bias <= 0)
@@ -3120,6 +3608,17 @@ double get_decfun_bias(const struct model *model_, int label_idx)
 		return bias*get_w_value(model_, bias_idx, label_idx);
 }
 
+double get_decfun_rho(const struct model *model_)
+{
+	if(check_oneclass_model(model_))
+		return model_->rho;
+	else
+	{
+		fprintf(stderr, "ERROR: get_decfun_rho can be called only for a one-class SVM model\n");
+		return 0;
+	}
+}
+
 void free_model_content(struct model *model_ptr)
 {
 	if(model_ptr->w != NULL)
@@ -3159,6 +3658,21 @@ const char *check_parameter(const problem *prob, const parameter *param)
 	if(param->p < 0)
 		return "p < 0";
 
+	if(prob->bias >= 0 && param->solver_type == ONECLASS_SVM)
+		return "prob->bias >=0, but this is ignored in ONECLASS_SVM";
+
+	if(param->regularize_bias == 0)
+	{
+		if(prob->bias != 1.0)
+			return "To not regularize bias, must specify -B 1 along with -R";
+		if(param->solver_type != L2R_LR
+			&& param->solver_type != L2R_L2LOSS_SVC
+			&& param->solver_type != L1R_L2LOSS_SVC
+			&& param->solver_type != L1R_LR
+			&& param->solver_type != L2R_L2LOSS_SVR)
+			return "-R option supported only for solver L2R_LR, L2R_L2LOSS_SVC, L1R_L2LOSS_SVC, L1R_LR, and L2R_L2LOSS_SVR";
+	}
+
 	if(param->solver_type != L2R_LR
 		&& param->solver_type != L2R_L2LOSS_SVC_DUAL
 		&& param->solver_type != L2R_L2LOSS_SVC
@@ -3169,12 +3683,15 @@ const char *check_parameter(const problem *prob, const parameter *param)
 		&& param->solver_type != L2R_LR_DUAL
 		&& param->solver_type != L2R_L2LOSS_SVR
 		&& param->solver_type != L2R_L2LOSS_SVR_DUAL
-		&& param->solver_type != L2R_L1LOSS_SVR_DUAL)
+		&& param->solver_type != L2R_L1LOSS_SVR_DUAL
+		&& param->solver_type != ONECLASS_SVM)
 		return "unknown solver type";
 
 	if(param->init_sol != NULL
-		&& param->solver_type != L2R_LR && param->solver_type != L2R_L2LOSS_SVC)
-		return "Initial-solution specification supported only for solver L2R_LR and L2R_L2LOSS_SVC";
+		&& param->solver_type != L2R_LR
+		&& param->solver_type != L2R_L2LOSS_SVC
+		&& param->solver_type != L2R_L2LOSS_SVR)
+		return "Initial-solution specification supported only for solvers L2R_LR, L2R_L2LOSS_SVC, and L2R_L2LOSS_SVR";
 
 	return NULL;
 }
@@ -3193,6 +3710,11 @@ int check_regression_model(const struct model *model_)
 			model_->param.solver_type==L2R_L2LOSS_SVR_DUAL);
 }
 
+int check_oneclass_model(const struct model *model_)
+{
+	return model_->param.solver_type == ONECLASS_SVM;
+}
+
 void set_print_string_function(void (*print_func)(const char*))
 {
 	if (print_func == NULL)