numo-liblinear 2.2.1 → 2.4.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: fbd4a8fc87f4ae430183e396e9977337f31b0f3abe565045f7216cd49c30857d
-  data.tar.gz: 03b97573731e979cda4d3e4d71b6647a6e16b3133fb9227be366292b80135986
+  metadata.gz: 5c3697071b67bf2898d6c75e461c4b40cfc1c665b06d36b007e2572487805afb
+  data.tar.gz: 595a2214e41b9654422cad1bf4604b1cb84df40f1430b5b7756e23bbb1f4ee95
 SHA512:
-  metadata.gz: 139cacb7349ebf5bee31b2292aa1de97eefbdc565affd44390359bf25a91e806d402c7d4104015fd1d6eba9b030b9fda5a7307f00923eaf259e90737559f1391
-  data.tar.gz: cc50ab17ba43f8d59f83c97daa50d0da5750473fd0b65913b51223b253157b058464b17c7b499e240496c2065eb2f7ef12cb161575bfbce53eb2ceb117967b22
+  metadata.gz: cffb328201a5ad1be57613933dd28bf03e47c2cd439c5e601cf7b5c284d8cf0b2abcc0ad8aeab57d3e63651d43854a418e366b44d96d29a3b53e984f72b66407
+  data.tar.gz: c547f4c52f80c049e9ccb9eb033321367821bb3fc3fc474e99bf7acca9c7421435a30acc267aa6f4a65bff968abb47f4a2b0c5d5abb3426de12d6c1a55807af0

data/CHANGELOG.md

@@ -1,3 +1,11 @@
+# [[2.4.0](https://github.com/yoshoku/numo-liblinear/compare/v2.3.0...v2.4.0)] - 2025-05-31
+
+- Update bundled LIBLINEAR to 2.49
+  - Add `w_recalc` parameter.
+
+# 2.3.0
+- Update bundled LIBLINEAR to 2.46
+
 # 2.2.1
 - Fix build failure with Xcode 14 and Ruby 3.1.x.
 

data/LICENSE.txt

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

data/ext/numo/liblinear/liblinearext.cpp

