Remove all uses of Variable.fgraph

This change requires the addition of an `fgraph` argument to the
`Op.infer_shape` method used by `ShapeFeature`.

Author: brandonwillard

doc/extending/cop.txt

@@ -177,13 +177,13 @@ There are less methods to define for an Op than for a Type:
     .. method:: c_cleanup_code_struct(node, name)
 
        Allows you to specify code that will be inserted in the struct
-       destructor of the Op.  This is for cleaninp up allocations and
+       destructor of the `Op`.  This is for cleaninp up allocations and
        stuff like this when the thunk is released (when you "free" a
        compiled function using this op).
 
-    .. method:: infer_shape(node, (i0_shapes,i1_shapes,...))
+    .. method:: infer_shape(fgraph, node, (i0_shapes,i1_shapes,...))
 
-       Allow optimizations to lift the Shape op over this op.  An
+       Allow optimizations to lift the `Shape` `Op` over this `Op`.  An
        example of why this is good is when we only need the shape of a
        variable: we will be able to obtain it without computing the
        variable itself.
@@ -192,8 +192,8 @@ There are less methods to define for an Op than for a Type:
        the shape of one output.
 
        For example, for the matrix-matrix product ``infer_shape`` will
-       have as inputs (node, ((x0,x1), (y0,y1))) and should return
-       [(x0, y1)]. Both the inputs and the return value may be Theano
+       have as inputs ``(fgraph, node, ((x0,x1), (y0,y1)))`` and should return
+       ``[(x0, y1)]``. Both the inputs and the return value may be Theano
        variables.
 
     .. method:: c_code_cache_version()

doc/extending/extending_theano.txt

@@ -114,7 +114,7 @@ possibilities you may encounter or need.  For that refer to
         def R_op(self, inputs, eval_points):
             pass
 
-        def infer_shape(node, input_shapes):
+        def infer_shape(self, fgraph, node, input_shapes):
             pass
 
 An op has to implement some methods defined in the the interface of
@@ -237,9 +237,9 @@ There are other methods that can be optionally defined by the op:
   :attr:`__props__` will also generate a  suitable :func:`__str__` for your op.
   This requires development version after September 1st, 2014 or version 0.7.
 
-  The :func:`infer_shape` method allows to infer the shape of the op
-  output variables, without actually computing the outputs.
-  It takes as input ``node``, a reference to the op Apply node,
+  The :func:`infer_shape` method allows an `Op` to infer the shape of its
+  output variables without actually computing them.
+  It takes as input ``fgraph``, a `FunctionGraph`; ``node``, a reference to the op Apply node;
   and a list of Theano symbolic Varables (``i0_shape``, ``i1_shape``, ...)
   which are the shape of the op input Variables.
   :func:`infer_shape` returns a list where each element is a tuple representing
@@ -302,7 +302,7 @@ Example: Op definition
             z = output_storage[0]
             z[0] = x * 2
 
-        def infer_shape(self, node, i0_shapes):
+        def infer_shape(self, fgraph, node, i0_shapes):
             return i0_shapes
 
         def grad(self, inputs, output_grads):
@@ -333,7 +333,7 @@ Example: Op definition
             z = output_storage[0]
             z[0] = x * 2
 
-        def infer_shape(self, node, i0_shapes):
+        def infer_shape(self, fgraph, node, i0_shapes):
             return i0_shapes
 
         def grad(self, inputs, output_grads):
@@ -508,7 +508,7 @@ and ``b`` are equal.
             z = output_storage[0]
             z[0] = self.a * x + self.b
 
-        def infer_shape(self, node, i0_shapes):
+        def infer_shape(self, fgraph, node, i0_shapes):
             return i0_shapes
 
         def grad(self, inputs, output_grads):
@@ -750,12 +750,13 @@ signature:
 
 .. code-block:: none
 
-    def infer_shape(node, input_shapes):
+    def infer_shape(fgraph, node, input_shapes):
         # ...
         return output_shapes
 
   - `input_shapes` and `output_shapes` are lists of tuples that
-    represent the shape of the corresponding inputs/outputs.
+    represent the shape of the corresponding inputs/outputs, and `fgraph`
+    is a `FunctionGraph`.
 
 .. note::
 
@@ -788,7 +789,7 @@ as_op Example
     from theano import function
     from theano.compile.ops import as_op
 
-    def infer_shape_numpy_dot(node, input_shapes):
+    def infer_shape_numpy_dot(fgraph, node, input_shapes):
         ashp, bshp = input_shapes
         return [ashp[:-1] + bshp[-1:]]
 

doc/extending/extending_theano_solution_1.py

@@ -34,7 +34,7 @@ def perform(self, node, inputs, output_storage):
         z = output_storage[0]
         z[0] = x * y
 
-    def infer_shape(self, node, i0_shapes):
+    def infer_shape(self, fgraph, node, i0_shapes):
         return [i0_shapes[0]]
 
     def grad(self, inputs, output_grads):
@@ -71,7 +71,7 @@ def perform(self, node, inputs, output_storage):
         z1[0] = x + y
         z2[0] = x - y
 
