def hourglass_module(inpt, n_classes, n_channles): x = inpt features = [x] # from x4 to x64 n_levels = len(n_channles) # encoder: s1 residual + s2 residual for i in range(n_levels): if i != 0: x = residual(x, n_channles[i], strides=1) features.append(x) if i != n_levels - 1: x = residual(x, n_channles[i + 1], strides=2) # mid connection: 4 residuals for i in range(4): x = residual(x, n_channles[-1], strides=1) # decoder: for i in range(n_levels - 2, -1, -1): # skip: 2 residuals skip = features[i] skip = residual(skip, n_channles[i], strides=1) skip = residual(skip, n_channles[i], strides=1) # features x = residual(x, n_channles[i]) x = residual(x, n_channles[i]) x = UpSampling2D()(x) # add x = add([x, skip]) # head branches x_intermediate = Conv2D(n_classes, 1, strides=1, padding='same', activation='sigmoid')(x) input_branch = Conv2D(n_channles[0], 1, strides=1, padding='same', use_bias=False)(inpt) output_branch = Conv2D(n_channles[0], 1, strides=1, padding='same', use_bias=False)(x) x = add([input_branch, output_branch]) x = ReLU()(x) return x, x_intermediate
def separable(x, filters_pw, block_num, strides=(1, 1), trainable=True): if strides != (1, 1): x = ZeroPadding2D(((0, 1), (0, 1)), name='conv_pad_%d' % block_num)(x) x = DepthwiseConv2D(kernel_size=(3, 3), strides=strides, padding='same' if strides == (1, 1) else 'valid', use_bias=False, depthwise_initializer=glorot_uniform(), trainable=trainable, name='conv_dw_%d' % block_num)(x) x = BatchNormalization(trainable=trainable, name='conv_dw_%d_bn' % block_num)(x) x = ReLU(6., name='conv_dw_%d_relu' % block_num)(x) x = Conv2D(filters=filters_pw, kernel_size=(1, 1), strides=(1, 1), padding='same', use_bias=False, kernel_initializer=glorot_uniform(), trainable=trainable, name='conv_pw_%d' % block_num)(x) x = BatchNormalization(trainable=trainable, name='conv_pw_%d_bn' % block_num)(x) x = ReLU(6., name='conv_pw_%d_relu' % block_num)(x) return x
def temporal_and_mask_multi_propagation(inputs, inputs_image_keys, inputs_mask_keys): x1 = temporal_propagation(inputs_image_keys) x1_multi = [] for i in range(len(inputs_image_keys)): x1_multi.append(ReLU(name="x1_" + str(i))(x1)) x2 = mask_propagation(inputs_mask_keys) x2_multi = [] for i in range(len(inputs_mask_keys)): x2_multi.append(ReLU(name="x2_" + str(i))(x2)) x = Conv2D_BN_Relu(inputs, 256, kernel_size=(3, 3), name="input_downsample", padding="valid", strides=(2, 2)) x, x1, x2 = triple_multi_attention(x, x1_multi, x2_multi, name="tri_multi_attention") add = Add(name="TMPropp_add") relu = ReLU(name="TMProp_relu") res = [] for f1, f2 in zip(x1, x2): x = add([f1, f2]) x = relu(x) res.append(x) x = Add(name="TMProp_output_add")([x] + res) x = ReLU(name="TMProp_output_relu")(x) x = Conv2D_BN_Relu(x, 256, (3, 3), "output", padding="same") return x
def triple_single_attention(inputs, inputs_image_keys, inputs_mask_keys, name): x = Conv2D_BN_Relu(inputs, 64, kernel_size=(3, 3), name=name + "_input_a", padding="same", strides=(1, 1)) x1 = Conv2D_BN_Relu(inputs_image_keys, 64, kernel_size=(3, 3), name=name + "_images_a", padding="same", strides=(1, 1)) x2 = Conv2D_BN_Relu(inputs_mask_keys, 64, kernel_size=(3, 3), name=name + "_masks_a", padding="same", strides=(1, 1)) x1 = Add(name=name + "_image_add")([x, x1]) x1 = ReLU(name=name + "_image_relu")(x1) x2 = Add(name=name + "_mask_add")([x, x2]) x2 = ReLU(name=name + "_mask_relu")(x2) x1 = Conv2D_BN_Relu(x1, 64, kernel_size=(3, 3), name=name + "_image_b", padding="same", strides=(1, 1)) x2 = Conv2D_BN_Relu(x2, 64, kernel_size=(3, 3), name=name + "_mask_b", padding="same", strides=(1, 1)) f = Multiply(name=name + "_multiply")([x1, x2]) x1 = Add(name=name + "_image_output_add1")([x1, f]) x1 = ReLU(name=name + "_image_output_relu1")(x1) x2 = Add(name=name + "_image_output_add2")([x2, f]) x2 = ReLU(name=name + "_image_output_relu2")(x2) x = Add(name=name + "_output_add")([x, f]) x = ReLU(name=name + "_output_relu")(x) return x, x1, x2
def ch_CNN(layer): # layer=BatchNormalization()(layer) """ layer=Conv2D(16,(3,3))(layer) layer=se_block(16,layer) layer=BatchNormalization()(layer) layer=ReLU()(layer) layer=MaxPooling2D(pool_size=(2,2))(layer) layer=res_block(16,layer) layer=MaxPooling2D(pool_size=(2,2))(layer) layer=res_block(32,layer) layer=MaxPooling2D(pool_size=(2,2))(layer) layer=res_block(64,layer) layer=MaxPooling2D(pool_size=(2,2))(layer) """ layer = Conv2D(64, (5, 5), padding='same')(layer) # layer=BatchNormalization()(layer) layer = ReLU()(layer) layer = MaxPooling2D(pool_size=(2, 2))(layer) # layer=se_block(64,layer) layer = Conv2D(128, (3, 3), padding='same')(layer) # layer=BatchNormalization()(layer) layer = ReLU()(layer) layer = MaxPooling2D(pool_size=(2, 2))(layer) # layer=se_block(128,layer) layer = Conv2D(256, (3, 3), padding='same')(layer) # layer=BatchNormalization()(layer) layer = ReLU()(layer) layer = MaxPooling2D(pool_size=(2, 2))(layer) # layer=se_block(256,layer) return layer
def ch_CNN(layer): # layer=BatchNormalization()(layer) """ layer=Conv2D(16,(3,3))(layer) layer=se_block(16,layer) layer=BatchNormalization()(layer) layer=ReLU()(layer) layer=MaxPooling2D(pool_size=(2,2))(layer) layer=res_block(16,layer) layer=MaxPooling2D(pool_size=(2,2))(layer) layer=res_block(32,layer) layer=MaxPooling2D(pool_size=(2,2))(layer) layer=res_block(64,layer) layer=MaxPooling2D(pool_size=(2,2))(layer) """ layer = Conv2D(16, (2, 2))(layer) # layer=BatchNormalization()(layer) layer = ReLU()(layer) layer = MaxPooling2D(pool_size=(2, 2))(layer) layer = se_block(16, layer) layer = Conv2D(32, (3, 3))(layer) # layer=BatchNormalization()(layer) layer = ReLU()(layer) layer = MaxPooling2D(pool_size=(2, 2))(layer) layer = se_block(32, layer) layer = Conv2D(64, (3, 3))(layer) # layer=BatchNormalization()(layer) layer = ReLU()(layer) layer = MaxPooling2D(pool_size=(2, 2))(layer) layer = se_block(64, layer) return layer
def _build_inverse_net(self): inputs = Input( [self._input_size[0] // 4, self._input_size[1] // 4, 256]) def instance_norm(inputs): return tf.contrib.layers.instance_norm(inputs) # assume x as shape[None, w/4, h/4, 256] x = Conv2D(filters=128, kernel_size=3, padding='same', use_bias=False)(inputs) x = Lambda(instance_norm)(x) x = ReLU()(x) # upsample to [w/2, h/2] x = UpSampling2D()(x) x = Conv2D(filters=128, kernel_size=3, padding='same', use_bias=False)(x) x = Lambda(instance_norm)(x) x = ReLU()(x) x = Conv2D(filters=64, kernel_size=3, padding='same', use_bias=False)(x) x = Lambda(instance_norm)(x) x = ReLU()(x) # upsample to [w, h] x = UpSampling2D()(x) x = Conv2D(filters=64, kernel_size=3, padding='same', use_bias=False)(x) x = Lambda(instance_norm)(x) x = ReLU()(x) x = Conv2D(filters=3, kernel_size=3, padding='same', activation='relu')(x) self.inverse_net = Model(inputs, x)
def build_policy_head(head_base, num_classes, head_name): x = Conv2D(2, kernel_size=(1, 1), padding='same', kernel_regularizer=l2(L2_WEIGHT_DECAY))(head_base) x = BatchNormalization()(x) x = ReLU()(x) x = Flatten()(x) policy_head = Dense(num_classes, activation='softmax', name=head_name, kernel_regularizer=l2(L2_WEIGHT_DECAY), bias_regularizer=l2(L2_WEIGHT_DECAY))(x) return policy_head
def depthwise_conv_block(input, conv_filter, depth_multiplier, strides=(1, 1)): if strides == (1, 1): x = input padding_type = 'same' else: x = ZeroPadding2D(padding=((1, 1), (1, 1)))(input) padding_type = 'valid' x = DepthwiseConv2D((3, 3), padding=padding_type, depth_multiplier=depth_multiplier, strides=strides, use_bias=False)(x) x = BatchNormalization()(x) x = ReLU(6.)(x) x = Conv2D(conv_filter, (1, 1), padding='same', use_bias=False, strides=(1, 1))(x) x = BatchNormalization()(x) return ReLU(6.)(x)
def identity_block(input_tensor, pointwise_conv_filters, alpha, depth_multiplier=1, strides=(1, 1), block_id='1'): channel_axis = 1 if image_data_format() == 'channels_first' else -1 pointwise_conv_filters = int(pointwise_conv_filters * alpha) x = input_tensor x = DepthwiseConv2D(kernel_size=(3, 3), padding='same', depth_multiplier=depth_multiplier, strides=strides, use_bias=False, name='identity_conv_dw_%s' % block_id)(x) x = BatchNormalization(axis=channel_axis, name='identity_conv_dw_%s_bn' % block_id)(x) x = ReLU(name='identity_conv_dw_%s_relu' % block_id)(x) x = Conv2D(filters=pointwise_conv_filters, kernel_size=(1, 1), padding='same', use_bias=False, strides=(1, 1), name='identity_conv_pw_%s' % block_id)(x) x = BatchNormalization(axis=channel_axis, name='identity_conv_pw_%s_bn' % block_id)(x) x = ReLU(name='identity_conv_pw_%s_relu' % block_id)(x) return x
def build_generator(): gen_model = Sequential() gen_model.add(Dense(input_dim = 100, output_dim = 2048)) gen_model.add(ReLU()) gen_model.add(Dense(256 * 8 * 8)) gen_model.add(BatchNormalization()) gen_model.add(ReLU()) gen_model.add(Reshape((8, 8, 256), input_shape = (256 * 8 * 8,))) gen_model.add(UpSampling2D(size=(2,2))) gen_model.add(Conv2D(128,(5,5),padding = 'same')) gen_model.add(ReLU()) gen_model.add(UpSampling2D(size = (2,2))) gen_model.add(Conv2D(64,(5,5),padding = 'same')) gen_model.add(ReLU()) gen_model.add(UpSampling2D(size=(2,2))) gen_model.add(Conv2D(3,(5,5),padding = 'same')) gen_model.add(Activation('tanh')) return gen_model
def ConvBlock(inputs, n_filters, kernel_size=[3, 3]): """ Basic conv block for Encoder-Decoder Apply successivly Convolution, BatchNormalization, ReLU nonlinearity """ net = Conv2D(n_filters, kernel_size, padding='same')(inputs) net = BatchNormalization()(net) net = ReLU()(net) # TODO: Check order! # net = tf.nn.relu(slim.batch_norm(inputs, fused=True)) # net = slim.conv2d(net, n_filters, kernel_size, activation_fn=None, normalizer_fn=None) return net
def ConvUpscaleBlock(inputs, n_filters, kernel_size=[3, 3], scale=2): """ Basic conv transpose block for Encoder-Decoder upsampling Apply successivly Transposed Convolution, BatchNormalization, ReLU nonlinearity """ net = Conv2DTranspose(n_filters, kernel_size, strides = (scale,scale))(inputs) net = BatchNormalization()(net) net = ReLU()(net) # TODO: Check order! # net = tf.nn.relu(slim.batch_norm(inputs, fused=True)) # net = slim.conv2d_transpose(net, n_filters, kernel_size=[3, 3], stride=[scale, scale], activation_fn=None) return net
def stub(x): # if latent_filters is None: # latent_filters = K.int_shape(x)[-1] y = Conv2D(latent_filters, (1, 1), padding='same')(x) y = ReLU(max_value=ReLU_Max)(y) y = SeperableConvBlock(output_filters=output_filters, ReLU_Max=ReLU_Max, strides=strides)(y) if skipFunction is not None: if strides is not (1, 1): print("Strides can't be used with attention") x = skipFunction([x, y]) return x else: return y
def vdcnn(): model = Sequential() model.add(Lambda(encode, input_shape=(None,), input_dtype='uint8', output_shape=(None, len(tokens)))) model.add(Conv1D(filters=64, kernel_size=3)) model.add(BatchNormalization()) blocks = [64, 64, 128, 128, 256, 256, 512, 512] pools = range(1, len(blocks), 2) for i in range(len(blocks)): filter_size = blocks[i] model.add(Conv1D(filters=filter_size, kernel_size=3)) model.add(BatchNormalization()) model.add(ReLU()) model.add(Conv1D(filters=filter_size, kernel_size=3)) model.add(BatchNormalization()) model.add(ReLU()) if i in pools and i < len(blocks) - 1: model.add(MaxPooling1D(pool_size=3, strides=2)) model.add(GlobalMaxPooling1D()) model.add(Dense(2048, activation='relu')) model.add(BatchNormalization()) model.add(Dense(2048, activation='relu')) model.add(BatchNormalization()) model.add(Dense(1, activation='sigmoid')) return model
def InvertedRes(input, expansion): ''' Args: input: input tensor expansion: expand filters size Output: output: output tensor ''' #Pointwise Convolution x = Conv2D(expansion*3,(1,1), padding='same')(input) x = BatchNormalization()(x) x = ReLU()(x) #Depthwise Convolution x = DepthwiseConv2D((3,3), padding='same')(x) x = BatchNormalization()(x) x = ReLU()(x) #Pointwise Convolution x = Conv2D(3,(1,1))(x) x = BatchNormalization()(x) x = linear(x) x = Add()([x, input]) return x
def __init__(self, filters, kernel_size, gp_num=3, pad_type="constant", **kwargs): super(FlatConv, self).__init__(name="FlatConv") padding = (kernel_size - 1) // 2 padding = (padding, padding) self.model = tf.keras.models.Sequential() self.model.add(get_padding(pad_type, padding)) self.model.add(GroupNormalization(groups=gp_num, axis=-1)) self.model.add(Conv2D(filters, kernel_size)) self.model.add(ReLU())
def __new__(self, inputs, filters, l2_reg): from keras.layers import Conv2D, add, BatchNormalization, ReLU from keras.regularizers import l2 residual = inputs conv_1 = Conv2D(filters, (4, 4), padding='same', use_bias=False, kernel_regularizer=l2(l2_reg))(inputs) norm_1 = BatchNormalization()(conv_1) relu_1 = ReLU()(norm_1) conv_2 = Conv2D(filters, (4, 4), padding='same', use_bias=False, kernel_regularizer=l2(l2_reg))(relu_1) norm_2 = BatchNormalization()(conv_2) out = add([residual, norm_2]) out = ReLU()(out) return out
def __init__(self, input_shape, num_classes=20, num_hidden=1, hidden_size=500, include_relu=False, weights=None): super().__init__(input_shape, num_classes=num_classes) model_input = Input(shape=input_shape) model = Dense(hidden_size)(model_input) model = BatchNormalization()(model) model = ReLU()(model) if num_hidden > 1: for i in range(num_hidden - 1): model = Dense(hidden_size)(model) model = BatchNormalization()(model) model = ReLU()(model) model = Dense(self.num_classes)(model) if include_relu: model = ReLU()(model) self.model = Model(inputs=model_input, outputs=model)
def conv_block(x, filters=64, strides=1, n_blocks=3): inpt = x inpt = Conv_BN(x, filters * 4, kernel_size=1, strides=strides, activation=False) for i in range(n_blocks): stride = strides if i == 0 else 1 x = Conv_BN(x, filters, kernel_size=1, strides=stride, activation=True) x = Conv_BN(x, filters, kernel_size=3, strides=1, activation=True) x = Conv_BN(x, filters * 4, kernel_size=1, strides=1, activation=False) x = add([x, inpt]) x = ReLU()(x) return x
def _bottleneck(inputs, filters, kernel, t, s, r=False): 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 = ReLU(6.0)(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 Conv_BN(x, filters, kernel_size, strides, activation=True, dilation_rate=1): x = Conv2D(filters, kernel_size, strides=strides, padding='same', dilation_rate=dilation_rate)(x) x = BatchNormalization()(x) if activation: x = ReLU()(x) return x
def class_encoder_k(shape): Y_input = Input(shape=shape) Y = Conv2D(64, kernel_size=1, strides=1, padding='same')(Y_input) Y = ReLU()(Y) Y = Conv2D(128, kernel_size=1, strides=2, padding='same')(Y) Y = ReLU()(Y) Y = Conv2D(256, kernel_size=1, strides=2, padding='same')(Y) Y = ReLU()(Y) Y = Conv2D(512, kernel_size=1, strides=2, padding='same')(Y) Y = ReLU()(Y) Y = Conv2D(1024, kernel_size=1, strides=2, padding='same')(Y) Y = ReLU()(Y) Y = AveragePooling2D()(Y) # Y = Dense(512)(Y) Y = Flatten()(Y) return Y
def __create_g_input(self): """Create generator input shape""" n_filters = self.filter_shape_list[0] img_shape = self.img_shape_list[0] input_shape = n_filters * img_shape * img_shape logging.debug(f'G_input: {n_filters, img_shape}') model = Sequential() model.add(Dense(input_shape, input_shape=(self.latent_shape,))) model.add(ReLU()) model.add(Reshape((img_shape, img_shape, n_filters))) model.name = 'GENERATOR_INPUT' return model
def build_model(DropoutRatio=0.5): capacity = 16 input_layer = Input((28, 28, 1)) # 28 * 28 conv1 = Conv2D(32, (3, 3), padding="same")(input_layer) conv1 = ReLU()(conv1) # 14*14 conv1 = Conv2D(64, (3, 3), padding="same")(conv1) conv1 = ReLU()(conv1) conv1 = MaxPooling2D(pool_size=(2, 2))(conv1) flatten = Flatten()(conv1) dense = Dense(128)(flatten) dense = ReLU()(dense) dense = Dense(10)(dense) softmax = Softmax()(dense) model = Model(input_layer, softmax) return model
def p3d_resblock_a(inpt, filters, strides=1, padding='same'): x = ConvBN(inpt, filters // 4, kernel_size=1, strides=strides, activation='relu') x = ConvBN(x, filters // 4, kernel_size=(1, 3, 3), activation='relu') x = ConvBN(x, filters // 4, kernel_size=(3, 1, 1), activation='relu') x = ConvBN(x, filters, kernel_size=1, activation=None) if strides != 1 or inpt._keras_shape[-1] != filters: inpt = ConvBN(inpt, filters, 1, strides=strides, activation=None) x = add([x, inpt]) x = ReLU()(x) return x
def triple_multi_attention(inputs, inputs_image_keys, inputs_mask_keys, name): x = Conv2D_BN_Relu(inputs, 64, kernel_size=(3, 3), name=name + "_input_a", padding="same", strides=(1, 1)) inputs_image_keys = multi_input_Conv2D_BN_Relu(inputs_image_keys, 64, kernel_size=(3, 3), name=name + "_images_a", padding="same", strides=(1, 1)) inputs_mask_keys = multi_input_Conv2D_BN_Relu(inputs_mask_keys, 64, kernel_size=(3, 3), name=name + "_masks_a", padding="same", strides=(1, 1)) f1 = [] f2 = [] for i, (x1, x2) in enumerate(zip(inputs_image_keys, inputs_mask_keys)): x1 = Add(name=name + "_image_add_" + str(i))([x, x1]) x1 = ReLU(name=name + "_image_relu_" + str(i))(x1) f1.append(x1) x2 = Add(name=name + "_mask_add_" + str(i))([x, x2]) x2 = ReLU(name=name + "_mask_relu_" + str(i))(x2) f2.append(x2) f1 = multi_input_Conv2D_BN_Relu(f1, 64, kernel_size=(3, 3), name=name + "_images_b", padding="same", strides=(1, 1)) f2 = multi_input_Conv2D_BN_Relu(f2, 64, kernel_size=(3, 3), name=name + "_masks_b", padding="same", strides=(1, 1)) res = [] add = Add(name=name + "_output_add") relu = ReLU(name=name + "_output_relu") output_image_features = [] output_mask_features = [] for i, (f1_v, f2_v) in enumerate(zip(f1, f2)): f = Multiply(name=name + "_multiply_" + str(i))([f1_v, f2_v]) f1_v = Add(name=name + "_image_output_add_" + str(i))([f1_v, f]) f1_v = ReLU(name=name + "_image_output_relu_" + str(i))(f1_v) output_image_features.append(f1_v) f2_v = Add(name=name + "_mask_output_add_" + str(i))([f2_v, f]) f2_v = ReLU(name=name + "_mask_output_relu_" + str(i))(f2_v) output_mask_features.append(f2_v) x = add([x, f]) x = relu(x) outputs = x return outputs, output_image_features, output_mask_features
def generator_model(self): generator_input = keras.Input(shape=(self.latent_dim, )) x = Dense(128 * 32 * 32)(generator_input) x = ReLU()(x) x = Reshape((32, 32, 128))(x) x = Conv2D(256, 5, padding='same')(x) x = ReLU()(x) x = Conv2DTranspose(256, 4, strides=2, padding='same')(x) x = ReLU()(x) x = Conv2D(256, 5, padding='same')(x) x = ReLU()(x) x = Conv2D(256, 5, padding='same')(x) x = ReLU()(x) x = Conv2D(self.channels, 7, activation='tanh', padding='same')(x) generator = keras.models.Model(generator_input, x) # generator.summary() print("Generator built") return generator
def multi_input_Atrous_Conv2D_BN_Relu(input_list, filters, kernel_size, name, padding, dilation_rate, strides=(1, 1), use_bias=True): h_kernel, w_kernel = kernel_size conv = Conv2D(filters, (h_kernel, w_kernel), strides=strides, padding=padding, dilation_rate=dilation_rate, name=name + "_atrous_conv2d", use_bias=use_bias) bn = BatchNormalization(name=name + "_bn") features = [] for i, x in enumerate(input_list): x = conv(x) x = bn(x) x = ReLU(name=name + "_relu_" + str(i))(x) features.append(x) return features
def residual_layer(input_block): x = Conv2D(filters=RESIDUAL_LAYER_PARAMETERS["filters"], kernel_size=RESIDUAL_LAYER_PARAMETERS["kernel_size"], padding=RESIDUAL_LAYER_PARAMETERS["padding"], data_format="channels_first", kernel_regularizer=RESIDUAL_LAYER_PARAMETERS["kernel_regularizer"] )(input_block) x = BatchNormalization(axis=1)(x) x = Add()([input_block, x]) x = ReLU()(x) return x # Are the parentheses needed?