pep8 stuff as well removed testing stuff

Author: yamins81

scikits/learn/svm/base.py

@@ -5,14 +5,15 @@
 from . import _liblinear
 from ..base import BaseEstimator
 
+
 def _get_class_weight(class_weight, y):
     """
     Estimate class weights for unbalanced datasets.
     """
     if class_weight == 'auto':
         uy = np.unique(y)
         weight_label = np.asarray(uy, dtype=np.int32, order='C')
-        weight = np.array([1.0 / np.sum(y==i) for i in uy],
+        weight = np.array([1.0 / np.sum(y == i) for i in uy],
                           dtype=np.float64, order='C')
         weight *= uy.shape[0] / np.sum(weight)
     else:
@@ -44,7 +45,7 @@ def __init__(self, impl, kernel, degree, gamma, coef0, cache_size,
 
         if not (kernel in self._kernel_types or hasattr(kernel, '__call__')):
             raise ValueError("kernel should be one of %s or a callable, " \
-                             "%s was given." % ( self._kernel_types, kernel))
+                             "%s was given." % (self._kernel_types, kernel))
 
         self.kernel = kernel
         self.impl = impl
@@ -74,7 +75,6 @@ def _get_kernel(self, X):
             _X = X
         return kernel_type, _X
 
-
     def fit(self, X, y, class_weight={}, sample_weight=[], **params):
         """
         Fit the SVM model according to the given training data and
@@ -122,7 +122,7 @@ def fit(self, X, y, class_weight={}, sample_weight=[], **params):
 
         self.class_weight, self.class_weight_label = \
                      _get_class_weight(class_weight, y)
-            
+
         # check dimensions
         solver_type = self._svm_types.index(self.impl)
         if solver_type != 2 and _X.shape[0] != y.shape[0]:
@@ -132,12 +132,12 @@ def fit(self, X, y, class_weight={}, sample_weight=[], **params):
 
         if (kernel_type in [1, 2]) and (self.gamma == 0):
             # if custom gamma is not provided ...
-            self.gamma = 1.0/_X.shape[0]
+            self.gamma = 1.0 / _X.shape[0]
 
         self.support_, self.support_vectors_, self.n_support_, \
         self.dual_coef_, self.intercept_, self.label_, self.probA_, \
         self.probB_ = \
-        libsvm_train( _X, y, solver_type, kernel_type, self.degree,
+        libsvm_train(_X, y, solver_type, kernel_type, self.degree,
                       self.gamma, self.coef0, self.eps, self.C,
                       self.nu, self.cache_size, self.p,
                       self.class_weight_label, self.class_weight,
@@ -169,7 +169,7 @@ def predict(self, T):
         T = np.atleast_2d(np.asanyarray(T, dtype=np.float64, order='C'))
         kernel_type, T = self._get_kernel(T)
 
-        return libsvm_predict (T, self.support_vectors_,
+        return libsvm_predict(T, self.support_vectors_,
                       self.dual_coef_, self.intercept_,
                       self._svm_types.index(self.impl), kernel_type,
                       self.degree, self.gamma, self.coef0, self.eps,
@@ -249,7 +249,7 @@ def predict_log_proba(self, T):
 
     def decision_function(self, T):
         """
-        Calculate the distance of the samples in T to the separating hyperplane.
+        Calculate the distance of the samples T to the separating hyperplane.
 
         Parameters
         ----------
@@ -264,7 +264,7 @@ def decision_function(self, T):
         T = np.atleast_2d(np.asanyarray(T, dtype=np.float64, order='C'))
         kernel_type, T = self._get_kernel(T)
 
-        dec_func = libsvm_decision_function (T, self.support_vectors_,
+        dec_func = libsvm_decision_function(T, self.support_vectors_,
                       self.dual_coef_, self.intercept_,
                       self._svm_types.index(self.impl), kernel_type,
                       self.degree, self.gamma, self.coef0, self.eps,
@@ -275,7 +275,6 @@ def decision_function(self, T):
                       self.support_, self.label_, self.probA_,
                       self.probB_)
 
-
         if self.impl != 'one_class':
             # libsvm has the convention of returning negative values for
             # rightmost labels, so we invert the sign since our label_ is
@@ -297,14 +296,14 @@ class BaseLibLinear(BaseEstimator):
     """
 
     _solver_type_dict = {
-        'PL2_LLR_D0' : 0, # L2 penalty, logistic regression
-        'PL2_LL2_D1' : 1, # L2 penalty, L2 loss, dual form
-        'PL2_LL2_D0' : 2, # L2 penalty, L2 loss, primal form
-        'PL2_LL1_D1' : 3, # L2 penalty, L1 Loss, dual form
-        'MC_SVC'     : 4, # Multi-class Support Vector Classification
-        'PL1_LL2_D0' : 5, # L1 penalty, L2 Loss, primal form
-        'PL1_LLR_D0' : 6, # L1 penalty, logistic regression
-        'PL2_LLR_D1' : 7, # L2 penalty, logistic regression, dual form
+        'PL2_LLR_D0' : 0,  # L2 penalty, logistic regression
+        'PL2_LL2_D1' : 1,  # L2 penalty, L2 loss, dual form
+        'PL2_LL2_D0' : 2,  # L2 penalty, L2 loss, primal form
+        'PL2_LL1_D1' : 3,  # L2 penalty, L1 Loss, dual form
+        'MC_SVC'     : 4,  # Multi-class Support Vector Classification
+        'PL1_LL2_D0' : 5,  # L1 penalty, L2 Loss, primal form
+        'PL1_LLR_D0' : 6,  # L1 penalty, logistic regression
+        'PL2_LLR_D1' : 7,  # L2 penalty, logistic regression, dual form
         }
 
     def __init__(self, penalty='l2', loss='l2', dual=True, eps=1e-4, C=1.0,
@@ -328,14 +327,14 @@ def _get_solver_type(self):
         if self.multi_class:
             solver_type = 'MC_SVC'
         else:
-            solver_type = "P%s_L%s_D%d"  % (
+            solver_type = "P%s_L%s_D%d" % (
                 self.penalty.upper(), self.loss.upper(), int(self.dual))
         if not solver_type in self._solver_type_dict:
             raise ValueError('Not supported set of arguments: '
                              + solver_type)
         return self._solver_type_dict[solver_type]
 
-    def fit(self, X, y, class_weight={},**params):
+    def fit(self, X, y, class_weight={}, **params):
         """
         Fit the model according to the given training data and
         parameters.
@@ -369,7 +368,6 @@ def fit(self, X, y, class_weight={},**params):
                        self._get_bias(), self.C,
                        self.class_weight_label, self.class_weight)
 
-
         return self
 
     def predict(self, X):
@@ -386,9 +384,9 @@ def predict(self, X):
         """
         X = np.asanyarray(X, dtype=np.float64, order='C')
         self._check_n_features(X)
-        
+
         coef = self.raw_coef_
-            
+
         return _liblinear.predict_wrap(X, coef,
                                       self._get_solver_type(),
                                       self.eps, self.C,
@@ -413,9 +411,9 @@ def decision_function(self, X):
         """
         X = np.atleast_2d(np.asanyarray(X, dtype=np.float64, order='C'))
         self._check_n_features(X)
-        
+
         coef = self.raw_coef_
-        
+
         dec_func = _liblinear.decision_function_wrap(X, coef,
                                       self._get_solver_type(),
                                       self.eps, self.C,
@@ -428,24 +426,25 @@ def decision_function(self, X):
             return -dec_func
         else:
             return dec_func
-            
 
     def _check_n_features(self, X):
         n_features = self.raw_coef_.shape[1]
-        if self.fit_intercept: n_features -= 1
+        if self.fit_intercept:
+            n_features -= 1
         if X.shape[1] != n_features:
             raise ValueError("X.shape[1] should be %d, not %d." % (n_features,
                                                                    X.shape[1]))
+
     @property
     def intercept_(self):
         if self.fit_intercept:
-            return self.intercept_scaling * self.raw_coef_[:,-1]
+            return self.intercept_scaling * self.raw_coef_[:, -1]
         return 0.0
 
     @property
     def coef_(self):
         if self.fit_intercept:
-            return self.raw_coef_[:,:-1]
+            return self.raw_coef_[:, : -1]
         return self.raw_coef_
 
     def predict_proba(self, T):

scikits/learn/svm/sparse/base.py

@@ -7,6 +7,7 @@
 
 from .. import _liblinear
 
+
 class SparseBaseLibSVM(BaseLibSVM):
 
     _kernel_types = ['linear', 'poly', 'rbf', 'sigmoid', 'precomputed']
@@ -21,7 +22,7 @@ def __init__(self, impl, kernel, degree, gamma, coef0, cache_size,
 
         assert kernel in self._kernel_types, \
                "kernel should be one of %s, "\
-               "%s was given." % ( self._kernel_types, kernel)
+               "%s was given." % (self._kernel_types, kernel)
 
         self.kernel = kernel
         self.impl = impl
@@ -37,20 +38,19 @@ def __init__(self, impl, kernel, degree, gamma, coef0, cache_size,
         self.probability = probability
 
         # container for when we call fit
-        self._support_data    = np.empty (0, dtype=np.float64, order='C')
-        self._support_indices = np.empty (0, dtype=np.int32, order='C')
-        self._support_indptr  = np.empty (0, dtype=np.int32, order='C')
+        self._support_data = np.empty(0, dtype=np.float64, order='C')
+        self._support_indices = np.empty(0, dtype=np.int32, order='C')
+        self._support_indptr = np.empty(0, dtype=np.int32, order='C')
 
         # strictly speaking, dual_coef is not sparse (see Notes above)
-        self._dual_coef_data    = np.empty (0, dtype=np.float64, order='C')
-        self._dual_coef_indices = np.empty (0, dtype=np.int32,   order='C')
-        self._dual_coef_indptr  = np.empty (0, dtype=np.int32,   order='C')
-        self.intercept_         = np.empty (0, dtype=np.float64, order='C')
+        self._dual_coef_data = np.empty(0, dtype=np.float64, order='C')
+        self._dual_coef_indices = np.empty(0, dtype=np.int32,   order='C')
+        self._dual_coef_indptr = np.empty(0, dtype=np.int32,   order='C')
+        self.intercept_ = np.empty(0, dtype=np.float64, order='C')
 
         # only used in classification
         self.n_support = np.empty(0, dtype=np.int32, order='C')
 
-
     def fit(self, X, y, class_weight={}, sample_weight=[], **params):
         """
         Fit the SVM model according to the given training data and
@@ -92,7 +92,7 @@ def fit(self, X, y, class_weight={}, sample_weight=[], **params):
         import scipy.sparse
         X = scipy.sparse.csr_matrix(X)
         X.data = np.asanyarray(X.data, dtype=np.float64, order='C')
-        y      = np.asanyarray(y,      dtype=np.float64, order='C')
+        y = np.asanyarray(y, dtype=np.float64, order='C')
         sample_weight = np.asanyarray(sample_weight, dtype=np.float64,
                                       order='C')
 
@@ -104,9 +104,9 @@ def fit(self, X, y, class_weight={}, sample_weight=[], **params):
 
         if (kernel_type == 2) and (self.gamma == 0):
             # if custom gamma is not provided ...
-            self.gamma = 1.0/X.shape[0]
+            self.gamma = 1.0 / X.shape[0]
 
-        self.label_, self.probA_, self.probB_ = libsvm_sparse_train (
+        self.label_, self.probA_, self.probB_ = libsvm_sparse_train(
                  X.shape[1], X.data, X.indices, X.indptr, y,
                  solver_type, kernel_type, self.degree, self.gamma,
                  self.coef0, self.eps, self.C, self._support_data,
@@ -128,7 +128,7 @@ def fit(self, X, y, class_weight={}, sample_weight=[], **params):
         self.support_vectors_ = scipy.sparse.csr_matrix((self._support_data,
                                            self._support_indices,
                                            self._support_indptr),
-                                           (n_SV, X.shape[1]) )
+                                           (n_SV, X.shape[1]))
 
         self.dual_coef_ = scipy.sparse.csr_matrix((self._dual_coef_data,
                                              dual_coef_indices,
@@ -137,7 +137,6 @@ def fit(self, X, y, class_weight={}, sample_weight=[], **params):
                                             )
         return self
 
-
     def predict(self, T):
         """
         This function does classification or regression on an array of
@@ -162,15 +161,15 @@ def predict(self, T):
         T.data = np.asanyarray(T.data, dtype=np.float64, order='C')
         kernel_type = self._kernel_types.index(self.kernel)
 
-        return libsvm_sparse_predict (T.data, T.indices, T.indptr,
+        return libsvm_sparse_predict(T.data, T.indices, T.indptr,
                       self.support_vectors_.data,
                       self.support_vectors_.indices,
                       self.support_vectors_.indptr,
                       self.dual_coef_.data, self.intercept_,
                       self._svm_types.index(self.impl), kernel_type,
                       self.degree, self.gamma, self.coef0, self.eps,
-                      self.C, self.class_weight_label, self.class_weight, self.nu,
-                      self.cache_size, self.p, self.shrinking,
+                      self.C, self.class_weight_label, self.class_weight,
+                      self.nu, self.cache_size, self.p, self.shrinking,
                       self.probability, self.n_support, self.label_,
                       self.probA_, self.probB_)
 
@@ -208,8 +207,8 @@ def fit(self, X, y, class_weight={}, **params):
                        _liblinear.csr_train_wrap(X.shape[1], X.data, X.indices,
                        X.indptr, y,
                        self._get_solver_type(),
-                       self.eps, self._get_bias(), self.C, self.class_weight_label,
-                       self.class_weight)
+                       self.eps, self._get_bias(), self.C,
+                       self.class_weight_label, self.class_weight)
 
         return self
 
@@ -270,7 +269,5 @@ def decision_function(self, X):
             return -dec_func
         else:
             return dec_func
-    
-
 
 set_verbosity_wrap(0)