coderark
diff --git a/‎sklearn/svm/base.py
Lines changed: 41 additions & 14 deletions b/‎sklearn/svm/base.py
Lines changed: 41 additions & 14 deletions
@@ -366,29 +366,58 @@ def decision_function(self, X):
         # NOTE: _validate_for_predict contains check for is_fitted
         # hence must be placed before any other attributes are used.
         X = self._validate_for_predict(X)
-        if self._sparse:
-            raise NotImplementedError("Decision_function not supported for"
-                                      " sparse SVM.")
         X = self._compute_kernel(X)
 
+        X = self._validate_for_predict(X)
+
+        if self._sparse:
+            dec_func = self._sparse_decision_function(X)
+        else:
+            dec_func = self._dense_decision_function(X)
+
+        # In binary case, we need to flip the sign of coef, intercept and
+        # decision function.
+        if self.impl != 'one_class' and len(self.classes_) == 2:
+            return -dec_func
+
+        return dec_func
+
+    def _dense_decision_function(self, X):
+        X = check_array(X, dtype=np.float64, order="C")
+
         kernel = self.kernel
         if callable(kernel):
             kernel = 'precomputed'
 
-        dec_func = libsvm.decision_function(
+        return libsvm.decision_function(
             X, self.support_, self.support_vectors_, self.n_support_,
             self._dual_coef_, self._intercept_,
             self.probA_, self.probB_,
             svm_type=LIBSVM_IMPL.index(self._impl),
             kernel=kernel, degree=self.degree, cache_size=self.cache_size,
             coef0=self.coef0, gamma=self._gamma)
 
-        # In binary case, we need to flip the sign of coef, intercept and
-        # decision function.
-        if self._impl in ['c_svc', 'nu_svc'] and len(self.classes_) == 2:
-            return -dec_func.ravel()
+    def _sparse_decision_function(self, X):
+        X.data = np.asarray(X.data, dtype=np.float64, order='C')
 
-        return dec_func
+        kernel = self.kernel
+        if hasattr(kernel, '__call__'):
+            kernel = 'precomputed'
+
+        kernel_type = self._sparse_kernels.index(kernel)
+
+        return libsvm_sparse.libsvm_sparse_decision_function(
+            X.data, X.indices, X.indptr,
+            self.support_vectors_.data,
+            self.support_vectors_.indices,
+            self.support_vectors_.indptr,
+            self._dual_coef_.data, self._intercept_,
+            LIBSVM_IMPL.index(self.impl), kernel_type,
+            self.degree, self.gamma, self.coef0, self.tol,
+            self.C, self.class_weight_,
+            self.nu, self.epsilon, self.shrinking,
+            self.probability, self.n_support_, self._label,
+            self.probA_, self.probB_)
 
     def _validate_for_predict(self, X):
         check_is_fitted(self, 'support_')
@@ -666,9 +695,8 @@ def _get_liblinear_solver_type(multi_class, penalty, loss, dual):
                                 % (penalty, loss, dual))
             else:
                 return solver_num
-
-    raise ValueError(('Unsupported set of arguments: %s, '
-                      'Parameters: penalty=%r, loss=%r, dual=%r')
+    raise ValueError('Unsupported set of arguments: %s, '
+                     'Parameters: penalty=%r, loss=%r, dual=%r'
                      % (error_string, penalty, loss, dual))
 
 
@@ -811,8 +839,7 @@ def _fit_liblinear(X, y, C, fit_intercept, intercept_scaling, class_weight,
     raw_coef_, n_iter_ = liblinear.train_wrap(
         X, y_ind, sp.isspmatrix(X), solver_type, tol, bias, C,
         class_weight_, max_iter, rnd.randint(np.iinfo('i').max),
-        epsilon
-        )
+        epsilon)
     # Regarding rnd.randint(..) in the above signature:
     # seed for srand in range [0..INT_MAX); due to limitations in Numpy
     # on 32-bit platforms, we can't get to the UINT_MAX limit that