scikit-learn
diff --git a/‎sklearn/svm/base.py
Lines changed: 19 additions & 11 deletions b/‎sklearn/svm/base.py
Lines changed: 19 additions & 11 deletions
@@ -14,7 +14,7 @@
 from ..utils import column_or_1d, check_X_y
 from ..utils import compute_class_weight
 from ..utils.extmath import safe_sparse_dot
-from ..utils.validation import check_is_fitted
+from ..utils.validation import check_is_fitted, _num_samples
 from ..utils.multiclass import check_classification_targets
 from ..externals import six
 from ..exceptions import ConvergenceWarning
@@ -144,7 +144,10 @@ def fit(self, X, y, sample_weight=None):
             raise TypeError("Sparse precomputed kernels are not supported.")
         self._sparse = sparse and not callable(self.kernel)
 
-        X, y = check_X_y(X, y, dtype=np.float64, order='C', accept_sparse='csr')
+        if callable(self.kernel):
+            check_consistent_length(X, y)
+        else:
+            X, y = check_X_y(X, y, dtype=np.float64, order='C', accept_sparse='csr')
         y = self._validate_targets(y)
 
         sample_weight = np.asarray([]
@@ -153,15 +156,16 @@ def fit(self, X, y, sample_weight=None):
         solver_type = LIBSVM_IMPL.index(self._impl)
 
         # input validation
-        if solver_type != 2 and X.shape[0] != y.shape[0]:
+        n_samples = _num_samples(X)
+        if solver_type != 2 and n_samples != y.shape[0]:
             raise ValueError("X and y have incompatible shapes.\n" +
                              "X has %s samples, but y has %s." %
-                             (X.shape[0], y.shape[0]))
+                             (n_samples, y.shape[0]))
 
-        if self.kernel == "precomputed" and X.shape[0] != X.shape[1]:
+        if self.kernel == "precomputed" and n_samples != X.shape[1]:
             raise ValueError("X.shape[0] should be equal to X.shape[1]")
 
-        if sample_weight.shape[0] > 0 and sample_weight.shape[0] != X.shape[0]:
+        if sample_weight.shape[0] > 0 and sample_weight.shape[0] != n_samples:
             raise ValueError("sample_weight and X have incompatible shapes: "
                              "%r vs %r\n"
                              "Note: Sparse matrices cannot be indexed w/"
@@ -210,7 +214,10 @@ def fit(self, X, y, sample_weight=None):
         fit(X, y, sample_weight, solver_type, kernel, random_seed=seed)
         # see comment on the other call to np.iinfo in this file
 
-        self.shape_fit_ = X.shape
+        if hasattr(X, 'shape'):
+            self.shape_fit_ = X.shape
+        else:
+            self.shape_fit_ = (_num_samples(X), )
 
         # In binary case, we need to flip the sign of coef, intercept and
         # decision function. Use self._intercept_ and self._dual_coef_ internally.
@@ -324,7 +331,6 @@ def predict(self, X):
         return predict(X)
 
     def _dense_predict(self, X):
-        n_samples, n_features = X.shape
         X = self._compute_kernel(X)
         if X.ndim == 1:
             X = check_array(X, order='C')
@@ -450,7 +456,8 @@ def _sparse_decision_function(self, X):
     def _validate_for_predict(self, X):
         check_is_fitted(self, 'support_')
 
-        X = check_array(X, accept_sparse='csr', dtype=np.float64, order="C")
+        if not callable(self.kernel):
+            X = check_array(X, accept_sparse='csr', dtype=np.float64, order="C")
         if self._sparse and not sp.isspmatrix(X):
             X = sp.csr_matrix(X)
         if self._sparse:
@@ -460,14 +467,15 @@ def _validate_for_predict(self, X):
             raise ValueError(
                 "cannot use sparse input in %r trained on dense data"
                 % type(self).__name__)
-        n_samples, n_features = X.shape
+        if not callable(self.kernel):
+            n_features = X.shape[1]
 
         if self.kernel == "precomputed":
             if X.shape[1] != self.shape_fit_[0]:
                 raise ValueError("X.shape[1] = %d should be equal to %d, "
                                  "the number of samples at training time" %
                                  (X.shape[1], self.shape_fit_[0]))
-        elif n_features != self.shape_fit_[1]:
+        elif not callable(self.kernel) and n_features != self.shape_fit_[1]:
             raise ValueError("X.shape[1] = %d should be equal to %d, "
                              "the number of features at training time" %
                              (n_features, self.shape_fit_[1]))