add basic tests

theano/gpuarray/tests/test_opt.py

@@ -22,6 +22,30 @@ from ..subtensor import GpuSubtensor
 from ..linalg import GpuCusolverSolve, cusolver_available, GpuCholesky
 
 from .config import mode_with_gpu, mode_without_gpu, test_ctx_name, SkipTest
+import unittest
+from theano.tensor.nnet.abstract_conv import (AbstractConv2d,
+                                              AbstractConv2d_gradInputs,
+                                              AbstractConv2d_gradWeights,
+                                              AbstractConv3d,
+                                              AbstractConv3d_gradWeights,
+                                              AbstractConv3d_gradInputs,
+                                              conv2d,
+                                              conv2d_grad_wrt_weights,
+                                              conv2d_grad_wrt_inputs,
+                                              conv3d,
+                                              conv3d_grad_wrt_weights,
+                                              conv3d_grad_wrt_inputs)
+
+from theano.gpuarray.opt import (local_abstractconv_gemm_alternative,
+                                 local_abstractconv_gemm_gradweights_alt,
+                                 local_abstractconv_gradinputs_gemm_alt,
+                                 local_abstractconv_cudnn_alternative,
+                                 local_abstractconv3d2d,
+                                 local_abstractconv3d_alt,
+                                 local_abstractconv3d_gemm_gradweights_alt,
+                                 local_abstractconv3d_gradinputs_gemm_alt,
+                                 local_abstractconv3d_cudnn_alternative,
+                                 local_conv_gpu_conv)
 
 
 def test_local_assert():
@@ -699,3 +723,112 @@ def test_crossentropycategorical1hot_lifter():
                    for n in f.maker.fgraph.apply_nodes)
     f(rng.uniform(0.1, 0.9, (13, 5)).astype(theano.config.floatX),
       rng.randint(5, size=(13,)))