@@ -1,5 +1,5 @@
 /**
- * Copyright (c) 2019-2022 Atsushi Tatsuma
+ * Copyright (c) 2019-2024 Atsushi Tatsuma
  * All rights reserved.
  *
  * Redistribution and use in source and binary forms, with or without

data/ext/numo/liblinear/liblinearext.hpp

@@ -1,5 +1,5 @@
 /**
- * Copyright (c) 2019-2022 Atsushi Tatsuma
+ * Copyright (c) 2019-2024 Atsushi Tatsuma
  * All rights reserved.
  *
  * Redistribution and use in source and binary forms, with or without
@@ -234,6 +234,8 @@ LibLinearParameter* convertHashToLibLinearParameter(VALUE param_hash) {
   el = rb_hash_aref(param_hash, ID2SYM(rb_intern("init_sol")));
   param->init_sol = !NIL_P(el) ? convertNArrayToVectorXd(el) : NULL;
   param->regularize_bias = 1;
+  el = rb_hash_aref(param_hash, ID2SYM(rb_intern("w_recalc")));
+  param->w_recalc = !NIL_P(el) ? (RTEST(el) ? true : false) : false;
   return param;
 }
 
@@ -250,6 +252,7 @@ VALUE convertLibLinearParameterToHash(const LibLinearParameter* const param) {
   rb_hash_aset(param_hash, ID2SYM(rb_intern("p")), DBL2NUM(param->p));
   rb_hash_aset(param_hash, ID2SYM(rb_intern("nu")), DBL2NUM(param->nu));
   rb_hash_aset(param_hash, ID2SYM(rb_intern("init_sol")), Qnil);
+  rb_hash_aset(param_hash, ID2SYM(rb_intern("w_recalc")), param->w_recalc ? Qtrue : Qfalse);
   return param_hash;
 }
 

data/ext/numo/liblinear/src/COPYRIGHT

@@ -1,5 +1,5 @@
 
-Copyright (c) 2007-2022 The LIBLINEAR Project.
+Copyright (c) 2007-2023 The LIBLINEAR Project.
 All rights reserved.
 
 Redistribution and use in source and binary forms, with or without

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

@@ -1064,6 +1064,21 @@ static int solve_l2r_l1l2_svc(const problem *prob, const parameter *param, doubl
 	info("Objective value = %lf\n",v/2);
 	info("nSV = %d\n",nSV);
 
+	// Reconstruct w from the primal-dual relationship w=sum(\alpha_i y_i x_i)
+	// This may reduce the weight density. Some zero weights become non-zeros
+	// due to the numerical update w <- w + (alpha[i] - alpha_old) y_i x_i.
+	if (param->w_recalc)
+	{
+		for(i=0; i<w_size; i++)
+			w[i] = 0;
+		for(i=0; i<l; i++)
+		{
+			feature_node * const xi = prob->x[i];
+			if(alpha[i] > 0)
+				sparse_operator::axpy(y[i]*alpha[i], xi, w);
+		}
+	}
+
 	delete [] QD;
 	delete [] alpha;
 	delete [] y;
@@ -2155,75 +2170,62 @@ static int solve_l1r_lr(const problem *prob_col, const parameter *param, double
 	return newton_iter;
 }
 
-struct heap {
-	enum HEAP_TYPE { MIN, MAX };
-	int _size;
-	HEAP_TYPE _type;
-	feature_node* a;
+static int compare_feature_node(const void *a, const void *b)
+{
+	double a_value = (*(feature_node *)a).value;
+	double b_value = (*(feature_node *)b).value;
+	int a_index = (*(feature_node *)a).index;
+	int b_index = (*(feature_node *)b).index;
 
-	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)
+	if(a_value < b_value)
+		return -1;
+	else if(a_value == b_value)
 	{
-		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;
-		}
+		if(a_index < b_index)
+			return -1;
+		else if(a_index == b_index)
+			return 0;
 	}
-	void pop()
-	{
-		_size--;
-		a[0] = a[_size];
-		int i = 0;
-		while(i*2+1 < _size)
+	return 1;
+}
+
+// elements before the returned index are < pivot, while those after are >= pivot
+static int partition(feature_node *nodes, int low, int high)
+{
+	int i;
+	int index;
+
+	swap(nodes[low + rand()%(high-low+1)], nodes[high]); // select and move pivot to the end
+
+	index = low;
+	for(i = low; i < high; i++)
+		if (compare_feature_node(&nodes[i], &nodes[high]) == -1)
 		{
-			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;
+			swap(nodes[index], nodes[i]);
+			index++;
 		}
-	}
-	feature_node top()
-	{
-		return a[0];
-	}
-};
+
+	swap(nodes[high], nodes[index]);
+	return index;
+}
+
+// rearrange nodes so that
+// nodes[i] <= nodes[k] for all i < k
+// nodes[k] <= nodes[j] for all j > k
+// low and high are the bounds of the index range during the rearranging process
+static void quick_select_min_k(feature_node *nodes, int low, int high, int k)
+{
+	int pivot;
+	if(low == high || high < k)
+		return;
+	pivot = partition(nodes, low, high);
+	if(pivot == k)
+		return;
+	else if(k-1 < pivot)
+		return quick_select_min_k(nodes, low, pivot-1, k);
+	else
+		return quick_select_min_k(nodes, pivot+1, high, k);
+}
 
 // A two-level coordinate descent algorithm for
 // a scaled one-class SVM dual problem
@@ -2262,11 +2264,12 @@ static int solve_oneclass_svm(const problem *prob, const parameter *param, doubl
 	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];
+	double negGmax;                 // max { -grad(f)_i | i in Iup }
+	double negGmin;                 // min { -grad(f)_i | i in Ilow }
+	// Iup = { i | alpha_i < 1 }, Ilow = { i | alpha_i > 0 }
+	feature_node *max_negG_of_Iup = new feature_node[l];
+	feature_node *min_negG_of_Ilow = new feature_node[l];
+	feature_node node;
 
 	int n = (int)(nu*l);            // # of alpha's at upper bound
 	for(i=0; i<n; i++)
@@ -2328,9 +2331,8 @@ static int solve_oneclass_svm(const problem *prob, const parameter *param, doubl
 		}
 
 		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;
+		int len_Iup = 0;
+		int len_Ilow = 0;
 		for(s=0; s<active_size; s++)
 		{
 			i = index[s];
@@ -2339,44 +2341,28 @@ static int solve_oneclass_svm(const problem *prob, const parameter *param, doubl
 
 			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);
-				}
+				max_negG_of_Iup[len_Iup] = node;
+				len_Iup++;
 			}
 
 			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);
-				}
+				min_negG_of_Ilow[len_Ilow] = node;
+				len_Ilow++;
 			}
 		}
-		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();
+		max_inner_iter = min(max_inner_iter, min(len_Iup, len_Ilow));
 
-		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();
-		}
+		quick_select_min_k(max_negG_of_Iup, 0, len_Iup-1, len_Iup-max_inner_iter);
+		qsort(&(max_negG_of_Iup[len_Iup-max_inner_iter]), max_inner_iter, sizeof(struct feature_node), compare_feature_node);
+
+		quick_select_min_k(min_negG_of_Ilow, 0, len_Ilow-1, max_inner_iter);
+		qsort(min_negG_of_Ilow, max_inner_iter, sizeof(struct feature_node), compare_feature_node);
 
 		for (s=0; s<max_inner_iter; s++)
 		{
-			i = most_violating_i[s];
-			j = most_violating_j[s];
+			i = max_negG_of_Iup[len_Iup-s-1].index;
+			j = min_negG_of_Ilow[s].index;
 
 			if ((alpha[i] == 0 && alpha[j] == 0) ||
 			    (alpha[i] == 1 && alpha[j] == 1))
@@ -2484,15 +2470,14 @@ static int solve_oneclass_svm(const problem *prob, const parameter *param, doubl
 		*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;
+	delete [] max_negG_of_Iup;
+	delete [] min_negG_of_Ilow;
 
 	return iter;
 }
@@ -3678,10 +3663,10 @@ double get_decfun_rho(const struct model *model_)
 
 void free_model_content(struct model *model_ptr)
 {
-	if(model_ptr->w != NULL)
-		free(model_ptr->w);
-	if(model_ptr->label != NULL)
-		free(model_ptr->label);
+	free(model_ptr->w);
+	model_ptr->w = NULL;
+	free(model_ptr->label);
+	model_ptr->label = NULL;
 }
 
 void free_and_destroy_model(struct model **model_ptr_ptr)
@@ -3691,17 +3676,18 @@ void free_and_destroy_model(struct model **model_ptr_ptr)
 	{
 		free_model_content(model_ptr);
 		free(model_ptr);
+		*model_ptr_ptr = NULL;
 	}
 }
 
 void destroy_param(parameter* param)
 {
-	if(param->weight_label != NULL)
-		free(param->weight_label);
-	if(param->weight != NULL)
-		free(param->weight);
-	if(param->init_sol != NULL)
-		free(param->init_sol);
+	free(param->weight_label);
+	param->weight_label = NULL;
+	free(param->weight);
+	param->weight = NULL;
+	free(param->init_sol);
+	param->init_sol = NULL;
 }
 
 const char *check_parameter(const problem *prob, const parameter *param)
@@ -3750,6 +3736,11 @@ const char *check_parameter(const problem *prob, const parameter *param)
 		&& param->solver_type != L2R_L2LOSS_SVR)
 		return "Initial-solution specification supported only for solvers L2R_LR, L2R_L2LOSS_SVC, and L2R_L2LOSS_SVR";
 
+	if(param->w_recalc == true
+		&& param->solver_type != L2R_L2LOSS_SVC_DUAL
+		&& param->solver_type != L2R_L1LOSS_SVC_DUAL)
+		return "Recalculating w in the end is only for dual solvers for L2-regularized L1/L2-loss SVM";
+
 	return NULL;
 }
 

data/ext/numo/liblinear/src/linear.h

@@ -1,7 +1,8 @@
+#include <stdbool.h>
 #ifndef _LIBLINEAR_H
 #define _LIBLINEAR_H
 
-#define LIBLINEAR_VERSION 245
+#define LIBLINEAR_VERSION 249
 
 #ifdef __cplusplus
 extern "C" {
@@ -39,6 +40,7 @@ struct parameter
 	double nu;
 	double *init_sol;
 	int regularize_bias;
+	bool w_recalc;		/* for -s 1, 3; may be extended to -s 12, 13, 21 */
 };
 
 struct model

