def feature_extractor(input_data): # conv stage 0 (64x64=>32x32) h0_0 = dnn_conv(input_data, conv_w0_0, border_mode=(1, 1)) + conv_b0_0.dimshuffle("x", 0, "x", "x") h0_1 = dnn_conv(relu(h0_0), conv_w0_1, border_mode=(1, 1)) + conv_b0_1.dimshuffle("x", 0, "x", "x") h0 = dnn_pool(relu(h0_1), ws=(2, 2), stride=(2, 2)) # conv stage 1 (32x32=>16x16) h1_0 = dnn_conv(h0, conv_w1_0, border_mode=(1, 1)) + conv_b1_0.dimshuffle("x", 0, "x", "x") h1_1 = dnn_conv(relu(h1_0), conv_w1_1, border_mode=(1, 1)) + conv_b1_1.dimshuffle("x", 0, "x", "x") h1 = dnn_pool(relu(h1_1), ws=(2, 2), stride=(2, 2)) # conv stage 2 (16x16=>8x8) h2_0 = dnn_conv(h1, conv_w2_0, border_mode=(1, 1)) + conv_b2_0.dimshuffle("x", 0, "x", "x") h2_1 = dnn_conv(relu(h2_0), conv_w2_1, border_mode=(1, 1)) + conv_b2_1.dimshuffle("x", 0, "x", "x") h2_2 = dnn_conv(relu(h2_1), conv_w2_2, border_mode=(1, 1)) + conv_b2_2.dimshuffle("x", 0, "x", "x") h2 = dnn_pool(relu(h2_2), ws=(2, 2), stride=(2, 2)) # conv stage 3 (8x8=>4x4) h3_0 = dnn_conv(h2, conv_w3_0, border_mode=(1, 1)) + conv_b3_0.dimshuffle("x", 0, "x", "x") h3_1 = dnn_conv(relu(h3_0), conv_w3_1, border_mode=(1, 1)) + conv_b3_1.dimshuffle("x", 0, "x", "x") h3_2 = dnn_conv(relu(h3_1), conv_w3_2, border_mode=(1, 1)) + conv_b3_2.dimshuffle("x", 0, "x", "x") h3 = dnn_pool(relu(h3_2), ws=(2, 2), stride=(2, 2)) # conv stage 4 (4x4=>2x2) h4_0 = dnn_conv(h3, conv_w4_0, border_mode=(1, 1)) + conv_b4_0.dimshuffle("x", 0, "x", "x") h4_1 = dnn_conv(relu(h4_0), conv_w4_1, border_mode=(1, 1)) + conv_b4_1.dimshuffle("x", 0, "x", "x") h4_2 = dnn_conv(relu(h4_1), conv_w4_2, border_mode=(1, 1)) + conv_b4_2.dimshuffle("x", 0, "x", "x") h4 = dnn_pool(relu(h4_2), ws=(2, 2), stride=(2, 2)) return T.flatten(h4, 2)
def apply(self, input_): """Apply the pooling (subsampling) transformation. Parameters ---------- input_ : :class:`~tensor.TensorVariable` An tensor with dimension greater or equal to 3. The last two dimensions will be downsampled. For example, with videos this means that the last three dimensions should represent the duration, height and width of your image. Returns ------- output : :class:`~tensor.TensorVariable` A tensor with the same number of dimensions as `input_`, but with the last two dimensions downsampled. """ if self.pooling_size == (1, 1, 1): return input_ # Pooling on last two dimensions input__shape = input_.shape input_ = input_.reshape((input__shape[0], input__shape[1] * input__shape[2], input__shape[3], input__shape[4])) p = dnn_pool(img=input_, ws=tuple(self.pooling_size[1:]), stride=tuple(self.step[1:])) p_shape = p.shape p = p.reshape((p_shape[0], input__shape[1], input__shape[2], p_shape[2], p_shape[3])) # Pooling on first dimension p_shape = p.shape p = p.reshape((p_shape[0], p_shape[1], p_shape[2], p_shape[3] * p_shape[4])) output = dnn_pool(img=p, ws=(self.pooling_size[0], 1), stride=(self.step[0], 1)) output_shape = output.shape output = output.reshape((output_shape[0], output_shape[1], output_shape[2], p_shape[3] , p_shape[4])) return output
def dnn_pool3d2d(inputs, pool_shape, pool_stride, image_shape, mode='max'): """ Pool first all time-slices, so 2d-poolings over width and height. Then do a 1dpooling over the time (done as fake2d pooling with pooling shape 1 for the ignored dimension.""" for i in xrange(3): assert pool_shape[i] <= image_shape[i], ("pool shape should be less" " or equal than image shape, {:d} > {:d} for " "pool_shape: {:s}, image_shape:{:s}").format(pool_shape[i], image_shape[i], pool_shape, image_shape) output_shape = [((image_shape[i] - pool_shape[i]) // pool_stride[i]) + 1 for i in xrange(3)] output2d_pooled = gpu_alloc_empty(inputs.shape[0], inputs.shape[1], output_shape[0], output_shape[1], image_shape[2]) for z in range(image_shape[2]): pooled_slice = dnn_pool(inputs[:,:,:,:,z], ws=pool_shape[0:2], stride=pool_stride[0:2], mode=mode) output2d_pooled = T.set_subtensor(output2d_pooled[:,:,:,:,z], pooled_slice) # now 1d-pool over last dimension... # could use first or second dimension as input of pool1d.. # compute maximum y index after first pooling output = gpu_alloc_empty(inputs.shape[0], inputs.shape[1], output_shape[0], output_shape[1], output_shape[2]) max_y = output_shape[1] for y in range(max_y): # ignore first=0 dimension, alrdy pooled in loop before # so set stride and shape to 1 there final_pooled_slice = dnn_pool(output2d_pooled[:,:,:,y,:], ws=(1, pool_shape[2]), stride=(1, pool_stride[2]), mode=mode) output = T.set_subtensor(output[:,:,:,y,:], final_pooled_slice) return output
def __init__(self,h_low,h_high,method="adascan_mod"): kern = build_filters(h_low,h_high) sharedKern = theano.shared(kern,name='sharedKern') input = theano.tensor.tensor4(name='input') self.conv_fun = theano.function([input],dnn_conv(input,sharedKern)) self.down_x = theano.function([input],dnn_pool(input,(2,1),stride=(2,1),mode='average_inc_pad')) self.down_y = theano.function([input],dnn_pool(input,(1,2),stride=(1,2),mode='average_inc_pad')) self.h_low, self.h_high, self.method = h_low, h_high, method
def __call__(self, x): if self.glob: return dnn.dnn_pool(x, (x.shape[2], x.shape[3]), stride=(1, 1), mode=self.mode, pad=(0, 0)) return dnn.dnn_pool(x, (self.size, 1), stride=(self.stride, 1), mode=self.mode, pad=(self.pad, 0))
def test_dnn_pool_desc_merge(): if not cuda.dnn.dnn_available(): raise SkipTest(cuda.dnn.dnn_available.msg) x = theano.tensor.ftensor4("x") y = dnn.dnn_pool(x, (2, 2)) z = dnn.dnn_pool(x, (2, 2)) f = theano.function([x], [y, z]) descs = [n for n in f.maker.fgraph.apply_nodes if isinstance(n.op, dnn.GpuDnnPoolDesc)] assert len(descs) == 1, f.maker.fgraph
def model(X, h2_u, h3_u, h2_s, h3_s, w, w2, g2, b2, w3, g3, b3, wy ): h = lrelu(dnn_conv(X, w, subsample=(2, 2), border_mode=(2, 2))) h2 = lrelu(batchnorm(dnn_conv(h, w2, subsample=(2, 2), border_mode=(2, 2)), g=g2, b=b2, u=h2_u, s=h2_s)) h3 = lrelu(batchnorm(dnn_conv(h2, w3, subsample=(2, 2), border_mode=(2, 2)), g=g3, b=b3, u=h3_u, s=h3_s)) h = T.flatten(dnn_pool(h, (4, 4), (4, 4), mode='max'), 2) h2 = T.flatten(dnn_pool(h2, (2, 2), (2, 2), mode='max'), 2) h3 = T.flatten(dnn_pool(h3, (1, 1), (1, 1), mode='max'), 2) f = T.concatenate([h, h2, h3], axis=1) return [f]
def pool2d(x, pool_size, strides=(1, 1), border_mode='valid', dim_ordering='th', pool_mode='max'): if border_mode == 'same': # TODO: add implementation for border_mode="same" raise Exception('border_mode="same" not supported with Theano.') elif border_mode == 'valid': ignore_border = True padding = (0, 0) else: raise Exception('Invalid border mode: ' + str(border_mode)) if dim_ordering not in {'th', 'tf'}: raise Exception('Unknown dim_ordering ' + str(dim_ordering)) if dim_ordering == 'tf': x = x.dimshuffle((0, 3, 1, 2)) if pool_mode == 'max': if _on_gpu() and dnn.dnn_available(): pool_out = dnn_pool(x, pool_size, stride=strides, mode='max') else: pool_out = downsample.max_pool_2d(x, ds=pool_size, st=strides, ignore_border=ignore_border, padding=padding, mode='max') elif pool_mode == 'avg': if _on_gpu() and dnn.dnn_available(): pool_out = dnn_pool(x, pool_size, stride=strides, mode='average_exc_pad') else: pool_out = downsample.max_pool_2d(x, ds=pool_size, st=strides, ignore_border=ignore_border, padding=padding, mode='average_exc_pad') else: raise Exception('Invalid pooling mode: ' + str(pool_mode)) if dim_ordering == 'tf': pool_out = pool_out.dimshuffle((0, 2, 3, 1)) return pool_out
def apply(self, input_): """Apply the pooling (subsampling) transformation. """ if self.pooling_size == (1, 1, 1): return input_ # Pooling on last two dimensions input_ = input_.reshape((input_.shape[0], input_.shape[1] * input_.shape[2], input_.shape[3], input_.shape[4])) p = dnn_pool(img=input_, ws=tuple(self.pooling_size[1:]), stride=tuple(self.step[1:])) p = p.reshape((p.shape[0], input_.shape[1], input_.shape[2], p.shape[2], p.shape[3])) # Pooling on first dimension p = p.reshape((p.shape[0], p.shape[1], p.shape[2], p.shape[3] * p.shape[4])) output = dnn_pool(img=p, ws=(self.pooling_size[0], 1), stride=(self.step[0], 1)) output = output.reshape((output.shape[0], output.shape[1], output.shape[2], p.shape[3], p.shape[4])) return output
def apply(self, input): """ Apply this discriminator module to the given input. This produces a collection of filter responses for feedforward and a spatial grid of discriminator outputs. """ bm = int((self.filt_dim - 1) / 2) # use "same" mode convolutions ss = self.ds_stride # stride for "learned downsampling" # apply first conv layer h1 = dnn_conv(input, self.w1, subsample=(1, 1), border_mode=(bm, bm)) if self.apply_bn_1: h1 = batchnorm(h1, g=self.g1, b=self.b1) h1 = lrelu(h1) # apply second conv layer (may include downsampling) if self.use_pooling: h2 = dnn_conv(h1, self.w2, subsample=(1, 1), border_mode=(bm, bm)) if self.apply_bn_2: h2 = batchnorm(h2, g=self.g2, b=self.b2) h2 = lrelu(h2) h2 = dnn_pool(h2, (ss,ss), stride=(ss, ss), mode='max', pad=(0, 0)) else: h2 = dnn_conv(h1, self.w2, subsample=(ss, ss), border_mode=(bm, bm)) if self.apply_bn_2: h2 = batchnorm(h2, g=self.g2, b=self.b2) h2 = lrelu(h2) # apply discriminator layer y = dnn_conv(h2, self.wd, subsample=(1, 1), border_mode=(bm, bm)) y = sigmoid(T.flatten(y, 2)) # flatten to (batch_size, num_preds) return h2, y
def compute_output(self, network, in_vw): mode = network.find_hyperparameter(["mode"]) pool_size = network.find_hyperparameter(["pool_size"]) dim = len(pool_size) # works for sizes 2 and 3 assert dim in [2, 3] stride = network.find_hyperparameter(["pool_stride", "stride"], None) if stride is None: stride = pool_size pad = network.find_hyperparameter(["pool_pad", "pad"], (0,) * dim) assert dim == len(stride) == len(pad) if dim == 2: pool_axes = (2, 3) elif dim == 3: pool_axes = (2, 3, 4) out_shape = downsample.pool_output_shape( input_shape=in_vw.shape, axes=pool_axes, pool_shape=pool_size, strides=stride, pads=pad) out_var = dnn.dnn_pool(img=in_vw.variable, ws=pool_size, stride=stride, pad=pad, mode=mode) network.create_vw( "default", variable=out_var, shape=out_shape, tags={"output"}, )
def get_fprop(self, video, video_mask, label, popstats=None): if self.options.rec_bn and self.options.use_popstats: popstats_enc = popstats else: popstats_enc = None ''' Encoder ''' m, t, x, y = video.shape state_vid = video.dimshuffle(1,0,2,3,4) state_mask = video_mask.dimshuffle(1,0) for l in xrange(0, len(self.encoders)): ### Conv RNN rvals = self.layers[0].fprop(state_vid, state_mask, popstats=popstats_enc) state_vid = rvals[0] ### Spatial Pool if self.options.layer_pool[0] != (0, 0): state_vid = dnn_pool(state_vid.reshape((t*m,x, y)), size=self.options.pool[0], stride=self.options.pool_stride[0])) state_vid = state_vid.reshape(t, m, x, y) ''' Classifier ''' video_ctx = state_vid[0].flatten(2) # (m,d) output = T.dot(logit, self.W) + self.b y_hat = T.nnet.softmax(output) '''cost''' ce = tensor.nnet.categorical_crossentropy(y_hat, label) cost = ce.mean() ### Returns Err as well return [cost, ce]
def get_convpool(self, img, kerns, conv_b, subsample, border_mode, pooling, ws=None, stride=None, normalizing=False): conv_out = dnn.dnn_conv( img=img, kerns=kerns, subsample=subsample, border_mode=border_mode ) conv_out += conv_b.dimshuffle('x',0,'x','x') conv_out = T.maximum(conv_out, 0) if pooling: pool_out = dnn.dnn_pool( conv_out, ws=ws, stride=stride ) else: pool_out = conv_out if normalizing: norm_out = CrossChannelNormalization()(pool_out) else: norm_out = pool_out return norm_out
def get_output_for(self, input, **kwargs): dimshuffle = range(len(self.input_shape)) for axis in self.pool_axes: dimshuffle.remove(axis) for axis in self.pool_axes: dimshuffle.append(axis) new_shape = [ -1, 1, ] + [self.input_shape[axis] for axis in self.pool_axes] input = input.dimshuffle(*dimshuffle).reshape(new_shape) pooled = dnn.dnn_pool(input, self.pool_size, self.stride, self.mode, self.pad) non_pool_output_shape = list(self.input_shape) non_pool_output_shape = [ i for j, i in enumerate(non_pool_output_shape) if j not in self.pool_axes ] pooled = pooled.reshape( replace_None(non_pool_output_shape + [self.output_shape[i] for i in self.pool_axes])) reverse_dimshuffle = [ dimshuffle.index(i) for i in xrange(len(self.input_shape)) ] pooled = pooled.dimshuffle(*reverse_dimshuffle) return pooled
def apply(self, input_): """Apply the pooling (subsampling) transform Parameters ---------- input_ : :class:`~tensor.TensorVariable` 3D tensor with axes batch size, sequence, features Returns ------- output: :class:`~tensor.TensorVariable` 3D tensor with axes batch size, sequence, features """ shuffled = input_.dimshuffle(0, 2, 1, 'x') # batch_size, num_filters, x_map, 1 if self.step == None: st = (1,1) else: st = (self.step, 1) #output = max_pool_2d(shuffled, (self.pooling_length, 1), st=st) output = dnn_pool(shuffled, (self.pooling_length, 1), stride=st) sequence_out = output[:, :, :, 0].dimshuffle(0, 2, 1) return sequence_out
def spp_predict(fmaps, pyramid): """ From input confidence maps, perform "SPP" prediction across a scale pyramid and using spatial pruning of labels and confidences. Arguments: fmaps theano symbolic 4D tensor with shape (nb_images, nb_labels, nb_rows, nb_cols) pyramid python list of average pooling kernel sizes, e.g. [3, 5]. Returns: symbolic (nb_images, nb_labels) tensor of spatially pooled multi-scale predictions. """ # Step 1: average pooling of the confidences across multiple scales, then average pooling # of that using spatial information to get multi-scale spatial confidences. pooled_maps = fmaps nb_images, nb_labels, nb_rows, nb_cols = fmaps.shape for ws in pyramid: pooled_maps += resize( dnn_pool(fmaps, (ws, ws), (1, 1), mode='average'), (nb_rows, nb_cols) ) pooled_maps /= len(pyramid) + 1 # Step 2: spatial max-pooling across labels. label_conf, label_map = T.max_and_argmax(pooled_maps, axis=1, keepdims=True) bcast_labels = T.addbroadcast(T.arange(nb_labels).reshape([1, nb_labels, 1, 1]), 0, 2, 3) label_mask = T.eq(bcast_labels, label_map) return T.mean(label_mask * label_conf, axis=[2,3])
def output(self, input): ''' dnn ''' if self.border_mode == 'same': conv_out = dnn.dnn_conv( img=input, kerns=self.W, subsample=(1, 1), border_mode=self.border, #conv_mode='cross' ) else: raise Exception('Unknown conv type') # downsample each feature map individually, using maxpooling if self.poolsize[0] == 1 and self.poolsize[1] == 1: pooled_out = conv_out else: pooled_out = dnn.dnn_pool(img=conv_out, ws=self.poolsize, stride=self.poolsize, mode='max', pad=(0, 0)) # add the bias term. Since the bias is a vector (1D array), we first # reshape it to a tensor of shape (1, n_filters, 1, 1). Each bias will # thus be broadcasted across mini-batches and feature map # width & height lin_output = pooled_out + self.b.dimshuffle('x', 0, 'x', 'x') return (lin_output if self.activation is None else self.activation(lin_output))
def apply(self, input_): """Apply the pooling (subsampling) transform Parameters ---------- input_ : :class:`~tensor.TensorVariable` 3D tensor with axes batch size, sequence, features Returns ------- output: :class:`~tensor.TensorVariable` 3D tensor with axes batch size, sequence, features """ shuffled = input_.dimshuffle(0, 2, 1, 'x') # batch_size, num_filters, x_map, 1 if self.step == None: st = (1, 1) else: st = (self.step, 1) #output = max_pool_2d(shuffled, (self.pooling_length, 1), st=st) output = dnn_pool(shuffled, (self.pooling_length, 1), stride=st) sequence_out = output[:, :, :, 0].dimshuffle(0, 2, 1) return sequence_out
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, inputs=None, size=(1, 1), stride=None, pad=(0, 0), mode='max', ignore_border=True): """ Parameters ---------- inputs : tuple(shape, `Theano.TensorType`) tuple(shape, `Theano.TensorType`) or None describing the input to use for this layer. `shape` will be a monad tuple representing known sizes for each dimension in the `Theano.TensorType`. If 4D images as input, expect formatted as (batch_size, #channels, rows, cols). size : tuple(int) or int Downsample factor over (rows, columns). If it is an int, it will be the same size for rows and cols. stride : tuple(int) or int Stride size (step size), which is the number of shifts over rows/cols to get the next pool region. If it is an int, it will be the same size for rows and cols. pad : tuple(int) or int (pad_h, pad_w), pad zeros to extend beyond four borders of the images, pad_h is the size of the top and bottom margins, and pad_w is the size of the left and right margins. If it is an int, it will be the same size for rows and cols. mode : 'max', 'sum', 'average_inc_pad', 'average_exc_pad' Operation executed on each window. `max` and `sum` always exclude the padding in the computation. `average` gives you the choice to include or exclude it. ignore_border : bool If `size` doesn't divide the input `shape`, do we include an extra row/col of partial downsampling (False) or ignore it (True). When True, (5,5) input with size=(2,2) will generate a (2,2) output. (3,3) otherwise. """ super(Pool2D, self).__init__(inputs=inputs, size=size, stride=stride, pad=pad) input_shape, self.input = self.inputs[0] if isinstance(size, int): size = (size, ) * 2 if stride is None: stride = size if isinstance(stride, int): stride = (stride, ) * 2 if isinstance(pad, int): pad = (pad, ) * 2 assert len(size) == len(stride) == len(pad), "Size, stride, and pad must have the same number of dimensions." self.output_size = tuple(_pool_out_size(imgshape=input_shape, ds=size, st=stride, ignore_border=ignore_border, padding=pad)) cudnn_modes = ['max', 'average_inc_pad', 'average_exc_pad'] if has_cudnn and mode in cudnn_modes and ignore_border and self.input.ndim == 4: self.output = dnn_pool(img=self.input, ws=size, stride=stride, mode=mode, pad=pad) else: self.output = max_pool_2d(input=self.input, ds=size, st=stride, padding=pad, mode=mode, ignore_border=ignore_border)
def pool2d(x, pool_size, strides=(1, 1), border_mode='valid', dim_ordering='th', pool_mode='max'): # ====== dim ordering ====== # if dim_ordering not in {'th', 'tf'}: raise Exception('Unknown dim_ordering ' + str(dim_ordering)) if dim_ordering == 'tf': x = x.dimshuffle((0, 3, 1, 2)) # ====== border mode ====== # if border_mode == 'same': w_pad = pool_size[0] - 2 if pool_size[0] % 2 == 1 else pool_size[0] - 1 h_pad = pool_size[1] - 2 if pool_size[1] % 2 == 1 else pool_size[1] - 1 padding = (w_pad, h_pad) elif border_mode == 'valid': padding = (0, 0) elif isinstance(border_mode, (tuple, list)): padding = tuple(border_mode) else: raise Exception('Invalid border mode: ' + str(border_mode)) # ====== pooling ====== # if _on_gpu() and dnn.dnn_available(): pool_out = dnn.dnn_pool(x, pool_size, stride=strides, mode=pool_mode, pad=padding) else: # CPU veresion support by theano pool_out = pool.pool_2d(x, ds=pool_size, st=strides, ignore_border=True, padding=padding, mode=pool_mode) if dim_ordering == 'tf': pool_out = pool_out.dimshuffle((0, 2, 3, 1)) return pool_out
def __init__(self, layers, size=(2, 2), stride=None, pad=(0, 0), mode="max", ignore_border=True, json_param={}): super().__init__(layer_index=len(layers)) self.input = layers[-1].output self.input_shape = layers[-1].output_shape self.size = json_param.get("size", size) self.pad = json_param.get("pad", pad) self.ignore_border = json_param.get("ignoreBorder", ignore_border) self.mode = json_param.get("mode", mode) self.stride = json_param.get("stride", stride) if self.stride is None: self.stride = self.size #output dim if self.ignore_border: h = int( math.floor( (self.input_shape[2] + 2 * self.pad[0] - self.size[0]) / self.stride[0])) + 1 w = int( math.floor( (self.input_shape[3] + 2 * self.pad[1] - self.size[1]) / self.stride[1])) + 1 else: h = int( math.ceil( (self.input_shape[2] + 2 * self.pad[0]) / self.stride[0])) w = int( math.ceil( (self.input_shape[3] + 2 * self.pad[1]) / self.stride[1])) #theano optimizer is sometimes failing to use cudnn pooling! use_cudnn = (dnn.dnn_available() and dnn.version() >= (4000, 4000) and self.ignore_border) if use_cudnn: self.output = dnn.dnn_pool(self.input, ws=self.size, pad=self.pad, stride=self.stride, mode=self.mode) else: self.output = tensor.signal.pool.pool_2d( self.input, ds=self.size, padding=self.pad, ignore_border=self.ignore_border, st=self.stride, mode=self.mode) self.output_shape = (self.input_shape[0], self.input_shape[1], h, w) logging.verbose("Adding", self)
def __init__(self, input, image_shape, filter_shape, convstride, padsize, poolsize, poolstride,poolpad, W, b, lrn=False, lib_conv='cudnn', ): self.filter_size = filter_shape self.convstride = convstride self.padsize = padsize self.channel = image_shape[0] self.lrn = lrn self.lib_conv = lib_conv self.filter_shape = np.asarray(filter_shape) self.image_shape = np.asarray(image_shape) self.W = W#Weight(self.filter_shape) self.b = b#Weight(self.filter_shape[3])#, bias_init, std=0) input_shuffled = input.dimshuffle(3, 0, 1, 2) # c01b to bc01 # in01out to outin01 # print image_shape_shuffled # print filter_shape_shuffled 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') # 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)) self.output = self.output.dimshuffle(1, 2, 3, 0) # bc01 to c01b # 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'] print "conv ({}) layer with shape_in: {}".format(lib_conv, str(image_shape))
def __init__(self, input, poolsize, poolstride, padsize=0): input_shuffled = input.dimshuffle(3, 0, 1, 2) self.output = dnn.dnn_pool(input_shuffled, ws=(poolsize, poolsize), stride=(poolstride, poolstride), pad=(padsize, padsize)) self.output = self.output.dimshuffle(1, 2, 3, 0)
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 symb_forward(self, symb_input): return _dnn.dnn_pool( img=symb_input, ws=(self.k_w, self.k_h), stride=(self.d_w, self.d_h), mode='max', pad=(self.pad_w, self.pad_h) )
def grad(self, inputs, grads): out, inp, inp_grad, ws, stride, pad = inputs mode = self.mode if mode not in ("average_inc_pad", "average_exc_pad"): raise NotImplementedError("Unsupported pooling mode for grad.") g_out = dnn.dnn_pool(grads[0], ws, stride=stride, pad=pad, mode=mode) def d(): return theano.gradient.DisconnectedType()() return d(), d(), g_out, d(), d(), d()
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 classify(X, w, g, b, w2, g2, b2, w3, g3, b3, w4, g4, b4, wfc1, wfc2, wy): h = relu( batchnorm3d(dnn_conv3d(X, w, subsample=(1, 1, 1), border_mode=(1, 1, 1)), g=g, b=b)) h = dnn_pool(h, ws=(2, 2, 2), stride=(2, 2, 2), mode='max') h2 = relu( batchnorm3d(dnn_conv3d(h, w2, subsample=(1, 1, 1), border_mode=(1, 1, 1)), g=g2, b=b2)) h2 = dnn_pool(h2, ws=(2, 2, 2), stride=(2, 2, 2), mode='max') h3 = relu( batchnorm3d(dnn_conv3d(h2, w3, subsample=(1, 1, 1), border_mode=(1, 1, 1)), g=g3, b=b3)) h3 = dnn_pool(h3, ws=(2, 2, 2), stride=(2, 2, 2), mode='max') h4 = relu( batchnorm3d(dnn_conv3d(h3, w4, subsample=(1, 1, 1), border_mode=(1, 1, 1)), g=g4, b=b4)) h4 = dnn_pool(h4, ws=(2, 2, 2), stride=(2, 2, 2), mode='max') h5 = T.flatten(h4, 2) h6 = relu(T.dot(h5, wfc1)) h7 = relu(T.dot(h6, wfc2)) y = softmax(T.dot(h7, wy)) return y
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 apply(self, input_): """Apply the pooling (subsampling) transformation. """ if self.pooling_size == (1, 1, 1): return input_ # Pooling on last two dimensions input__shape = input_.shape input_ = input_.reshape((input__shape[0], input__shape[1] * input__shape[2], input__shape[3], input__shape[4])) p = dnn_pool(img=input_, ws=tuple(self.pooling_size[1:]), stride=tuple(self.step[1:])) p_shape = p.shape p = p.reshape((p_shape[0], input__shape[1], input__shape[2], p_shape[2], p_shape[3])) # Pooling on first dimension p_shape = p.shape p = p.reshape((p_shape[0], p_shape[1], p_shape[2], p_shape[3] * p_shape[4])) output = dnn_pool(img=p, ws=(self.pooling_size[0], 1), stride=(self.step[0], 1)) output_shape = output.shape output = output.reshape((output_shape[0], output_shape[1], output_shape[2], p_shape[3] , p_shape[4])) return output
def model(X, h2_u, h3_u, h2_s, h3_s, w, w2, g2, b2, w3, g3, b3, wy): h = lrelu(dnn_conv(X, w, subsample=(2, 2), border_mode=(2, 2))) h2 = lrelu( batchnorm(dnn_conv(h, w2, subsample=(2, 2), border_mode=(2, 2)), g=g2, b=b2, u=h2_u, s=h2_s)) h3 = lrelu( batchnorm(dnn_conv(h2, w3, subsample=(2, 2), border_mode=(2, 2)), g=g3, b=b3, u=h3_u, s=h3_s)) h = T.flatten(dnn_pool(h, (4, 4), (4, 4), mode='max'), 2) h2 = T.flatten(dnn_pool(h2, (2, 2), (2, 2), mode='max'), 2) h3 = T.flatten(dnn_pool(h3, (1, 1), (1, 1), mode='max'), 2) f = T.concatenate([h, h2, h3], axis=1) return [f]
def process(self, input, tparams, BNparams): b, f, h0, w0 = input.shape result = [] for h, w in self.pymamid: win_h = T.ceil(h0 / h).astype('int32') win_w = T.ceil(w0 / w).astype('int32') str_h = T.floor(h0 / h).astype('int32') str_w = T.floor(w0 / w).astype('int32') result.append(dnn_pool( img=input, ws=(win_h, win_w), mode=self.mode, stride=(str_h, str_w), pad=(0, 0)).reshape([b, -1])) return T.concatenate(result, axis=1)
def dnn_pool3d2d(inputs, pool_shape, pool_stride, image_shape, mode='max'): """ Pool first all time-slices, so 2d-poolings over width and height. Then do a 1dpooling over the time (done as fake2d pooling with pooling shape 1 for the ignored dimension.""" for i in xrange(3): assert pool_shape[i] <= image_shape[i], ( "pool shape should be less" " or equal than image shape, {:d} > {:d} for " "pool_shape: {:s}, image_shape:{:s}").format( pool_shape[i], image_shape[i], pool_shape, image_shape) output_shape = [((image_shape[i] - pool_shape[i]) // pool_stride[i]) + 1 for i in xrange(3)] output2d_pooled = gpu_alloc_empty(inputs.shape[0], inputs.shape[1], output_shape[0], output_shape[1], image_shape[2]) for z in range(image_shape[2]): pooled_slice = dnn_pool(inputs[:, :, :, :, z], ws=pool_shape[0:2], stride=pool_stride[0:2], mode=mode) output2d_pooled = T.set_subtensor(output2d_pooled[:, :, :, :, z], pooled_slice) # now 1d-pool over last dimension... # could use first or second dimension as input of pool1d.. # compute maximum y index after first pooling output = gpu_alloc_empty(inputs.shape[0], inputs.shape[1], output_shape[0], output_shape[1], output_shape[2]) max_y = output_shape[1] for y in range(max_y): # ignore first=0 dimension, alrdy pooled in loop before # so set stride and shape to 1 there final_pooled_slice = dnn_pool(output2d_pooled[:, :, :, y, :], ws=(1, pool_shape[2]), stride=(1, pool_stride[2]), mode=mode) output = T.set_subtensor(output[:, :, :, y, :], final_pooled_slice) return output
def fprop(self, x): pooled_out = cuDNN.dnn_pool( img=x, ws=(self.poolSize, self.poolSize), stride=(self.poolStride,self.poolStride), pad = (self.pad, self.pad), mode=self.mode ) pooled_out = pooled_out if self.actFunc is None else self.actFunc(pooled_out) return pooled_out # End PoolLayer #-------------------------------------------------------------------------------
def __init__(self, input, poolsize, poolstride, poolpad, mode = 'max' ): self.poolsize = poolsize self.poolstride = poolstride self.poolpad = poolpad input_shuffled = input.dimshuffle(3, 0, 1, 2) # c01b to bc01 if self.poolsize != 1: self.output = dnn.dnn_pool(input_shuffled, ws=(poolsize, poolsize), stride=(poolstride, poolstride), mode=mode, pad=(poolpad, poolpad)) else: self.output = input self.output = self.output.dimshuffle(1, 2, 3, 0) # bc01 to c01b
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 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 __init__(self, input, poolsize, poolstride, poolpad, mode='max'): self.poolsize = poolsize self.poolstride = poolstride self.poolpad = poolpad input_shuffled = input.dimshuffle(3, 0, 1, 2) # c01b to bc01 if self.poolsize != 1: self.output = dnn.dnn_pool(input_shuffled, ws=(poolsize, poolsize), stride=(poolstride, poolstride), mode=mode, pad=(poolpad, poolpad)) else: self.output = input self.output = self.output.dimshuffle(1, 2, 3, 0) # bc01 to c01b
def __init__(self, rstream, index, x, params, useRglrz, bnPhase, poolShape, inFilters, outFilters, stride, ignore_border = False, b=None, a=None, normParam=None, rglrzParam=None): ''' Averaging layer + BN + noise ''' # noise self.paramsT2 = [] if 'addNoise' in params.rglrz and params.convLayers[index].noise: if rglrzParam is None: self.rglrzParam = {} tempValue = params.rglrzInitial['addNoise'][index] tempParam = np.asarray(tempValue, dtype=theano.config.floatX) noizParam = theano.shared(value=tempParam, name='%s_%d' % ('addNoise', index), borrow=True) self.rglrzParam['addNoise']=noizParam if params.useT2 and 'addNoise' in params.rglrzTrain: self.paramsT2 = [noizParam] #self.output = noiseup(self.output, splitPoint, noizParam, params.noiseT1, params, index, rstream) x = noiseup(x, useRglrz, noizParam, params.noiseT1, params, index, rstream) # averaging if cudasConv: self.output = cudnn.dnn_pool(x, poolShape, stride = stride, mode = 'average_exc_pad')#, ignore_border = ignore_border) else: self.output = pool.pool_2d(x, ds = poolShape, st = stride, ignore_border = ignore_border, mode = 'average_exc_pad') # if batch normalization if params.batchNorm and params.convLayers[index].bn: _, b, a = t1_shared(params=params, rng=0, index=index, nIn=0, nOut=0, outFilters=outFilters, filterShape=0, defineW=0) self.b = b; self.a = a self.paramsT1 = [b] if normParam is None: normParam, paramsBN = bn_shared(params, outFilters, index) self.normParam = normParam self.paramsBN = paramsBN self.output, updateBN = bn_layer(self.output, self.a, self.b, self.normParam, params, bnPhase) self.updateBN = updateBN # flattening and softmax self.output = T.flatten(self.output, outdim = 2) if params.convLayers[index].type == 'average+softmax': self.output = activation(self.output, 'softmax')
def apply(self, v, **kwargs): input = v.output #input = utils.PrintShapeOp(input, 'pool') if kwargs.get('use_cpu', False): output = downsample.max_pool_2d(input=input, ds=self.pooling_size, st=self.pooling_stride) else: output = dnn.dnn_pool(img=input, ws=self.pooling_size, stride=self.pooling_stride, pad=self.padding) print self.input_height, self.pooling_size, self.pooling_stride nv = vcopy(v) nv.update(output=output) return self.post_apply(nv, **kwargs)
def __init__(self, input, image_shape): """ Allocate a SumPoolLayer. :type input: theano.tensor.dtensor4 :param input: symbolic image tensor, of shape image_shape :type image_shape: tuple or list of length 2 :param image_shape: (image height, image width) """ self.input = input #downsample each feature map individually, usin sum over all the image. poolsize = (image_shape[0], image_shape[1]) total_cells = image_shape[0] * image_shape[1] pooled_out = dnn.dnn_pool(img=self.input, ws=poolsize, mode='sum') self.output = pooled_out
def pool2d(x, pool_size, strides, padding, dim_order, mode): if dim_order not in dim_orders or padding not in paddings: raise Exception('Error dim_order or padding parameter.') x = _shuffle(x, dim2d[dim_order], dim2d[AR]) if padding == 'same': shp = x.shape.eval() pad = tuple([(pool_size[i] - 2) if pool_size[i] % 2 == 1 else (pool_size[i] - 1) for i in range(len(pool_size))]) expected = [shp[i + 2] + strides[i] - 1 // strides[i] for i in range(len(strides))] else: pad = (0, 0) if env.get_device() == '': pool_out = pool.pool_2d(x, ds = pool_size, st = strides, ignore_border = True, padding = pad, mode = mode) else: pool_out = dnn.dnn_pool(x, pool_size, stride = strides, mode = mode, pad = pad) if padding == 'same': pool_out = pool_out[:, :, : expected[0], : expected[1]] return _shuffle(pool_out, dim2d[AR], dim2d[dim_order])
def pool3d(x, pool_size, strides, padding, dim_order, mode): if dim_order not in dim_orders or padding not in paddings: raise Exception('Error dim_order or padding parameter.') x = _shuffle(x, dim3d[dim_order], dim3d[AR]) if padding == 'same': shp = x.shape.eval() pad = tuple([(s - 2) if s % 2 == 1 else (s - 1) for s in pool_size]) expected = [shp[i + 2] + strides[i] - 1 // strides[i] for i in range(len(strides))] else: pad = (0, 0, 0) if env.get_device() == '': raise NotImplementedError else: output = dnn.dnn_pool(x, pool_size, stride = strides, mode = mode, pad = pad) if padding == 'same': output = output[:, :, : expected[0], : expected[1], : expected[2]] return _shuffle(output, dim3d[AR], dim3d[dim_order])
def build_computation_graph(self): if self.group == 1: conv_out = self.convolution(img=self.input, kerns=self.W, subsample=(self.convstride, self.convstride), border_mode=(self.padsize, self.padsize)) conv_out = conv_out + self.b.dimshuffle('x', 0, 'x', 'x') else: conv_out0 = self.convolution( img=self.input[:, :self.channel / 2, :, :], kerns=self.W0, subsample=(self.convstride, self.convstride), border_mode=(self.padsize, self.padsize)) conv_out0 = conv_out0 + self.b0.dimshuffle('x', 0, 'x', 'x') conv_out1 = self.convolution( img=self.input[:, self.channel / 2:, :, :], kerns=self.W1, subsample=(self.convstride, self.convstride), border_mode=(self.padsize, self.padsize)) conv_out1 = conv_out1 + self.b1.dimshuffle('x', 0, 'x', 'x') conv_out = T.concatenate([conv_out0, conv_out1], axis=1) # ReLu by default output = self.activation_func(conv_out) # Pooling if self.poolsize != 1: if has_cudnn: output = dnn.dnn_pool(output, ws=(self.poolsize, self.poolsize), stride=(self.poolstride, self.poolstride)) else: output = downsample.max_pool_2d(output, ds=(self.poolsize, self.poolsize), st=(self.poolstride, self.poolstride)) return output
def pool3d(x, pool_size, strides=(1, 1, 1), border_mode='valid', dim_ordering='th', pool_mode='max'): # ====== dim ordering ====== # if dim_ordering not in {'th', 'tf'}: raise Exception('Unknown dim_ordering ' + str(dim_ordering)) if dim_ordering == 'tf': x = x.dimshuffle((0, 4, 1, 2, 3)) # ====== border mode ====== # if border_mode == 'same': w_pad = pool_size[0] - 2 if pool_size[0] % 2 == 1 else pool_size[0] - 1 h_pad = pool_size[1] - 2 if pool_size[1] % 2 == 1 else pool_size[1] - 1 d_pad = pool_size[2] - 2 if pool_size[2] % 2 == 1 else pool_size[2] - 1 padding = (w_pad, h_pad, d_pad) elif border_mode == 'valid': padding = (0, 0, 0) elif isinstance(border_mode, (tuple, list)): padding = tuple(border_mode) else: raise Exception('Invalid border mode: ' + str(border_mode)) # ====== pooling ====== # if _on_gpu() and dnn.dnn_available(): pool_out = dnn.dnn_pool(x, pool_size, stride=strides, mode=pool_mode, pad=padding) else: padding = padding[:2] # pooling over conv_dim2, conv_dim1 (last two channels) output = pool.pool_2d(input=x.dimshuffle(0, 1, 4, 3, 2), ds=(pool_size[1], pool_size[0]), st=(strides[1], strides[0]), ignore_border=True, padding=padding, mode=pool_mode) # pooling over conv_dim3 pool_out = pool.pool_2d(input=output.dimshuffle(0, 1, 4, 3, 2), ds=(1, pool_size[2]), st=(1, strides[2]), ignore_border=True, padding=padding, mode=pool_mode) # ====== output ====== # if dim_ordering == 'tf': pool_out = pool_out.dimshuffle((0, 2, 3, 4, 1)) return pool_out
def local_response_normalization_2d_dnn(in_vw, alpha, k, beta, n): """ using cudnn mean pooling """ from theano.sandbox.cuda import dnn assert n % 2 == 1, "n must be odd" in_var = in_vw.variable b, ch, r, c = in_vw.symbolic_shape() squared = T.sqr(in_var) reshaped = squared.reshape((b, 1, ch, r * c)) pooled = dnn.dnn_pool(img=reshaped, ws=(n, 1), stride=(1, 1), pad=(n // 2, 0), mode="average_inc_pad") unreshaped = pooled.reshape((b, ch, r, c)) # multiply by n, since we did a mean pool instead of a sum pool return in_var / (((alpha * n) * unreshaped + k) ** beta)
def _build_computation_graph(self): if self.group == 1: conv_out = self.convolution_func( img=self.input, kerns=self.W, subsample=(self.convstride, self.convstride), border_mode=(self.padsize, self.padsize) ) conv_out = conv_out + self.b.dimshuffle('x', 0, 'x', 'x') else: conv_out0 = self.convolution_func( img=self.input[:, :self.channel / 2, :, :], kerns=self.W0, subsample=(self.convstride, self.convstride), border_mode=(self.padsize, self.padsize) ) conv_out0 = conv_out0 + self.b0.dimshuffle('x', 0, 'x', 'x') conv_out1 = self.convolution_func( img=self.input[:, self.channel / 2:, :, :], kerns=self.W1, subsample=(self.convstride, self.convstride), border_mode=(self.padsize, self.padsize) ) conv_out1 = conv_out1 + self.b1.dimshuffle('x', 0, 'x', 'x') conv_out = T.concatenate([conv_out0, conv_out1], axis=1) # ReLu by default output = self.activation_func(conv_out) # Pooling if self.poolsize != 1: if has_cudnn: output = dnn.dnn_pool(output, ws=(self.poolsize, self.poolsize), stride=(self.poolstride, self.poolstride)) else: output = downsample.max_pool_2d(output, ds=(self.poolsize, self.poolsize), st=(self.poolstride, self.poolstride)) return output
def __init__(self, input, poolsize, poolstride, lib_conv, poolpad=0, poolmode='max', caffe_style=False): ''' lib_conv can be cudnn (recommended)or cudaconvnet ''' self.poolsize = poolsize if lib_conv == 'cudaconvnet': # Pooling if self.poolsize != 1: self.pool_op = MaxPool(ds=poolsize, stride=poolstride) self.output = self.pool_op(input) elif 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 caffe_style: self.output = input_shuffled[:, :, ::-1, ::-1] else: self.output = input_shuffled # poolpad=1 if self.poolsize != 1: self.output = dnn.dnn_pool(self.output, ws=(poolsize, poolsize), stride=(poolstride, poolstride), mode=poolmode, pad=(poolpad, poolpad)) if caffe_style: self.output = self.output[:, :, ::-1, ::-1] self.output = self.output.dimshuffle(1, 2, 3, 0) # bc01 to c01b # self.pool_out=self.output else: NotImplementedError("lib_conv can only be cudaconvnet or cudnn")
def drop_output(self, input, drop=0, rng=None, p=0.5): # convolve input feature maps with filters ''' dnn ''' if self.border_mode == 'same': conv_out = dnn.dnn_conv( img=input, kerns=self.W, subsample=(1,1), border_mode=self.border, #conv_mode='cross' ) else: raise Exception('Unknown conv type') # downsample each feature map individually, using maxpooling if self.poolsize[0] == 1 and self.poolsize[1] == 1: pooled_out = conv_out else: pooled_out = dnn.dnn_pool( img=conv_out, ws=self.poolsize, stride=self.poolsize, mode='max', pad=(0,0) ) # add the bias term. Since the bias is a vector (1D array), we first # reshape it to a tensor of shape (1, n_filters, 1, 1). Each bias will # thus be broadcasted across mini-batches and feature map # width & height lin_output = pooled_out + self.b.dimshuffle('x', 0, 'x', 'x') output = ( lin_output if self.activation is None else self.activation(lin_output) ) droppedOutput = nonlinearity.dropout(rng, output, p) return T.switch(T.neq(drop, 0), droppedOutput, output)
def _output(self, input, *args, **kwargs): origin = input[:, - self.n_in:] r_3_r, r_5_r, r_7_r = origin, origin, origin c = 0 if self.n_out_3x3_r > 0: r_3_r = input[:, c:c + self.n_out_3x3_r] c += self.n_out_3x3_r if self.n_out_5x5_r > 0: r_5_r = input[:, c:c + self.n_out_5x5_r] c += self.n_out_5x5_r if self.n_out_7x7_r > 0: r_7_r = input[:, c:c + self.n_out_7x7_r] c += self.n_out_7x7_r input = origin r_1 = None if not None == self.W_1x1: r_1 = self._conv(self.W_1x1, self.b_1x1, img=input) if not self.W_mp_r == None: r_1 = r_1[:, :, 1:-1, 1:-1] pad_ = 1 if self.W_mp_r == None else 0 r_3 = self._conv(self.W_3x3, self.b_3x3, img=r_3_r, pad=pad_ + 0) r_5 = self._conv(self.W_5x5, self.b_5x5, img=r_5_r, pad=pad_ + 1) r_7 = self._conv(self.W_7x7, self.b_7x7, img=r_7_r, pad=pad_ + 2) r_mp = None if not None == self.W_mp_r: r_mp = dnn.dnn_pool(input, ws=(3, 3), stride=(1, 1)) r_mp = self._conv(self.W_mp_r, self.b_mp_r, img=r_mp) results = [] for r in [r_1, r_3, r_5, r_7, r_mp]: if not None == r: results.append(r) r = T.concatenate(results, axis=1) return r
def _output(self, input, *args, **kwargs): results = [] def conv(w, b, pad=0, img=None): if None == img: img = input if None == w: return None out = dnn.dnn_conv( img=img, kerns=w, subsample=(1, 1), border_mode=pad) out += b.dimshuffle('x', 0, 'x', 'x') out = T.maximum(out, 0) return out r_1 = None if not None == self.W_1x1: r_1 = conv(self.W_1x1, self.b_1x1) if not self.W_mp_r == None: r_1 = r_1[:, :, 1:-1, 1:-1] pad_ = 1 if self.W_mp_r == None else 0 r_3_r = conv(self.W_3x3_r, self.b_3x3_r) r_3 = conv(self.W_3x3, self.b_3x3, img=r_3_r, pad=pad_ + 0) r_5_r = conv(self.W_5x5_r, self.b_5x5_r) r_5 = conv(self.W_5x5, self.b_5x5, img=r_5_r, pad=pad_ + 1) r_7_r = conv(self.W_7x7_r, self.b_7x7_r) r_7 = conv(self.W_7x7, self.b_7x7, img=r_7_r, pad=pad_ + 2) r_mp = None if not None == self.W_mp_r: r_mp = dnn.dnn_pool(input, ws=(3, 3), stride=(1, 1)) r_mp = conv(self.W_mp_r, self.b_mp_r, img=r_mp) for r in [r_1, r_3, r_5, r_7, r_mp]: if not None == r: results.append(r) r = T.concatenate(results, axis=1) return r