def __init__(self, incoming, num_filters, filter_size, stride=(1, 1), pad=0, untie_biases=False, W=init.GlorotUniform(), b=init.Constant(0.), nonlinearity=nonlinearities.rectify, convolution=T.nnet.conv2d, **kwargs): super(Conv2DLayer, self).__init__(incoming, **kwargs) if nonlinearity is None: self.nonlinearity = nonlinearities.identity else: self.nonlinearity = nonlinearity self.num_filters = num_filters self.filter_size = as_tuple(filter_size, 2) self.stride = as_tuple(stride, 2) self.untie_biases = untie_biases self.convolution = convolution if pad == 'valid': self.pad = (0, 0) elif pad in ('full', 'same'): self.pad = pad else: self.pad = as_tuple(pad, 2, int) self.W = self.add_param(W, self.get_W_shape(), name="W") if b is None: self.b = None else: if self.untie_biases: biases_shape = (num_filters, self.output_shape[2], self. output_shape[3]) else: biases_shape = (num_filters,) self.b = self.add_param(b, biases_shape, name="b", regularizable=False)
def __init__(self, incoming, pnorm, pool_size, stride=None, pad=(0, 0), ignore_border=True, mode='average_inc_pad', **kwargs): super(LPPool2DLayer, self).__init__(incoming, **kwargs) if len(self.input_shape) != 4: raise ValueError("Tried to create a 2D pooling layer with " "input shape %r. Expected 4 input dimensions " "(batchsize, channels, 2 spatial dimensions)." % (self.input_shape, )) self.pnorm = T.cast(pnorm, dtype=theano.config.floatX) self.pool_size = as_tuple(pool_size, 2) if stride is None: self.stride = self.pool_size else: self.stride = as_tuple(stride, 2) self.pad = as_tuple(pad, 2) self.ignore_border = ignore_border # The ignore_border argument is for compatibility with MaxPool2DLayer. # ignore_border=False is not supported. Borders are always ignored. # if not ignore_border: # raise NotImplementedError("LPPool2DLayer is based on " # "Pool2DDNNLayer that does not support " # "ignore_border=False.") if mode != 'average_inc_pad' and mode != 'average_exc_pad': raise ValueError("LPPool2DLayer requires mode=average_inc_pad" " or mode=average_exc_pad, but received " "mode={} instead.".format(mode)) self.mode = mode
def __init__(self, incoming, pnorm, pool_size, stride=None, pad=(0, 0), ignore_border=True, mode='average_inc_pad', **kwargs): super(LPPool2DLayer, self).__init__(incoming, **kwargs) if len(self.input_shape) != 4: raise ValueError("Tried to create a 2D pooling layer with " "input shape %r. Expected 4 input dimensions " "(batchsize, channels, 2 spatial dimensions)." % (self.input_shape,)) self.pnorm = T.cast(pnorm, dtype=theano.config.floatX) self.pool_size = as_tuple(pool_size, 2) if stride is None: self.stride = self.pool_size else: self.stride = as_tuple(stride, 2) self.pad = as_tuple(pad, 2) self.ignore_border = ignore_border # The ignore_border argument is for compatibility with MaxPool2DLayer. # ignore_border=False is not supported. Borders are always ignored. # if not ignore_border: # raise NotImplementedError("LPPool2DLayer is based on " # "Pool2DDNNLayer that does not support " # "ignore_border=False.") if mode != 'average_inc_pad' and mode != 'average_exc_pad': raise ValueError("LPPool2DLayer requires mode=average_inc_pad" " or mode=average_exc_pad, but received " "mode={} instead.".format(mode)) self.mode = mode
def __init__(self, incoming, pool_size, stride=None, pad=(0, 0, 0), ignore_border=True, mode='max', **kwargs): super(Pool3DLayer, self).__init__(incoming, **kwargs) self.pool_size = as_tuple(pool_size, 3) if len(self.input_shape) != 5: raise ValueError("Tried to create a 3D pooling layer with " "input shape %r. Expected 5 input dimensions " "(batchsize, channels, 3 spatial dimensions)." % (self.input_shape, )) if stride is None: self.stride = self.pool_size else: self.stride = as_tuple(stride, 3) self.pad = as_tuple(pad, 3) self.ignore_border = ignore_border self.mode = mode
def __init__(self, incoming, num_filters, filter_size, stride=(1, 1), pad="same", untie_biases=False, W=lasagne.init.GlorotUniform(), b=lasagne.init.Constant(0.1), nonlinearity=lasagne.nonlinearities.rectify, convolution=T.nnet.conv2d, **kwargs): super(ConvMMax2DLayer, self).__init__(incoming, **kwargs) if nonlinearity is None: self.nonlinearity = lasagne.nonlinearities.identity else: self.nonlinearity = nonlinearity self.num_filters = num_filters self.filter_size = as_tuple(filter_size, 2) self.stride = as_tuple(stride, 2) self.untie_biases = untie_biases self.convolution = convolution if pad == 'valid': self.pad = (0, 0) elif pad in ('full', 'same'): self.pad = pad else: self.pad = as_tuple(pad, 2, int) self.W = self.add_param(W, self.get_W_shape(), name="W") if b is None: self.b = None else: if self.untie_biases: biases_shape = (num_filters, self.output_shape[2], self. output_shape[3]) else: biases_shape = (num_filters,) self.b = self.add_param(b, biases_shape, name="b", regularizable=False)
def __init__(self, incoming, num_filters, filter_size, stride=1, pad=0, untie_biases=False, W=init.GlorotUniform(), b=init.Constant(0.), nonlinearity=nonlinearities.rectify, flip_filters=True, n=None, **kwargs): super(BaseConvLayer, self).__init__(incoming, **kwargs) if nonlinearity is None: self.nonlinearity = nonlinearities.identity else: self.nonlinearity = nonlinearity if n is None: n = len(self.input_shape) - 2 elif n != len(self.input_shape) - 2: raise ValueError("Tried to create a %dD convolution layer with " "input shape %r. Expected %d input dimensions " "(batchsize, channels, %d spatial dimensions)." % (n, self.input_shape, n + 2, n)) self.n = n self.num_filters = num_filters self.filter_size = as_tuple(filter_size, n, int) self.flip_filters = flip_filters self.stride = as_tuple(stride, n, int) self.untie_biases = untie_biases if pad == 'same': if any(s % 2 == 0 for s in self.filter_size): raise NotImplementedError( '`same` padding requires odd filter size.') if pad == 'valid': self.pad = as_tuple(0, n) elif pad in ('full', 'same'): self.pad = pad else: self.pad = as_tuple(pad, n, int) self.W = self.add_param(W, self.get_W_shape(), name="W") if b is None: self.b = None else: if self.untie_biases: biases_shape = (num_filters, ) + self.output_shape[2:] else: biases_shape = (num_filters, ) self.b = self.add_param(b, biases_shape, name="b", regularizable=False)
def __init__(self, incoming, localization_network, method, scale_factor=1, resize_factor = 1, dtype = 'float32', **kwargs): super(PerspectiveLayer, self).__init__( [incoming, localization_network], **kwargs) self.scale_factor = as_tuple(scale_factor, 2) self.dtype = dtype self.resize_factor = as_tuple(resize_factor, 2) input_shp, loc_shp = self.input_shapes self.method = method if len(input_shp) != 4: raise ValueError("The input network must have a 4-dimensional " "output shape: (batch_size, num_input_channels, " "input_rows, input_columns)")
def __init__(self, incoming, num_filters, filter_size, stride=(1, 1), border_mode=None, untie_biases=False, W=upsample_filt([64,64,3,3]).astype(np.float32), pad=None, nonlinearity=lasagne.nonlinearities.rectify, flip_filters=False, **kwargs): super(DeConv2DDNNLayer, self).__init__(incoming, **kwargs) if nonlinearity is None: self.nonlinearity = nonlinearities.identity else: self.nonlinearity = nonlinearity self.num_filters = num_filters self.filter_size = as_tuple(filter_size, 2) self.stride = as_tuple(stride, 2) self.untie_biases = untie_biases self.flip_filters = flip_filters if border_mode is not None and pad is not None: raise RuntimeError("You cannot specify both 'border_mode' and " "'pad'. To avoid ambiguity, please specify " "only one of them.") elif border_mode is None and pad is None: # no option specified, default to valid mode self.pad = (0, 0) self.border_mode = 'valid' elif border_mode is not None: if border_mode == 'valid': self.pad = (0, 0) self.border_mode = 'valid' elif border_mode == 'full': self.pad = (self.filter_size[0] - 1, self.filter_size[1] - 1) self.border_mode = 'full' elif border_mode == 'same': # dnn_conv does not support same, so we just specify # padding directly. # only works for odd filter size, but the even filter size # case is probably not worth supporting. self.pad = ((self.filter_size[0] - 1) // 2, (self.filter_size[1] - 1) // 2) self.border_mode = None else: raise RuntimeError("Invalid border mode: '%s'" % border_mode) else: self.pad = as_tuple(pad, 2) self.border_mode = None #self.W = self.add_param(W, self.get_W_shape(), name="W") #W = upsample_filt([num_filters,num_filters,filter_size[0],filter_size[0]]).astype(np.float32) self.W = self.add_param(W, self.get_W_shape(), name='W', trainable=False, regularizable=False) '''
def __init__(self, incoming, pool_size, stride=None, pad=0, ignore_border=True, mode='max', **kwargs): super(Pool1DLayer, self).__init__(incoming, **kwargs) if len(self.input_shape) != 4: raise ValueError("Tried to create a 1D time-step pooling layer with " "input shape %r. Expected 4 input dimensions " "(batchsize, n-step, channels, 1 spatial dimensions)." % (self.input_shape,)) self.pool_size = as_tuple(pool_size, 1) self.stride = self.pool_size if stride is None else as_tuple(stride, 1) self.pad = as_tuple(pad, 1) self.ignore_border = ignore_border self.mode = mode
def transposed_convNd(input, kernel, crop, stride=1, n=None): if n is None: n = input.ndim - 2 if crop == 'valid': pad = 'full' elif crop == 'full': pad = 'valid' elif crop == 'same': pad = 'same' else: crop = as_tuple(crop, n, int) pad = tuple(f - 1 - c for f, c in zip(kernel.shape[2:], crop)) stride = as_tuple(stride, n, int) dilated_input = dilate(input, (1, 1) + stride) return convNd(dilated_input, kernel, pad, stride=1, n=n)
def __init__(self, incoming, num_filters, filter_size, stride=(1, 1), crop=0, untie_biases=False, W=init.GlorotUniform(), b=init.Constant(0.), nonlinearity=nonlinearities.rectify, flip_filters=False, output_size=None, **kwargs): # output_size must be set before calling the super constructor if (not isinstance(output_size, T.Variable) and output_size is not None): output_size = as_tuple(output_size, 2, int) self.output_size = output_size super(TransposedConv2DLayer, self).__init__(incoming, num_filters, filter_size, stride, crop, untie_biases, W, b, nonlinearity, flip_filters, n=2, **kwargs) # rename self.pad to self.crop: self.crop = self.pad del self.pad
def __init__(self, incoming, num_filters, filter_size, stride=(1, 1, 1), crop=0, untie_biases=False, W=lasagne.init.GlorotUniform(), b=lasagne.init.Constant(0.), nonlinearity=lasagne.nonlinearities.rectify, flip_filters=False, output_size=None, **kwargs): # output_size must be set before calling the super constructor if (not isinstance(output_size, T.Variable) and output_size is not None): output_size = as_tuple(output_size, 3, int) self.output_size = output_size BaseConvLayer.__init__(self, incoming, num_filters, filter_size, stride, crop, untie_biases, W, b, nonlinearity, flip_filters, n=3, **kwargs) # rename self.pad to self.crop: #if crop is None: self.crop = self.pad del self.pad
def __init__(self, incoming, scale_factor, **kwargs): super(Upscale3DLayer, self).__init__(incoming, **kwargs) self.scale_factor = as_tuple(scale_factor, 3) if any([s<1 for s in self.scale_factor]): raise ValueError('Scale factor must be >= 1, not {0}'.format( self.scale_factor))
def __init__(self, incoming, num_filters, filter_size, stride=1, pad=0, untie_biases=False, W=init.GlorotUniform(), b=init.Constant(0.), nonlinearity=nonlinearities.rectify, flip_filters=True, n=None, **kwargs): super(BaseConvLayer, self).__init__(incoming, **kwargs) if nonlinearity is None: self.nonlinearity = nonlinearities.identity else: self.nonlinearity = nonlinearity if n is None: n = len(self.input_shape) - 2 elif n != len(self.input_shape) - 2: raise ValueError("Tried to create a %dD convolution layer with " "input shape %r. Expected %d input dimensions " "(batchsize, channels, %d spatial dimensions)." % (n, self.input_shape, n+2, n)) self.n = n self.num_filters = num_filters self.filter_size = as_tuple(filter_size, n, int) self.flip_filters = flip_filters self.stride = as_tuple(stride, n, int) self.untie_biases = untie_biases if pad == 'same': if any(s % 2 == 0 for s in self.filter_size): raise NotImplementedError( '`same` padding requires odd filter size.') if pad == 'valid': self.pad = as_tuple(0, n) elif pad in ('full', 'same'): self.pad = pad else: self.pad = as_tuple(pad, n, int) self.W = self.add_param(W, self.get_W_shape(), name="W") if b is None: self.b = None else: if self.untie_biases: biases_shape = (num_filters,) + self.output_shape[2:] else: biases_shape = (num_filters,) self.b = self.add_param(b, biases_shape, name="b", regularizable=False)
def __init__(self, incoming, filter_size, init_std=5., W_logstd=None, stride=1, pad=0, nonlinearity=None, convolution=conv1d_mc0, **kwargs): super(GaussianScan1DLayer, self).__init__(incoming, **kwargs) # convolution = conv1d_gpucorrmm_mc0 # convolution = conv.conv1d_mc0 # convolution = T.nnet.conv2d if nonlinearity is None: self.nonlinearity = nonlinearities.identity else: self.nonlinearity = nonlinearity self.filter_size = as_tuple(filter_size, 1) self.stride = as_tuple(stride, 1) self.convolution = convolution # if self.filter_size[0] % 2 == 0: # raise NotImplementedError( # 'GaussianConv1dLayer requires odd filter size.') if pad == 'valid': self.pad = (0, ) elif pad in ('full', 'same', 'strictsame'): self.pad = pad else: self.pad = as_tuple(pad, 1, int) if W_logstd is None: init_std = np.asarray(init_std, dtype=floatX) W_logstd = init.Constant(np.log(init_std)) # print(W_std) # W_std = init.Constant(init_std), self.num_input_channels = self.input_shape[1] # self.num_filters = self.num_input_channels self.W_logstd = self.add_param(W_logstd, (self.num_input_channels, ), name="W_logstd", regularizable=False) self.W = self.make_gaussian_filter()
def __init__(self, incoming, scale_factor, pool2d_layer, pool2d_layer_in, **kwargs): super(Upscale2DLayer, self).__init__(incoming, **kwargs) self.scale_factor = as_tuple(scale_factor, 2) self.pool2d_layer = pool2d_layer self.pool2d_layer_in = pool2d_layer_in if self.scale_factor[0] < 1 or self.scale_factor[1] < 1: raise ValueError('Scale factor must be >= 1, not {0}'.format( self.scale_factor))
def __init__(self, incoming, pool_size, stride=None, pad=(0, 0), ignore_border=True, mode='max', **kwargs): super(Pool2DXLayer, self).__init__(incoming, **kwargs) self.pool_size = as_tuple(pool_size, 2) if stride is None: self.stride = self.pool_size else: self.stride = as_tuple(stride, 2) if pad == 'strictsamex': self.pad = pad else: self.pad = as_tuple(pad, 2) self.ignore_border = ignore_border self.mode = mode
def __init__(self, incoming, num_filters, filter_size, stride=(1, 1), pad=0, untie_biases=False, W=init.GlorotUniform(), b=init.Constant(0.), nonlinearity=nonlinearities.rectify, convolution=T.nnet.conv2d, **kwargs): super(Conv2DXLayer, self).__init__(incoming, **kwargs) if nonlinearity is None: self.nonlinearity = nonlinearities.identity else: self.nonlinearity = nonlinearity self.num_filters = num_filters self.filter_size = as_tuple(filter_size, 2) self.stride = as_tuple(stride, 2) self.untie_biases = untie_biases self.convolution = convolution if pad == 'same': if any(s % 2 == 0 for s in self.filter_size): raise NotImplementedError( '`same` padding requires odd filter size.') if pad == 'strictsamex': if not (stride == 1 or stride == (1, 1)): raise NotImplementedError( '`strictsamex` padding requires stride=(1, 1) or 1') if pad == 'valid': self.pad = (0, 0) elif pad in ('full', 'same', 'strictsamex'): self.pad = pad else: self.pad = as_tuple(pad, 2, int) self.W = self.add_param(W, self.get_W_shape(), name="W") if b is None: self.b = None else: if self.untie_biases: biases_shape = (num_filters, self.output_shape[2], self. output_shape[3]) else: biases_shape = (num_filters,) self.b = self.add_param(b, biases_shape, name="b", regularizable=False)
def transposed_convNd(input, kernel, crop, stride=1, n=None, extend=None): if n is None: n = input.ndim - 2 if crop == 'valid': pad = 'full' elif crop == 'full': pad = 'valid' elif crop == 'same': pad = 'same' else: crop = as_tuple(crop, n, int) pad = tuple(f - 1 - c for f, c in zip(kernel.shape[2:], crop)) stride = as_tuple(stride, n, int) dilated_input = dilate(input, (1, 1) + stride) if extend is not None: extend = as_tuple(extend, n, int) extend = [(0, p) for p in (0, 0) + extend] dilated_input = np.pad(dilated_input, extend, mode='constant') return convNd(dilated_input, kernel, pad, stride=1, n=n)
def __init__(self, incoming, num_filters, num_rot, filter_size, stride=(1, 1), border_mode="valid", untie_biases=False, W=init.GlorotUniform(), b=init.Constant(0.), nonlinearity=nonlinearities.rectify, convolution=T.nnet.conv2d, **kwargs): super(RotConv, self).__init__(incoming, **kwargs) if nonlinearity is None: self.nonlinearity = nonlinearities.identity else: self.nonlinearity = nonlinearity self.num_filters = num_filters self.num_rot = num_rot self.filter_size = as_tuple(filter_size, 2) self.stride = as_tuple(stride, 2) self.border_mode = border_mode self.untie_biases = untie_biases self.convolution = convolution if self.border_mode not in ['valid', 'full', 'same']: raise RuntimeError("Invalid border mode: '%s'" % self.border_mode) self.W = self.add_param(W, self.get_W_shape(), name="W") if b is None: self.b = None else: if self.untie_biases: biases_shape = (num_filters, self.output_shape[2], self.output_shape[3]) else: biases_shape = (num_filters, ) self.b = self.add_param(b, biases_shape, name="b", regularizable=False)
def __init__(self, incoming, filter_size, init_std=5., W_logstd=None, stride=1, pad=0, nonlinearity=None, convolution=conv1d_mc0, **kwargs): super(GaussianScan1DLayer, self).__init__(incoming, **kwargs) # convolution = conv1d_gpucorrmm_mc0 # convolution = conv.conv1d_mc0 # convolution = T.nnet.conv2d if nonlinearity is None: self.nonlinearity = nonlinearities.identity else: self.nonlinearity = nonlinearity self.filter_size = as_tuple(filter_size, 1) self.stride = as_tuple(stride, 1) self.convolution = convolution # if self.filter_size[0] % 2 == 0: # raise NotImplementedError( # 'GaussianConv1dLayer requires odd filter size.') if pad == 'valid': self.pad = (0,) elif pad in ('full', 'same', 'strictsame'): self.pad = pad else: self.pad = as_tuple(pad, 1, int) if W_logstd is None: init_std = np.asarray(init_std, dtype=floatX) W_logstd = init.Constant(np.log(init_std)) # print(W_std) # W_std = init.Constant(init_std), self.num_input_channels = self.input_shape[1] # self.num_filters = self.num_input_channels self.W_logstd = self.add_param(W_logstd, (self.num_input_channels,), name="W_logstd", regularizable=False) self.W = self.make_gaussian_filter()
def __init__(self, incoming, pool_size, stride=None, pad=(0, 0, 0), ignore_border=True, mode='max', **kwargs): super(Pool3DLayer, self).__init__(incoming, **kwargs) self.pool_size = as_tuple(pool_size, 3) if len(self.input_shape) != 5: raise ValueError("Tried to create a 3D pooling layer with " "input shape %r. Expected 5 input dimensions " "(batchsize, channels, 3 spatial dimensions)." % (self.input_shape,)) if stride is None: self.stride = self.pool_size else: self.stride = as_tuple(stride, 3) self.pad = as_tuple(pad, 3) self.ignore_border = ignore_border self.mode = mode
def test_as_tuple_fails(): from lasagne.utils import as_tuple, int_types with pytest.raises(ValueError) as exc: as_tuple([1, 2, 3], 4) assert "length 4" in exc.value.args[0] with pytest.raises(TypeError) as exc: as_tuple('asdf', 4, int) assert "of int," in exc.value.args[0] with pytest.raises(TypeError) as exc: as_tuple('asdf', 4, (int, float)) assert "of int or float," in exc.value.args[0] with pytest.raises(TypeError) as exc: as_tuple('asdf', 4, int_types) assert "of int," in exc.value.args[0]
def __init__(self, incoming, window=scipy.signal.hann, n_ch=2, n_fft=2048, hop_size=512, log_amplitude=True, **kwargs): """ """ super(STFTLayer, self).__init__(incoming, **kwargs) n = 2 # 2D convolution if n_ch > 2 or n_ch < 1: raise ValueError("n_ch should be either 1 (mono) or 2 (stereo)") self.n_ch = n_ch self.window = window self.n_fft = n_fft self.hop_size = hop_size self.log_amp = log_amplitude self.filter_size = as_tuple((n_fft, 1), n, int) self.stride = as_tuple((hop_size, 1), n, int) # dft kernels for real and imaginary domain W_r, W_i = _get_stft_kernels(n_fft, window=window, keras_ver='old') self.W_r = self.add_param(W_r, shape=W_r.shape, name='DFT_real_kernel', trainable=False, regularizable=False) self.W_i = self.add_param(W_i, shape=W_i.shape, name='DFT_image_kernel', trainable=False, regularizable=False)
def __init__(self, incoming, pool_size, stride=None, pad=0, ignore_border=True, mode='max', **kwargs): super(Pool1DLayer, self).__init__(incoming, **kwargs) if len(self.input_shape) != 4: raise ValueError( "Tried to create a 1D time-step pooling layer with " "input shape %r. Expected 4 input dimensions " "(batchsize, n-step, channels, 1 spatial dimensions)." % (self.input_shape, )) self.pool_size = as_tuple(pool_size, 1) self.stride = self.pool_size if stride is None else as_tuple(stride, 1) self.pad = as_tuple(pad, 1) self.ignore_border = ignore_border self.mode = mode
def __init__(self, incoming, scale_factor, mode='repeat', **kwargs): super(Upscale2DLayer, self).__init__(incoming, **kwargs) self.scale_factor = as_tuple(scale_factor, 2) if self.scale_factor[0] < 1 or self.scale_factor[1] < 1: raise ValueError('Scale factor must be >= 1, not {0}'.format( self.scale_factor)) if mode not in {'repeat', 'dilate'}: msg = "Mode must be either 'repeat' or 'dilate', not {0}" raise ValueError(msg.format(mode)) self.mode = mode
def __init__(self, incoming, filter_size, init_std=5., stride=1, pad=0, nonlinearity=None, convolution=conv1d_mc0, **kwargs): super(GaussianScan1DLayer, self).__init__(incoming, **kwargs) if nonlinearity is None: self.nonlinearity = nonlinearities.identity else: self.nonlinearity = nonlinearity self.filter_size = as_tuple(filter_size, 1) self.stride = as_tuple(stride, 1) self.convolution = convolution if pad == 'valid': self.pad = (0, ) elif pad in ('full', 'same', 'strictsame'): self.pad = pad else: self.pad = as_tuple(pad, 1, int) init_std = np.asarray(init_std, dtype=floatX) W_logstd = init.Constant(np.log(init_std)) # print(W_std) # W_std = init.Constant(init_std), self.num_input_channels = self.input_shape[1] # self.num_filters = self.num_input_channels self.W_logstd = self.add_param(W_logstd, (self.num_input_channels, ), name="W_logstd", regularizable=False, trainable=False) self.W = self.make_gaussian_filter()
def __init__(self, incoming, localization_network, downsample_factor=1, **kwargs): super(Transformer3DLayer, self).__init__( [incoming, localization_network], **kwargs) self.downsample_factor = as_tuple(downsample_factor, 3) input_shp, loc_shp = self.input_shapes if loc_shp[-1] != 12 or len(loc_shp) != 2: raise ValueError("The localization network must have " "output shape: (batch_size, 12)") if len(input_shp) != 5: raise ValueError("The input network must have a 5-dimensional " "output shape: (batch_size, num_input_channels, " "input_rows, input_columns, input_depth)")
def __init__(self, incoming, pool_size, stride=None, pad=(0, 0), ignore_border=True, mode='learned_norm', P=2.0, **kwargs): super(LearnedNorm2DLayer, self).__init__(incoming, pool_size, stride=None, pad=(0, 0), ignore_border=True, **kwargs) self.pool_size = as_tuple(pool_size, 2) if len(self.input_shape) != 4: raise ValueError("Tried to create a 2D pooling layer with " "input shape %r. Expected 4 input dimensions " "(batchsize, channels, 2 spatial dimensions)." % (self.input_shape,)) if stride is None: self.stride = self.pool_size else: self.stride = as_tuple(stride, 2) self.pad = as_tuple(pad, 2) self.ignore_border = ignore_border self.mode = mode self.P = self.add_param(numpy.asarray(P), numpy.shape(numpy.asarray(P)), name='P', trainable=True)
def conv2d(input, kernel, pad): """Execute a 2D convolution. Parameters ---------- input : numpy array kernel : numpy array pad : {0, 'valid', 'same', 'full'} Returns ------- numpy array """ if pad not in ['valid', 'same', 'full']: pad = as_tuple(pad, 2, int) input = np.pad(input, ((0, 0), (0, 0), (pad[0], pad[0]), (pad[1], pad[1])), mode='constant') pad = 'valid' output = np.zeros((input.shape[0], kernel.shape[0], input.shape[2] + kernel.shape[2] - 1, input.shape[3] + kernel.shape[3] - 1, )) for i in range(kernel.shape[2]): for j in range(kernel.shape[3]): k = kernel[:, :, i, j][:, :, np.newaxis, np.newaxis] output[:, :, i:i + input.shape[2], j:j + input.shape[3]] += (input[:, np.newaxis] * k).sum(2) if pad == 'valid': trim = (kernel.shape[2] - 1, kernel.shape[3] - 1) output = output[:, :, trim[0]:-trim[0] or None, trim[1]:-trim[1] or None] elif pad == 'same': shift_x = (kernel.shape[2] - 1) // 2 shift_y = (kernel.shape[3] - 1) // 2 output = output[:, :, shift_x:input.shape[2] + shift_x, shift_y:input.shape[3] + shift_y] return output
def __init__(self, incoming, localization_network, downsample_factor=1, **kwargs): super(TransformerLayer, self).__init__([incoming, localization_network], **kwargs) self.downsample_factor = as_tuple(downsample_factor, 2) input_shp, loc_shp = self.input_shapes if loc_shp[-1] != 6 or len(loc_shp) != 2: raise ValueError("The localization network must have " "output shape: (batch_size, 6)") if len(input_shp) != 4: raise ValueError("The input network must have a 4-dimensional " "output shape: (batch_size, num_input_channels, " "input_rows, input_columns)")
def conv2d(input, kernel, pad): """Execute a 2D convolution. Parameters ---------- input : numpy array kernel : numpy array pad : {0, 'valid', 'same', 'full'} Returns ------- numpy array """ if pad not in ['valid', 'same', 'full']: pad = as_tuple(pad, 2, int) input = np.pad(input, ((0, 0), (0, 0), (pad[0], pad[0]), (pad[1], pad[1])), mode='constant') pad = 'valid' output = np.zeros(( input.shape[0], kernel.shape[0], input.shape[2] + kernel.shape[2] - 1, input.shape[3] + kernel.shape[3] - 1, )) for i in range(kernel.shape[2]): for j in range(kernel.shape[3]): k = kernel[:, :, i, j][:, :, np.newaxis, np.newaxis] output[:, :, i:i + input.shape[2], j:j + input.shape[3]] += (input[:, np.newaxis] * k).sum(2) if pad == 'valid': trim = (kernel.shape[2] - 1, kernel.shape[3] - 1) output = output[:, :, trim[0]:-trim[0] or None, trim[1]:-trim[1] or None] elif pad == 'same': shift_x = (kernel.shape[2] - 1) // 2 shift_y = (kernel.shape[3] - 1) // 2 output = output[:, :, shift_x:input.shape[2] + shift_x, shift_y:input.shape[3] + shift_y] return output
def __init__(self, incoming, localization_network, downsample_factor=1, control_points=16, precompute_grid='auto', **kwargs): super(TPSTransformerLayer, self).__init__([incoming, localization_network], **kwargs) self.downsample_factor = as_tuple(downsample_factor, 2) self.control_points = control_points input_shp, loc_shp = self.input_shapes # Error checking if loc_shp[-1] != 2 * control_points or len(loc_shp) != 2: raise ValueError("The localization network must have " "output shape: (batch_size, " "2*control_points)") if round(np.sqrt(control_points)) != np.sqrt(control_points): raise ValueError("The number of control points must be" " a perfect square.") if len(input_shp) != 4: raise ValueError("The input network must have a 4-dimensional " "output shape: (batch_size, num_input_channels, " "input_rows, input_columns)") # Process precompute grid can_precompute_grid = all(s is not None for s in input_shp[2:]) if precompute_grid == 'auto': precompute_grid = can_precompute_grid elif precompute_grid and not can_precompute_grid: raise ValueError("Grid can only be precomputed if the input " "height and width are pre-specified.") self.precompute_grid = precompute_grid # Create source points and L matrix self.right_mat, self.L_inv, self.source_points, self.out_height, \ self.out_width = _initialize_tps( control_points, input_shp, self.downsample_factor, precompute_grid)
def __init__(self, incoming, localization_network, downsample_factor=1, control_points=16, border_mode='nearest', **kwargs): super(TPSTransformer, self).__init__([incoming, localization_network], **kwargs) self.border_mode = border_mode self.downsample_factor = as_tuple(downsample_factor, 2) self.control_points = control_points input_shp, loc_shp = self.input_shapes #localization should output coefficient (batch_size,2,num_l_points+3) # Create source points and L matrix self.right_mat, self.source_points, self.out_height, self.out_width = _initialize_tps( control_points, input_shp, self.downsample_factor)
def __init__(self, incoming, num_filters, filter_size, dilation=(1, 1), pad=0, untie_biases=False, W=init.GlorotUniform(), b=init.Constant(0.), nonlinearity=nonlinearities.rectify, flip_filters=False, **kwargs): self.dilation = as_tuple(dilation, 2, int) super(DilatedConv2DLayer, self).__init__( incoming, num_filters, filter_size, 1, pad, untie_biases, W, b, nonlinearity, flip_filters, n=2, **kwargs) # remove self.stride: del self.stride # require valid convolution if self.pad != (0, 0): raise NotImplementedError( "DilatedConv2DLayer requires pad=0 / (0,0) / 'valid', but " "got %r. For a padded dilated convolution, add a PadLayer." % (pad,)) # require unflipped filters if self.flip_filters: raise NotImplementedError( "DilatedConv2DLayer requires flip_filters=False.")
def __init__(self, incoming, n, W = lasagne.init.Normal(5), name=None, downsample_factor = 1, control_points=16, precompute_grid = 'auto', **kwargs): super(TPSTransformationMatrixLayer, self).__init__( incoming, **kwargs) self.n = n self.W = self.add_param(W, (n, control_points * 2), name = "localization") self.downsample_factor = as_tuple(downsample_factor, 2) self.control_points = control_points input_shp = self.input_shape if round(np.sqrt(control_points)) != np.sqrt( control_points): raise ValueError("The number of control points must be" " a perfect square.") if len(input_shp) != 4: raise ValueError("The input network must have a 4-dimensional " "output shape: (batch_size, num_input_channels, " "input_rows, input_columns)") # Process precompute grid can_precompute_grid = all(s is not None for s in input_shp[2:]) if precompute_grid == 'auto': precompute_grid = can_precompute_grid elif precompute_grid and not can_precompute_grid: raise ValueError("Grid can only be precomputed if the input " "height and width are pre-specified.") self.precompute_grid = precompute_grid # Create source points and L matrix self.right_mat, self.L_inv, self.source_points, self.out_height, \ self.out_width = initialize_tps( control_points, input_shp, self.downsample_factor, precompute_grid)
def convNd(input, kernel, pad, stride=1, n=None): """Execute a batch of a stack of N-dimensional convolutions. Parameters ---------- input : numpy array kernel : numpy array pad : {0, 'valid', 'same', 'full'}, int or tuple of int stride : int or tuple of int n : int Returns ------- numpy array """ if n is None: n = input.ndim - 2 if pad not in ['valid', 'same', 'full']: pad = as_tuple(pad, n, int) input = np.pad(input, [(p, p) for p in (0, 0) + pad], mode='constant') pad = 'valid' output = np.zeros((input.shape[0], kernel.shape[0]) + tuple(i + k - 1 for i, k in zip(input.shape[2:], kernel.shape[2:]))) if n == 1: for i in range(kernel.shape[2]): f = kernel[:, :, i:i+1] c = (input[:, np.newaxis] * f).sum(axis=2) output[:, :, i:i + input.shape[2]] += c elif n == 2: for i in range(kernel.shape[2]): for j in range(kernel.shape[3]): f = kernel[:, :, i:i+1, j:j+1] c = (input[:, np.newaxis] * f).sum(axis=2) output[:, :, i:i + input.shape[2], j:j + input.shape[3]] += c elif n == 3: for i in range(kernel.shape[2]): for j in range(kernel.shape[3]): for k in range(kernel.shape[4]): f = kernel[:, :, i:i+1, j:j+1, k:k+1] c = (input[:, np.newaxis] * f).sum(axis=2) output[:, :, i:i + input.shape[2], j:j + input.shape[3], k:k + input.shape[4]] += c else: raise NotImplementedError("convNd() only supports n in (1, 2, 3)") if pad == 'valid': trim = tuple(k - 1 for k in kernel.shape[2:]) slices = [slice(None), slice(None)] slices += [slice(t, -t or None) for t in trim] output = output[slices] elif pad == 'same': shift = tuple((k - 1) // 2 for k in kernel.shape[2:]) slices = [slice(None), slice(None)] slices += [slice(s, s + i) for s, i in zip(shift, input.shape[2:])] output = output[slices] stride = as_tuple(stride, n, int) if any(s > 1 for s in stride): slices = [slice(None), slice(None)] slices += [slice(None, None, s) for s in stride] output = output[slices] return output
def test_as_tuple_fails(): from lasagne.utils import as_tuple with pytest.raises(ValueError): as_tuple([1, 2, 3], 4) with pytest.raises(TypeError): as_tuple('asdf', 4, int)
def convNd(input, kernel, pad, stride=1, n=None): """Execute a batch of a stack of N-dimensional convolutions. Parameters ---------- input : numpy array kernel : numpy array pad : {0, 'valid', 'same', 'full'}, int or tuple of int stride : int or tuple of int n : int Returns ------- numpy array """ if n is None: n = input.ndim - 2 if pad not in ['valid', 'same', 'full']: pad = as_tuple(pad, n, int) input = np.pad(input, [(p, p) for p in (0, 0) + pad], mode='constant') pad = 'valid' output = np.zeros((input.shape[0], kernel.shape[0]) + tuple( i + k - 1 for i, k in zip(input.shape[2:], kernel.shape[2:]))) if n == 1: for i in range(kernel.shape[2]): f = kernel[:, :, i:i + 1] c = (input[:, np.newaxis] * f).sum(axis=2) output[:, :, i:i + input.shape[2]] += c elif n == 2: for i in range(kernel.shape[2]): for j in range(kernel.shape[3]): f = kernel[:, :, i:i + 1, j:j + 1] c = (input[:, np.newaxis] * f).sum(axis=2) output[:, :, i:i + input.shape[2], j:j + input.shape[3]] += c elif n == 3: for i in range(kernel.shape[2]): for j in range(kernel.shape[3]): for k in range(kernel.shape[4]): f = kernel[:, :, i:i + 1, j:j + 1, k:k + 1] c = (input[:, np.newaxis] * f).sum(axis=2) output[:, :, i:i + input.shape[2], j:j + input.shape[3], k:k + input.shape[4]] += c else: raise NotImplementedError("convNd() only supports n in (1, 2, 3)") if pad == 'valid': trim = tuple(k - 1 for k in kernel.shape[2:]) slices = [slice(None), slice(None)] slices += [slice(t, -t or None) for t in trim] output = output[slices] elif pad == 'same': shift = tuple((k - 1) // 2 for k in kernel.shape[2:]) slices = [slice(None), slice(None)] slices += [slice(s, s + i) for s, i in zip(shift, input.shape[2:])] output = output[slices] stride = as_tuple(stride, n, int) if any(s > 1 for s in stride): slices = [slice(None), slice(None)] slices += [slice(None, None, s) for s in stride] output = output[slices] return output
def __init__(self, incoming, filter_mask_size=(3, 3), filter_shape=(1, ), convolution_axes=(2, 3), channel_axes=(1, ), stride=1, width=1, pad='same', untie_biases=False, W=lasagne.init.Orthogonal("relu"), b=lasagne.init.Constant(0.), nonlinearity=lasagne.nonlinearities.rectify, flip_filters=False, **kwargs): assert len(filter_shape) == len(channel_axes) assert len(filter_mask_size) == len(convolution_axes) super(ConvolutionLayer, self).__init__(incoming, **kwargs) if nonlinearity is None: self.nonlinearity = lasagne.nonlinearities.identity else: self.nonlinearity = nonlinearity n = len(convolution_axes) self.channel_axes = channel_axes self.convolution_axes = convolution_axes self.filter_shape = filter_shape self.n = n self.num_filters = np.prod(filter_shape) self.filter_mask_size = filter_mask_size self.flip_filters = flip_filters self.stride = as_tuple(stride, n, int) self.width = as_tuple(width, n, int) self.untie_biases = untie_biases if pad == 'same': if any(s % 2 == 0 for s in self.filter_mask_size): raise NotImplementedError( '`same` padding requires odd filter size.') if pad == 'valid': self.pad = as_tuple(0, n) elif pad in ('full', 'same'): self.pad = pad else: self.pad = as_tuple(pad, n, int) if W is None: self.W = None else: self.W = self.add_param(W, self.get_W_shape(), name="W") if b is None: self.b = None else: if self.untie_biases is False: biases_shape = self.filter_shape else: biases_shape = self.filter_shape + tuple( [self.output_shape[i] for i in self.convolution_axes]) self.b = self.add_param(b, biases_shape, name="b", regularizable=False) assert all([ self.input_shape[self.convolution_axes[i]] % (self.width[i] * self.stride[i]) == 0 for i in xrange(len(self.filter_mask_size)) ])
def dilated_convNd(input, kernel, pad, dilation=1, n=None): if n is None: n = input.ndim - 2 dilation = as_tuple(dilation, n, int) dilated_kernel = dilate(kernel, (1, 1) + dilation) return convNd(input, dilated_kernel, pad, stride=1, n=n)
def __init__(self, x, cell_previous, hid_previous, filter_size, stride=(1, 1), pad='same', flip_filters=True, n=None, convolution=T.nnet.conv2d, ingate=Gate(W_in=init.GlorotUniform(), W_hid=init.GlorotUniform()), forgetgate=Gate(W_in=init.GlorotUniform(), W_hid=init.GlorotUniform()), cell=Gate(W_in=init.GlorotUniform(), W_hid=init.GlorotUniform(), W_cell=None, nonlinearity=nonlinearities.tanh), outgate=Gate(), nonlinearity=nonlinearities.tanh, cell_init=init.Constant(0.), hid_init=init.Constant(0.), learn_init=False, peepholes=True, grad_clipping=0, **kwargs): # Initialize parent layer super(ConvLSTMCell, self).__init__([x, cell_previous, hid_previous], **kwargs) # If the provided nonlinearity is None, make it linear if nonlinearity is None: self.nonlinearity = nonlinearities.identity else: self.nonlinearity = nonlinearity # Retrieve the dimensionality of the incoming layer self.input_shape_x = self.input_shapes[0] self.input_shape_c = self.input_shapes[1] self.input_shape_h = self.input_shapes[2] # From ConvNet if n is None: n = len(self.input_shape_x) - 2 elif n != len(self.input_shape_x) - 2: raise ValueError("Tried to create a %dD convolution layer with " "input shape %r. Expected %d input dimensions " "(batchsize, channels, %d spatial dimensions)." % (n, self.input_shape_x, n + 2, n)) self.n = n self.pad = pad self.num_filters = self.input_shape_h[1] self.filter_size = as_tuple(filter_size, n, int) self.flip_filters = flip_filters self.stride = as_tuple(stride, n, int) self.convolution = convolution if self.pad == 'same': if any(s % 2 == 0 for s in self.filter_size): raise NotImplementedError( '`same` padding requires odd filter size.') else: raise ValueError("You must use the 'same' padding") self.learn_init = learn_init self.peepholes = peepholes self.grad_clipping = grad_clipping def add_gate_params(gate, gate_name): """ Convenience function for adding layer parameters from a Gate instance. """ return (self.add_param(gate.W_in, self.get_W_shape(self.input_shape_x), name="W_in_to_{}".format(gate_name)), self.add_param(gate.W_hid, self.get_W_shape(self.input_shape_h), name="W_hid_to_{}".format(gate_name)), self.add_param(gate.b, (self.num_filters, ), name="b_{}".format(gate_name), regularizable=False), gate.nonlinearity) # Add in parameters from the supplied Gate instances (self.W_in_to_ingate, self.W_hid_to_ingate, self.b_ingate, self.nonlinearity_ingate) = add_gate_params(ingate, 'ingate') (self.W_in_to_forgetgate, self.W_hid_to_forgetgate, self.b_forgetgate, self.nonlinearity_forgetgate) = add_gate_params( forgetgate, 'forgetgate') (self.W_in_to_cell, self.W_hid_to_cell, self.b_cell, self.nonlinearity_cell) = add_gate_params(cell, 'cell') (self.W_in_to_outgate, self.W_hid_to_outgate, self.b_outgate, self.nonlinearity_outgate) = add_gate_params(outgate, 'outgate') # If peephole (cell to gate) connections were enabled, initialize # peephole connections. These are elementwise products with the cell # state, so they are represented as vectors. if self.peepholes: self.W_cell_to_ingate = self.add_param(ingate.W_cell, (self.num_filters, ), name="W_cell_to_ingate") self.W_cell_to_forgetgate = self.add_param( forgetgate.W_cell, (self.num_filters, ), name="W_cell_to_forgetgate") self.W_cell_to_outgate = self.add_param(outgate.W_cell, (self.num_filters, ), name="W_cell_to_outgate") # Setup initial values for the cell and the hidden units self.cell_init = self.add_param(cell_init, (1, ) + self.input_shape_c[1:], name="cell_init", trainable=learn_init, regularizable=False) self.hid_init = self.add_param(hid_init, (1, ) + self.input_shape_h[1:], name="hid_init", trainable=learn_init, regularizable=False)
def __init__(self, x, cell_previous, hid_previous, filter_size, stride=(1, 1), pad='same', flip_filters=True, n=None, convolution=T.nnet.conv2d, ingate=Gate(W_in=init.GlorotUniform(), W_hid=init.GlorotUniform()), forgetgate=Gate(W_in=init.GlorotUniform(), W_hid=init.GlorotUniform()), cell=Gate(W_in=init.GlorotUniform(), W_hid=init.GlorotUniform(), W_cell=None, nonlinearity=nonlinearities.tanh), outgate=Gate(), nonlinearity=nonlinearities.tanh, cell_init=init.Constant(0.), hid_init=init.Constant(0.), learn_init=False, peepholes=True, grad_clipping=0, **kwargs): # Initialize parent layer super(ConvLSTMCell, self).__init__( [x, cell_previous, hid_previous], **kwargs) # If the provided nonlinearity is None, make it linear if nonlinearity is None: self.nonlinearity = nonlinearities.identity else: self.nonlinearity = nonlinearity # Retrieve the dimensionality of the incoming layer self.input_shape_x = self.input_shapes[0] self.input_shape_c = self.input_shapes[1] self.input_shape_h = self.input_shapes[2] # From ConvNet if n is None: n = len(self.input_shape_x) - 2 elif n != len(self.input_shape_x) - 2: raise ValueError("Tried to create a %dD convolution layer with " "input shape %r. Expected %d input dimensions " "(batchsize, channels, %d spatial dimensions)." % (n, self.input_shape_x, n+2, n)) self.n = n self.pad = pad self.num_filters = self.input_shape_h[1] self.filter_size = as_tuple(filter_size, n, int) self.flip_filters = flip_filters self.stride = as_tuple(stride, n, int) self.convolution = convolution if self.pad == 'same': if any(s % 2 == 0 for s in self.filter_size): raise NotImplementedError( '`same` padding requires odd filter size.') else: raise ValueError("You must use the 'same' padding") self.learn_init = learn_init self.peepholes = peepholes self.grad_clipping = grad_clipping def add_gate_params(gate, gate_name): """ Convenience function for adding layer parameters from a Gate instance. """ return ( self.add_param( gate.W_in, self.get_W_shape(self.input_shape_x), name="W_in_to_{}".format(gate_name)), self.add_param( gate.W_hid, self.get_W_shape(self.input_shape_h), name="W_hid_to_{}".format(gate_name)), self.add_param( gate.b, (self.num_filters, ), name="b_{}".format(gate_name), regularizable=False), gate.nonlinearity) # Add in parameters from the supplied Gate instances (self.W_in_to_ingate, self.W_hid_to_ingate, self.b_ingate, self.nonlinearity_ingate) = add_gate_params(ingate, 'ingate') (self.W_in_to_forgetgate, self.W_hid_to_forgetgate, self.b_forgetgate, self.nonlinearity_forgetgate) = add_gate_params(forgetgate, 'forgetgate') (self.W_in_to_cell, self.W_hid_to_cell, self.b_cell, self.nonlinearity_cell) = add_gate_params(cell, 'cell') (self.W_in_to_outgate, self.W_hid_to_outgate, self.b_outgate, self.nonlinearity_outgate) = add_gate_params(outgate, 'outgate') # If peephole (cell to gate) connections were enabled, initialize # peephole connections. These are elementwise products with the cell # state, so they are represented as vectors. if self.peepholes: self.W_cell_to_ingate = self.add_param( ingate.W_cell, (self.num_filters, ), name="W_cell_to_ingate") self.W_cell_to_forgetgate = self.add_param( forgetgate.W_cell, (self.num_filters, ), name="W_cell_to_forgetgate") self.W_cell_to_outgate = self.add_param( outgate.W_cell, (self.num_filters, ), name="W_cell_to_outgate") # Setup initial values for the cell and the hidden units self.cell_init = self.add_param( cell_init, (1, ) + self.input_shape_c[1:], name="cell_init", trainable=learn_init, regularizable=False) self.hid_init = self.add_param( hid_init, (1, ) + self.input_shape_h[1:], name="hid_init", trainable=learn_init, regularizable=False)