def apply(self, input_): stride = self.stride if not stride: stride = self.pooling_size return dnn_pool(input_, ws=self.pooling_size, stride=stride, pad=self.pad)
def apply(self, input_): stride = self.stride if not stride: stride = self.pooling_size return dnn_pool(input_, ws=self.pooling_size, stride=stride, pad=self.pad, mode='average_inc_pad')
def local_gpua_pool_dnn_alternative(fgraph, op, ctx_name, inputs, outputs): if not dnn_available(ctx_name): return if not op.ignore_border: return img, ws, stride, pad = inputs nd = op.ndim if nd not in (2, 3): return img = gpu_contiguous(as_gpuarray_variable(img, ctx_name)) mode = op.mode # dnn_pool expects exactly 2 non-pooling dimensions if img.ndim == nd + 2: return dnn_pool(img, ws, stride=stride, pad=pad, mode=mode) else: # reshape to 4D or 5D with 2 non-pooling dimensions img_padded = pad_dims(img, 2, nd) ret_padded = dnn_pool(img_padded, ws, stride=stride, pad=pad, mode=mode) return unpad_dims(ret_padded, img, 2, nd)
def apply(self, input_): stride = self.stride if not stride: stride = self.pooling_size inter = input_**2 inter = dnn_pool(inter, ws=self.pooling_size, stride=stride, pad=self.pad, mode='average_inc_pad') return T.sqrt(inter)
def get_output_for(self, input, **kwargs): input_size = tuple( symb if fixed is None else fixed for fixed, symb in zip(self.input_shape[2:], input.shape[2:])) pool_list = [] for pool_dim in self.pool_dims: win_size = tuple( (i + pool_dim - 1) // pool_dim for i in input_size) str_size = tuple(i // pool_dim for i in input_size) pool = dnn.dnn_pool(input, win_size, str_size, self.mode, (0, 0)) pool = pool.flatten(3) pool_list.append(pool) return theano.tensor.concatenate(pool_list, axis=2)
def local_mypool_dnn_alternative(node): if not dnn_available(): return if isinstance(node.op, MyPool): if not node.op.ignore_border: return img, = node.inputs ds = node.op.ds stride = node.op.st pad = node.op.padding mode = node.op.mode if (img.owner and isinstance(img.owner.op, HostFromGpu)): ret = dnn_pool(gpu_contiguous(img.owner.inputs[0]), ds, stride=stride, pad=pad, mode=mode) return [host_from_gpu(ret)]
def __init__(self, input, poolsize, poolstride, poolpad, mode = 'max', printinfo=True, input_shape=None,output_shape=None): self.get_input_shape(input,input_shape) self.poolsize = poolsize self.poolstride = poolstride self.poolpad = poolpad if self.poolsize != 1: self.output = dnn.dnn_pool(self.input, ws=(poolsize, poolsize), stride=(poolstride, poolstride), mode=mode, pad=(poolpad, poolpad)) else: self.output = input if output_shape: self.output_shape = output_shape else: self.output_shape = self.get_output_shape(self.input_shape) self.name = 'Pool\t' if printinfo: self.print_shape()
def __init__(self, input, image_shape, filter_shape, convstride, padsize, group, poolsize, poolstride, bias_init, lrn=False, lib_conv='cudnn', verbose=False): ''' lib_conv can be cudnn (recommended)or cudaconvnet ''' self.filter_size = filter_shape self.convstride = convstride self.padsize = padsize self.poolsize = poolsize self.poolstride = poolstride self.channel = image_shape[0] self.lrn = lrn self.lib_conv = lib_conv self.verbose = verbose assert group in [1, 2] self.filter_shape = np.asarray(filter_shape) self.image_shape = np.asarray(image_shape) if self.lrn: self.lrn_func = CrossChannelNormalization() if group == 1: self.W = Weight(self.filter_shape) self.b = Weight(self.filter_shape[3], bias_init, std=0) else: self.filter_shape[0] = self.filter_shape[0] / 2 self.filter_shape[3] = self.filter_shape[3] / 2 self.image_shape[0] = self.image_shape[0] / 2 self.image_shape[3] = self.image_shape[3] / 2 self.W0 = Weight(self.filter_shape) self.W1 = Weight(self.filter_shape) self.b0 = Weight(self.filter_shape[3], bias_init, std=0) self.b1 = Weight(self.filter_shape[3], bias_init, std=0) if lib_conv == 'cudnn': input_shuffled = input.dimshuffle(3, 0, 1, 2) # c01b to bc01 # in01out to outin01 # print image_shape_shuffled # print filter_shape_shuffled if group == 1: W_shuffled = self.W.val.dimshuffle(3, 0, 1, 2) # c01b to bc01 conv_out = dnn.dnn_conv( img=input_shuffled, kerns=W_shuffled, subsample=(convstride, convstride), border_mode=padsize, ) conv_out = conv_out + self.b.val.dimshuffle('x', 0, 'x', 'x') else: W0_shuffled = \ self.W0.val.dimshuffle(3, 0, 1, 2) # c01b to bc01 conv_out0 = \ dnn.dnn_conv(img=input_shuffled[:, :self.channel / 2, :, :], kerns=W0_shuffled, subsample=(convstride, convstride), border_mode=padsize, ) conv_out0 = conv_out0 + \ self.b0.val.dimshuffle('x', 0, 'x', 'x') W1_shuffled = \ self.W1.val.dimshuffle(3, 0, 1, 2) # c01b to bc01 conv_out1 = \ dnn.dnn_conv(img=input_shuffled[:, self.channel / 2:, :, :], kerns=W1_shuffled, subsample=(convstride, convstride), border_mode=padsize, ) conv_out1 = conv_out1 + \ self.b1.val.dimshuffle('x', 0, 'x', 'x') conv_out = T.concatenate([conv_out0, conv_out1], axis=1) # ReLu self.output = T.maximum(conv_out, 0) # Pooling if self.poolsize != 1: self.output = dnn.dnn_pool(self.output, ws=(poolsize, poolsize), stride=(poolstride, poolstride)) self.output = self.output.dimshuffle(1, 2, 3, 0) # bc01 to c01b # elif lib_conv == 'cudaconvnet': # from pylearn2.sandbox.cuda_convnet.filter_acts import FilterActs # # self.conv_op = FilterActs(pad=self.padsize, stride=self.convstride, # partial_sum=1) # # from theano.sandbox.cuda.basic_ops import gpu_contiguous # # # Conv # if group == 1: # contiguous_input = gpu_contiguous(input) # contiguous_filters = gpu_contiguous(self.W.val) # conv_out = self.conv_op(contiguous_input, contiguous_filters) # conv_out = conv_out + self.b.val.dimshuffle(0, 'x', 'x', 'x') # else: # contiguous_input0 = gpu_contiguous( # input[:self.channel / 2, :, :, :]) # contiguous_filters0 = gpu_contiguous(self.W0.val) # conv_out0 = self.conv_op( # contiguous_input0, contiguous_filters0) # conv_out0 = conv_out0 + \ # self.b0.val.dimshuffle(0, 'x', 'x', 'x') # # contiguous_input1 = gpu_contiguous( # input[self.channel / 2:, :, :, :]) # contiguous_filters1 = gpu_contiguous(self.W1.val) # conv_out1 = self.conv_op( # contiguous_input1, contiguous_filters1) # conv_out1 = conv_out1 + \ # self.b1.val.dimshuffle(0, 'x', 'x', 'x') # conv_out = T.concatenate([conv_out0, conv_out1], axis=0) # # # ReLu # conv_out = gpu_contiguous(conv_out) # self.output = T.maximum(conv_out, 0) # # # Pooling # if self.poolsize != 1: # from pylearn2.sandbox.cuda_convnet.pool import MaxPool # self.pool_op = MaxPool(ds=poolsize, stride=poolstride) # self.output = self.pool_op(self.output) # # elif lib_conv == 'corrmm': # # from theano.sandbox.cuda.basic_ops import gpu_contiguous # from theano.sandbox.cuda.blas import GpuCorrMM # # border_mode = 'half' if padsize == (filter_shape[1]-1)/2 else (padsize, padsize) # self.corr_mm_op = GpuCorrMM(subsample=(convstride,convstride), # border_mode=border_mode) # flip_filters=True # input_shuffled = input.dimshuffle(3, 0, 1, 2) # c01b to bc01 # # # if group==1: # # filters = self.W.val.dimshuffle(3, 0, 1, 2) # # if flip_filters: # filters = filters[:, :, ::-1, ::-1] # flip top-down, left-right # contiguous_filters = gpu_contiguous(filters) # contiguous_input = gpu_contiguous(input_shuffled) # # conv_out = self.corr_mm_op(contiguous_input, contiguous_filters) # conv_out = conv_out + self.b.val.dimshuffle('x', 0, 'x', 'x') # # else: # # W0_shuffled = \ # self.W0.val.dimshuffle(3, 0, 1, 2) # c01b to bc01 # if flip_filters: # W0_shuffled = W0_shuffled[:, :, ::-1, ::-1] # # contiguous_filters0 = gpu_contiguous(W0_shuffled) # contiguous_input0 = gpu_contiguous(input_shuffled[:, :self.channel / 2,:, :]) # # conv_out0 = self.corr_mm_op(contiguous_input0, contiguous_filters0) # conv_out0 = conv_out0 + \ # self.b0.val.dimshuffle('x', 0, 'x', 'x') # # W1_shuffled = \ # self.W1.val.dimshuffle(3, 0, 1, 2) # c01b to bc01 # if flip_filters: # W1_shuffled = W1_shuffled[:, :, ::-1, ::-1] # # contiguous_filters1 = gpu_contiguous(W1_shuffled) # contiguous_input1 = gpu_contiguous(input_shuffled[:, self.channel / 2:,:, :]) # # conv_out1 = self.corr_mm_op(contiguous_input1, contiguous_filters1) # conv_out1 = conv_out1 + \ # self.b1.val.dimshuffle('x', 0, 'x', 'x') # conv_out = T.concatenate([conv_out0, conv_out1], axis=1) # # # ReLu # self.output = T.maximum(conv_out, 0) # # # Pooling # if self.poolsize != 1: # from theano.tensor.signal import downsample # self.output = downsample.max_pool_2d(self.output, # ds=(poolsize,poolsize), # st=(poolstride,poolstride), # ignore_border=False, # padding=(0,0), # mode='max', # ) # # self.output = self.output.dimshuffle(1, 2, 3, 0) # bc01 to c01b else: NotImplementedError("lib_conv can only be cudnn for now") # LRN if self.lrn: # lrn_input = gpu_contiguous(self.output) self.output = self.lrn_func(self.output) if group == 1: self.params = [self.W.val, self.b.val] self.weight_type = ['W', 'b'] else: self.params = [self.W0.val, self.b0.val, self.W1.val, self.b1.val] self.weight_type = ['W', 'b', 'W', 'b'] if self.verbose: print "conv ({}) layer with shape_in: {}".format( lib_conv, str(image_shape))
def get_output_for(self, input, **kwargs): return dnn.dnn_pool(input, self.pool_size, self.stride, self.mode, self.pad)
def __init__(self, input, image_shape, filter_shape, convstride, padsize, group, poolsize, poolstride, bias_init, lrn=False, lib_conv='cudnn', verbose=False ): ''' lib_conv can be cudnn (recommended)or cudaconvnet ''' self.filter_size = filter_shape self.convstride = convstride self.padsize = padsize self.poolsize = poolsize self.poolstride = poolstride self.channel = image_shape[0] self.lrn = lrn self.lib_conv = lib_conv self.verbose = verbose assert group in [1, 2] self.filter_shape = np.asarray(filter_shape) self.image_shape = np.asarray(image_shape) if self.lrn: self.lrn_func = CrossChannelNormalization() if group == 1: self.W = Weight(self.filter_shape) self.b = Weight(self.filter_shape[3], bias_init, std=0) else: self.filter_shape[0] = self.filter_shape[0] / 2 self.filter_shape[3] = self.filter_shape[3] / 2 self.image_shape[0] = self.image_shape[0] / 2 self.image_shape[3] = self.image_shape[3] / 2 self.W0 = Weight(self.filter_shape) self.W1 = Weight(self.filter_shape) self.b0 = Weight(self.filter_shape[3], bias_init, std=0) self.b1 = Weight(self.filter_shape[3], bias_init, std=0) if lib_conv == 'cudnn': input_shuffled = input.dimshuffle(3, 0, 1, 2) # c01b to bc01 # in01out to outin01 # print image_shape_shuffled # print filter_shape_shuffled if group == 1: W_shuffled = self.W.val.dimshuffle(3, 0, 1, 2) # c01b to bc01 conv_out = dnn.dnn_conv(img=input_shuffled, kerns=W_shuffled, subsample=(convstride, convstride), border_mode=padsize, ) conv_out = conv_out + self.b.val.dimshuffle('x', 0, 'x', 'x') else: W0_shuffled = \ self.W0.val.dimshuffle(3, 0, 1, 2) # c01b to bc01 conv_out0 = \ dnn.dnn_conv(img=input_shuffled[:, :self.channel / 2, :, :], kerns=W0_shuffled, subsample=(convstride, convstride), border_mode=padsize, ) conv_out0 = conv_out0 + \ self.b0.val.dimshuffle('x', 0, 'x', 'x') W1_shuffled = \ self.W1.val.dimshuffle(3, 0, 1, 2) # c01b to bc01 conv_out1 = \ dnn.dnn_conv(img=input_shuffled[:, self.channel / 2:, :, :], kerns=W1_shuffled, subsample=(convstride, convstride), border_mode=padsize, ) conv_out1 = conv_out1 + \ self.b1.val.dimshuffle('x', 0, 'x', 'x') conv_out = T.concatenate([conv_out0, conv_out1], axis=1) # ReLu self.output = T.maximum(conv_out, 0) # Pooling if self.poolsize != 1: self.output = dnn.dnn_pool(self.output, ws=(poolsize, poolsize), stride=(poolstride, poolstride)) self.output = self.output.dimshuffle(1, 2, 3, 0) # bc01 to c01b # elif lib_conv == 'cudaconvnet': # from pylearn2.sandbox.cuda_convnet.filter_acts import FilterActs # # self.conv_op = FilterActs(pad=self.padsize, stride=self.convstride, # partial_sum=1) # # from theano.sandbox.cuda.basic_ops import gpu_contiguous # # # Conv # if group == 1: # contiguous_input = gpu_contiguous(input) # contiguous_filters = gpu_contiguous(self.W.val) # conv_out = self.conv_op(contiguous_input, contiguous_filters) # conv_out = conv_out + self.b.val.dimshuffle(0, 'x', 'x', 'x') # else: # contiguous_input0 = gpu_contiguous( # input[:self.channel / 2, :, :, :]) # contiguous_filters0 = gpu_contiguous(self.W0.val) # conv_out0 = self.conv_op( # contiguous_input0, contiguous_filters0) # conv_out0 = conv_out0 + \ # self.b0.val.dimshuffle(0, 'x', 'x', 'x') # # contiguous_input1 = gpu_contiguous( # input[self.channel / 2:, :, :, :]) # contiguous_filters1 = gpu_contiguous(self.W1.val) # conv_out1 = self.conv_op( # contiguous_input1, contiguous_filters1) # conv_out1 = conv_out1 + \ # self.b1.val.dimshuffle(0, 'x', 'x', 'x') # conv_out = T.concatenate([conv_out0, conv_out1], axis=0) # # # ReLu # conv_out = gpu_contiguous(conv_out) # self.output = T.maximum(conv_out, 0) # # # Pooling # if self.poolsize != 1: # from pylearn2.sandbox.cuda_convnet.pool import MaxPool # self.pool_op = MaxPool(ds=poolsize, stride=poolstride) # self.output = self.pool_op(self.output) # # elif lib_conv == 'corrmm': # # from theano.sandbox.cuda.basic_ops import gpu_contiguous # from theano.sandbox.cuda.blas import GpuCorrMM # # border_mode = 'half' if padsize == (filter_shape[1]-1)/2 else (padsize, padsize) # self.corr_mm_op = GpuCorrMM(subsample=(convstride,convstride), # border_mode=border_mode) # flip_filters=True # input_shuffled = input.dimshuffle(3, 0, 1, 2) # c01b to bc01 # # # if group==1: # # filters = self.W.val.dimshuffle(3, 0, 1, 2) # # if flip_filters: # filters = filters[:, :, ::-1, ::-1] # flip top-down, left-right # contiguous_filters = gpu_contiguous(filters) # contiguous_input = gpu_contiguous(input_shuffled) # # conv_out = self.corr_mm_op(contiguous_input, contiguous_filters) # conv_out = conv_out + self.b.val.dimshuffle('x', 0, 'x', 'x') # # else: # # W0_shuffled = \ # self.W0.val.dimshuffle(3, 0, 1, 2) # c01b to bc01 # if flip_filters: # W0_shuffled = W0_shuffled[:, :, ::-1, ::-1] # # contiguous_filters0 = gpu_contiguous(W0_shuffled) # contiguous_input0 = gpu_contiguous(input_shuffled[:, :self.channel / 2,:, :]) # # conv_out0 = self.corr_mm_op(contiguous_input0, contiguous_filters0) # conv_out0 = conv_out0 + \ # self.b0.val.dimshuffle('x', 0, 'x', 'x') # # W1_shuffled = \ # self.W1.val.dimshuffle(3, 0, 1, 2) # c01b to bc01 # if flip_filters: # W1_shuffled = W1_shuffled[:, :, ::-1, ::-1] # # contiguous_filters1 = gpu_contiguous(W1_shuffled) # contiguous_input1 = gpu_contiguous(input_shuffled[:, self.channel / 2:,:, :]) # # conv_out1 = self.corr_mm_op(contiguous_input1, contiguous_filters1) # conv_out1 = conv_out1 + \ # self.b1.val.dimshuffle('x', 0, 'x', 'x') # conv_out = T.concatenate([conv_out0, conv_out1], axis=1) # # # ReLu # self.output = T.maximum(conv_out, 0) # # # Pooling # if self.poolsize != 1: # from theano.tensor.signal import downsample # self.output = downsample.max_pool_2d(self.output, # ds=(poolsize,poolsize), # st=(poolstride,poolstride), # ignore_border=False, # padding=(0,0), # mode='max', # ) # # self.output = self.output.dimshuffle(1, 2, 3, 0) # bc01 to c01b else: NotImplementedError("lib_conv can only be cudnn for now") # LRN if self.lrn: # lrn_input = gpu_contiguous(self.output) self.output = self.lrn_func(self.output) if group == 1: self.params = [self.W.val, self.b.val] self.weight_type = ['W', 'b'] else: self.params = [self.W0.val, self.b0.val, self.W1.val, self.b1.val] self.weight_type = ['W', 'b', 'W', 'b'] if self.verbose: print "conv ({}) layer with shape_in: {}".format(lib_conv, str(image_shape))
def op(self, state): X = self.l_in.op(state=state) return dnn_pool(X, self.shape, self.stride, self.mode, self.pad)
def forward(self, input): self.output = dnn_pool(input, self.pooling_size, stride=self.step, mode=self.mode) return self.output
def __init__(self, input, convstride, padsize, poolsize, poolstride, b, W = None, filter_shape = None, poolpad=0, mode = 'max', lrn=False, lib_conv='cudnn', printinfo=True, input_shape=None, output_shape=None ): if W == None and filter_shape == None: raise AttributeError('need to specify at least one of W and filtershape') self.get_input_shape(input,input_shape) self.filter_shape = filter_shape self.convstride = convstride self.padsize = padsize self.lib_conv = lib_conv if W: self.W = W #Weight(self.filter_shape,) else: self.W = Normal(filter_shape, mean = 0.0, std=0.1) self.b = b #Weight(self.filter_shape[3]) self.channel = self.input_shape[1] self.lrn = lrn conv_out = dnn.dnn_conv(img=self.input, kerns=self.W.val, subsample=(convstride, convstride), border_mode=padsize, ) conv_out = conv_out + self.b.val.dimshuffle('x', 0, 'x', 'x') # ReLu self.output = T.maximum(conv_out, 0) # Pool self.poolsize = poolsize self.poolstride = poolstride self.poolpad = poolpad if self.poolsize != 1: self.output = dnn.dnn_pool(self.output, ws=(poolsize, poolsize), stride=(poolstride, poolstride), mode='max', pad=(poolpad, poolpad)) # LRN if self.lrn: self.lrn_func = CrossChannelNormalization() # lrn_input = gpu_contiguous(self.output) self.output = self.lrn_func(self.output) self.params = [self.W.val, self.b.val] self.weight_type = ['W', 'b'] if output_shape: self.output_shape = output_shape else: self.output_shape = self.get_output_shape(self.input_shape) self.name = 'ConvPoolLRN(%s)' % lib_conv if printinfo: self.print_shape()
def __init__(self, input, convstride, padsize, poolsize, poolstride, group, b, W = None, filter_shape = None, poolpad=0, mode = 'max', lrn=False, lib_conv='cudnn', printinfo=True, input_shape=None, output_shape=None, ): ''' ConvPoolLRN layer To be used in AlexNet lib_conv can be cudnn (recommended)or cudaconvnet ''' self.get_input_shape(input,input_shape) self.convstride = convstride self.padsize = padsize self.lib_conv = lib_conv self.poolsize = poolsize self.poolstride = poolstride self.poolpad = poolpad self.lrn = lrn if self.lrn: self.lrn_func = CrossChannelNormalization() if W == None and filter_shape!=None: assert group in [1, 2] self.filter_shape = np.asarray(filter_shape) if group == 1: self.W = Normal(self.filter_shape, mean=0, std=0.01) self.b = Constant(self.filter_shape[3], val=b) else: self.filter_shape[0] = self.filter_shape[0] // 2 self.filter_shape[3] = self.filter_shape[3] // 2 # self.input_shape[0] = self.input_shape[0] / 2 # self.input_shape[3] = self.input_shape[3] / 2 channel = self.input_shape[0] self.W0 = Normal(self.filter_shape, mean=0, std=0.01) self.W1 = Normal(self.filter_shape, mean=0, std=0.01) self.b0 = Constant(self.filter_shape[3], val=b) self.b1 = Constant(self.filter_shape[3], val=b) elif W!=None and filter_shape==None: assert group ==1 self.filter_shape = W.val.shape.eval() self.W=W self.b = Constant(self.filter_shape[3], val=b) else: raise AttributeError('need to specify exactly one of W and filtershape') if lib_conv == 'cudnn': input_shuffled = self.input.dimshuffle(3, 0, 1, 2) # c01b to bc01 # in01out to outin01 # print image_shape_shuffled # print filter_shape_shuffled if group == 1: W_shuffled = self.W.val.dimshuffle(3, 0, 1, 2) # c01b to bc01 conv_out = dnn.dnn_conv(img=input_shuffled, kerns=W_shuffled, subsample=(convstride, convstride), border_mode=padsize, ) conv_out = conv_out + self.b.val.dimshuffle('x', 0, 'x', 'x') else: W0_shuffled = \ self.W0.val.dimshuffle(3, 0, 1, 2) # c01b to bc01 # print W0_shuffled.shape.eval()# c01b to bc01 # 96, 5, 5, 256 -> 128, 48, 5, 5 # # x_in = np.zeros((96, 27, 27, 128), dtype=np.float32) # c01b to bc01 # 96, 27, 27, 128 -> 128, 48, 27, 27 # test = input_shuffled[:, :self.channel / 2,:, :] # # print test.shape conv_out0 = \ dnn.dnn_conv(img=input_shuffled[:, :channel//2, :, :], kerns=W0_shuffled, subsample=(convstride, convstride), border_mode=padsize, ) conv_out0 = conv_out0 + \ self.b0.val.dimshuffle('x', 0, 'x', 'x') W1_shuffled = \ self.W1.val.dimshuffle(3, 0, 1, 2) # c01b to bc01 conv_out1 = \ dnn.dnn_conv(img=input_shuffled[:, channel//2:, :, :], kerns=W1_shuffled, subsample=(convstride, convstride), border_mode=padsize, ) conv_out1 = conv_out1 + \ self.b1.val.dimshuffle('x', 0, 'x', 'x') conv_out = T.concatenate([conv_out0, conv_out1], axis=1) # ReLu self.output = T.maximum(conv_out, 0) # Pooling if poolsize != 1: self.output = dnn.dnn_pool(self.output, ws=(poolsize, poolsize), stride=(poolstride, poolstride)) self.output = self.output.dimshuffle(1, 2, 3, 0) # bc01 to c01b # elif lib_conv == 'cudaconvnet': # # from pylearn2.sandbox.cuda_convnet.filter_acts import FilterActs # # self.conv_op = FilterActs(pad=self.padsize, stride=self.convstride, # partial_sum=1) # # from theano.gpuarray.basic_ops import gpu_contiguous # # # Conv # if group == 1: # contiguous_input = gpu_contiguous(self.input) # contiguous_filters = gpu_contiguous(self.W.val) # conv_out = self.conv_op(contiguous_input, contiguous_filters) # conv_out = conv_out + self.b.val.dimshuffle(0, 'x', 'x', 'x') # else: # contiguous_input0 = gpu_contiguous( # self.input[:channel//2, :, :, :]) # contiguous_filters0 = gpu_contiguous(self.W0.val) # conv_out0 = self.conv_op( # contiguous_input0, contiguous_filters0) # conv_out0 = conv_out0 + \ # self.b0.val.dimshuffle(0, 'x', 'x', 'x') # # contiguous_input1 = gpu_contiguous( # self.input[channel//2:, :, :, :]) # contiguous_filters1 = gpu_contiguous(self.W1.val) # conv_out1 = self.conv_op( # contiguous_input1, contiguous_filters1) # conv_out1 = conv_out1 + \ # self.b1.val.dimshuffle(0, 'x', 'x', 'x') # conv_out = T.concatenate([conv_out0, conv_out1], axis=0) # # # ReLu # conv_out = gpu_contiguous(conv_out) # self.output = T.maximum(conv_out, 0) # # # Pooling # if poolsize != 1: # from pylearn2.sandbox.cuda_convnet.pool import MaxPool # self.pool_op = MaxPool(ds=poolsize, stride=poolstride) # self.output = self.pool_op(self.output) elif lib_conv == 'corrmm': from theano.gpuarray.basic_ops import gpu_contiguous from theano.gpuarray.blas import GpuCorrMM border_mode = 'half' if padsize == (filter_shape[1]-1)//2 else (padsize, padsize) self.corr_mm_op = GpuCorrMM(subsample=(convstride,convstride), border_mode=border_mode) input_shuffled = self.input.dimshuffle(3, 0, 1, 2) # c01b to bc01 if group==1: filters = self.W.val.dimshuffle(3, 0, 1, 2) # flip top-down, left-right to compute convolution instead of correlation contiguous_filters = gpu_contiguous(filters[:, :, ::-1, ::-1]) contiguous_input = gpu_contiguous(input_shuffled) conv_out = self.corr_mm_op(contiguous_input, contiguous_filters) conv_out = conv_out + self.b.val.dimshuffle('x', 0, 'x', 'x') else: W0_shuffled = self.W0.val.dimshuffle(3, 0, 1, 2) # c01b to bc01 contiguous_filters0 = gpu_contiguous(W0_shuffled[:, :, ::-1, ::-1]) contiguous_input0 = gpu_contiguous(input_shuffled[:, :channel // 2,:, :]) conv_out0 = self.corr_mm_op(contiguous_input0, contiguous_filters0) conv_out0 = conv_out0 + self.b0.val.dimshuffle('x', 0, 'x', 'x') W1_shuffled = self.W1.val.dimshuffle(3, 0, 1, 2) # c01b to bc01 contiguous_filters1 = gpu_contiguous(W1_shuffled[:, :, ::-1, ::-1]) contiguous_input1 = gpu_contiguous(input_shuffled[:, channel // 2:,:, :]) conv_out1 = self.corr_mm_op(contiguous_input1, contiguous_filters1) conv_out1 = conv_out1 + self.b1.val.dimshuffle('x', 0, 'x', 'x') conv_out = T.concatenate([conv_out0, conv_out1], axis=1) # ReLu self.output = T.maximum(conv_out, 0) # Pooling if poolsize != 1: from theano.gpuarray.pool import GpuPool ds_op = GpuPool(ignore_border=False, mode='max', ndim=2) self.output = ds_op(inp=self.output, ws=(poolsize,poolsize), stride=(poolstride,poolstride), pad=(0,0)) self.output = self.output.dimshuffle(1, 2, 3, 0) # bc01 to c01b else: NotImplementedError("lib_conv can only be cudnn or cudaconvnet for now") # LRN if self.lrn: # lrn_input = gpu_contiguous(self.output) self.output = self.lrn_func(self.output) if group == 1: self.params = [self.W.val, self.b.val] self.weight_type = ['W', 'b'] else: self.params = [self.W0.val, self.b0.val, self.W1.val, self.b1.val] self.weight_type = ['W', 'b', 'W', 'b'] if output_shape: self.output_shape = output_shape else: self.output_shape = self.get_output_shape(self.input_shape) self.name = 'ConvPoolLRN(%s)' % lib_conv if printinfo: self.print_shape()