data/lib/numo/liblinear/version.rb

@@ -3,6 +3,6 @@
 module Numo
   module Liblinear
     # The version of Numo::Liblienar you are using.
-    VERSION = '2.2.1'
+    VERSION = '2.4.0'
   end
 end

data/sig/numo/liblinear.rbs

@@ -36,6 +36,7 @@ module Numo
       weight: Numo::DFloat?,
       p: Float?,
       nu: Float?,
+      w_recalc: bool?,
       verbose: bool?,
       random_seed: Integer?
     }

metadata

@@ -1,14 +1,13 @@
 --- !ruby/object:Gem::Specification
 name: numo-liblinear
 version: !ruby/object:Gem::Version
-  version: 2.2.1
+  version: 2.4.0
 platform: ruby
 authors:
 - yoshoku
-autorequire:
 bindir: exe
 cert_chain: []
-date: 2022-11-27 00:00:00.000000000 Z
+date: 1980-01-02 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: numo-narray
@@ -63,7 +62,6 @@ metadata:
   source_code_uri: https://github.com/yoshoku/numo-liblinear
   documentation_uri: https://yoshoku.github.io/numo-liblinear/doc/
   rubygems_mfa_required: 'true'
-post_install_message:
 rdoc_options: []
 require_paths:
 - lib
@@ -78,8 +76,7 @@ required_rubygems_version: !ruby/object:Gem::Requirement
     - !ruby/object:Gem::Version
       version: '0'
 requirements: []
-rubygems_version: 3.3.26
-signing_key:
+rubygems_version: 3.6.7
 specification_version: 4
 summary: Numo::Liblinear is a Ruby gem binding to the LIBLINEAR library. Numo::Liblinear
   makes to use the LIBLINEAR functions with dataset represented by Numo::NArray.