Merge branch 'master' of github.com:scikit-learn/scikit-learn

Author: duchesnay

scikits/learn/linear_model/ridge.py

@@ -6,9 +6,6 @@
 # License: Simplified BSD
 
 import numpy as np
-import scipy.sparse as sp
-from scipy import linalg
-from scipy.sparse import linalg as sp_linalg
 
 from .base import LinearModel
 from ..utils.extmath import safe_sparse_dot
@@ -85,6 +82,7 @@ def fit(self, X, y, sample_weight=1.0, solver="default", **params):
         X, y, Xmean, ymean = \
            LinearModel._center_data(X, y, self.fit_intercept)
 
+        import scipy.sparse as sp
         if sp.issparse(X):
             self._solve_sparse(X, y, sample_weight)
         else:
@@ -116,6 +114,7 @@ def _solve_dense(self, X, y, sample_weight):
     def _solve_sparse(self, X, y, sample_weight):
         n_samples, n_features = X.shape
 
+        import scipy.sparse as sp
         if n_features > n_samples or \
            isinstance(sample_weight, np.ndarray) or \
            sample_weight != 1.0:
@@ -132,14 +131,17 @@ def _solve_sparse(self, X, y, sample_weight):
     def _solve(self, A, b):
         if self.solver == "cg":
             # this solver cannot handle a 2-d b.
+            from scipy.sparse import linalg as sp_linalg
             sol, error = sp_linalg.cg(A, b)
             if error:
                 raise ValueError("Failed with error code %d" % error)
             return sol
         else:
+            import scipy.sparse as sp
             # we are working with dense symmetric positive A
             if sp.issparse(A):
                 A = A.todense()
+            from scipy import linalg
             return linalg.solve(A, b, sym_pos=True, overwrite_a=True)
 
 
@@ -255,6 +257,7 @@ def __init__(self, alphas=[0.1, 1.0, 10.0], fit_intercept=True,
     def _pre_compute(self, X, y):
         # even if X is very sparse, K is usually very dense
         K = safe_sparse_dot(X, X.T, dense_output=True)
+        from scipy import linalg
         v, Q = linalg.eigh(K)
         return K, v, Q
 

scikits/learn/linear_model/tests/test_least_angle.py

@@ -1,5 +1,5 @@
 import numpy as np
-from numpy.testing import assert_, assert_array_almost_equal
+from numpy.testing import assert_array_almost_equal
 
 from scikits.learn import linear_model, datasets
 
@@ -84,7 +84,7 @@ def test_collinearity():
     y = np.array([1., 0., 0])
 
     _, _, coef_path_ = linear_model.lars_path(X, y)
-    assert_(not np.isnan(coef_path_).any())
+    assert (not np.isnan(coef_path_).any())
     assert_array_almost_equal(np.dot(X, coef_path_[:,-1]), y)
 
 

scikits/learn/svm/base.py

@@ -221,6 +221,8 @@ def predict_proba(self, T):
                     "probability estimates must be enabled to use this method")
         T = np.atleast_2d(np.asanyarray(T, dtype=np.float64, order='C'))
         kernel_type, T = self._get_kernel(T)
