Remove unused variable theta from GpuDnnTransformerGradI

theano/gpuarray/c_code/dnn_sptf_gi.c

@@ -55,7 +55,6 @@ if ( APPLY_SPECIFIC(dydesc) != NULL )
 
 int
 APPLY_SPECIFIC(dnn_sptf_gi)(PyGpuArrayObject * input,
-                            PyGpuArrayObject * theta,
                             PyGpuArrayObject * grid,
                             PyGpuArrayObject * dy,
                             cudnnSpatialTransformerDescriptor_t desc,
@@ -93,15 +92,6 @@ APPLY_SPECIFIC(dnn_sptf_gi)(PyGpuArrayObject * input,
         return -1;
     }
 
-    if ( theta->ga.typecode != GA_FLOAT &&
-         theta->ga.typecode != GA_DOUBLE &&
-         theta->ga.typecode != GA_HALF )
-    {
-        PyErr_SetString( PyExc_TypeError,
-            "GpuDnnTransformerGradI: unsupported data type for theta in spatial transformer gradients." );
-        return -1;
-    }
-
     if ( grid->ga.typecode != GA_FLOAT &&
          grid->ga.typecode != GA_DOUBLE &&
          grid->ga.typecode != GA_HALF )
@@ -138,7 +128,6 @@ APPLY_SPECIFIC(dnn_sptf_gi)(PyGpuArrayObject * input,
     cuda_enter( gpu_ctx->ctx );
 
     cuda_wait( input->ga.data, GPUARRAY_CUDA_WAIT_READ );
-    cuda_wait( theta->ga.data, GPUARRAY_CUDA_WAIT_READ );
     cuda_wait( grid->ga.data, GPUARRAY_CUDA_WAIT_READ );
     cuda_wait( dy->ga.data, GPUARRAY_CUDA_WAIT_READ );
     cuda_wait( (*input_grad)->ga.data, GPUARRAY_CUDA_WAIT_WRITE );
@@ -151,7 +140,6 @@ APPLY_SPECIFIC(dnn_sptf_gi)(PyGpuArrayObject * input,
         PyGpuArray_DEV_DATA( *grid_grad ) );
 
     cuda_record( input->ga.data, GPUARRAY_CUDA_WAIT_READ );
-    cuda_record( theta->ga.data, GPUARRAY_CUDA_WAIT_READ );
     cuda_record( grid->ga.data, GPUARRAY_CUDA_WAIT_READ );
     cuda_record( dy->ga.data, GPUARRAY_CUDA_WAIT_READ );
     cuda_record( (*input_grad)->ga.data, GPUARRAY_CUDA_WAIT_WRITE );

theano/gpuarray/dnn.py

@@ -2936,11 +2936,11 @@ class GpuDnnTransformer(DnnBase):
         return Apply(self, inputs, outputs)
 
     def L_op(self, inputs, outputs, grads):
-        img, theta, grid_dims, desc = inputs
+        img, _, grid_dims, desc = inputs
         _, grid = outputs
         dy = grads[0]
 
-        dimg, dgrid = GpuDnnTransformerGradI()(img, theta, grid, dy, desc)
+        dimg, dgrid = GpuDnnTransformerGradI()(img, grid, dy, desc)
         dtheta = GpuDnnTransformerGradT()(dgrid, desc)
         dgrid_dims = grad_not_implemented(self, grid_dims, 2)
 
@@ -2956,15 +2956,15 @@ class GpuDnnTransformerGradI(DnnBase):
     Gradients of inputs of the spatial transformer
     """
     __props__ = ()
-    _cop_num_inputs = 5
+    _cop_num_inputs = 4
     _cop_num_outputs = 2
     _f16_ok = True
 
     def __init__(self, dtype=theano.config.floatX):
         DnnBase.__init__(self, ["c_code/dnn_sptf_gi.c"], "APPLY_SPECIFIC(dnn_sptf_gi)")
 
-    def make_node(self, img, theta, grid, dy, desc):
-        context_name = infer_context_name(img, theta, grid, dy, desc)
+    def make_node(self, img, grid, dy, desc):
+        context_name = infer_context_name(img, grid, dy, desc)
 
         if (not isinstance(desc.type, CDataType) or
                 desc.type.ctype != 'cudnnSpatialTransformerDescriptor_t'):
@@ -2974,10 +2974,6 @@ class GpuDnnTransformerGradI(DnnBase):
         if img.ndim != 4:
             raise TypeError('img must have 4 dimensions.')
 
-        theta = as_gpuarray_variable(gpu_contiguous(theta), context_name)
-        if theta.ndim != 3:
-            raise TypeError('theta must have 3 dimensions')
-
         grid = as_gpuarray_variable(gpu_contiguous(grid), context_name)
         if img.ndim != grid.ndim:
             raise TypeError('grid should have the same number of dimensions as img')
@@ -2989,25 +2985,24 @@ class GpuDnnTransformerGradI(DnnBase):
         dimg = img.type()
         dgrid = grid.type()
 
-        inputs = [img, theta, grid, dy, desc]
+        inputs = [img, grid, dy, desc]
         outputs = [dimg, dgrid]
 
         return Apply(self, inputs, outputs)
 
     def L_op(self, inputs, outputs, grads):
-        img, theta, grid, dy, desc = inputs
+        img, grid, dy, desc = inputs
         dimg_out, dgrid = outputs
         grad_cost = grads[0]
 
         dimg = dimg_out * grad_cost
-        dtheta = GpuDnnTransformerGradT()(dgrid, desc)
-        d_dy = grad_not_implemented(self, dy, 3)
+        d_dy = grad_not_implemented(self, dy, 2)
 
-        return [dimg, dtheta, dgrid, d_dy, DisconnectedType()()]
+        return [dimg, dgrid, d_dy, DisconnectedType()()]
 
     def connection_pattern(self, node):
         # not connected to desc
-        return [[1, 1], [1, 1], [1, 1], [1, 1], [0, 0]]
+        return [[1, 1], [1, 1], [1, 1], [0, 0]]
 
 
 class GpuDnnTransformerGradT(DnnBase):