Added parameter normalize to omp.py

JeanKossaifi · JeanKossaifi · commit 295dc3c982f5 · 2011-08-10T10:32:48.000+02:00
Some changes in Linear_Model
diff --git a/scikits/learn/linear_model/base.py b/scikits/learn/linear_model/base.py
@@ -12,6 +12,7 @@
 # License: BSD Style.
 
 import numpy as np
+import scipy.sparse
 
 from ..base import BaseEstimator, RegressorMixin, ClassifierMixin
 from .sgd_fast import Hinge, Log, ModifiedHuber, SquaredLoss, Huber
@@ -47,39 +48,41 @@ def predict(self, X):
         return safe_sparse_dot(X, self.coef_.T) + self.intercept_
 
     @staticmethod
-    def _center_data(X, y, fit_intercept, normalize=False):
+    def _center_data(X, y, fit_intercept, normalize=False, copy=False):
         """
         Centers data to have mean zero along axis 0. This is here because
         nearly all linear models will want their data to be centered.
         """
-        import scipy.sparse  # importing scipy.sparse just for this is overkill
         if fit_intercept:
             if scipy.sparse.issparse(X):
-                Xmean = np.zeros(X.shape[1])
-                Xstd = np.ones(X.shape[1])
+                X_mean = np.zeros(X.shape[1])
+                X_std = np.ones(X.shape[1])
             else:
-                Xmean = X.mean(axis=0)
-                X = X - Xmean
+                if copy:
+                    X = X.copy()
+
+                X_mean = X.mean(axis=0)
+                X = X - X_mean
                 if normalize:
-                    Xstd = X.std(axis=0)
-                    Xstd[Xstd==0] = 1
-                    X = X / Xstd
+                    X_std = np.sqrt(np.sum(X ** 2, axis=0))
+                    X_std[X_std==0] = 1
+                    X = X / X_std
                 else:
-                    Xstd = np.ones(X.shape[1])
-            ymean = y.mean()
-            y = y - ymean
+                    X_std = np.ones(X.shape[1])
+            y_mean = y.mean()
+            y = y - y_mean
         else:
-            Xmean = np.zeros(X.shape[1])
-            Xstd = np.ones(X.shape[1])
-            ymean = 0.
-        return X, y, Xmean, ymean, Xstd
+            X_mean = np.zeros(X.shape[1])
+            X_std = np.ones(X.shape[1])
+            y_mean = 0.
+        return X, y, X_mean, y_mean, X_std
 
-    def _set_intercept(self, Xmean, ymean, Xstd):
+    def _set_intercept(self, X_mean, y_mean, X_std):
         """Set the intercept_
         """
         if self.fit_intercept:
-            self.coef_ = self.coef_ / Xstd
-            self.intercept_ = ymean - np.dot(Xmean, self.coef_.T)
+            self.coef_ = self.coef_ / X_std
+            self.intercept_ = y_mean - np.dot(X_mean, self.coef_.T)
         else:
             self.intercept_ = 0
 
@@ -132,12 +135,13 @@ def fit(self, X, y, **params):
         X = np.asanyarray(X)
         y = np.asanyarray(y)
 
-        X, y, Xmean, ymean, Xstd = LinearModel._center_data(X, y, self.fit_intercept, self.normalize)
+        X, y, X_mean, y_mean, X_std = LinearModel._center_data(X, y,
+                self.fit_intercept, self.normalize)
 
         self.coef_, self.residues_, self.rank_, self.singular_ = \
                 np.linalg.lstsq(X, y)
 
-        self._set_intercept(Xmean, ymean, Xstd)
+        self._set_intercept(X_mean, y_mean, X_std)
         return self
 
 ##
diff --git a/scikits/learn/linear_model/omp.py b/scikits/learn/linear_model/omp.py
@@ -497,11 +497,8 @@ def fit(self, X, y, Gram=None, Xy=None, overwrite_x=False,
         X = np.atleast_2d(X)
         y = np.atleast_1d(y)
 
-        X, y, Xmean, ymean = LinearModel._center_data(X, y, self.fit_intercept)
-        if self.normalize:
-            norms = np.sqrt(np.sum(X ** 2, axis=0))
-            nonzeros = np.flatnonzero(norms)
-            X[:, nonzeros] /= norms[nonzeros]
+        X, y, X_mean, y_mean, X_std = self._center_data(X, y, self.fit_intercept,
+                self.normalize, not(overwrite_x))
         if Gram is not None:
             Gram = np.atleast_2d(Gram)
 
@@ -520,11 +517,11 @@ def fit(self, X, y, Gram=None, Xy=None, overwrite_x=False,
                 if not overwrite_xy:
                     Xy = Xy.copy()
                 if self.normalize:
-                    Xy /= norms
+                    Xy /= X_std
 
             if self.normalize:
-                Gram /= norms
-                Gram /= norms[:, np.newaxis]
+                Gram /= X_std
+                Gram /= X_std[:, np.newaxis]
 
             norms_sq = np.sum((y ** 2), axis=0) if eps is not None else None
             self.coef_ = orthogonal_mp_gram(Gram, Xy, self.n_nonzero_coefs,
@@ -538,7 +535,5 @@ def fit(self, X, y, Gram=None, Xy=None, overwrite_x=False,
                                        precompute_gram=precompute_gram,
                                        overwrite_x=overwrite_x).T
 
-        if self.normalize:
-            self.coef_ /= norms
-        self._set_intercept(Xmean, ymean)
+        self._set_intercept(X_mean, y_mean, X_std)
         return self
