pep8 compliant at last!

Author: yamins81

scikits/learn/svm/tests/test_svm.py

@@ -24,13 +24,14 @@
 iris.data = iris.data[perm]
 iris.target = iris.target[perm]
 
+
 def test_libsvm_parameters():
     """
     Test parameters on classes that make use of libsvm.
     """
 
     clf = svm.SVC(kernel='linear').fit(X, Y)
-    assert_array_equal(clf.dual_coef_, [[ 0.25, -.25]])
+    assert_array_equal(clf.dual_coef_, [[0.25, -.25]])
     assert_array_equal(clf.support_, [1, 3])
     assert_array_equal(clf.support_vectors_, (X[1], X[3]))
     assert_array_equal(clf.intercept_, [0.])
@@ -77,7 +78,7 @@ def test_precomputed():
     KT = np.zeros_like(KT)
     for i in range(len(T)):
         for j in clf.support_:
-            KT[i,j] = np.dot(T[i], X[j])
+            KT[i, j] = np.dot(T[i], X[j])
 
     pred = clf.predict(KT)
     assert_array_equal(pred, true_result)
@@ -113,7 +114,7 @@ def test_precomputed():
     K = np.zeros_like(K)
     for i in range(len(iris.data)):
         for j in clf.support_:
-            K[i,j] = np.dot(iris.data[i], iris.data[j])
+            K[i, j] = np.dot(iris.data[i], iris.data[j])
 
     pred = clf.predict(K)
     assert_almost_equal(np.mean(pred == iris.target), .99, decimal=2)
@@ -149,8 +150,8 @@ def test_SVR():
                               decimal=3)
     assert_raises(NotImplementedError, lambda: clf.coef_)
     assert_array_almost_equal(clf.support_vectors_, X)
-    assert_array_almost_equal(clf.intercept_, [ 1.49997261])
-    assert_array_almost_equal(pred, [ 1.10001274, 1.86682485, 1.73300377])
+    assert_array_almost_equal(clf.intercept_, [1.49997261])
+    assert_array_almost_equal(pred, [1.10001274, 1.86682485, 1.73300377])
 
 
 def test_oneclass():
@@ -163,7 +164,7 @@ def test_oneclass():
 
     assert_array_almost_equal(pred, [1, -1, -1])
     assert_array_almost_equal(clf.intercept_, [-1.351], decimal=3)
-    assert_array_almost_equal(clf.dual_coef_, [[ 0.750, 0.749, 0.749, 0.750]],
+    assert_array_almost_equal(clf.dual_coef_, [[0.750, 0.749, 0.749, 0.750]],
                               decimal=3)
     assert_raises(NotImplementedError, lambda: clf.coef_)
 
@@ -201,8 +202,8 @@ def test_probability():
     T = [[0, 0, 0, 0],
          [2, 2, 2, 2]]
     assert_array_almost_equal(clf.predict_proba(T),
-                [[ 0.993, 0.003, 0.002],
-                 [ 0.740, 0.223  , 0.035]],
+                [[0.993, 0.003, 0.002],
+                 [0.740, 0.223, 0.035]],
                  decimal=2)
 
     assert_almost_equal(clf.predict_proba(T),
@@ -236,11 +237,11 @@ def test_decision_function():
     dec = np.empty(n_class * (n_class - 1) / 2)
     p = 0
     for i in range(n_class):
-        for j in range(i+1, n_class):
-            coef1 = clf.dual_coef_[j-1]
+        for j in range(i + 1, n_class):
+            coef1 = clf.dual_coef_[j - 1]
             coef2 = clf.dual_coef_[i]
-            idx1 = slice(sv_start[i], sv_start[i+1])
-            idx2 = slice(sv_start[j], sv_start[j+1])
+            idx1 = slice(sv_start[i], sv_start[i + 1])
+            idx2 = slice(sv_start[j], sv_start[j + 1])
             s = np.dot(coef1[idx1],  kvalue[idx1]) + \
                 np.dot(coef2[idx2], kvalue[idx2]) + \
                 clf.intercept_[p]
@@ -260,10 +261,10 @@ def test_weight():
     # so all predicted values belong to class 2
     assert_array_almost_equal(clf.predict(X), [2] * 6)
 
-    X_, y_ = test_dataset_classif(n_samples=200, n_features=100, param=[5,1],
+    X_, y_ = test_dataset_classif(n_samples=200, n_features=100, param=[5, 1],
                                   seed=0)
     for clf in (linear_model.LogisticRegression(), svm.LinearSVC(), svm.SVC()):
-        clf.fit(X_[:180], y_[:180], class_weight={0:5})
+        clf.fit(X_[: 180], y_[: 180], class_weight={0: 5})
         y_pred = clf.predict(X_[180:])
         assert np.sum(y_pred == y_[180:]) >= 11
 
@@ -276,7 +277,7 @@ def test_sample_weights():
     clf.fit(X, Y)
     assert_array_equal(clf.predict(X[2]), [1.])
 
-    sample_weight=[.1]*3 + [10]*3
+    sample_weight = [.1] * 3 + [10] * 3
     clf.fit(X, Y, sample_weight=sample_weight)
     assert_array_equal(clf.predict(X[2]), [2.])
 
@@ -298,7 +299,7 @@ def test_auto_weight():
     assert_array_almost_equal(clf.coef_, clf_auto.coef_, 6)
 
     # build an very very imbalanced dataset out of iris data
-    X_0 = X[y == 0,:]
+    X_0 = X[y == 0, :]
     y_0 = y[y == 0]
 
     X_imbalanced = np.vstack([X] + [X_0] * 10)
@@ -319,13 +320,13 @@ def test_error():
     Test that it gives proper exception on deficient input
     """
     # impossible value of C
-    assert_raises (ValueError, svm.SVC(C=-1).fit, X, Y)
+    assert_raises(ValueError, svm.SVC(C=-1).fit, X, Y)
 
     # impossible value of nu
     clf = svm.NuSVC(nu=0.0)
     assert_raises(ValueError, clf.fit, X, Y)
 
-    Y2 = Y[:-1] # wrong dimensions for labels
+    Y2 = Y[:-1]  # wrong dimensions for labels
     assert_raises(ValueError, clf.fit, X, Y2)
     assert_raises(AssertionError, svm.SVC, X, Y2)
 
@@ -368,6 +369,7 @@ def test_LinearSVC_iris():
     clf = svm.LinearSVC().fit(iris.data, iris.target)
     assert np.mean(clf.predict(iris.data) == iris.target) > 0.95
 
+
 def test_dense_liblinear_intercept_handling(classifier=svm.LinearSVC):
     """
     Test that dense liblinear honours intercept_scaling param
@@ -430,9 +432,9 @@ def liblinear_prediction_function(farray, clf, labels):
     a, b = weights.shape
     weights = weights.reshape((b, a))
 
-    D = np.column_stack([farray,np.ones(farray.shape[0])])
+    D = np.column_stack([farray, np.ones(farray.shape[0])])
 
-    H = np.dot(D,weights)
+    H = np.dot(D, weights)
 
     return H.argmax(1)