-    def infer_shape(self, node, i0_shapes):
+    def infer_shape(self, fgraph, node, i0_shapes):
         return [i0_shapes[0], i0_shapes[0]]
 
     def grad(self, inputs, output_grads):
@@ -172,7 +172,7 @@ def test_infer_shape(self):
 from theano.compile.ops import as_op
 
 
-def infer_shape_numpy_dot(node, input_shapes):
+def infer_shape_numpy_dot(fgraph, node, input_shapes):
     ashp, bshp = input_shapes
     return [ashp[:-1] + bshp[-1:]]
 
@@ -183,7 +183,7 @@ def numpy_add(a, b):
     return np.add(a, b)
 
 
-def infer_shape_numpy_add_sub(node, input_shapes):
+def infer_shape_numpy_add_sub(fgraph, node, input_shapes):
     ashp, bshp = input_shapes
     # Both inputs should have that same shape, so we just return one of them.
     return [ashp[0]]

doc/extending/op.txt

@@ -215,7 +215,7 @@ Optional methods or attributes
    will use your Op and build the graphs that you want and call that
    instead of the Op instance directly.
 
-.. function:: infer_shape(node, shapes)
+.. function:: infer_shape(fgraph, node, shapes)
 
    This function is needed for shape optimization. ``shapes`` is a
    list with one tuple for each input of the Apply node (which corresponds

doc/hpcs2011_tutorial/presentation.tex

@@ -1390,7 +1390,7 @@ \subsection{Theano}
 {\color{gray}# optional:}
     def __init__(self, ...):
     def grad(self, inputs, g):
-    def infer_shape(node, (i0_shapes, ...))
+    def infer_shape(fgraph, node, (i0_shapes, ...))
 \end{Verbatim}
 \end{frame}
 

tests/compile/test_monitormode.py

@@ -11,7 +11,7 @@ def test_detect_nan():
 
     nan_detected = [False]
 
-    def detect_nan(i, node, fn):
+    def detect_nan(fgraph, i, node, fn):
         for output in fn.outputs:
             if np.isnan(output[0]).any():
                 print("*** NaN detected ***")
@@ -41,7 +41,7 @@ def test_optimizer():
 
     nan_detected = [False]
 
-    def detect_nan(i, node, fn):
+    def detect_nan(fgraph, i, node, fn):
         for output in fn.outputs:
             if np.isnan(output[0]).any():
                 print("*** NaN detected ***")
@@ -73,7 +73,7 @@ def test_not_inplace():
 
     nan_detected = [False]
 
-    def detect_nan(i, node, fn):
+    def detect_nan(fgraph, i, node, fn):
         for output in fn.outputs:
             if np.isnan(output[0]).any():
                 print("*** NaN detected ***")

tests/compile/test_ops.py

@@ -69,7 +69,7 @@ def test_infer_shape(self):
         y = dvector("y")
         y.tag.test_value = [0, 0, 0, 0]
 
-        def infer_shape(node, shapes):
+        def infer_shape(fgraph, node, shapes):
             x, y = shapes
             return [y]
 

tests/gof/test_fg.py

@@ -216,13 +216,6 @@ def test_replace(self):
         var5 = op3(var4, var2, var2)
         fg = FunctionGraph([var1, var2], [var3, var5], clone=False)
 
-        with pytest.raises(Exception, match="Cannot replace.*"):
-            var4.fgraph = object()
-            # Trigger a `FunctionGraph` ownership error
-            fg.replace(var4, var1, verbose=True)
-
-        var4.fgraph = fg
-
         with pytest.raises(BadOptimization):
             var0 = MyVariable2("var0")
             # The types don't match and one cannot be converted to the other
@@ -262,7 +255,6 @@ def test_replace_bad_state(self):
 
         with pytest.raises(MissingInputError):
             var0 = MyVariable("var0")
-            var0.fgraph = object()
 
             # FIXME TODO XXX: This breaks the state of the `FunctionGraph`,
             # because it doesn't check for validity of the replacement *first*.
@@ -299,7 +291,6 @@ def test_check_integrity(self):
 
         with pytest.raises(Exception, match="Undeclared input.*"):
             var6 = MyVariable2("var6")
-            var6.fgraph = fg
             fg.clients[var6] = [(var5.owner, 3)]
             fg.variables.add(var6)
             var5.owner.inputs.append(var6)

tests/gof/test_link.py

@@ -138,7 +138,7 @@ class TestWrapLinker:
     def test_0(self):
         nodes = []
 
-        def wrap(i, node, th):
+        def wrap(fgraph, i, node, th):
             nodes.append(node.op)
 
         x, y, z = inputs()
@@ -155,7 +155,7 @@ def wrap(i, node, th):
     def test_1(self):
         nodes = []
 
-        def wrap(i, node, th):
+        def wrap(fgraph, i, node, th):
             nodes.append(node.op)
             th()
 

tests/gpuarray/test_cgpukernelbase.py

@@ -54,7 +54,7 @@ def make_node(self, n, m):
 
         return Apply(self, [n, m], [otype()])
 
-    def infer_shape(self, node, in_shapes):
+    def infer_shape(self, fgraph, node, in_shapes):
         out_shape = [node.inputs[0], node.inputs[1]]
         return [out_shape]