A new 'load_params_from' is more clever about loading weights.

Specifically, it will match layers by name and copy weights if names match,
instead of the brute-force approach using list indices, which doesn't work
reliably in some cases.

Aims to supercede #77.  Still needs better testing and possibly a way to
override some of the matching.

Author: dnouri

nolearn/lasagne/base.py

@@ -5,6 +5,7 @@
 import functools
 import itertools
 import operator
+from warnings import warn
 from time import time
 import pdb
 
@@ -414,27 +415,50 @@ def get_all_params(self):
         params = sum([l.get_params() for l in layers], [])
         return unique(params)
 
-    def load_weights_from(self, source):
+    def get_all_params_values(self):
+        return_value = OrderedDict()
+        for name, layer in self.layers_.items():
+            return_value[name] = [p.get_value() for p in layer.get_params()]
+        return return_value
+
+    def load_params_from(self, source):
         self.initialize()
 
         if isinstance(source, str):
-            source = np.load(source)
+            with open(source, 'rb') as f:
+                source = pickle.load(f)
 
         if isinstance(source, NeuralNet):
-            source = source.get_all_params()
+            source = source.get_all_params_values()
 
-        source_weights = [
-            w.get_value() if hasattr(w, 'get_value') else w for w in source]
+        for key, values in source.items():
+            layer = self.layers_.get(key)
+            if layer is not None:
+                for p1, p2v in zip(layer.get_params(), values):
+                    if p1.get_value().shape == p2v.shape:
+                        p1.set_value(p2v)
 
-        for w1, w2 in zip(source_weights, self.get_all_params()):
-            if w1.shape != w2.get_value().shape:
-                continue
-            w2.set_value(w1)
+    def save_params_to(self, fname):
+        params = self.get_all_params_values()
+        with open(fname, 'wb') as f:
+            pickle.dump(params, f, -1)
+
+    def load_weights_from(self, source):
+        warn("The 'load_weights_from' method will be removed in nolearn 0.6. "
+             "Please use 'load_params_from' instead.")
+
+        if isinstance(source, list):
+            raise ValueError(
+                "Loading weights from a list of parameter values is no "
+                "longer supported.  Please send me something like the "
+                "return value of 'net.get_all_param_values()' instead.")
+
+        return self.load_params_from(source)
 
     def save_weights_to(self, fname):
-        weights = [w.get_value() for w in self.get_all_params()]
-        with open(fname, 'wb') as f:
-            pickle.dump(weights, f, -1)
+        warn("The 'save_weights_to' method will be removed in nolearn 0.6. "
+             "Please use 'save_params_to' instead.")
+        return self.save_params_to(fname)
 
     def __getstate__(self):
         state = dict(self.__dict__)

nolearn/tests/test_lasagne.py

@@ -118,9 +118,16 @@ def on_epoch_finished(nn, train_history):
 
     # Use load_weights_from to initialize an untrained model:
     nn3 = clone(nn_def)
-    nn3.load_weights_from(nn2)
+    nn3.load_params_from(nn2)
     assert np.array_equal(nn3.predict(X_test), y_pred)
 
+    # Use save_params_to and load_params_from with a path:
+    path = '/tmp/test_lasagne_functional_mnist.params'
+    nn.save_params_to(path)
+    nn4 = clone(nn_def)
+    nn4.load_params_from(path)
+    assert np.array_equal(nn4.predict(X_test), y_pred)
+
 
 def test_lasagne_functional_grid_search(mnist, monkeypatch):
     # Make sure that we can satisfy the grid search interface.