Cleaned up and fixed pep8

theano/gpuarray/dnn.py

@@ -25,7 +25,7 @@ from theano.tensor.signal.pool import (
 from . import pygpu
 from .type import get_context, gpu_context_type, list_contexts, GpuArrayType
 from .basic_ops import (as_gpuarray_variable, infer_context_name,
-                        gpu_contiguous, GpuAllocEmpty, gpu_alloc_empty, 
+                        gpu_contiguous, gpu_alloc_empty,
                         empty_like)
 from .elemwise import GpuElemwise
 
@@ -942,8 +942,8 @@ def dnn_conv(img, kerns, border_mode='valid', subsample=(1, 1),
         shape2 = shape_i(img, 2, fgraph) + shape_i(kerns, 2, fgraph) - 1
         shape3 = shape_i(img, 3, fgraph) + shape_i(kerns, 3, fgraph) - 1
         out = gpu_alloc_empty(img.dtype, ctx_name)(shape_i(img, 0, fgraph),
-                                                 shape_i(kerns, 1, fgraph),
-                                                 shape2, shape3)
+                                                   shape_i(kerns, 1, fgraph),
+                                                   shape2, shape3)
         desc = GpuDnnConvDesc(border_mode='valid', subsample=(1, 1),
                               conv_mode=conv_mode, precision=precision)(kerns.shape)
         return gpu_dnn_conv_gradI()(kerns, img, out, desc)
@@ -1412,11 +1412,11 @@ class GpuDnnSoftmaxGrad(GpuDnnSoftmaxBase):
 @local_optimizer([AbstractConv2d, AbstractConv2d_gradWeights,
                   AbstractConv2d_gradInputs])
 @register_opt2([AbstractConv2d, AbstractConv2d_gradWeights,
-                  AbstractConv2d_gradInputs], 'fast_compile')
+                AbstractConv2d_gradInputs], 'fast_compile')
 def local_abstractconv_cudnn_graph(op, context_name, inputs):
     if (not isinstance(op, (AbstractConv2d,
-                                 AbstractConv2d_gradWeights,
-                                 AbstractConv2d_gradInputs))):
+                            AbstractConv2d_gradWeights,
+                            AbstractConv2d_gradInputs))):
         return None
 
     inp1 = inputs[0]
@@ -1462,8 +1462,8 @@ def local_abstractconv_cudnn_graph(op, context_name, inputs):
 @local_optimizer([AbstractConv2d, AbstractConv2d_gradWeights,
                   AbstractConv2d_gradInputs])
 def local_abstractconv_cudnn(node):
-    ctx = infer_context(*node.inputs)
-    return local_abstractconv_dnn_graph(node.op, ctx, node.inputs)
+    ctx = infer_context_name(*node.inputs)
+    return local_abstractconv_cudnn_graph(node.op, ctx, node.inputs)
 
 conv_groupopt.register('local_abstractconv_cudnn_graph',
                        local_abstractconv_cudnn_graph, 20,

theano/gpuarray/extra_ops.py

@@ -9,7 +9,7 @@ except ImportError:
     pass
 
 from .basic_ops import (as_gpuarray_variable, GpuKernelBase, Kernel,
-                        infer_context_name, GpuFromHost)
+                        infer_context_name)
 from .opt import register_opt, op_lifter, register_opt2
 
 
@@ -450,10 +450,11 @@ class GpuCumsum(GpuKernelBase, Op):
         """ % locals()
         return super(GpuCumsum, self).c_support_code_struct(node, nodename) + code
 
+
 @register_opt('fast_compile')
 @op_lifter([CumsumOp])
 @register_opt2([CumsumOp], 'fast_compile')
-def use_gpu_cumsumop(op, ctx_name, inputs,  ):
+def use_gpu_cumsumop(op, ctx_name, inputs):
     if inputs[0].dtype == 'float32':
         axis = op.axis
         x = inputs[0]

theano/gpuarray/nerv.py

@@ -10,7 +10,7 @@ from theano.scalar import as_scalar, constant
 
 from . import opt
 from .basic_ops import (as_gpuarray_variable, GpuAllocEmpty,
-                        infer_context_name)
+                        infer_context_name, gpu_alloc_empty)
 from .type import gpu_context_type
 from .opt_util import alpha_merge, output_merge
 

theano/gpuarray/opt_util.py

@@ -325,7 +325,7 @@ def inplace_allocempty(op, idx):
                     isinstance(alloc.owner.op, GpuAllocEmpty) and
                     len(alloc.clients) > 1):
                 alloc_op = gpu_alloc_empty(alloc.owner.op.dtype,
-                                         alloc.owner.op.context_name)
+                                           alloc.owner.op.context_name)
                 inputs[idx] = alloc_op(*alloc.owner.inputs)
             return maker(node, inputs)
         return opt