Merge pull request scikit-learn#198 from amueller/fastICA_transposed

ogrisel · ogrisel · commit d0750d05fa23 · 2011-06-06T05:26:25.000-07:00
Merge amueller's branch on consistent shape handling for the ICA module.
diff --git a/examples/decomposition/plot_ica_blind_source_separation.py b/examples/decomposition/plot_ica_blind_source_separation.py
@@ -20,33 +20,32 @@
 np.random.seed(0)
 n_samples = 2000
 time = np.linspace(0, 10, n_samples)
-s1 = np.sin(2*time) # Signal 1 : sinusoidal signal
-s2 = np.sign(np.sin(3*time)) # Signal 2 : square signal
-S = np.c_[s1,s2].T
-S += 0.2*np.random.normal(size=S.shape) # Add noise
+s1 = np.sin(2 * time)  # Signal 1 : sinusoidal signal
+s2 = np.sign(np.sin(3 * time))  # Signal 2 : square signal
+S = np.c_[s1, s2]
+S += 0.2 * np.random.normal(size=S.shape)  # Add noise
 
-S /= S.std(axis=1)[:,np.newaxis] # Standardize data
+S /= S.std(axis=0)  # Standardize data
 # Mix data
-A = [[1, 1], [0.5, 2]] # Mixing matrix
-X = np.dot(A, S) # Generate observations
+A = np.array([[1, 1], [0.5, 2]])  # Mixing matrix
+X = np.dot(S, A.T)  # Generate observations
 # Compute ICA
 ica = FastICA()
-S_ = ica.fit(X).transform(X) # Get the estimated sources
-A_ = ica.get_mixing_matrix() # Get estimated mixing matrix
-
-assert np.allclose(X, np.dot(A_, S_))
+S_ = ica.fit(X).transform(X)  # Get the estimated sources
+A_ = ica.get_mixing_matrix()  # Get estimated mixing matrix
+assert np.allclose(X, np.dot(S_, A_.T))
 
 ###############################################################################
 # Plot results
 pl.figure()
 pl.subplot(3, 1, 1)
-pl.plot(S.T)
+pl.plot(S)
 pl.title('True Sources')
 pl.subplot(3, 1, 2)
-pl.plot(X.T)
+pl.plot(X)
 pl.title('Observations (mixed signal)')
 pl.subplot(3, 1, 3)
-pl.plot(S_.T)
+pl.plot(S_)
 pl.title('ICA estimated sources')
 pl.subplots_adjust(0.09, 0.04, 0.94, 0.94, 0.26, 0.36)
 pl.show()
diff --git a/examples/decomposition/plot_ica_vs_pca.py b/examples/decomposition/plot_ica_vs_pca.py
@@ -37,28 +37,28 @@
 
 ###############################################################################
 # Generate sample data
-S = np.random.standard_t(1.5, size=(2, 10000))
+S = np.random.standard_t(1.5, size=(10000, 2))
 S[0] *= 2.
 
 # Mix data
-A = [[1, 1], [0, 2]]  # Mixing matrix
+A = np.array([[1, 1], [0, 2]])  # Mixing matrix
 
-X = np.dot(A, S)  # Generate observations
+X = np.dot(S, A.T)  # Generate observations
 
 pca = PCA()
-S_pca_ = pca.fit(X.T).transform(X.T).T
+S_pca_ = pca.fit(X).transform(X)
 
 ica = FastICA()
 S_ica_ = ica.fit(X).transform(X)  # Estimate the sources
 
-S_ica_ /= S_ica_.std(axis=1)[:, np.newaxis]
+S_ica_ /= S_ica_.std(axis=0)
 
 
 ###############################################################################
 # Plot results
 
 def plot_samples(S, axis_list=None):
-    pl.scatter(S[0], S[1], s=2, marker='o', linewidths=0, zorder=10)
+    pl.scatter(S[:,0], S[:,1], s=2, marker='o', linewidths=0, zorder=10)
     if axis_list is not None:
         colors = [(0, 0.6, 0), (0.6, 0, 0)]
         for color, axis in zip(colors, axis_list):
