-added GpuConv.version that allow to specify the version to use and set everything to make it work.

theano/sandbox/conv.py

@@ -336,7 +336,9 @@ class ConvOp(Op):
                     unroll_batch=un_b, unroll_kern=un_k,
                     imshp_logical=imshp_logical,
                     kshp_logical=kshp_logical,
-                    kshp_logical_top_aligned=kshp_logical_top_aligned)
+                    kshp_logical_top_aligned=kshp_logical_top_aligned,
+                    version=self.version,
+                    verbose=self.verbose)
         if hasattr(self,'flops'):
             dw.set_flops()
         dw = dw(img,filters)
@@ -357,7 +359,9 @@ class ConvOp(Op):
                      1,1, output_mode=mode,
                      unroll_batch=un_b, unroll_kern=un_k,
                      imshp_logical=(self.nkern, self.fulloutshp[0], self.fulloutshp[1]),
-                     kshp_logical=None)
+                     kshp_logical=None,
+                     version=self.version,
+                     verbose=self.verbose)
         if hasattr(self,'flops'):
             din.set_flops()
         din = din(gz,filters)

theano/sandbox/cuda/blas.py

@@ -131,6 +131,7 @@ class GpuConv(Op):
             logical_img_hw=None, 
             logical_kern_hw=None,
             logical_kern_align_top=True,
+            version=-1,
             verbose=0):
         self.border_mode = border_mode
         self.subsample = subsample
@@ -147,6 +148,7 @@ class GpuConv(Op):
             # grid
         self.logical_kern_hw = tuple(logical_kern_hw)
         self.logical_kern_align_top = logical_kern_align_top
+        self.version=version
         self.verbose=verbose
 
     def __eq__(self, other):
@@ -190,6 +192,7 @@ class GpuConv(Op):
                 logical_img_shape=self.logical_img_hw,
                 logical_kern_shape=self.logical_kern_hw,
                 kern_align=self.logical_kern_align_top,
+                version=self.version,
                 verbose=self.verbose)
 
 class GpuDownsampleFactorMax(Op):

theano/sandbox/cuda/opt.py

@@ -314,6 +314,7 @@ def local_gpu_conv(node):
                     logical_img_hw=op.imshp_logical[1:3],
                     logical_kern_hw=op.kshp_logical,
                     logical_kern_align_top=op.kshp_logical_top_aligned,
+                    version=op.version,
                     verbose=op.verbose
                     )
         #HACK to print the number of MFlops in the profiler output.

theano/sandbox/cuda/tests/test_nnet.py

@@ -238,7 +238,7 @@ def test_conv_nnet2():
         assert numpy.allclose(rval_cpu, rval_gpu,rtol=1e-4,atol=1e-4)
 
 def run_conv_nnet2_classif(shared_fn, isize, ksize, n_batch, n_iter,
-                           downsample_ops=True, verbose=0):
+                           downsample_ops=True, verbose=0, version=-1):
     isize1=isize
     isize2=isize
     if isinstance(isize,(tuple,)):
@@ -276,10 +276,10 @@ def run_conv_nnet2_classif(shared_fn, isize, ksize, n_batch, n_iter,
     lr = tensor.fscalar('lr')
 
     conv_op = theano.sandbox.conv.ConvOp(shape_img[2:], shape_kern[2:], n_kern,
-                                         n_batch, 1, 1, verbose=verbose)
+                                         n_batch, 1, 1, verbose=verbose, version=version)
     conv_op1 = theano.sandbox.conv.ConvOp(
         (n_kern,logical_hid_shape[0]/2, logical_hid_shape[1]/2),
-        shape_kern1[2:], n_kern1, n_batch, 1, 1,verbose=verbose)
+        shape_kern1[2:], n_kern1, n_batch, 1, 1,verbose=verbose, version=version)
     conv_op.set_flops()
     conv_op1.set_flops()
 
