Merge pull request #158 from brandonwillard/remove-fgraph-property

Remove Variable.fgraph and Variable.clients properties

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/fibby.txt

@@ -110,7 +110,7 @@ TODO: talk about OPTIMIZATION STAGES
    # Remove any fibby(zeros(...))
    @theano.tensor.opt.register_specialize
    @theano.gof.local_optimizer([fibby])
-   def fibby_of_zero(node):
+   def fibby_of_zero(fgraph, node):
        if node.op == fibby:
            x = node.inputs[0]
            try:
@@ -124,8 +124,8 @@ tells Theano to use it in the specialization stage.
 The ``local_optimizer`` decorator builds a class instance around our global
 function.  The ``[fibby]`` argument is a hint that our optimizer works on nodes
 whose ``.op`` attribute equals ``fibby``.
-The function here (``fibby_of_zero``) expects an ``Apply`` instance as an
-argument for parameter ``node``. It tests using
+The function here (``fibby_of_zero``) expects a ``FunctionGraph`` and an ``Apply`` instance as
+arguments for the parameters ``fgraph`` and ``node``. It tests using
 function ``get_scalar_constant_value``, which determines if a
 Variable (``x``) is guaranteed to be a constant, and if so, what constant.
 

doc/extending/graphstructures.txt

@@ -344,7 +344,7 @@ pairs:
   function outputs this variable.
 
 In both types of pairs, the second element of the tuple is an index,
-such that: ``var.clients[*][0].inputs[index]`` or
+such that: ``fgraph.clients[var][*][0].inputs[index]`` or
 ``fgraph.outputs[index]`` is that variable.
 
 
@@ -357,15 +357,16 @@ Sum{acc_dtype=float64} [id A] ''   1
    |TensorConstant{(1,) of 1.0} [id C]
    |<TensorType(float64, vector)> [id D]
 >>> # Sorted list of all nodes in the compiled graph.
->>> topo = f.maker.fgraph.toposort()
->>> topo[0].outputs[0].clients
+>>> fgraph = f.maker.fgraph
+>>> topo = fgraph.toposort()
+>>> fgraph.clients[topo[0].outputs[0]]
 [(Sum{acc_dtype=float64}(Elemwise{add,no_inplace}.0), 0)]
->>> topo[1].outputs[0].clients
+>>> fgraph.clients[topo[1].outputs[0]]
 [('output', 0)]
 
 >>> # An internal variable
 >>> var = topo[0].outputs[0]
->>> client = var.clients[0]
+>>> client = fgraph.clients[var][0]
 >>> client
 (Sum{acc_dtype=float64}(Elemwise{add,no_inplace}.0), 0)
 >>> type(client[0])
@@ -374,10 +375,10 @@ Sum{acc_dtype=float64} [id A] ''   1
 
 >>> # An output of the graph
 >>> var = topo[1].outputs[0]
->>> client = var.clients[0]
+>>> client = fgraph.clients[var][0]
 >>> client
 ('output', 0)
->>> assert f.maker.fgraph.outputs[client[1]] is var
+>>> assert fgraph.outputs[client[1]] is var
 
 
 Automatic Differentiation

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
@@ -254,7 +254,7 @@ Optional methods or attributes
      If you set `__props__`, this will be automatically generated.
      You can still overide it for custom output.
 
-.. function:: do_constant_folding(node)
+.. function:: do_constant_folding(fgraph, node)
 
    *Default:* Return True
 
@@ -323,7 +323,7 @@ These are the function required to work with gradient.grad().
   return the gradient of the Op's output. theano.tensor.grad computes
   gradients; Op.grad is a helper function that computes terms that
   appear in gradients.
-  
+
   If an Op has a single vector-valued output y and a single
   vector-valued input x, then the grad method will be passed x and a
   second vector z. Define J to be the Jacobian of y with respect to
@@ -393,7 +393,7 @@ These are the function required to work with gradient.grad().
   :math:`[grad_{x_1}(C), grad_{x_2}(C), ..., grad_{x_m}(C)]`, where
   :math:`(grad_{y}(Z))_i = \frac{\partial Z}{\partial y_i}` (and
   :math:`i` can stand for multiple dimensions).
