Minor changes SVM

Author: Rbiessy

example/src/mnist/run_svm.cpp

@@ -20,7 +20,7 @@ int main(int argc, char** argv) {
   pca_args.keep_percent = 0.8;  // Keep at least 80% of information
   pca_args.scale_factor = 1E2;  // More accurate but slower PCA
 
-  run_classifier(mnist_path, pca_args, ml::svm<svm_kernel_t, label_t>(C, ker, 2, 0.1));
+  run_classifier(mnist_path, pca_args, ml::svm<svm_kernel_t, label_t>(C, ker, 2, 0.1, 0.1));
 
   return 0;
 }

include/ml/classifiers/classifier.hpp

@@ -51,11 +51,11 @@ class classifier {
    * @param[in] expected
    * @param nb_obs
    */
-  void print_score(const LabelT* predicted, const LabelT* expected, unsigned nb_obs) {
-    auto nb_labels = get_nb_labels();
+  static void print_score(const LabelT* predicted, const LabelT* expected, unsigned nb_obs, unsigned nb_labels,
+                          const std::unordered_map<LabelT, unsigned>& label_user_to_label_idx) {
     std::vector<unsigned> cm(nb_labels * nb_labels, 0);
     for (unsigned i = 0; i < nb_obs; ++i)
-      cm[_label_user_to_label_idx[expected[i]] * nb_labels + _label_user_to_label_idx[predicted[i]]] += 1;
+      cm[label_user_to_label_idx.at(expected[i]) * nb_labels + label_user_to_label_idx.at(predicted[i])] += 1;
 
     double success_rate = 0;
     double precision = 0;
@@ -100,6 +100,10 @@ class classifier {
     std::cout.fill(prev_fill);
   }
 
+  inline void print_score(const LabelT* predicted, const LabelT* expected, unsigned nb_obs) {
+    classifier<DataT, LabelT>::print_score(predicted, expected, nb_obs, get_nb_labels(), _label_user_to_label_idx);
+  }
+
   virtual void load_from_disk(queue&) { assert(false); }
   virtual void save_to_disk(queue&) { assert(false); }
 

include/ml/classifiers/svm/smo.hpp

@@ -284,15 +284,15 @@ struct smo_out {
  * @param[in] x data of size mxn where m is the number of observation
  * @param[in] y labels must be a vector of size pow2(m) with -1 or 1 the first m elements and 0 after
  * @param c parameter for C-SVM
- * @param tol criteria for stopping condition, should be greater than eps
- * @param eps threshold above which alpha needs to be to be used as a weight of a support vector
+ * @param tol criteria for stopping condition
+ * @param alpha_eps threshold above which alpha needs to be to be used as a weight of a support vector
  * @param max_nb_iter maximum number of iterations
  * @param kernel_cache
  * @return smo_out containing the support vectors svs, the alphas (multiplied by their respective labels) and
  *         the offset rho
  */
 template <class KernelCacheT, class T>
-smo_out<T> smo(queue& q, matrix_t<T>& x, vector_t<T>& y, T c, T tol, T eps, SYCLIndexT max_nb_iter,
+smo_out<T> smo(queue& q, matrix_t<T>& x, vector_t<T>& y, T c, T tol, T alpha_eps, SYCLIndexT max_nb_iter,
               KernelCacheT kernel_cache) {
   auto m = access_ker_dim(x, 0);
   assert_eq(y.kernel_range.get_global_linear_range(), to_pow2(m));
@@ -309,8 +309,8 @@ smo_out<T> smo(queue& q, matrix_t<T>& x, vector_t<T>& y, T c, T tol, T eps, SYCL
   vector_t<T> vec_cond_greater(y.data_range, y.kernel_range);
   vector_t<T> vec_cond_less(y.data_range, y.kernel_range);
 
-  auto cond_greater = [c, eps](T y, T a) { return T((y > 0 && a < c) || (y < 0 && a > eps)); };
-  auto cond_less = [c, eps](T y, T a) { return T((y > 0 && a > eps) || (y < 0 && a < c)); };
+  auto cond_greater = [c, alpha_eps](T y, T a) { return T((y > 0 && a < c) || (y < 0 && a > alpha_eps)); };
+  auto cond_less = [c, alpha_eps](T y, T a) { return T((y > 0 && a > alpha_eps) || (y < 0 && a < c)); };
 
   // Compute initial cond
   vec_unary_op(q, y, vec_cond_greater, ml::functors::positive<T>());
@@ -325,6 +325,7 @@ smo_out<T> smo(queue& q, matrix_t<T>& x, vector_t<T>& y, T c, T tol, T eps, SYCL
   SYCLIndexT j;
   T diff;
   SYCLIndexT nb_iter = 0;
+  T eps = 1E-8;
   while (nb_iter < max_nb_iter) {
     if (!detail::select_wss(q, y, gradient, vec_cond_greater, vec_cond_less, tol, eps, start_search_indices,
                             start_search_rng, find_size_threshold_host, kernel_cache, i, j, diff)) {
@@ -360,19 +361,17 @@ smo_out<T> smo(queue& q, matrix_t<T>& x, vector_t<T>& y, T c, T tol, T eps, SYCL
     // Update gradient
     T delta_ai = yi * (ai - old_ai);
     T delta_aj = yj * (aj - old_aj);
+
     // Shouldn't happen in theory but can because of precision issue
-    if (std::abs(delta_ai) < eps && std::abs(delta_aj) < eps) {
-      std::cerr << "SVM cannot converge, try setting a smaller eps or a bigger tol." << std::endl;
-      break;
-    }
-    else {
-      detail::update_gradient(q, delta_ai, delta_aj, ker_i_t, ker_j_t, gradient);
-      vec_cond_greater.write_from_host(i, cond_greater(yi, ai));
-      vec_cond_greater.write_from_host(j, cond_greater(yj, aj));
-      vec_cond_less.write_from_host(i, cond_less(yi, ai));
-      vec_cond_less.write_from_host(j, cond_less(yj, aj));
-      ++nb_iter;
-    }
+    assert(std::abs(delta_ai) >= eps);
+    assert(std::abs(delta_aj) >= eps);
+
+    detail::update_gradient(q, delta_ai, delta_aj, ker_i_t, ker_j_t, gradient);
+    vec_cond_greater.write_from_host(i, cond_greater(yi, ai));
+    vec_cond_greater.write_from_host(j, cond_greater(yj, aj));
+    vec_cond_less.write_from_host(i, cond_less(yi, ai));
+    vec_cond_less.write_from_host(j, cond_less(yj, aj));
+    ++nb_iter;
   }
 
   if (nb_iter == max_nb_iter)
@@ -382,7 +381,7 @@ smo_out<T> smo(queue& q, matrix_t<T>& x, vector_t<T>& y, T c, T tol, T eps, SYCL
   auto host_alphas = alphas.template get_access<access::mode::read>();
   std::vector<uint32_t> host_sv_indices;
   for (unsigned k = 0; k < m; ++k) {
-    if (host_alphas[k] > eps)
+    if (host_alphas[k] > alpha_eps)
       host_sv_indices.push_back(k);
   }
   auto nb_sv = host_sv_indices.size();

include/ml/classifiers/svm/svm.hpp

@@ -51,7 +51,7 @@ class svm : public classifier<typename KernelType::DataType, LabelType> {
    * @param max_nb_iter
    */
   explicit svm(DataType c, KernelType ker = KernelType(), SYCLIndexT nb_cache_line = 2,
-               DataType tol = 1E-2, DataType eps = 1E-8, SYCLIndexT max_nb_iter = 0) :
+               DataType tol = 1E-2, DataType eps = 1E-2, SYCLIndexT max_nb_iter = 0) :
       _c(c), _ker(ker), _tol(tol), _eps(eps), _nb_cache_line(nb_cache_line), _max_nb_iter(max_nb_iter),
       _data_dim(0), _data_dim_pow2(0), _nb_labels(0), _smo_outs()
   {
@@ -196,7 +196,9 @@ class svm : public classifier<typename KernelType::DataType, LabelType> {
         std::cout << "Training (" << i << ", " << j << ") ..." << std::endl;
         // The padded nb_obs of act_data don't need to be initialized
         push_back_smo(q, act_data, act_internal_labels);
-        std::cout << "Number support vectors: " << _smo_outs.back().alphas.data_range[0] << "\n" << std::endl;
+        auto back = _smo_outs.back();
+        std::cout << "Nb iter: " << back.nb_iter << "\n";
+        std::cout << "Number support vectors: " << back.alphas.data_range[0] << "\n" << std::endl;
       }
     }
   }