Make using varying criteria work until #86.

Note that this make it slower if the criterion is always constructed
on-the-fly as it will always have a different ID. It's not perfect
either, but a slow-down on "misuse" is better than wrong values on
"misuse".

Author: lucasb-eyer

DeepFried2/Module.py

@@ -81,7 +81,7 @@ def forward(self, data):
         return self._collect_extra_outputs(fn, outs)
 
     def accumulate_gradients(self, data_in, data_tgt, crit):
-        if self._mode not in self._fn_accum_grads:
+        if (self._mode, id(crit)) not in self._fn_accum_grads:
             symb_in = tensors_for_ndarrays(data_in, 'X')
             symb_tgt = tensors_for_ndarrays(data_tgt, 'T')
             symb_out = self(symb_in)
@@ -92,14 +92,14 @@ def accumulate_gradients(self, data_in, data_tgt, crit):
             symb_grads = df.th.grad(cost=symb_cost, wrt=[p.param for p in params])
             grads_updates = [(p.grad, p.grad + symb_grad) for p, symb_grad in zip(params, symb_grads)]
 
-            fn = self._fn_accum_grads[self._mode] = df.th.function(
+            fn = self._fn_accum_grads[self._mode, id(crit)] = df.th.function(
                 inputs=flatten(symb_in) + flatten(symb_tgt),
                 outputs=flatten(symb_cost) + flatten(extra_out),
                 updates=grads_updates
             )
             fn._df2_extra = extra_out
 
-        fn = self._fn_accum_grads[self._mode]
+        fn = self._fn_accum_grads[self._mode, id(crit)]
         args = flatten(data_in) + flatten(data_tgt)
         outs = fn(*args)
         return self._collect_extra_outputs(fn, outs)

DeepFried2/tests/test_Module.py

@@ -0,0 +1,21 @@
+#!/usr/bin/env python3
+
+import DeepFried2 as df
+
+import unittest
+import numpy as np
+
+class TestModule(unittest.TestCase):
+
+    def testDifferentCriteriaInstances(self):
+        T = np.random.randn(10,10).astype(df.floatX)
+        c1 = df.MSECriterion()
+        c2 = df.MADCriterion()
+        err = 0.5
+
+        net = df.Identity()
+        l1 = float(net.accumulate_gradients(T+err, T, c1))
+        l2 = float(net.accumulate_gradients(T+err, T, c2))
+
+        np.testing.assert_almost_equal(l1, err**2)
+        np.testing.assert_almost_equal(l2, abs(err))