Use op.__call__() instead of op.make_node() to have test value inserted during opt.

theano/scan_module/scan_opt.py

@@ -227,7 +227,11 @@ class PushOutNonSeqScan(gof.Optimizer):
                                  'this on theano-users list'), x)
                     outside_ins = [x.type.filter_variable(y) for x, y in
                                    zip(nd.inputs, outside_ins)]
-                    nw_outer_node = nd.op.make_node(*outside_ins)
+
+                    # Do not call make_node for test_value
+                    nw_outer_node = nd.op(*outside_ins,
+                                          return_list=True)[0].owner
+
                     # Step 2. Create variables for replacements
                     for idx, y in enumerate(nd.outputs):
 
@@ -285,7 +289,10 @@ class PushOutNonSeqScan(gof.Optimizer):
             op_ins, op_outs = scan_utils.reconstruct_graph(_op_ins, _op_outs)
             # Reconstruct node
             nwScan = scan_op.Scan(op_ins, op_outs, op.info)
-            nw_node = nwScan.make_node(* (node.inputs + nw_outer))
+
+            # Do not call make_node for test_value
+            nw_node = nwScan(*(node.inputs + nw_outer), return_list=True)[0].owner
+
             fgraph.replace_all_validate_remove(
                 zip(node.outputs, nw_node.outputs),
                 remove=[node],
@@ -387,7 +394,9 @@ class PushOutSeqScan(gof.Optimizer):
                                  'to move some computation fron scan '
                                  'which is not allowed to move. Report '
                                  'this on theano-users list'), x)
-                    nw_outer_node = nd.op.make_node(*outside_ins)
+                    # Do not call make_node for test_value
+                    nw_outer_node = nd.op(*outside_ins, return_list=True)[0].owner
+
                     # Step 2. Create variables for replacements
                     for idx, y in enumerate(nd.outputs):
 
@@ -473,8 +482,10 @@ class PushOutSeqScan(gof.Optimizer):
             nw_info = op.info.copy()
             nw_info['n_seqs'] += len(nw_inner)
             nwScan = scan_op.Scan(op_ins, op_outs, nw_info)
-            nw_node = nwScan.make_node(* (node.inputs[:1] + nw_outer +
-                                          node.inputs[1:]))
+            # Do not call make_node for test_value
+            nw_node = nwScan(* (node.inputs[:1] + nw_outer +
+                                node.inputs[1:]), return_list=True)[0].owner
+
             fgraph.replace_all_validate_remove(
                 zip(node.outputs, nw_node.outputs),
                 remove=[node],

theano/tensor/opt.py

@@ -394,10 +394,12 @@ def local_dimshuffle_lift(node):
     input = node.inputs[0]
     inode = input.owner
     if inode and isinstance(inode.op, Elemwise) and (len(input.clients) == 1):
-        return inode.op.make_node(*[DimShuffle(input.type.broadcastable,
-                                               op.new_order,
-                                               op.inplace)(input) for input in
-                                    inode.inputs]).outputs
+        # Don't use make_node to have tag.test_value set.
+        ret = inode.op(*[DimShuffle(input.type.broadcastable,
+                                    op.new_order,
+                                    op.inplace)(input) for input in
+                         inode.inputs], return_list=True)
+        return ret
     if inode and isinstance(inode.op, DimShuffle):
         new_order = [x == 'x' and 'x' or inode.op.new_order[x] for x in
                      op.new_order]
@@ -407,8 +409,9 @@ def local_dimshuffle_lift(node):
                                                    iinput.type.ndim):
             return [iinput]
         else:
-            return DimShuffle(iinput.type.broadcastable, new_order,
-                              inplace).make_node(iinput).outputs
+            ret = DimShuffle(iinput.type.broadcastable, new_order,
+                             inplace)(iinput, return_list=True)
+            return ret
 
 
 @register_canonicalize
@@ -783,7 +786,8 @@ class ShapeFeature(object):
         if hasattr(r.type, "broadcastable") and r.type.broadcastable[i]:
             return self.lscalar_one
         else:
-            return Shape_i(i).make_node(r).outputs[0]
+            # Do not call make_node for test_value
+            return Shape_i(i)(r)
 
     def shape_tuple(self, r):
         """Return a tuple of symbolic shape vars for tensor variable r"""
@@ -1945,7 +1949,8 @@ def local_subtensor_merge(node):
             sl_ins = Subtensor.collapse(
                 merged_slices,
                 lambda x: isinstance(x, T.Variable))
-            out = subtens.make_node(x, *sl_ins).outputs[0]
+            # Do not call make_node for test_value
+            out = subtens(x, *sl_ins)
 
             return [out]
 
@@ -4679,7 +4684,8 @@ your code will run correctly, but may be slower.""")
         C = scalar.Composite(s_inputs, [s_new_out])
 
         #create the new node.
-        n = OP(C).make_node(*inputs)
+        #Do not call make_node to have test_value
+        n = OP(C)(*inputs).owner
         assert len(n.outputs) == 1
         assert node.outputs[0].dtype == n.outputs[0].dtype