+        if self.impl not in ('c_svc', 'nu_svc'):
+            raise NotImplementedError
 
         pprob = libsvm_predict_proba(T, self.support_vectors_,
                       self.dual_coef_, self.intercept_,

scikits/learn/svm/src/libsvm/_libsvm.c

@@ -229,11 +229,14 @@ def libsvm_train (np.ndarray[np.float64_t, ndim=2, mode='c'] X,
     cdef np.ndarray[np.float64_t, ndim=1, mode='c'] probA
     cdef np.ndarray[np.float64_t, ndim=1, mode='c'] probB
     if probability != 0:
-        # this is only valid for SVC
-        probA = np.empty(n_class*(n_class-1)/2, dtype=np.float64)
-        probB = np.empty(n_class*(n_class-1)/2, dtype=np.float64)
+        if svm_type < 2: # SVC and NuSVC
+            probA = np.empty(n_class*(n_class-1)/2, dtype=np.float64)
+            probB = np.empty(n_class*(n_class-1)/2, dtype=np.float64)
+            copy_probB(probB.data, model, probB.shape)
+        else:
+            probA = np.empty(1, dtype=np.float64)
+            probB = np.empty(0, dtype=np.float64)
         copy_probA(probA.data, model, probA.shape)
-        copy_probB(probB.data, model, probB.shape)
 
     # memory deallocation
     svm_free_and_destroy_model(&model)

scikits/learn/svm/src/libsvm/_libsvm.pyx

@@ -170,11 +170,13 @@ def libsvm_sparse_train ( int n_features,
     cdef np.ndarray[np.float64_t, ndim=1, mode='c'] probA
     cdef np.ndarray[np.float64_t, ndim=1, mode='c'] probB
     if probability != 0:
-        # this is only valid for SVC
-        probA = np.empty(nr*(nr-1)/2, dtype=np.float64)
-        probB = np.empty(nr*(nr-1)/2, dtype=np.float64)
-        copy_probA(probA.data, model, probA.shape)
-        copy_probB(probB.data, model, probB.shape)
+        if svm_type < 2: # SVC and NuSVC
+            probA = np.empty(n_class*(n_class-1)/2, dtype=np.float64)
+            probB = np.empty(n_class*(n_class-1)/2, dtype=np.float64)
+            copy_probB(probB.data, model, probB.shape)
+        else:
+            probA = np.empty(1, dtype=np.float64)
+            probB = np.empty(0, dtype=np.float64)
 
     svm_csr_free_and_destroy_model (&model)
     free_problem(problem)

scikits/learn/svm/src/libsvm/_libsvm_sparse.pyx

@@ -212,21 +212,14 @@ def test_probability():
     clf = svm.SVC(probability=True)
     clf.fit(iris.data, iris.target)
 
-    # predict on a simple dataset
-    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]],
-                 decimal=2)
-
-    assert_almost_equal(clf.predict_proba(T),
-                        np.exp(clf.predict_log_proba(T)), 8)
-
-    # make sure probabilities sum to one
-    pprob = clf.predict_proba(X)
-    assert_array_almost_equal(pprob.sum(axis=1),
-                               np.ones(len(X)))
+    prob_predict = clf.predict_proba(iris.data)
+    assert_array_almost_equal(
+        np.sum(prob_predict, 1), np.ones(iris.data.shape[0]))
+    assert np.mean(np.argmax(prob_predict, 1) 
+                   == clf.predict(iris.data)) > 0.95
+
+    assert_almost_equal(clf.predict_proba(iris.data),
+                        np.exp(clf.predict_log_proba(iris.data)), 8)
 
 
 def test_decision_function():

scikits/learn/svm/tests/test_svm.py

@@ -1,6 +1,5 @@
 import numpy as np
-from numpy.testing import assert_array_almost_equal, assert_array_equal, \
-     assert_
+from numpy.testing import assert_array_almost_equal, assert_array_equal
 
 from scikits.learn import neighbors, datasets
 
@@ -58,13 +57,13 @@ def test_neighbors_iris():
         assert_array_equal(clf.predict(iris.data), iris.target)
 
         clf.fit(iris.data, iris.target, n_neighbors=9, algorithm=s)
-        assert_(np.mean(clf.predict(iris.data)== iris.target) > 0.95)
+        assert np.mean(clf.predict(iris.data)== iris.target) > 0.95
 
         for m in ('barycenter', 'mean'):
             rgs = neighbors.NeighborsRegressor()
             rgs.fit(iris.data, iris.target, mode=m, algorithm=s)
-            assert_(np.mean(
-                rgs.predict(iris.data).round() == iris.target) > 0.95)
+            assert np.mean(
+                rgs.predict(iris.data).round() == iris.target) > 0.95
 
 
 def test_kneighbors_graph():