Apply isort to tests.tensor.nnet sub-package modules

tests/tensor/nnet/speed_test_conv.py

@@ -3,8 +3,7 @@ import time
 import numpy as N
 
 import theano.tensor as tt
-
-from theano import function, Mode
+from theano import Mode, function
 from theano.tensor.nnet.conv import ConvOp
 
 
@@ -103,8 +102,8 @@ def exec_multilayer_conv_nnet_old(
         outval = N.zeros(N.r_[bsize, outshp])
         if validate:
             # causes an atexit problem
+            from scipy.signal.signaltools import _bvalfromboundary, _valfrommode
             from scipy.signal.sigtools import _convolve2d
-            from scipy.signal.signaltools import _valfrommode, _bvalfromboundary
 
             val = _valfrommode(conv_mode)
             bval = _bvalfromboundary("fill")

tests/tensor/nnet/test_abstract_conv.py

-import pytest
-
 import numpy as np
+import pytest
 
 import theano
-
-from theano import tensor
-from theano import change_flags
+from tests import unittest_tools as utt
+from theano import change_flags, tensor
 from theano.gof.opt import check_stack_trace
-from theano.tensor.nnet import corr, corr3d, conv2d_transpose, abstract_conv as conv
+from theano.tensor.nnet import abstract_conv as conv
+from theano.tensor.nnet import conv2d_transpose, corr, corr3d
 from theano.tensor.nnet.abstract_conv import (
-    get_conv_output_shape,
-    get_conv_gradweights_shape,
-    get_conv_gradinputs_shape,
-    check_conv_gradinputs_shape,
+    AbstractConv2d,
+    AbstractConv2d_gradInputs,
+    AbstractConv2d_gradWeights,
     assert_conv_shape,
     assert_shape,
+    bilinear_kernel_1D,
+    bilinear_kernel_2D,
+    bilinear_upsampling,
+    causal_conv1d,
+    check_conv_gradinputs_shape,
+    get_conv_gradinputs_shape,
+    get_conv_gradweights_shape,
+    get_conv_output_shape,
+    separable_conv2d,
+    separable_conv3d,
 )
-from theano.tensor.nnet.abstract_conv import AbstractConv2d
-from theano.tensor.nnet.abstract_conv import AbstractConv2d_gradInputs
-from theano.tensor.nnet.abstract_conv import AbstractConv2d_gradWeights
-from theano.tensor.nnet.abstract_conv import bilinear_kernel_1D
-from theano.tensor.nnet.abstract_conv import bilinear_kernel_2D
-from theano.tensor.nnet.abstract_conv import bilinear_upsampling
-from theano.tensor.nnet.abstract_conv import separable_conv2d, separable_conv3d
-from theano.tensor.nnet.abstract_conv import causal_conv1d
-from theano.tensor.nnet.corr import CorrMM, CorrMM_gradWeights, CorrMM_gradInputs
-from theano.tensor.nnet.corr3d import (
-    Corr3dMM,
-    Corr3dMMGradWeights,
-    Corr3dMMGradInputs,
-)
-
-from tests import unittest_tools as utt
+from theano.tensor.nnet.corr import CorrMM, CorrMM_gradInputs, CorrMM_gradWeights
+from theano.tensor.nnet.corr3d import Corr3dMM, Corr3dMMGradInputs, Corr3dMMGradWeights
 
 
 def conv2d_corr(

tests/tensor/nnet/test_blocksparse.py

@@ -2,17 +2,17 @@
     Tests for block sparse dot
 """
 import numpy as np
-import theano
-import tests.unittest_tools as utt
-
 from numpy.random import randn
+
+import tests.unittest_tools as utt
+import theano
 from theano import tensor
 from theano.tensor.nnet.blocksparse import (
+    SparseBlockGemv,
+    SparseBlockOuter,
     sparse_block_dot,
     sparse_block_gemv,
     sparse_block_outer,
-    SparseBlockGemv,
-    SparseBlockOuter,
 )
 
 

tests/tensor/nnet/test_bn.py

-import pytest
+from collections import OrderedDict
 
 import numpy as np
+import pytest
 
 import theano
 import theano.tensor as tt
-
-from collections import OrderedDict
-
-from theano.tensor.nnet import bn
-
 from tests import unittest_tools as utt
+from theano.tensor.nnet import bn
 
 
 def test_BNComposite():

tests/tensor/nnet/test_conv.py

 import time
 
-import pytest
-
 import numpy as np
+import pytest
 
 import theano
 import theano.tensor as tt
-
-from theano.tensor.nnet import conv, conv2d
-from theano.tensor.basic import _allclose, NotScalarConstantError
-
 from tests import unittest_tools as utt
+from theano.tensor.basic import NotScalarConstantError, _allclose
+from theano.tensor.nnet import conv, conv2d
 
 
 @pytest.mark.skipif(

tests/tensor/nnet/test_conv3d2d.py

 import time
-import pytest
+
 import numpy as np
+import pytest
+
 import theano
 
+
 try:
     from scipy import ndimage
 except ImportError:
     ndimage = None
 
+import tests.unittest_tools as utt
 from theano.gof.opt import check_stack_trace
 from theano.tensor.nnet.conv3d2d import (
-    conv3d,
-    get_diagonal_subtensor_view,
     DiagonalSubtensor,
     IncDiagonalSubtensor,
+    conv3d,
+    get_diagonal_subtensor_view,
 )
 
-import tests.unittest_tools as utt
-
 
 def test_get_diagonal_subtensor_view(wrap=lambda a: a):
     x = np.arange(20).reshape(5, 4).astype("float32")

tests/tensor/nnet/test_corr.py

-import pytest
 import numpy as np
-import theano
-import theano.tensor as tt
-
+import pytest
 from six import integer_types
-from theano.tensor.nnet import corr, conv
 
+import theano
+import theano.tensor as tt
 from tests import unittest_tools as utt
-from tests.tensor.nnet.test_abstract_conv import (
-    TestGroupedConvNoOptim,
-    TestUnsharedConv,
-)
 from tests.tensor.nnet.test_abstract_conv import (
     TestAsymmetricPadding,
     TestCausalConv,
+    TestGroupedConvNoOptim,
+    TestUnsharedConv,
 )
+from theano.tensor.nnet import conv, corr
 
 
 @pytest.mark.skipif(

tests/tensor/nnet/test_corr3d.py

-import pytest
 import numpy as np
-import theano
-import theano.tensor as tt
-
+import pytest
 from six import integer_types
 
-from theano.tensor.nnet import corr3d, conv
-
+import theano
+import theano.tensor as tt
 from tests import unittest_tools as utt
 from tests.tensor.nnet.test_abstract_conv import TestGroupedConv3dNoOptim
+from theano.tensor.nnet import conv, corr3d
 
 
 @pytest.mark.skipif(

tests/tensor/nnet/test_ctc.py

-import pytest
 import numpy as np
+import pytest
+
 import theano
 import theano.tensor as tt
-
+from tests import unittest_tools as utt
 from theano.tensor.nnet.ctc import (
-    ctc_available,
-    ctc,
     ConnectionistTemporalClassification,
+    ctc,
+    ctc_available,
 )
 
-from tests import unittest_tools as utt
-
 
 def setup_torch_case():
     # Test obtained from Torch tutorial at:

tests/tensor/nnet/test_neighbours.py

-import pytest
 import numpy as np
+import pytest
+
 import theano
 import theano.tensor as tt
-
-from theano import change_flags
-from theano import shared, function
-from theano.tensor.nnet.neighbours import images2neibs, neibs2images, Images2Neibs
-
 from tests import unittest_tools
+from theano import change_flags, function, shared
+from theano.tensor.nnet.neighbours import Images2Neibs, images2neibs, neibs2images
 
 
 mode_without_gpu = theano.compile.mode.get_default_mode().excluding("gpu")

tests/tensor/nnet/test_nnet.py

-import pytest
-
 import numpy as np
+import pytest
 
 import theano
 import theano.tensor as tt
-
-from theano import config
-from theano import gof
+from tests import unittest_tools as utt
+from tests.tensor.test_basic import (
+    _good_broadcast_unary_normal_float_no_complex,
+    check_floatX,
+    makeBroadcastTester,
+    upcast_int8_nfunc,
+)
+from theano import config, gof, printing
 from theano.gof.opt import check_stack_trace
-from theano import printing
+from theano.tensor import lvector, matrix, scalar, vector
 from theano.tensor.nnet import (
+    CrossentropyCategorical1Hot,
+    CrossentropyCategorical1HotGrad,
+    CrossentropySoftmax1HotWithBiasDx,
+    CrossentropySoftmaxArgmax1HotWithBias,
+    Prepend_scalar_constant_to_each_row,
+    Prepend_scalar_to_each_row,
+    Softmax,
+    SoftmaxGrad,
+    SoftmaxWithBias,
+    binary_crossentropy,
     categorical_crossentropy,
+    confusion_matrix,
     crossentropy_categorical_1hot,
     crossentropy_softmax_1hot,
     crossentropy_softmax_1hot_with_bias,
     crossentropy_softmax_1hot_with_bias_dx,
     crossentropy_softmax_argmax_1hot_with_bias,
-    CrossentropySoftmax1HotWithBiasDx,
-    CrossentropySoftmaxArgmax1HotWithBias,
-    CrossentropyCategorical1Hot,
-    CrossentropyCategorical1HotGrad,
-    sigmoid,
-    softplus,
-    Softmax,
-    softmax,
-    softmax_op,
-    softmax_graph,
-    SoftmaxWithBias,
-    softmax_with_bias,
+    elu,
+    h_softmax,
+    logsoftmax,
     logsoftmax_op,
-    softmax_grad,
-    SoftmaxGrad,
-    Prepend_scalar_constant_to_each_row,
-    Prepend_scalar_to_each_row,
     relu,
-    h_softmax,
-    elu,
     selu,
-    binary_crossentropy,
+    sigmoid,
     sigmoid_binary_crossentropy,
-    confusion_matrix,
-    logsoftmax,
-)
-from theano.tensor import matrix, vector, lvector, scalar
-from theano.tensor.nnet.nnet import softsign, LogSoftmax
-
-from tests import unittest_tools as utt
-from tests.tensor.test_basic import (
-    makeBroadcastTester,
-    check_floatX,
-    _good_broadcast_unary_normal_float_no_complex,
-    upcast_int8_nfunc,
+    softmax,
+    softmax_grad,
+    softmax_graph,
+    softmax_op,
+    softmax_with_bias,
+    softplus,
 )
+from theano.tensor.nnet.nnet import LogSoftmax, softsign
 
 
 class TestSigmoid:

tests/tensor/nnet/test_opt.py

 import theano
-
+from tests.unittest_tools import assertFailure_fast
 from theano import tensor
 from theano.gof.opt import check_stack_trace
 from theano.tensor.nnet.blocksparse import (
     sparse_block_dot,
-    sparse_block_gemv_inplace,
-    sparse_block_outer_inplace,
     sparse_block_gemv,
+    sparse_block_gemv_inplace,
     sparse_block_outer,
+    sparse_block_outer_inplace,
 )
 
-from tests.unittest_tools import assertFailure_fast
-
 
 def test_blocksparse_inplace_gemv_opt():
     b = tensor.fmatrix()

tests/tensor/nnet/test_sigm.py

@@ -2,35 +2,33 @@ import numpy as np
 
 import theano
 import theano.tensor as tt
-
+from tests import unittest_tools as utt
+from tests.tensor.test_basic import (
+    _good_broadcast_unary_normal_no_complex,
+    check_floatX,
+    copymod,
+    makeBroadcastTester,
+    upcast_int8_nfunc,
+)
 from theano import config
-from theano.tensor.inplace import neg_inplace
 from theano.gof.opt import check_stack_trace
 from theano.gof.toolbox import is_same_graph
+from theano.tensor.inplace import neg_inplace
 from theano.tensor.nnet import (
+    hard_sigmoid,
     sigmoid,
     sigmoid_inplace,
     softplus,
     ultra_fast_sigmoid,
-    hard_sigmoid,
 )
 from theano.tensor.nnet.sigm import (
+    ScalarSoftplus,
     compute_mul,
     is_1pexp,
     parse_mul_tree,
     perform_sigm_times_exp,
     register_local_1msigmoid,
     simplify_mul,
-    ScalarSoftplus,
-)
-
-from tests import unittest_tools as utt
-from tests.tensor.test_basic import (
-    makeBroadcastTester,
-    copymod,
-    check_floatX,
-    upcast_int8_nfunc,
-    _good_broadcast_unary_normal_no_complex,
 )