rearranged _traverse to be easier to read

theano/gradient.py

@@ -213,67 +213,68 @@ def Rop(f, wrt, eval_points):
 
     def _traverse(node):
         """ TODO: writeme """
+
         if node is None:
-            return None
-        else:
-            op = node.op
-            inputs = node.inputs
+            return
 
-            # Compute the evaluation points corresponding to each of the
-            # inputs of the node
-            local_eval_points = []
-            for inp in inputs:
-                if inp in wrt:
-                    local_eval_points.append(eval_points[wrt.index(inp)])
-                elif inp.owner is None:
-                    try:
-                        local_eval_points.append(inp.zeros_like())
-                    except:
-                        # None should be used for non-differentiable
-                        # arguments, like for example random states
-                        local_eval_points.append(None)
-                elif inp.owner in seen_nodes:
-
-                    local_eval_points.append(
-                        seen_nodes[inp.owner][inp.owner.outputs.index(inp)])
+        op = node.op
+        inputs = node.inputs
 
-                else:
-                    # We actually need to compute the R_op for this node
-
-                    _traverse(inp.owner)
-                    local_eval_points.append(
-                        seen_nodes[inp.owner][inp.owner.outputs.index(inp)])
-            same_type_eval_points = []
-            for x, y in zip(inputs, local_eval_points):
-                if y is not None:
-                    if not isinstance(x, gof.Variable):
-                        x = as_tensor_variable(x)
-                    if not isinstance(y, gof.Variable):
-                        y = as_tensor_variable(y)
-                    try:
-                        y = x.type.filter_variable(y)
-                    except TypeError:
-                        # This is a hack
-                        # Originally both grad and Rop were written
-                        # with the assumption that a variable and the
-                        # gradient wrt that variable would have the same
-                        # dtype. This was a bad assumption because the
-                        # gradient wrt an integer can take on non-integer
-                        # values.
-                        # grad is now fixed, but Rop is not, so when grad
-                        # does the right thing and violates this assumption
-                        # we have to make it be wrong for Rop to keep working
-                        # Rop should eventually be upgraded to handle integers
-                        # correctly, the same as grad
-                        y = theano.tensor.cast(y,x.type.dtype)
-                        y = x.type.filter_variable(y)
-                    assert x.type == y.type
-                    same_type_eval_points.append(y)
-                else:
-                    same_type_eval_points.append(y)
+        # Compute the evaluation points corresponding to each of the
+        # inputs of the node
+        local_eval_points = []
+        for inp in inputs:
+            if inp in wrt:
+                local_eval_points.append(eval_points[wrt.index(inp)])
+            elif inp.owner is None:
+                try:
+                    local_eval_points.append(inp.zeros_like())
+                except:
+                    # None should be used for non-differentiable
+                    # arguments, like for example random states
+                    local_eval_points.append(None)
+            elif inp.owner in seen_nodes:
+
+                local_eval_points.append(
+                    seen_nodes[inp.owner][inp.owner.outputs.index(inp)])
+
+            else:
+                # We actually need to compute the R_op for this node
+
+                _traverse(inp.owner)
+                local_eval_points.append(
+                    seen_nodes[inp.owner][inp.owner.outputs.index(inp)])
+        same_type_eval_points = []
+        for x, y in zip(inputs, local_eval_points):
+            if y is not None:
+                if not isinstance(x, gof.Variable):
+                    x = as_tensor_variable(x)
+                if not isinstance(y, gof.Variable):
+                    y = as_tensor_variable(y)
+                try:
+                    y = x.type.filter_variable(y)
+                except TypeError:
+                    # This is a hack
+                    # Originally both grad and Rop were written
+                    # with the assumption that a variable and the
+                    # gradient wrt that variable would have the same
+                    # dtype. This was a bad assumption because the
+                    # gradient wrt an integer can take on non-integer
+                    # values.
+                    # grad is now fixed, but Rop is not, so when grad
+                    # does the right thing and violates this assumption
+                    # we have to make it be wrong for Rop to keep working
+                    # Rop should eventually be upgraded to handle integers
+                    # correctly, the same as grad
+                    y = theano.tensor.cast(y,x.type.dtype)
+                    y = x.type.filter_variable(y)
+                assert x.type == y.type
+                same_type_eval_points.append(y)
+            else:
+                same_type_eval_points.append(y)
 
-            seen_nodes[node] = op.R_op(node.inputs, same_type_eval_points)
-            return None
+        seen_nodes[node] = op.R_op(node.inputs, same_type_eval_points)
+    #end _traverse
 
     # Populate the dictionary
     for out in f: