scikit-learn
diff --git a/‎sklearn/svm/_base.py
Lines changed: 7 additions & 6 deletions b/‎sklearn/svm/_base.py
Lines changed: 7 additions & 6 deletions
diff --git a/‎sklearn/svm/tests/test_svm.py
Lines changed: 33 additions & 29 deletions b/‎sklearn/svm/tests/test_svm.py
Lines changed: 33 additions & 29 deletions
@@ -149,7 +149,6 @@ def fit(self, X, y, sample_weight=None):
             X, y = check_X_y(X, y, dtype=np.float64,
                              order='C', accept_sparse='csr',
                              accept_large_sparse=False)
-            X, y = check_X_y(X, y, dtype=np.float64, order='C', accept_sparse='csr')
 
         y = self._validate_targets(y)
 
@@ -177,7 +176,13 @@ def fit(self, X, y, sample_weight=None):
                              "boolean masks (use `indices=True` in CV)."
                              % (sample_weight.shape, X.shape))
 
-        if isinstance(self.gamma, str):
+        kernel = self.kernel
+        if callable(kernel):
+            kernel = 'precomputed'
+
+        if kernel == 'precomputed':
+            self._gamma = 0.  # unused but needs to be a float
+        elif isinstance(self.gamma, str):
             if self.gamma == 'scale':
                 # var = E[X^2] - E[X]^2 if sparse
                 X_var = ((X.multiply(X)).mean() - (X.mean()) ** 2
@@ -193,10 +198,6 @@ def fit(self, X, y, sample_weight=None):
         else:
             self._gamma = self.gamma
 
-        kernel = self.kernel
-        if callable(kernel):
-            kernel = 'precomputed'
-
         fit = self._sparse_fit if self._sparse else self._dense_fit
         if self.verbose:  # pragma: no cover
             print('[LibSVM]', end='')
 
@@ -23,6 +23,7 @@
 from sklearn.utils._testing import assert_raise_message
 from sklearn.utils._testing import ignore_warnings
 from sklearn.utils._testing import assert_no_warnings
+from sklearn.utils.validation import _num_samples
 from sklearn.utils import shuffle
 from sklearn.exceptions import ConvergenceWarning
 from sklearn.exceptions import NotFittedError, UndefinedMetricWarning
@@ -125,7 +126,7 @@ def test_precomputed():
 
     kfunc = lambda x, y: np.dot(x, y.T)
     clf = svm.SVC(kernel=kfunc)
-    clf.fit(X, Y)
+    clf.fit(np.array(X), Y)
     pred = clf.predict(T)
 
     assert_array_equal(clf.dual_coef_, [[-0.25, .25]])
@@ -980,7 +981,7 @@ def test_svc_bad_kernel():
 def test_timeout():
     a = svm.SVC(kernel=lambda x, y: np.dot(x, y.T), probability=True,
                 random_state=0, max_iter=1)
-    assert_warns(ConvergenceWarning, a.fit, X, Y)
+    assert_warns(ConvergenceWarning, a.fit, np.array(X), Y)
 
 
 def test_unfitted():
@@ -1250,30 +1251,33 @@ def test_svm_probA_proB_deprecated(SVMClass, data, deprecated_prob):
         getattr(clf, deprecated_prob)
 
 
-def test_callable_kernel():
-    data = ["foo", "foof", "b", "a", "qwert", "1234567890", "abcde", "bar", "", "q"]
-    targets = [1, 1, 2, 2, 1, 3, 1, 1, 2, 2]
-    targets = np.array(targets)
-
-    def string_kernel(X, X2):
-        assert isinstance(X[0], str)
-        len = _num_samples(X)
-        len2 = _num_samples(X2)
-        ret = np.zeros((len, len2))
-        smaller = np.min(ret.shape)
-        ret[np.arange(smaller), np.arange(smaller)] = 1
-        return ret
-
-    svc = svm.SVC(kernel=string_kernel)
-    svc.fit(data, targets)
-    svc.score(data, targets)
-    svc.score(np.array(data), targets)
-
-    svc.fit(np.array(data), targets)
-    svc.score(data, targets)
-    svc.score(np.array(data), targets)
-
-
-def test_string_kernel():
-    # meaningful string kernel test
-    assert True
+def test_custom_kernel_not_array_input():
+    """Test using a custom kernel that is not fed with array-like for floats"""
+    data = ["A A", "A", "B", "B B", "A B"]
+    X = np.array([[2, 0], [1, 0], [0, 1], [0, 2], [1, 1]])  # count encoding
+    y = np.array([1, 1, 2, 2, 1])
+
+    def string_kernel(X1, X2):
+        assert isinstance(X1[0], str)
+        n_samples1 = _num_samples(X1)
+        n_samples2 = _num_samples(X2)
+        K = np.zeros((n_samples1, n_samples2))
+        for ii in range(n_samples1):
+            for jj in range(ii, n_samples2):
+                K[ii, jj] = X1[ii].count('A') * X2[jj].count('A')
+                K[ii, jj] += X1[ii].count('B') * X2[jj].count('B')
+                K[jj, ii] = K[ii, jj]
+        return K
+
+    K = string_kernel(data, data)
+    assert_array_equal(np.dot(X, X.T), K)
+
+    svc1 = svm.SVC(kernel=string_kernel).fit(data, y)
+    svc2 = svm.SVC(kernel='linear').fit(X, y)
+    svc3 = svm.SVC(kernel='precomputed').fit(K, y)
+
+    assert svc1.score(data, y) == svc3.score(K, y)
+    assert svc1.score(data, y) == svc2.score(X, y)
+    assert_array_almost_equal(svc1.decision_function(data),
+                              svc2.decision_function(X))
+    assert_array_equal(svc1.predict(data), svc2.predict(X))