@@ -74,8 +74,8 @@ def plot_samples(S, axis_list=None):
     pl.vlines(0, -3, 3)
     pl.xlim(-3, 3)
     pl.ylim(-3, 3)
-    pl.xlabel('$x$')
-    pl.ylabel('$y$')
+    pl.xlabel('x')
+    pl.ylabel('y')
 
 pl.subplot(2, 2, 1)
 plot_samples(S / S.std())
@@ -88,7 +88,7 @@ def plot_samples(S, axis_list=None):
 pl.title('Observations')
 
 pl.subplot(2, 2, 3)
-plot_samples(S_pca_ / np.std(S_pca_, axis=-1)[:, np.newaxis])
+plot_samples(S_pca_ / np.std(S_pca_, axis=0))
 pl.title('PCA scores')
 
 pl.subplot(2, 2, 4)
diff --git a/scikits/learn/decomposition/fastica_.py b/scikits/learn/decomposition/fastica_.py
@@ -10,6 +10,7 @@
 # License: BSD 3 clause
 
 import types
+import warnings
 import numpy as np
 from scipy import linalg
 
@@ -182,13 +183,23 @@ def fastica(X, n_components=None, algorithm="parallel", whiten=True,
     matrix. In short ICA attempts to `un-mix' the data by estimating an
     un-mixing matrix W where S = W K X.
 
+    This implementation was originally made for data of shape
+    [n_features, n_samples]. Now the input is transposed
+    before the algorithm is applied. This makes it slightly
+    faster for Fortran-ordered input.
+
     Implemented using FastICA:
 
     * A. Hyvarinen and E. Oja, Independent Component Analysis:
       Algorithms and Applications, Neural Networks, 13(4-5), 2000,
       pp. 411-430
 
     """
+    # make interface compatible with other decompositions
+    warnings.warn("The interface of fastica changed: X is now\
+        assumed to be of shape [n_samples, n_features]")
+    X = X.T
+
     algorithm_funcs = {'parallel': _ica_par,
                        'deflation': _ica_def}
 
@@ -281,10 +292,10 @@ def gprime(x, fun_args):
 
     if whiten:
         S = np.dot(np.dot(W, K), X)
-        return K, W, S
+        return K, W, S.T
     else:
         S = np.dot(W, X)
-        return W, S
+        return W, S.T
 
 
 class FastICA(BaseEstimator):
@@ -359,9 +370,9 @@ def fit(self, X, **params):
     def transform(self, X):
         """Apply un-mixing matrix "W" to X to recover the sources
 
-        S = W * X
+        S = X * W.T
         """
-        return np.dot(self.unmixing_matrix_, X)
+        return np.dot(X, self.unmixing_matrix_.T)
 
     def get_mixing_matrix(self):
         """Compute the mixing matrix
diff --git a/scikits/learn/decomposition/tests/test_fastica.py b/scikits/learn/decomposition/tests/test_fastica.py
@@ -71,8 +71,8 @@ def test_fastica(add_noise=False):
     non_linearity = ['logcosh', 'exp', 'cube']
     for nl in non_linearity:
         for algo in algorithm:
-            k_, mixing_, s_ = fastica(m, fun=nl, algorithm=algo)
-
+            k_, mixing_, s_ = fastica(m.T, fun=nl, algorithm=algo)
+            s_ = s_.T
             # Check that the mixing model described in the docstring holds:
             assert_almost_equal(s_, np.dot(np.dot(mixing_, k_), m))
 
@@ -122,7 +122,8 @@ def test_non_square_fastica(add_noise=False):
 
     center_and_norm(m)
 
-    k_, mixing_, s_ = fastica(m, n_components=2)
+    k_, mixing_, s_ = fastica(m.T, n_components=2)
+    s_ = s_.T
 
     # Check that the mixing model described in the docstring holds:
     assert_almost_equal(s_, np.dot(np.dot(mixing_, k_), m))
