Support kernel='rbf' in SVM benchmarks (#16)

* Support both binary and multiclass SVM in one native benchmark

* native SVM: determine sv_len in binary case

* native SVM: Factor out accuracy_score function

* Reduce long lines

* Remove common_svm.hpp and two_class_svm_bench.cpp

* Run svm_bench.cpp through clang-format

* Update CLI11 to 1.8.0

* Native SVM: add support for RBF kernel

* Update Makefiles

* Run svm_bench.cpp through clang-format again

* Add support for kernel='rbf' in sklearn/daal4py SVM benches

* native SVM: Add C, tol, tau, maxiter command line arguments

Author: bibikar

Makefile

@@ -53,8 +53,8 @@ NATIVE_distances = distances
 NATIVE_ridge = ridge
 NATIVE_linear = linear
 NATIVE_kmeans = kmeans
-NATIVE_svm2 = two_class_svm
-NATIVE_svm5 = multi_class_svm
+NATIVE_svm2 = svm
+NATIVE_svm5 = svm
 NATIVE_logreg2 = log_reg_lbfgs
 NATIVE_logreg5 = log_reg_lbfgs
 NATIVE_dfclf2 = decision_forest_clsf

daal4py/svm.py

@@ -6,7 +6,8 @@
 from bench import parse_args, time_mean_min, print_header, print_row, \
                   size_str, accuracy_score
 import numpy as np
-from daal4py import svm_training, svm_prediction, kernel_function_linear, \
+from daal4py import svm_training, svm_prediction, \
+                    kernel_function_linear, kernel_function_rbf, \
                     multi_class_classifier_training, \
                     multi_class_classifier_prediction
 from daal4py.sklearn.utils import getFPType
@@ -194,10 +195,19 @@ def construct_dual_coefs(model, num_classes, X, y):
     return support_
 
 
+def daal_kernel(name, fptype, gamma=1.0):
+
+    if name == 'linear':
+        return kernel_function_linear(fptype=fptype)
+    else:
+        sigma = np.sqrt(0.5 / gamma)
+        return kernel_function_rbf(fptype=fptype, sigma=sigma)
+
+
 def test_fit(X, y, params):
 
     fptype = getFPType(X)
-    kf = kernel_function_linear(fptype=fptype)
+    kf = daal_kernel(params.kernel, fptype, gamma=params.gamma)
 
     if params.n_classes == 2:
         y[y == 0] = -1
@@ -246,7 +256,7 @@ def test_fit(X, y, params):
 def test_predict(X, training_result, params):
 
     fptype = getFPType(X)
-    kf = kernel_function_linear(fptype=fptype)
+    kf = daal_kernel(params.kernel, fptype, gamma=params.gamma)
 
     svm_predict = svm_prediction(
             fptype=fptype,
@@ -287,8 +297,10 @@ def main():
                         help='Input file with labels, in NPY format')
     parser.add_argument('-C', dest='C', type=float, default=0.01,
                         help='SVM slack parameter')
-    parser.add_argument('--kernel', choices=('linear',), default='linear',
-                        help='SVM kernel function')
+    parser.add_argument('--kernel', choices=('linear', 'rbf'),
+                        default='linear', help='SVM kernel function')
+    parser.add_argument('--gamma', type=float, default=None,
+                        help="Parameter for kernel='rbf'")
     parser.add_argument('--maxiter', type=int, default=2000,
                         help='Maximum iterations for the iterative solver. '
                              '-1 means no limit.')
@@ -301,12 +313,16 @@ def main():
     parser.add_argument('--no-shrinking', action='store_false', default=True,
                         dest='shrinking',
                         help="Don't use shrinking heuristic")
-    params = parse_args(parser, loop_types=('fit', 'predict'), prefix='daal4py')
+    params = parse_args(parser, loop_types=('fit', 'predict'),
+                        prefix='daal4py')
 
     # Load data and cast to float64
     X_train = np.load(params.filex.name).astype('f8')
     y_train = np.load(params.filey.name).astype('f8')
 
+    if params.gamma is None:
+        params.gamma = 1 / X_train.shape[1]
+
     cache_size_bytes = get_optimal_cache_size(X_train.shape[0],
                                               max_cache=params.max_cache_size)
     params.cache_size_mb = cache_size_bytes / 2**20

native/Makefile

@@ -2,8 +2,7 @@
 #
 # SPDX-License-Identifier: MIT
 
-BENCHMARKS += distances kmeans linear ridge pca \
-	      two_class_svm multi_class_svm log_reg_lbfgs \
+BENCHMARKS += distances kmeans linear ridge pca svm log_reg_lbfgs \
 	      decision_forest_regr decision_forest_clsf
 FOBJ = $(addprefix lbfgsb/,lbfgsb.o linpack.o timer.o)
 CXXSRCS = $(addsuffix _bench.cpp,$(BENCHMARKS))

native/common.hpp

@@ -204,6 +204,61 @@ copy_submatrix(dm::NumericTablePtr src,
 }
 
 
+int count_classes(dm::NumericTablePtr y) {
+
+    /* compute min and max labels with DAAL */
+    da::low_order_moments::Batch<double> algorithm;
+    algorithm.input.set(da::low_order_moments::data, y);
+    algorithm.compute();
+    da::low_order_moments::ResultPtr res = algorithm.getResult();
+    dm::NumericTablePtr min_nt = res->get(da::low_order_moments::minimum);
+    dm::NumericTablePtr max_nt = res->get(da::low_order_moments::maximum);
+
+    int min, max;
+    dm::BlockDescriptor<double> block;
+    min_nt->getBlockOfRows(0, 1, dm::readOnly, block);
+    min = block.getBlockPtr()[0];
+    max_nt->getBlockOfRows(0, 1, dm::readOnly, block);
+    max = block.getBlockPtr()[0];
+    return 1 + max - min;
+
+}
+
+
+size_t count_same_labels(dm::NumericTablePtr y1, dm::NumericTablePtr y2,
+                         double tol = 1e-6) {
+
+    size_t equal_counter = 0;
+    size_t n_rows = std::min(y1->getNumberOfRows(), y2->getNumberOfRows());
+    dm::BlockDescriptor<double> block_y1, block_y2;
+    y1->getBlockOfRows(0, n_rows, dm::readOnly, block_y1);
+    y2->getBlockOfRows(0, n_rows, dm::readOnly, block_y2);
+
+    double *ptr1 = block_y1.getBlockPtr();
+    double *ptr2 = block_y2.getBlockPtr();
+
+    for (size_t i = 0; i < n_rows; i++) {
+        if (abs(ptr1[i] - ptr2[i]) < tol) {
+            equal_counter++;
+        }
+    }
+    y1->releaseBlockOfRows(block_y1);
+    y2->releaseBlockOfRows(block_y2);
+
+    return equal_counter;
+
+}
+
+
+double accuracy_score(dm::NumericTablePtr y1, dm::NumericTablePtr y2,
+                      double tol = 1e-6) {
+
+    double n_rows = std::min(y1->getNumberOfRows(), y2->getNumberOfRows());
+    return (double) count_same_labels(y1, y2) / n_rows;
+
+}
+
+
 /*
  * Generate an array of random numbers.
  */