Make the useless Equilibrium an in2out() with a LocalGroupOpt. Later another…

theano/compile/mode.py

@@ -150,13 +150,15 @@ optdb = gof.SequenceDB()
 optdb.register('merge1', gof.MergeOptimizer(),
                0, 'fast_run', 'fast_compile', 'merge')
 
+local_useless = gof.optdb.LocalGroupDB()
+optdb.register('useless', gof.optdb.TopoDB(local_useless),
+               0.6, 'fast_run', 'fast_compile')
+
 # After scan1 opt at 0.5 and before ShapeOpt at 1
 # This should only remove nodes.
 # The opt should not do anything that need shape inference.
 # New nodes that don't have infer_shape need that the original node
 # also don't have infer_shape
-optdb.register('useless', gof.EquilibriumDB(ignore_newtrees=False),
-               0.6, 'fast_run', 'fast_compile')
 optdb.register('merge1.1', gof.MergeOptimizer(),
                0.65, 'fast_run', 'fast_compile', 'merge')
 

theano/gof/optdb.py

@@ -406,6 +406,32 @@ class LocalGroupDB(SequenceDB):
         self.failure_callback = None
 
 
+class TopoDB(DB):
+    """
+    Generate a local optimizer of type LocalOptGroup instead
+    of a global optimizer.
+
+    It supports the tracks, to only get applied to some Op.
+
+    """
+
+    seq_opt = opt.TopoOptimizer
+
+    def __init__(self, db, order='in_to_out', ignore_newtrees=False,
+                 failure_callback=None):
+        super(TopoDB, self).__init__()
+        self.db = db
+        self.order = order
+        self.ignore_newtrees = ignore_newtrees
+        self.failure_callback = failure_callback
+
+    def query(self, *tags, **kwtags):
+        return opt.TopoOptimizer(self.db.query(*tags, **kwtags),
+                                 self.order,
+                                 self.ignore_newtrees,
+                                 self.failure_callback)
+
+
 class ProxyDB(DB):
     """
     Wrap an existing proxy.

theano/tensor/opt.py

@@ -377,8 +377,8 @@ def register_useless(lopt, *tags, **kwargs):
         return register
     else:
         name = kwargs.pop('name', None) or lopt.__name__
-        compile.optdb['useless'].register(name, lopt, 'fast_run',
-                                          *tags, **kwargs)
+        compile.mode.local_useless.register(name, lopt, 'last', 'fast_run',
+                                            *tags, **kwargs)
         return lopt