pep8

theano/sandbox/cuda/dnn.py

@@ -13,7 +13,6 @@ from theano.compile.ops import shape_i
 from theano.tensor.nnet import SoftmaxGrad
 from theano.tensor.signal.downsample import (
     DownsampleFactorMax, MaxPoolGrad, AveragePoolGrad)
-from theano.tensor.opt import register_specialize_device
 from theano.sandbox.cuda.type import CudaNdarrayType
 
 from theano.sandbox.cuda import GpuOp
@@ -33,8 +32,6 @@ from theano.sandbox.cuda.nvcc_compiler import NVCC_compiler
 from theano.tensor.nnet.abstract_conv2d import (AbstractConv2d,
                                                 AbstractConv2d_gradWeights,
                                                 AbstractConv2d_gradInputs)
-from theano.tensor.opt import register_specialize_device
-
 
 
 def dnn_available():
@@ -2453,8 +2450,8 @@ def local_abstractconv_cudnn(node):
                                  AbstractConv2d_gradInputs))):
         return None
 
-    if not isinstance(inp1.type, CudaNdarrayType) or \
-            not isinstance(inp2.type, CudaNdarrayType):
+    if (not isinstance(inp1.type, CudaNdarrayType) or
+            not isinstance(inp2.type, CudaNdarrayType)):
         return None
     if not dnn_available():
         return None

theano/sandbox/cuda/extra_ops.py

@@ -9,7 +9,7 @@ from theano.tensor.extra_ops import CumsumOp
 if cuda_available:
     from theano.sandbox.cuda import CudaNdarrayType
     from theano.sandbox.cuda.basic_ops import host_from_gpu, gpu_from_host, HostFromGpu
-    from theano.sandbox.cuda.opt import register_opt as register_gpu_opt
+    from theano.sandbox.cuda import register_opt as register_gpu_opt
 
 
 class GpuCumsum(CumsumOp, GpuOp):

theano/sandbox/cuda/opt.py

 from __future__ import print_function
-import logging
-_logger = logging.getLogger('theano.sandbox.cuda.opt')
 
 import copy
+import logging
+import pdb
 import sys
 import time
 import warnings
-import pdb
 
 import numpy
+from six.moves import reduce, xrange
 
 import theano
 from theano import scalar as scal
 from theano import config, tensor, gof
 import theano.ifelse
 
-from six.moves import reduce, xrange
 from theano.compile import optdb
 from theano.gof import (local_optimizer, EquilibriumDB, ProxyDB,
                         Optimizer, TopoOptimizer, toolbox)
@@ -66,6 +65,7 @@ from theano.sandbox.cuda.elemwise import erfinv_gpu
 from theano.sandbox.cuda.elemwise import erfcx_gpu
 from theano.sandbox.cuda.var import CudaNdarrayConstant
 from theano.sandbox.cuda import gpu_optimizer, register_opt, gpu_seqopt, GpuOp
+import theano.sandbox.cuda.extra_ops
 from theano.scan_module import scan_utils, scan_op, scan_opt
 from theano.tensor.blas import _is_real_vector, _is_real_matrix
 
@@ -75,7 +75,8 @@ from theano.tensor import slinalg
 from theano.tensor.nnet.Conv3D import Conv3D
 from theano.tests.breakpoint import PdbBreakpoint
 
-from theano.tensor.nnet.abstract_conv2d import (BaseAbstractConv2d, AbstractConv2d,
+from theano.tensor.nnet.abstract_conv2d import (BaseAbstractConv2d,
+                                                AbstractConv2d,
                                                 AbstractConv2d_gradWeights,
                                                 AbstractConv2d_gradInputs)
 from theano.tensor.opt import register_specialize_device
@@ -88,6 +89,8 @@ except ImportError:
     pass
 
 
+_logger = logging.getLogger('theano.sandbox.cuda.opt')
+
 # optdb.print_summary()  # shows what is currently registered
 
 gpu_cut_copies = EquilibriumDB()
@@ -2627,11 +2630,11 @@ optdb.register('local_inplace_gpu_sparse_block_outer',
                60, 'fast_run', 'inplace', 'gpu')  # DEBUG
 
 
-import theano.sandbox.cuda.extra_ops
-
-### Move to Gpu optimization
+# Move to Gpu optimization
 @local_optimizer([gpu_from_host,
-                  AbstractConv2d, AbstractConv2d_gradWeights, AbstractConv2d_gradInputs])
+                  AbstractConv2d,
+                  AbstractConv2d_gradWeights,
+                  AbstractConv2d_gradInputs])
 def local_conv2d_gpu_conv(node):
     """
     gpu_from_host(AbstractConv) -> AbstractConv(gpu_from_host)
@@ -2640,7 +2643,8 @@ def local_conv2d_gpu_conv(node):
     """
     if isinstance(node.op, GpuFromHost):
         host_input = node.inputs[0]
-        if host_input.owner and  isinstance(host_input.owner.op, BaseAbstractConv2d):
+        if host_input.owner and isinstance(host_input.owner.op,
+                                           BaseAbstractConv2d):
 
             conv = host_input.owner.op
             inps = list(host_input.owner.inputs)
@@ -2686,8 +2690,7 @@ def local_conv2d_gpu_conv(node):
 register_opt()(local_conv2d_gpu_conv)
 
 
-
-### Corrmm opt
+# Corrmm opt
 @local_optimizer([AbstractConv2d])
 def local_abstractconv_gemm(node):
     if not isinstance(node.op, AbstractConv2d):
@@ -2720,7 +2723,7 @@ def local_abstractconv_gemm(node):
         # is larger than inputChannels * outputHeight * outputWidth.
         # GpuConv does not always store information on the batchsize and
         # channels, though, so we only use what information we have.)
-        if ((subsample == (1,1)) and
+        if ((subsample == (1, 1)) and
                 (node.op.imshp is not None) and
                 (None not in node.op.imshp[-2:]) and
                 (node.op.kshp is not None) and
@@ -2745,6 +2748,7 @@ def local_abstractconv_gemm(node):
                     ).dimshuffle(1, 0, 2, 3))
     return [rval]
 
+
 @local_optimizer([AbstractConv2d_gradWeights])
 def local_abstractconv_gradweight_gemm(node):
     if not isinstance(node.op, AbstractConv2d_gradWeights):
@@ -2763,6 +2767,7 @@ def local_abstractconv_gradweight_gemm(node):
     rval = as_cuda_ndarray_variable(rval)
     return [rval]
 
+
 @local_optimizer([AbstractConv2d_gradInputs])
 def local_abstractconv_gradinputs_gemm(node):
     if not isinstance(node.op, AbstractConv2d_gradInputs):