@@ -326,7 +326,8 @@ def cmp_run_conv_nnet2_classif(seed, isize, ksize, bsize,
                                float_atol=1e-08,
                                check_isfinite=True,
                                pickle=False,
-                               verbose=0):
+                               verbose=0,
+                               version=-1):
     """
        float_atol: None mean use the default value.
        check_isfinite: the debug mode option. We forward this value to debug mode.
@@ -349,7 +350,7 @@ def cmp_run_conv_nnet2_classif(seed, isize, ksize, bsize,
             theano.tensor.basic.float32_atol=float_atol
         if not cpu_only:
             rval_gpu, tg, gpu_mode = run_conv_nnet2_classif(
-                tcn.shared_constructor, isize, ksize, bsize, n_iter, verbose)
+                tcn.shared_constructor, isize, ksize, bsize, n_iter, verbose=verbose, version=version)
     finally:
         predefined_modes["DEBUG_MODE"].check_isfinite = orig_check_isfinite
         theano.tensor.basic.float32_atol=orig_float32_atol
@@ -361,7 +362,8 @@ def cmp_run_conv_nnet2_classif(seed, isize, ksize, bsize,
     try:
         predefined_modes["DEBUG_MODE"].check_isfinite = check_isfinite
         numpy.random.seed(seed)
-        rval_cpu, tc, cpu_mode = run_conv_nnet2_classif(shared, isize, ksize, bsize, n_iter, verbose)
+        rval_cpu, tc, cpu_mode = run_conv_nnet2_classif(shared, isize, ksize, bsize, n_iter,
+                                                        verbose=verbose, version=version)
         if pickle and isinstance(cpu_mode,(theano.compile.ProfileMode,)):
             import pickle
             print "BEGIN GPU profile mode dump"
@@ -392,24 +394,25 @@ def cmp_run_conv_nnet2_classif(seed, isize, ksize, bsize,
 gpu_only=False
 cpu_only=False
 ignore_error=False
-verbose=0
+verbose=1
+version=-1
 
 def test_lenet_28(): #MNIST
     cmp_run_conv_nnet2_classif(23485, 28, 5, 60, n_iter=10,
                                ignore_error=ignore_error, gpu_only=gpu_only,
-                               cpu_only=cpu_only, verbose=verbose)
+                               cpu_only=cpu_only, verbose=verbose, version=version)
 
 def test_lenet_32(): #CIFAR10 / Shapeset
     cmp_run_conv_nnet2_classif(23485, 32, 5, 60, n_iter=10,
                                ignore_error=ignore_error, gpu_only=gpu_only,
-                               verbose=verbose)
+                               verbose=verbose, version=version)
 
 def test_lenet_32_long(): #CIFAR10 / Shapeset
     # this tests the gradient of downsample on the GPU, 
     # which does not recieve specific testing
     cmp_run_conv_nnet2_classif(23485, 32, 5, 30, n_iter=50,
                                ignore_error=ignore_error, gpu_only=gpu_only,
-                               cpu_only=cpu_only, verbose=verbose)
+                               cpu_only=cpu_only, verbose=verbose, version=version)
 
 def test_lenet_64(): # ???
     #float_atol need to pass in debug mode
@@ -417,30 +420,30 @@ def test_lenet_64(): # ???
     cmp_run_conv_nnet2_classif(23485, 64, 7, 10, n_iter=10,
                                ignore_error=ignore_error, gpu_only=gpu_only,
                                cpu_only=cpu_only, verbose=verbose,
-                               float_atol=5e-4, check_isfinite=True)
+                               float_atol=5e-4, check_isfinite=True, version=version)
 
 def test_lenet_108(): # NORB
     cmp_run_conv_nnet2_classif(23485, 108, 7, 10, n_iter=5,
                                ignore_error=ignore_error, gpu_only=gpu_only,
                                cpu_only=cpu_only, verbose=verbose,
-                               check_isfinite=True)
+                               check_isfinite=True, version=version)
 
 def test_lenet_256(): # ImageNet
     cmp_run_conv_nnet2_classif(23485, 256, 9, 2, n_iter=3,
                                ignore_error=ignore_error, gpu_only=gpu_only,
                                cpu_only=cpu_only, verbose=verbose,
-                               check_isfinite=True)
+                               check_isfinite=True, version=version)
 
 #I did a wanted error in the name as we don't want it to execute automatically for now as it don't work
 def tes_lenet_hd(): #HD 720p: 1280(wid)x720(len)
     cmp_run_conv_nnet2_classif(23485, (720,1280), 9, 2, n_iter=3,
                                ignore_error=ignore_error, gpu_only=gpu_only,
                                cpu_only=cpu_only, verbose=verbose,
-                               check_isfinite=True)
+                               check_isfinite=True, version=version)
 
 #I did a wanted error in the name as we don't want it to execute automatically for now as it don't work
 def tes_lenet_full_hd(): #HD 1080p: 1920(wid)x1080(len)
     cmp_run_conv_nnet2_classif(23485, (1080,1920), 9, 2, n_iter=3,
                                ignore_error=ignore_error, gpu_only=gpu_only,
                                cpu_only=cpu_only, verbose=verbose,
-                               check_isfinite=True)
+                               check_isfinite=True, version=version)