+
+
+class Conv_opt_test(unittest.TestCase):
+
+    def optimizer_2d(self, input_shapes, direction, optimizer, border_mode='valid',
+                     subsample=(1, 1), filter_dilation=(1, 1)):
+
+        inp1 = theano.shared(np.random.random(input_shapes[0]).astype(theano.config.floatX))
+        inp2 = theano.shared(np.random.random(input_shapes[1]).astype(theano.config.floatX))
+        if(direction == 0):
+            abstract_op = AbstractConv2d
+            conv_op = conv2d(inp1,
+                             inp2,
+                             border_mode=border_mode,
+                             subsample=subsample,
+                             filter_dilation=filter_dilation)
+
+        if(direction == 1):
+            abstract_op = AbstractConv2d_gradWeights
+            conv_op = conv2d_grad_wrt_weights(inp1,
+                                              inp2,
+                                              input_shapes[2],
+                                              border_mode=border_mode,
+                                              subsample=subsample,
+                                              filter_dilation=filter_dilation)
+
+        if(direction == 2):
+            abstract_op = AbstractConv2d_gradInputs
+            conv_op = conv2d_grad_wrt_inputs(inp1,
+                                             inp2,
+                                             input_shapes[2],
+                                             border_mode=border_mode,
+                                             subsample=subsample,
+                                             filter_dilation=filter_dilation)
+
+        ref_func = theano.function([], conv_op)
+        conv_node = conv_op.owner
+
+        if isinstance(conv_node.op, abstract_op):
+            conv_op = local_conv_gpu_conv.transform(conv_node)
+
+        if isinstance(conv_node.op, abstract_op):
+            conv_op = optimizer.transform(conv_op[0].owner.inputs[0].owner)
+
+        conv_func = theano.function([], conv_op[0])
+        assert not any([isinstance(node.op, abstract_op)
+                       for node in conv_func.maker.fgraph.toposort()])
+        utt.assert_allclose(conv_func(), ref_func())
+
+    def optimizer_3d(self, input_shapes, direction, optimizer, border_mode='valid',
+                     subsample=(1, 1, 1), filter_dilation=(1, 1, 1)):
+        inp1 = theano.shared(np.random.random(input_shapes[0]).astype(theano.config.floatX))
+        inp2 = theano.shared(np.random.random(input_shapes[1]).astype(theano.config.floatX))
+        if(direction == 0):
+            abstract_op = AbstractConv3d
+            conv_op = conv3d(inp1, inp2)
+
+        if(direction == 1):
+            abstract_op = AbstractConv3d_gradWeights
+            conv_op = conv3d_grad_wrt_weights(inp1, inp2, input_shapes[2])
+
+        if(direction == 2):
+            abstract_op = AbstractConv3d_gradInputs
+            conv_op = conv3d_grad_wrt_inputs(inp1, inp2, input_shapes[2])
+
+        ref_func = theano.function([], conv_op)
+        conv_node = conv_op.owner
+
+        if isinstance(conv_node.op, abstract_op):
+            conv_op = local_conv_gpu_conv.transform(conv_node)
+
+        if isinstance(conv_node.op, abstract_op):
+            conv_op = optimizer.transform(conv_op[0].owner.inputs[0].owner)
+
+        conv_func = theano.function([], conv_op[0])
+        assert not any([isinstance(node.op, abstract_op)
+                       for node in conv_func.maker.fgraph.toposort()])
+        utt.assert_allclose(conv_func(), ref_func())
+
+    def test_optimizers(self):
+        self.optimizer_2d([(2, 3, 5, 5), (4, 3, 3, 3), (2, 4, 3, 3)], 0,
+                          local_abstractconv_gemm_alternative)
+        self.optimizer_2d([(2, 3, 5, 5), (2, 4, 3, 3), (4, 3, 3, 3)], 1,
+                          local_abstractconv_gemm_gradweights_alt)
+        self.optimizer_2d([(2, 4, 3, 3), (4, 3, 3, 3), (2, 3, 5, 5)], 2,
+                          local_abstractconv_gradinputs_gemm_alt)
+        self.optimizer_2d([(2, 3, 5, 5), (4, 3, 3, 3), (2, 4, 3, 3)], 0,
+                          local_abstractconv_cudnn_alternative)
+        self.optimizer_2d([(2, 3, 5, 5), (2, 4, 3, 3), (4, 3, 3, 3)], 1,
+                          local_abstractconv_cudnn_alternative)
+        self.optimizer_2d([(2, 4, 3, 3), (4, 3, 3, 3), (2, 3, 5, 5)], 2,
+                          local_abstractconv_cudnn_alternative)
+        self.optimizer_3d([(2, 3, 5, 5, 5), (4, 3, 3, 3, 3), (2, 4, 3, 3, 3)], 0,
+                          local_abstractconv3d_alt)
+        self.optimizer_3d([(2, 3, 5, 5, 5), (4, 3, 3, 3, 3), (2, 4, 3, 3, 3)], 0,
+                          local_abstractconv3d2d)
+        self.optimizer_3d([(2, 3, 5, 5, 5), (2, 4, 3, 3, 3), (4, 3, 3, 3, 3)], 1,
+                          local_abstractconv3d_gemm_gradweights_alt)
+        self.optimizer_3d([(2, 4, 3, 3, 3), (4, 3, 3, 3, 3), (2, 3, 5, 5, 5)], 2,
+                          local_abstractconv3d_gradinputs_gemm_alt)
+        '''
+        will fail until bug is fixed
+        self.optimizer_3d([(2, 3, 5, 5, 5), (4, 3, 3, 3, 3), (2, 4, 3, 3, 3)], 0,
+                          local_abstractconv3d_cudnn_alternative)
+        '''
+        self.optimizer_3d([(2, 3, 5, 5, 5), (2, 4, 3, 3, 3), (4, 3, 3, 3, 3)], 1,
+                          local_abstractconv3d_cudnn_alternative)
+        self.optimizer_3d([(2, 4, 3, 3, 3), (4, 3, 3, 3, 3), (2, 3, 5, 5, 5)], 2,
+                          local_abstractconv3d_cudnn_alternative)