def _inverted_res_block(inputs, expansion, stride, alpha, filters, block_id, skip_connection, rate=1): in_channels = inputs._keras_shape[-1] pointwise_conv_filters = int(filters * alpha) pointwise_filters = _make_divisible(pointwise_conv_filters, 8) x = inputs prefix = 'expanded_conv_{}_'.format(block_id) if block_id: # Expand x = Conv2D(expansion * in_channels, kernel_size=1, padding='same', use_bias=False, activation=None, name=prefix + 'expand')(x) x = BatchNormalization(epsilon=1e-3, momentum=0.999, name=prefix + 'expand_BN')(x) x = Activation(relu6, name=prefix + 'expand_relu')(x) else: prefix = 'expanded_conv_' # Depthwise x = DepthwiseConv2D(kernel_size=3, strides=stride, activation=None, use_bias=False, padding='same', dilation_rate=(rate, rate), name=prefix + 'depthwise')(x) x = BatchNormalization(epsilon=1e-3, momentum=0.999, name=prefix + 'depthwise_BN')(x) # x = Activation(relu(x, max_value=6.), name=prefix + 'depthwise_relu')(x) x = Lambda(lambda x: relu(x, max_value=6.), name=prefix + 'depthwise_relu')(x) x = Conv2D(pointwise_filters, kernel_size=1, padding='same', use_bias=False, activation=None, name=prefix + 'project')(x) x = BatchNormalization(epsilon=1e-3, momentum=0.999, name=prefix + 'project_BN')(x) if skip_connection: return Add(name=prefix + 'add')([inputs, x]) # if in_channels == pointwise_filters and stride == 1: # return Add(name='res_connect_' + str(block_id))([inputs, x]) return x
def _inverted_res_block(inputs, expansion, stride, alpha, filters, block_id): channel_axis = -1 in_channels = K.int_shape(inputs)[channel_axis] pointwise_conv_filters = int(filters * alpha) pointwise_filters = _make_divisible(pointwise_conv_filters, 8) x = inputs prefix = 'block_{}_'.format(block_id) if block_id: # Expand # use bias x = Conv2D(expansion * in_channels, kernel_size=1, padding='same', use_bias=True, activation=None, name=prefix + 'expand_Q')(x) x = BatchNormalization(axis=channel_axis, epsilon=1e-3, momentum=0.999, name=prefix + 'expand_BN_Q')(x) x = ReLU(6., name=prefix + 'expand_relu_Q')(x) else: prefix = 'expanded_conv_' # Depthwise if stride == 2: correct_pad = ((0, 1), (0, 1)) x = ZeroPadding2D(padding=correct_pad, name=prefix + 'pad_Q')(x) x = DepthwiseConv2D(kernel_size=3, strides=stride, activation=None, use_bias=True, padding='same' if stride == 1 else 'valid', name=prefix + 'depthwise_Q')(x) x = BatchNormalization(axis=channel_axis, epsilon=1e-3, momentum=0.999, name=prefix + 'depthwise_BN_Q')(x) x = ReLU(6., name=prefix + 'depthwise_relu_Q')(x) # Project x = Conv2D(pointwise_filters, kernel_size=1, padding='same', use_bias=True, activation=None, name=prefix + 'project_Q')(x) x = BatchNormalization(axis=channel_axis, epsilon=1e-3, momentum=0.999, name=prefix + 'project_BN_Q')(x) if in_channels == pointwise_filters and stride == 1: return Add(name=prefix + 'add_Q')([inputs, x]) return x
def mobilenet_3d(input_shape: tuple, model_2d: Model): input_image = Input(input_shape) x = ZeroPadding3D()(input_image) x = conv2d3d(model_2d.get_layer('conv1'))(x) x = BatchNormalization()(x) x = Activation('relu')(x) x = ZeroPadding3D()(x) x = DepthwiseConv2D()(x)
def __global_depthwise_block(self, _inputs): assert _inputs._keras_shape[1] == _inputs._keras_shape[2] kernel_size = _inputs._keras_shape[1] x = DepthwiseConv2D((kernel_size, kernel_size), strides=(1, 1), depth_multiplier=1, padding='same')(_inputs) return x
def _depthwise_conv_block(inputs, pointwise_conv_filters, strides=(1, 1)): x = DepthwiseConv2D((3, 3),padding='same',depth_multiplier=1,strides=strides)(inputs) x = Dropout(0.1)(x) x = BatchNormalization(axis = -1)(x) x = Activation(relu6)(x) x = Conv2D(pointwise_conv_filters, (1, 1),padding='same',use_bias=False,strides=(1, 1))(x) x = BatchNormalization(axis = -1)(x) return Activation(relu6)(x)
def aspp(x, input_shape, out_stride): # 膨胀率6 12 12 b0 = Conv2D(128, (1, 1), padding="same", use_bias=False)(x) b0 = BatchNormalization()(b0) b0 = Activation("relu")(b0) b1 = DepthwiseConv2D((3, 3), dilation_rate=(6, 6), padding="same", use_bias=False)(x) b1 = BatchNormalization()(b1) b1 = Activation("relu")(b1) b1 = Conv2D(128, (1, 1), padding="same", use_bias=False)(b1) b1 = BatchNormalization()(b1) b1 = Activation("relu")(b1) b2 = DepthwiseConv2D((3, 3), dilation_rate=(12, 12), padding="same", use_bias=False)(x) b2 = BatchNormalization()(b2) b2 = Activation("relu")(b2) b2 = Conv2D(128, (1, 1), padding="same", use_bias=False)(b2) b2 = BatchNormalization()(b2) b2 = Activation("relu")(b2) b3 = DepthwiseConv2D((3, 3), dilation_rate=(12, 12), padding="same", use_bias=False)(x) b3 = BatchNormalization()(b3) b3 = Activation("relu")(b3) b3 = Conv2D(128, (1, 1), padding="same", use_bias=False)(b3) b3 = BatchNormalization()(b3) b3 = Activation("relu")(b3) out_shape = int(input_shape[0] / out_stride) out_shape1 = int(input_shape[1] / out_stride) b4 = AveragePooling2D(pool_size=(out_shape, out_shape1))(x) b4 = Conv2D(128, (1, 1), padding="same", use_bias=False)(b4) b4 = BatchNormalization()(b4) b4 = Activation("relu")(b4) b4 = BilinearUpsampling((out_shape, out_shape1))(b4) x = Concatenate()([b4, b0, b1, b2, b3]) return x
def _layer(inp): gaussian_layer = DepthwiseConv2D(k, use_bias=False, padding='same', name='gaussian_blur_block') output = gaussian_layer(inp) # print(weights.shape, gaussian_layer.get_weights()[0].shape) gaussian_layer.set_weights([_kernel()]) gaussian_layer.trainable = False return output
def add_m_inception(inp,n,m,use_tiny=True,merge='add'): outs=[] outs.append(Conv2D(n,(1,1),padding='same',data_format='channels_last',activation='relu')(inp)) for i in range(1,m): out=inp for m in range(i): if(use_tiny): out=DepthwiseConv2D((1,3),padding='same',data_format='channels_last',activation=None,use_bias=False)(out) out=DepthwiseConv2D((3,1),padding='same',data_format='channels_last',activation=None,use_bias=False)(out) out=Conv2D(n,(1,1),padding='same',data_format='channels_last',activation='relu')(out) else: out=SeparableConv2D(n,(3,3),padding='same',data_format='channels_last',activation='relu')(out) outs.append(out) if(merge=='concat'): return Concatenate()(outs) else: return Add()(outs)
def DW_Conv_BN(x, kernel_size=3, strides=1, padding='same', activation=swish, kernel_initializer=CONV_KERNEL_INITIALIZER, kernel_regularizer=KERNEL_REGULIZER): x = DepthwiseConv2D(kernel_size, strides=strides, padding=padding, use_bias=False, depthwise_initializer=kernel_initializer, depthwise_regularizer=kernel_regularizer)(x) x = BatchNormalization()(x) if activation: x = Activation(activation)(x) return x
def create_3d_model(inputs, hyper_params, H, W, CHANNELS): # inputs=Input(shape=(40,40,16)) x = BatchNormalization()(inputs) x = DepthwiseConv2D(kernel_size=(3, 3), activation='relu', padding='same')(x) x = MaxPooling2D(pool_size=(3, 3))(x) x = Flatten()(x) return x
def downsampling_block(x, filters, width, padding='same', activation='relu'): x = BatchNormalization(scale=True)(x) x = Activation(activation)(x) x1 = MaxPooling2D(pool_size=2, strides=2, padding=padding)(x) x2 = DepthwiseConv2D(3, depth_multiplier=1, strides=2, padding=padding)(x) x = concatenate([x1, x2], axis=3) x = Conv2D(filters, 1, strides=1)(x) return x
def xception_block(x, channels): x = Activation('relu')(x) x = DepthwiseConv2D((3, 3), padding='same', use_bias=False)(x) x = BatchNormalization()(x) x = Conv2D(channels, (1, 1), padding='same', use_bias=False)(x) x = BatchNormalization()(x) x = Activation('relu')(x) x = DepthwiseConv2D((3, 3), padding='same', use_bias=False)(x) x = BatchNormalization()(x) x = Conv2D(channels, (1, 1), padding='same', use_bias=False)(x) x = BatchNormalization()(x) x = Activation('relu')(x) x = DepthwiseConv2D((3, 3), padding='same', use_bias=False)(x) x = BatchNormalization()(x) x = Conv2D(channels, (1, 1), padding='same', use_bias=False)(x) x = BatchNormalization()(x) return x
def build_model(): inputs = Input(shape=target_dims) net = Conv2D(32, kernel_size=3, strides=1, padding="same")(inputs) net = LeakyReLU()(net) net = Conv2D(32, kernel_size=3, strides=1, padding="same")(net) net = LeakyReLU()(net) net = Conv2D(32, kernel_size=3, strides=2, padding="same")(net) net = LeakyReLU()(net) net = Conv2D(32, kernel_size=3, strides=1, padding="same")(net) net = LeakyReLU()(net) net = Conv2D(32, kernel_size=3, strides=1, padding="same")(net) net = LeakyReLU()(net) net = Conv2D(32, kernel_size=3, strides=2, padding="same")(net) net = LeakyReLU()(net) shortcut = net net = DepthwiseConv2D(kernel_size=3, strides=1, padding='same', kernel_initializer='he_normal')(net) net = BatchNormalization(axis=3)(net) net = LeakyReLU()(net) net = Conv2D(filters=32, kernel_size=1, strides=1, padding='same', kernel_initializer='he_normal')(net) net = BatchNormalization(axis=3)(net) net = LeakyReLU()(net) net = DepthwiseConv2D(kernel_size=3, strides=1, padding='same', kernel_initializer='he_normal')(net) net = BatchNormalization(axis=3)(net) net = LeakyReLU()(net) net = Conv2D(filters=32, kernel_size=1, strides=1, padding='same', kernel_initializer='he_normal')(net) net = BatchNormalization(axis=3)(net) net = LeakyReLU()(net) net = Add()([net, shortcut]) net = GlobalAveragePooling2D()(net) net = Dropout(0.2)(net) net = Dense(128, activation='relu')(net) outputs = Dense(num_classes, activation='softmax')(net) model = Model(inputs=inputs, outputs=outputs) model.compile(optimizer='adam', loss='categorical_crossentropy', metrics=["accuracy"]) model.summary() return model
def _bottleneck(self, filters, strides, t, prev_layers, depth_kernel, alpha, *, res_con = False, first = False, downsample = True): tk = K.int_shape(prev_layers)[-1] * t k_prime = self._make_divisible(int(filters*alpha)) #pointwise filter if first: first_cv_filter = self._make_divisible(x = 32 * alpha) if downsample: x = self._conv_def(filters = 32, kernel_size = 3, strides = 2, padding = 'valid', prev_layers = prev_layers) else: x = self._conv_def(filters = 32, kernel_size = 3, strides = 1, padding = 'valid', prev_layers = prev_layers) x = self._bn_def(prev_layers = x) x = Activation(self._relu6)(x) elif first is False: x = self._conv_def(tk, kernel_size = 1, prev_layers = prev_layers) x = self._bn_def(prev_layers = x) x = Activation(self._relu6)(x) if strides > 1: padding = 'valid' zpad = self._zero_pad(prev_layers = x) dcv = DepthwiseConv2D(kernel_size = depth_kernel, strides = strides, padding = padding, use_bias = False)(zpad) elif strides == 1: padding = 'same' dcv = DepthwiseConv2D(kernel_size = depth_kernel, strides = strides, padding = padding, use_bias = False)(x) x = self._bn_def(prev_layers = dcv) x = Activation(self._relu6)(x) x = self._conv_def(k_prime, kernel_size = 1, prev_layers = x) x = self._bn_def(prev_layers = x) if res_con: return Add()([prev_layers, x]) return x
def DW_Conv_BN(x, kernel_size=3, strides=1, depth_multiplier=1): # depth-wise x = DepthwiseConv2D(kernel_size, strides=strides, padding='same', depth_multiplier=depth_multiplier)(x) x = BatchNormalization()(x) x = ReLU(6.)(x) return x
def get_block(x_input, input_channels, output_channels): x = Conv2D(input_channels, kernel_size=(1, 1), padding='same', use_bias=False)(x_input) x = get_top(x) # depthwise convolution işlemi her bir kanalda ayrı ayrı çalışarak hesaplama maliyetini azaltır x = DepthwiseConv2D(kernel_size=(1, 3), padding='same', use_bias=False)(x) x = get_top(x) x = MaxPooling2D(pool_size=(2, 1), strides=(2, 1))(x) x = DepthwiseConv2D(kernel_size=(3, 1), padding='same', use_bias=False)(x) x = get_top(x) x = Conv2D(output_channels, kernel_size=(2, 1), strides=(1, 2), padding='same', use_bias=False)(x) return x
def build(self, input_shape): """Creates the layer weights. Must be implemented on all layers that have weights. Parameters ---------- input_shape: Union[list, tuple, Any] Keras tensor (future input to layer) or list/tuple of Keras tensors to reference for weight shape computations. """ DepthwiseConv2D.build(self, input_shape) self.init_neurons(input_shape) if self.config.getboolean('cell', 'bias_relaxation'): self.b0 = k.variable(k.get_value(self.bias)) self.add_update([(self.bias, self.update_b())])
def mobilenet_block(x, f, s=1): x = DepthwiseConv2D(3, strides=s, padding='same')(x) x = BatchNormalization()(x) x = ReLU()(x) x = Conv2D(f, 1, strides=1, padding='same')(x) x = BatchNormalization()(x) x = ReLU()(x) return x
def _inverted_res_block(inputs, filters, expansion, stride, alpha, block_id, use_se=False): channel_axis = 1 if K.image_data_format() == 'channels_first' else -1 in_channels = K.int_shape(inputs)[-1] pointwise_filters = int(filters * alpha) x = inputs prefix = 'block_{}_'.format(block_id) # Expand x = Conv2D(expansion * in_channels, kernel_size=1, padding='same', use_bias=False, name=prefix + 'expand')(x) x = BatchNormalization(axis=-1, epsilon=1e-3, momentum=0.999, name=prefix + 'expand_BN')(x) x = ReLU(6, name=prefix + 'expand_relu')(x) # Depthwise if stride == 2: x = ZeroPadding2D(name=prefix + 'pad')(x) x = DepthwiseConv2D(kernel_size=3, strides=stride, padding='same' if stride == 1 else 'valid', use_bias=False, name=prefix + 'depthwise')(x) x = BatchNormalization(axis=-1, epsilon=1e-3, momentum=0.999, name=prefix + 'depthwise_BN')(x) x = ReLU(6, name=prefix + 'depthwise_relu')(x) # Project x = Conv2D(pointwise_filters, kernel_size=1, padding='same', use_bias=False, name=prefix + 'project')(x) x = BatchNormalization(axis=-1, epsilon=1e-3, momentum=0.999, name=prefix + 'project_BN')(x) # Use SE block if needed if use_se: x = squeeze_excite_block(x) if in_channels == pointwise_filters and stride == 1: return Add(name=prefix + 'add')([inputs, x]) return x
def _inverted_res_block(inputs, expansion, stride, alpha, filters, block_id): prefix = 'block_{}_'.format(block_id) in_channels = inputs._keras_shape[-1] pointwise_conv_filters = int(filters * alpha) pointwise_filters = _make_divisible(pointwise_conv_filters, 8) x = inputs # Expand if block_id: x = Conv2D(expansion * in_channels, kernel_size=1, strides=1, padding='same', use_bias=False, activation=None, kernel_initializer="he_normal", kernel_regularizer=regularizers.l2(4e-5), name=prefix + 'expand')(x) x = BatchNormalization(epsilon=1e-3, momentum=0.999, name=prefix + 'expand_BN')(x) x = ReLU(6., name=prefix + 'expand_relu')(x) else: prefix = 'expanded_conv_' # Depthwise x = DepthwiseConv2D(kernel_size=3, strides=stride, activation=None, use_bias=False, padding='same', kernel_initializer="he_normal", depthwise_regularizer=regularizers.l2(4e-5), name=prefix + 'depthwise')(x) x = BatchNormalization(epsilon=1e-3, momentum=0.999, name=prefix + 'depthwise_BN')(x) x = ReLU(6., name=prefix + 'depthwise_relu')(x) # Project x = Conv2D(pointwise_filters, kernel_size=1, strides=1, padding='same', use_bias=False, activation=None, kernel_initializer="he_normal", kernel_regularizer=regularizers.l2(4e-5), name=prefix + 'project')(x) x = BatchNormalization(epsilon=1e-3, momentum=0.999, name=prefix + 'project_BN')(x) if in_channels == pointwise_filters and stride == 1: return Add(name=prefix + 'add')([inputs, x]) return x
def _inverted_res_block(inputs, expansion, stride, alpha, filters, block_id): in_channels = backend.int_shape(inputs)[-1] prefix = 'block_{}_'.format(block_id) x = inputs pointwise_filters = _make_divisible(int(filters * alpha), 8) #---------------------------------# # part1 利用1x1卷积进行通道上升 #---------------------------------# if block_id: x = Conv2D(expansion * in_channels, kernel_size=1, padding='same', use_bias=False, activation=None, name=prefix + 'expand')(x) x = BatchNormalization(epsilon=1e-3, momentum=0.999, name=prefix + 'expand_BN')(x) x = Activation(relu6, name=prefix + 'expand_relu')(x) else: prefix = 'expanded_conv_' if stride == 2: x = ZeroPadding2D(padding=correct_pad(x, 3), name=prefix + 'pad')(x) #---------------------------------# # part2 进行3x3的深度可分离卷积 #---------------------------------# x = DepthwiseConv2D(kernel_size=3, strides=stride, activation=None, use_bias=False, padding='same' if stride == 1 else 'valid', name=prefix + 'depthwise')(x) x = BatchNormalization(epsilon=1e-3, momentum=0.999, name=prefix + 'depthwise_BN')(x) x = Activation(relu6, name=prefix + 'depthwise_relu')(x) #-----------------------------------------------------------# # part3 利用1x1卷积进行通道的下降 # 而且不使用relu函数,保证特征不被破坏 #-----------------------------------------------------------# x = Conv2D(pointwise_filters, kernel_size=1, padding='same', use_bias=False, activation=None, name=prefix + 'project')(x) x = BatchNormalization(epsilon=1e-3, momentum=0.999, name=prefix + 'project_BN')(x) if in_channels == pointwise_filters and stride == 1: return Add(name=prefix + 'add')([inputs, x]) return x
def aspp(x:ops.Tensor,input_shape:Tuple,out_stride:int)->ops.Tensor: ''' To build aspp layer args: x:operate tensor input_shape:training shape out_stride:dilate rate returns: x:operated tensor ''' b0=Conv2D(256,(1,1),padding="same",use_bias=False)(x) b0=BatchNormalization()(b0) b0=Activation("relu")(b0) b1=DepthwiseConv2D((3,3),dilation_rate=(6,6),padding="same",use_bias=False)(x) b1=BatchNormalization()(b1) b1=Activation("relu")(b1) b1=Conv2D(256,(1,1),padding="same",use_bias=False)(b1) b1=BatchNormalization()(b1) b1=Activation("relu")(b1) b2=DepthwiseConv2D((3,3),dilation_rate=(12,12),padding="same",use_bias=False)(x) b2=BatchNormalization()(b2) b2=Activation("relu")(b2) b2=Conv2D(256,(1,1),padding="same",use_bias=False)(b2) b2=BatchNormalization()(b2) b2=Activation("relu")(b2) b3=DepthwiseConv2D((3,3),dilation_rate=(12,12),padding="same",use_bias=False)(x) b3=BatchNormalization()(b3) b3=Activation("relu")(b3) b3=Conv2D(256,(1,1),padding="same",use_bias=False)(b3) b3=BatchNormalization()(b3) b3=Activation("relu")(b3) out_shape=int(input_shape[0]/out_stride) b4=AveragePooling2D(pool_size=(out_shape,out_shape))(x) b4=Conv2D(256,(1,1),padding="same",use_bias=False)(b4) b4=BatchNormalization()(b4) b4=Activation("relu")(b4) b4=BilinearUpsampling((out_shape,out_shape))(b4) x=Concatenate()([b4,b0,b1,b2,b3]) return x
def _bottleneck(inputs, filters, kernel, t, s, r=False): #2x2的_bottleneck """Bottleneck This function defines a basic bottleneck structure. # Arguments inputs: Tensor, input tensor of conv layer. filters: Integer, the dimensionality of the output space. kernel: An integer or tuple/list of 2 integers, specifying the width and height of the 2D convolution window. t: Integer, expansion factor. t is always applied to the input size. s: An integer or tuple/list of 2 integers,specifying the strides of the convolution along the width and height.Can be a single integer to specify the same value for all spatial dimensions. r: Boolean, Whether to use the residuals. # Returns Output tensor. """ channel_axis = 1 if K.image_data_format() == 'channels_first' else -1 tchannel = K.int_shape(inputs)[channel_axis] * t x = _conv_block(inputs, tchannel, (1, 1), (1, 1)) x = DepthwiseConv2D(kernel, strides=(s, s), depth_multiplier=1, padding='same')(x) x = BatchNormalization(axis=channel_axis)(x) x = keras.layers.ReLU(6.)(x) #添加2x2 x = DepthwiseConv2D(kernel, strides=(s, s), depth_multiplier=1, padding='same')(x) x = BatchNormalization(axis=channel_axis)(x) x = keras.layers.ReLU(6.)(x) #x = Activation(relu6)(x) x = Conv2D(filters, (1, 1), strides=(1, 1), padding='same')(x) x = BatchNormalization(axis=channel_axis)(x) if r: x = add([x, inputs]) return x
def _inverted_res_block(inputs, expansion, stride, alpha, filters, block_id): channel_axis = -1 if K.image_data_format() == 'channels_last' else 1 in_channels = K.int_shape(inputs)[channel_axis] pointwise_conv_filters = int(filters * alpha) pointwise_filters = _make_divisible(pointwise_conv_filters, 8) x = inputs prefix = 'block_{}_'.format(block_id) if block_id: # Expand the in_channels x = Conv2D(expansion * in_channels, kernel_size=1, padding='same', use_bias=False, activation=None, name=prefix + 'expand')(x) x = BatchNormalization(axis=channel_axis, epsilon=1e-3, momentum=0.999, name=prefix + 'expand_BN')(x) x = ReLU(6., name=prefix + 'expand_relu')(x) else: prefix = 'expanded_conv_' # Apply the Depthwise Conv. if stride == 2: x = ZeroPadding2D(padding=correct_pad(K, x, 3), name=prefix + 'pad')(x) x = DepthwiseConv2D(kernel_size=3, strides=stride, activation=None, use_bias=False, padding='same' if stride == 1 else 'valid', name=prefix + 'depthwise')(x) x = BatchNormalization(axis=channel_axis, epsilon=1e-3, momentum=0.999, name=prefix + 'depthwise_BN')(x) x = ReLU(6., name=prefix + 'depthwise_relu')(x) # Project x = Conv2D(pointwise_filters, kernel_size=1, padding='same', use_bias=False, activation=None, name=prefix + 'project')(x) x = BatchNormalization(axis=channel_axis, epsilon=1e-3, momentum=0.999, name=prefix + 'project_BN')(x) if in_channels == pointwise_filters and stride == 1: return Add(name=prefix + 'add')([inputs, x]) return x
def _bottleneck(inputs, filters, kernel, t, s, r=False): """Bottleneck This function defines a basic bottleneck structure. # Arguments inputs: Tensor, input tensor of conv layer. filters: Integer, the dimensionality of the output space. kernel: An integer or tuple/list of 2 integers, specifying the width and height of the 2D convolution window. t: Integer, expansion factor. t is always applied to the input size. s: An integer or tuple/list of 2 integers,specifying the strides of the convolution along the width and height.Can be a single integer to specify the same value for all spatial dimensions. r: Boolean, Whether to use the residuals. # Returns Output tensor. """ global nlay channel_axis = 1 if K.image_data_format() == 'channels_first' else -1 # Create expansions layer only if needed (expansion factor >1) if t > 1: tchannel = K.int_shape(inputs)[channel_axis] * t x = _conv_block(inputs, tchannel, (1, 1), (1, 1), use_bias=False) else: x = inputs x = DepthwiseConv2D(kernel, strides=(s, s), depth_multiplier=1, padding='same', name='expanded_conv_%d_depthwise' % nlay, use_bias=False)(x) x = BatchNormalization( axis=channel_axis, name='expanded_conv_%d_depthwise_batch_normalization' % nlay)(x) x = Activation(relu6, name='expanded_conv_%d_depthwise_activation' % nlay)(x) x = Conv2D(filters, (1, 1), strides=(1, 1), padding='same', name='expanded_conv_%d_project' % nlay, use_bias=False)(x) x = BatchNormalization( axis=channel_axis, name='expanded_conv_%d_project_batch_normalization' % nlay)(x) if r: x = add([x, inputs], name="expanded_conv_%d_add" % nlay) nlay += 1 return x
def ghostBottleneck(x, hidden_dim, out_dim, kernel_size=3, ratio=2, strides=1, use_se=False, kernel_initializer='he_normal', kernel_regularizer=None): assert strides in [1, 2] input_dim = int(x.shape[3]) hidden = GhostModule(x, hidden_dim, kernel_size=1, ratio=ratio, kernel_initializer=kernel_initializer, kernel_regularizer=kernel_regularizer) if strides == 2: hidden = DepthwiseConv2D( kernel_size, strides=2, padding='SAME', depthwise_regularizer=kernel_regularizer, depthwise_initializer=kernel_initializer)(hidden) if use_se: # pass hidden = SELayer(hidden, hidden_dim) res = GhostModule(hidden, out_dim, kernel_size=1, ratio=ratio, relu=False, kernel_initializer=kernel_initializer, kernel_regularizer=kernel_regularizer) shortcut = x if strides == 2: shortcut = DepthwiseConv2D(3, strides=2, padding='SAME')(shortcut) if input_dim != out_dim: shortcut = Conv2D(out_dim, 1)(shortcut) shortcut = BatchNormalization()(shortcut) out = Add()([res, shortcut]) # 使用keras layer包装 # out = res+shortcut return out
def xception_downsample_block(x, channels, top_relu=False): if (top_relu): x = Activation('relu')(x) x = DepthwiseConv2D((3, 3), padding='same', use_bias=False)(x) x = BatchNormalization()(x) x = Conv2D(channels, (1, 1), padding='same', use_bias=False)(x) x = BatchNormalization()(x) x = Activation('relu')(x) x = DepthwiseConv2D((3, 3), padding='same', use_bias=False)(x) x = BatchNormalization()(x) x = Conv2D(channels, (1, 1), padding='same', use_bias=False)(x) x = BatchNormalization()(x) x = Activation('relu')(x) x = DepthwiseConv2D((3, 3), strides=(2, 2), padding='same', use_bias=False)(x) x = BatchNormalization()(x) x = Conv2D(channels, (1, 1), padding='same', use_bias=False)(x) x = BatchNormalization()(x) return x
def mobile_block(x, f1, f2, s): conv1 = DepthwiseConv2D( kernel_size=[3, 3], strides=[s, s], padding='same', use_bias=False)(x) bn1 = BatchNormalization()(conv1) relu1 = ReLU()(bn1) conv2 = Conv2D(filters=f2, kernel_size=[1, 1], strides=[1, 1], padding='same', use_bias=False)(relu1) bn2 = BatchNormalization()(conv2) relu2 = ReLU()(bn2) return relu2
def __init__(self, k_size, H, d, glu_split_dim=-1): super(LightConv).__init__() self.H = H self.d = d self.glu_split_dim = glu_split_dim self.input_dense = Dense(2 * d) self.dep_conv = DepthwiseConv2D(kernel_size=(k_size, 1), kernel_constraint=SoftmaxConstraint(), padding='same') self.output_dense = Dense(d)
def _sep_conv_bn(inputs, filters, kernel, strides, depth_activation=False): # depthwise x = DepthwiseConv2D(kernel, strides=strides, padding='same')(inputs) x = BatchNormalization(axis=-1)(x) x = ReLU(max_value=6)(x) # pointwise x = Conv2D(filters, (1, 1), strides=1, padding='same')(x) x = BatchNormalization(axis=-1)(x) x = ReLU(max_value=6)(x) return x