partial fit iteration tracking, test still fails

examples/decomposition/plot_denoise.py

@@ -67,7 +67,7 @@
     data = data.reshape(len(data), 6, 6)
 
     lenb[fragment] = reconstruct_from_patches_2d(data, (100, 100))
-    if i == 3:  # tresholding is not a reconstruction
+    if i == 3:  # tresholding breaks the range
         lenb[fragment] -= lenb[fragment].min()
         lenb[fragment] = lenb[fragment] / float(lenb.max()) * 256.0
 

scikits/learn/decomposition/dict_learning.py

@@ -299,7 +299,7 @@ def fit(self, X, y=None, **params):
         self.components_ = U
         return self
 
-    def partial_fit(self, X, y=None, **params):
+    def partial_fit(self, X, y=None, iter_offset=0, **params):
         """Updates the model using the data in X as a mini-batch.
 
         Parameters
@@ -318,13 +318,14 @@ def partial_fit(self, X, y=None, **params):
         if hasattr(self, 'components_'):
             dict_init = self.components_
         else:
-            dict_init = None
+            dict_init = self.dict_init
         U = dict_learning_online(X, self.n_atoms, self.alpha,
                                  n_iter=self.n_iter,
                                  coding_method=self.coding_method,
                                  n_jobs=self.n_jobs,
                                  dict_init=dict_init,
                                  chunk_size=len(X), shuffle=False,
-                                 verbose=self.verbose, return_code=False)
+                                 verbose=self.verbose, return_code=False,
+                                 iter_offset=iter_offset)
         self.components_ = U
         return self

scikits/learn/decomposition/sparse_pca.py

@@ -364,7 +364,7 @@ def cost_function():
 def dict_learning_online(X, n_atoms, alpha, n_iter=100, return_code=True,
                          dict_init=None, callback=None, chunk_size=3,
                          verbose=False, shuffle=True, n_jobs=1,
-                         coding_method='lars'):
+                         coding_method='lars', iter_offset=0):
     """Solves a dictionary learning matrix factorization problem online.
 
     Finds the best dictionary and the corresponding sparse code for
@@ -415,6 +415,10 @@ def dict_learning_online(X, n_atoms, alpha, n_iter=100, return_code=True,
     method: 'lars' | 'lasso',
         method to use for solving the lasso sparse coding problem
 
+    iter_offset: int, default 0
+        number of previous iterations completed on the dictionary used for
+        initialization
+
     Returns
     -------
     dictionary: array of shape (n_atoms, n_features),
@@ -462,7 +466,8 @@ def dict_learning_online(X, n_atoms, alpha, n_iter=100, return_code=True,
     # The data approximation
     B = np.zeros((n_features, n_atoms))
 
-    for ii, this_X in itertools.izip(xrange(n_iter), batches):
+    for ii, this_X in itertools.izip(xrange(iter_offset, iter_offset + n_iter),
+                                     batches):
         #this_Y = this_Y.squeeze()
         dt = (time.time() - t0)
         if verbose == 1:

scikits/learn/decomposition/tests/test_dict_learning.py

@@ -81,16 +81,17 @@ def test_dict_learning_online_partial_fit():
     n_samples, n_features = 10, 8
     n_atoms = 12
     X = np.random.randn(n_samples, n_features)
-    dico1 = DictionaryLearningOnline(n_atoms, n_iter=20,
-                                     transform_method='lasso_lars',
-                                     chunk_size=1, shuffle=False).fit(X)
-    dico2 = DictionaryLearningOnline(n_atoms, n_iter=20,
-                                     transform_method='lasso_lars')
-    for sample in X:
-        dico2.partial_fit(sample)
+    V = np.random.randn(n_atoms, n_features)  # random init
+    dico1 = DictionaryLearningOnline(n_atoms, n_iter=10, chunk_size=1,
+                                     shuffle=False, dict_init=V,
+                                     transform_method='treshold').fit(X)
+    dico2 = DictionaryLearningOnline(n_atoms, n_iter=1, dict_init=V,
+                                     transform_method='treshold')
+    for ii, sample in enumerate(X):
+        dico2.partial_fit(sample, iter_offset=ii * dico2.n_iter)
 
-    code1 = dico1.transform(X, alpha=0.1)
-    code2 = dico2.transform(X, alpha=0.1)
+    code1 = dico1.transform(X, alpha=1)
+    code2 = dico2.transform(X, alpha=1)
     X1 = np.dot(code1, dico1.components_)
     X2 = np.dot(code2, dico2.components_)
     assert_array_equal(X1, X2)