- 
+
   In other words, :func:`grad` does not return :math:`\frac{d f_i}{d
   x_j}`, but instead the appropriate dot product specified by the
   chain rule: :math:`\frac{d C}{d x_j} = \frac{d C}{d f_i} \cdot
@@ -402,7 +402,7 @@ These are the function required to work with gradient.grad().
 
   Theano currently imposes the following constraints on the values
   returned by the grad method:
-  
+
   1) They must be Variable instances.
   2) When they are types that have dtypes, they must never have an integer dtype.
 
@@ -525,27 +525,27 @@ These are the function required to work with gradient.grad().
 
    This function implements the application of the R-operator on the
    function represented by your op. Let assume that function is :math:`f`,
-   with input :math:`x`, applying the R-operator means computing the 
-   Jacobian of :math:`f` and right-multiplying it by :math:`v`, the evaluation 
-   point, namely: :math:`\frac{\partial f}{\partial x} v`. 
+   with input :math:`x`, applying the R-operator means computing the
+   Jacobian of :math:`f` and right-multiplying it by :math:`v`, the evaluation
+   point, namely: :math:`\frac{\partial f}{\partial x} v`.
 
-   ``inputs`` are the symbolic variables corresponding to the value of 
+   ``inputs`` are the symbolic variables corresponding to the value of
    the input where you want to evaluate the jacobian, and ``eval_points``
    are the symbolic variables corresponding to the value you want to
-   right multiply the jacobian with. 
+   right multiply the jacobian with.
 
    Same conventions as for the grad method hold. If your op is not
-   differentiable, you can return None. Note that in contrast to 
+   differentiable, you can return None. Note that in contrast to
    the method :func:`grad`, for :func:`R_op` you need to return the
    same number of outputs as there are ouputs of the op. You can think
    of it in the following terms. You have all your inputs concatenated
-   into a single vector :math:`x`. You do the same with the evaluation 
+   into a single vector :math:`x`. You do the same with the evaluation
    points (which are as many as inputs and of the shame shape) and obtain
-   another vector :math:`v`. For each output, you reshape it into a vector, 
-   compute the jacobian of that vector with respect to :math:`x` and 
+   another vector :math:`v`. For each output, you reshape it into a vector,
+   compute the jacobian of that vector with respect to :math:`x` and
    multiply it by :math:`v`. As a last step you reshape each of these
-   vectors you obtained for each outputs (that have the same shape as 
-   the outputs) back to their corresponding shapes and return them as the 
+   vectors you obtained for each outputs (that have the same shape as
+   the outputs) back to their corresponding shapes and return them as the
    output of the :func:`R_op` method.
 
    :ref:`List of op with r op support <R_op_list>`.
@@ -777,4 +777,3 @@ your disposal to create these objects as efficiently as possible.
 
 **Exercise**: Make a generic DoubleOp, where the number of
 arguments can also be given as a parameter.
-

doc/extending/optimization.txt

@@ -57,7 +57,7 @@ Global optimization
 A global optimization (or optimizer) is an object which defines the following
 methods:
 
-.. class:: Optimizer
+.. class:: GlobalOptimizer
 
     .. method:: apply(fgraph)
 
@@ -75,7 +75,7 @@ methods:
 
       This is the interface function called by Theano.
 
-      *Default:* this is defined by Optimizer as ``add_requirement(fgraph);
+      *Default:* this is defined by GlobalOptimizer as ``add_requirement(fgraph);
       apply(fgraph)``.
 
 See the section about :class:`FunctionGraph` to understand how to define these
@@ -89,14 +89,14 @@ A local optimization is an object which defines the following methods:
 
 .. class:: LocalOptimizer
 
-    .. method:: transform(node)
+    .. method:: transform(fgraph, node)
 
-      This method takes an :ref:`apply` node and returns either ``False`` to
-      signify that no changes are to be done or a list of Variables which
-      matches the length of the node's ``outputs`` list. When the
-      LocalOptimizer is applied by a Navigator, the outputs of the node
-      passed as argument to the LocalOptimizer will be replaced by the
-      list returned.
+      This method takes a :ref:`FunctionGraph` and an :ref:`Apply` node and
+      returns either ``False`` to signify that no changes are to be done or a
+      list of `Variable`s which matches the length of the node's ``outputs``
+      list. When the `LocalOptimizer` is applied by a `Navigator`, the outputs
+      of the node passed as argument to the `LocalOptimizer` will be replaced by
+      the list returned.
 
 
 
@@ -125,7 +125,7 @@ simplification described above:
    from theano import gof
    from theano.gof import toolbox
 
-   class Simplify(gof.Optimizer):
+   class Simplify(gof.GlobalOptimizer):
        def add_requirements(self, fgraph):
            fgraph.attach_feature(toolbox.ReplaceValidate())
        def apply(self, fgraph):
@@ -252,7 +252,7 @@ The local version of the above code would be the following:
 .. testcode::
 
    class LocalSimplify(gof.LocalOptimizer):
-       def transform(self, node):
+       def transform(self, fgraph, node):
            if node.op == true_div:
                x, y = node.inputs
                if x.owner and x.owner.op == mul:
@@ -471,7 +471,7 @@ Here are a few examples of how to use a Query on optdb to produce an
 Optimizer:
 
 .. testcode::
-   
+
    from theano.gof import Query
    from theano.compile import optdb
 

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}
 

doc/tutorial/debug_faq.txt

@@ -363,11 +363,11 @@ shows how to print all inputs and outputs:
     from __future__ import print_function
     import theano
 
-    def inspect_inputs(i, node, fn):
+    def inspect_inputs(fgraph, i, node, fn):
         print(i, node, "input(s) value(s):", [input[0] for input in fn.inputs],
               end='')
 
-    def inspect_outputs(i, node, fn):
+    def inspect_outputs(fgraph, i, node, fn):
         print(" output(s) value(s):", [output[0] for output in fn.outputs])
 
     x = theano.tensor.dscalar('x')
@@ -406,7 +406,7 @@ can be achieved as follows:
     # ``theano.compile.monitormode.detect_nan`` that will always
     # contain the current suggested version.
 
-    def detect_nan(i, node, fn):
+    def detect_nan(fgraph, i, node, fn):
         for output in fn.outputs:
             if (not isinstance(output[0], numpy.random.RandomState) and
                 numpy.isnan(output[0]).any()):