def rnet_predict(): origins = Input(shape=(3), name='origins') inputs = Input(shape=(24, 24, 3), name='inputs') conv_1 = Conv2D(filters=28, kernel_size=(3, 3), kernel_initializer='zeros', name='conv_1')(inputs) prelu_1 = PReLU(name='prelu_1')(conv_1) pool_1 = MaxPool2D(name='pool_1')(prelu_1) conv_2 = Conv2D(filters=48, kernel_size=(3, 3), kernel_initializer='zeros', name='conv_2')(pool_1) prelu_2 = PReLU(name='prelu_2')(conv_2) pool_2 = MaxPool2D(pool_size=(3, 3), strides=2, name='pool_2')(prelu_2) conv_3 = Conv2D(filters=64, kernel_size=(2, 2), kernel_initializer='zeros', name='conv_3')(pool_2) prelu_3 = PReLU(name='prelu_3')(conv_3) flatten_1 = Flatten(name='flatten_1')(prelu_3) dense_1 = Dense(units=128, kernel_initializer='zeros', name='dense_1')(flatten_1) prelu_4 = PReLU(name='prelu_4')(dense_1) output_1 = Dense(units=2, activation='softmax', kernel_initializer='zeros', name='output_1')(prelu_4) output_2 = Dense(units=4, kernel_initializer='zeros', name='output_2')(prelu_4) output = Lambda(function=calibrate_and_nms, name='calibrate_and_nms')([output_1, output_2, origins]) model = Model(inputs=[inputs, origins], outputs=output) return model
def CNN3(input_shape=(48, 48, 1), n_classes=8): """ 参考论文实现 A Compact Deep Learning Model for Robust Facial Expression Recognition :param input_shape: :param n_classes: :return: """ # input input_layer = Input(shape=input_shape) x = Conv2D(32, (1, 1), strides=1, padding='same', activation='relu')(input_layer) # block1 x = Conv2D(64, (3, 3), strides=1, padding='same')(x) x = PReLU()(x) x = Conv2D(64, (5, 5), strides=1, padding='same')(x) x = PReLU()(x) x = MaxPooling2D(pool_size=(2, 2), strides=2)(x) # block2 x = Conv2D(64, (3, 3), strides=1, padding='same')(x) x = PReLU()(x) x = Conv2D(64, (5, 5), strides=1, padding='same')(x) x = PReLU()(x) x = MaxPooling2D(pool_size=(2, 2), strides=2)(x) # fc x = Flatten()(x) x = Dense(2048, activation='relu')(x) x = Dropout(0.5)(x) x = Dense(1024, activation='relu')(x) x = Dropout(0.5)(x) x = Dense(n_classes, activation='softmax')(x) model = Model(inputs=input_layer, outputs=x) return model
def pnet_predict_v2(): inputs = Input(shape=(None, None, 3), name='inputs') conv_1 = Conv2D(filters=10, kernel_size=(3, 3), kernel_initializer='zeros', name='conv_1')(inputs) prelu_1 = PReLU(shared_axes=[1, 2], name='prelu_1')(conv_1) pool_1 = MaxPool2D(name='pool_1')(prelu_1) conv_2 = Conv2D(filters=16, kernel_size=(3, 3), kernel_initializer='zeros', name='conv_2')(pool_1) prelu_2 = PReLU(shared_axes=[1, 2], name='prelu_2')(conv_2) conv_3 = Conv2D(filters=32, kernel_size=(3, 3), kernel_initializer='zeros', name='conv_3')(prelu_2) prelu_3 = PReLU(shared_axes=[1, 2], name='prelu_3')(conv_3) output_1 = Conv2D(filters=2, kernel_size=(1, 1), activation='softmax', kernel_initializer='zeros', name='output_1')(prelu_3) output_2 = Conv2D(filters=4, kernel_size=(1, 1), kernel_initializer='zeros', name='output_2')(prelu_3) output = Lambda(function=calibrate_and_nms_v2, name='calibrate_and_nms')([output_1, output_2]) model = Model(inputs=inputs, outputs=output) return model
def pnet_train3(train_with_landmark = False): X = Input(shape = (12, 12, 3), name = 'Pnet_input') M = Conv2D(10, 3, strides = 1, padding = 'valid', kernel_initializer = glorot_normal, kernel_regularizer = l2(0.00001), name = 'Pnet_conv1')(X) M = PReLU(shared_axes = [1, 2], name = 'Pnet_prelu1')(M) M = MaxPooling2D(pool_size = 2, name = 'Pnet_maxpool1')(M) M = Conv2D(16, 3, strides = 1, padding = 'valid', kernel_initializer = glorot_normal, kernel_regularizer = l2(0.00001), name = 'Pnet_conv2')(M) M = PReLU(shared_axes= [1, 2], name = 'Pnet_prelu2')(M) M = Conv2D(32, 3, strides = 1, padding = 'valid', kernel_initializer = glorot_normal, kernel_regularizer = l2(0.00001), name = 'Pnet_conv3')(M) M = PReLU(shared_axes= [1, 2], name = 'Pnet_prelu3')(M) Classifier_conv = Conv2D(2, 1, activation = 'softmax', name = 'Pnet_classifier_conv', kernel_initializer = glorot_normal)(M) Bbox_regressor_conv = Conv2D(4, 1, name = 'Pnet_bbox_regressor_conv', kernel_initializer = glorot_normal)(M) Classifier = Reshape((2, ), name = 'Pnet_classifier')(Classifier_conv) Bbox_regressor = Reshape((4, ), name = 'Pnet_bbox_regressor')(Bbox_regressor_conv) if train_with_landmark: Landmark_regressor_conv = Conv2D(12, 1, name = 'Pnet_landmark_regressor_conv', kernel_initializer = glorot_normal)(M) Landmark_regressor = Reshape((12, ), name = 'Pnet_landmark_regressor')(Landmark_regressor_conv) Pnet_output = Concatenate()([Classifier, Bbox_regressor, Landmark_regressor]) else: Pnet_output = Concatenate()([Classifier, Bbox_regressor]) model = Model(X, Pnet_output) return model
def PNet(input_shape=None): if input_shape is None: input_shape = (None, None, 3) input_ = Input(input_shape) # Conv2D ---- 1 x = Conv2D(10, kernel_size=(3, 3), strides=(1, 1), padding="valid")(input_) x = PReLU(shared_axes=[1, 2])(x) x = MaxPooling2D(pool_size=(2, 2), strides=(2, 2), padding="same")(x) # Conv2D --- 2 x = Conv2D(16, kernel_size=(3, 3), strides=(1, 1), padding="valid")(x) x = PReLU(shared_axes=[1, 2])(x) # Conv2D --- 3 x = Conv2D(32, kernel_size=(3, 3), strides=(1, 1), padding="valid")(x) x = PReLU(shared_axes=[1, 2])(x) output_1 = Conv2D(2, kernel_size=(1, 1), strides=(1, 1))(x) output_1 = Softmax(axis=3)(output_1) output_2 = Conv2D(4, kernel_size=(1, 1), strides=(1, 1))(x) pnet = Model(input_, [output_2, output_1]) return pnet
def parallel_unets_with_tf(input_shape=(192, 640, 3)): '''Define Parallel U-Nets model.''' #Define inputs rgb_input_1 = Input(input_shape, name='input1') #RGB Image at time=t rgb_input_2 = Input(input_shape, name='input2') #RGB Image at time=(t-1) d_input_1 = Input((192, 640, 1), name='input3') #Depth Image at time=t d_input_2 = Input((192, 640, 1), name='input4') #Depth Image at time=(t-1) d1_reshape = Reshape((192, 640, 1))(d_input_1) d2_reshape = Reshape((192, 640, 1))(d_input_2) #Build RGBD rgbd1 = Concatenate()([rgb_input_1, d1_reshape]) #RGBD Image at time=t rgbd2 = Concatenate()([rgb_input_2, d2_reshape]) #RGBD Image at time=t-1 cnn1 = cnn4()(rgbd1) cnn2 = cnn4()(rgbd2) flatten1 = Flatten()(cnn1) flatten2 = Flatten()(cnn2) dense_block1 = DenseBlock(input_shape=(flatten1.shape[0], 1))(flatten1) dense_block2 = DenseBlock(input_shape=(flatten2.shape[0], 1))(flatten2) merged = Concatenate()([dense_block1, dense_block2]) flatten3 = Flatten()(merged) dense2 = Dense(128, activation=PReLU())(flatten3) rpy_output = Dense(3, activation='linear', name='rpy_output')(dense2) #RPY dense4 = Dense(128, activation=PReLU())(flatten3) xyz_output = Dense(3, activation='linear', name='xyz_output')(dense4) #XYZ #Define inputs and outputs model = Model(inputs=[rgb_input_1, rgb_input_2, d_input_1, d_input_2], outputs=[rpy_output, xyz_output]) return model
def rnet(training = False, train_with_landmark = False): X = Input(shape = (24, 24, 3), name = 'Rnet_input') M = Conv2D(28, 3, strides = 1, padding = 'valid', name = 'Rnet_conv1')(X) M = PReLU(shared_axes=[1, 2], name = 'Rnet_prelu1')(M) M = MaxPooling2D(pool_size = 3, strides = 2, padding = 'same', name = 'Rnet_maxpool1')(M) M = Conv2D(48, 3, strides = 1, padding = 'valid', name = 'Rnet_conv2')(M) M = PReLU(shared_axes = [1, 2], name = 'Rnet_prelu2')(M) M = MaxPooling2D(pool_size = 3, strides = 2, name = 'Rnet_maxpool2')(M) M = Conv2D(64, 2, strides = 1, padding = 'valid', name = 'Rnet_conv3')(M) M = PReLU(shared_axes = [1, 2], name = 'Rnet_prelu3')(M) M = Flatten(name = 'Rnet_flatten')(M) M = Dense(128, name = 'Rnet_fc')(M) M = PReLU(name = 'Rnet_prelu4')(M) Classifier = Dense(1, activation = 'sigmoid', name = 'Rnet_classifier')(M) Bbox_regressor = Dense(4, name = 'Rnet_bbox_regressor')(M) if training and train_with_landmark: Landmark_regressor = Dense(12, name = 'Rnet_landmark_regressor')(M) Rnet_output = Concatenate()([Classifier, Bbox_regressor, Landmark_regressor]) model = Model(X, Rnet_output) elif training and not train_with_landmark: Rnet_output = Concatenate()([Classifier, Bbox_regressor, Landmark_regressor]) model = Model(X, Rnet_output) else: model = Model(X, [Classifier, Bbox_regressor]) return model
def o_net(training=False): x = Input(shape=(48, 48, 3)) y = Conv2D(32, 3, padding='same', strides=(1, 1), name='o_conv1')(x) y = PReLU(shared_axes=(1, 2), name='o_prelu1')(y) y = MaxPooling2D(pool_size=(3, 3), strides=(2, 2), name='o_max_pooling1')(y) y = Conv2D(64, 3, padding='valid', strides=(1, 1), name='o_conv2')(y) y = PReLU(shared_axes=(1, 2), name='o_prelu2')(y) y = MaxPooling2D(pool_size=(3, 3), strides=(2, 2), name='o_max_pooling2')(y) y = Conv2D(64, 3, padding='valid', strides=(1, 1), name='o_conv3')(y) y = PReLU(shared_axes=(1, 2), name='o_prelu3')(y) y = MaxPooling2D(pool_size=(2, 2), strides=(2, 2), name='o_max_pooling3')(y) y = Conv2D(128, 2, padding='valid', strides=(1, 1), name='o_conv4')(y) y = PReLU(shared_axes=(1, 2), name='o_prelu4')(y) y = Dense(256, name='o_dense')(y) y = PReLU(name='o_prelu5')(y) y = Flatten()(y) classifier = Dense(2, activation='softmax', name='o_classifier')(y) bbox = Dense(4, name='o_bbox')(y) landmark = Dense(10, name='o_landmark')(y) if training: outputs = Concatenate(name='o_predict')([classifier, bbox, landmark]) model = Model(inputs=[x], outputs=[outputs], name='O_Net') else: model = Model(inputs=[x], outputs=[classifier, bbox, landmark], name='O_Net') return model
def build_model(self, input_shape): """モデル構築""" model = Sequential() model.add(Dense(self.params["units"][0], input_shape=input_shape)) model.add(PReLU()) model.add(BatchNormalization()) model.add(Dropout(self.params["dropout"][0])) for l_i in range(1, self.params["layers"] - 1): model.add(Dense(self.params["units"][l_i])) model.add(PReLU()) model.add(BatchNormalization()) model.add(Dropout(self.params["dropout"][l_i])) model.add(Dense(self.params["nb_classes"])) model.add(Activation(self.params["pred_activation"])) if self.params["optimizer"] == "adam": opt = Adam(learning_rate=self.params["learning_rate"]) else: opt = SGD(learning_rate=self.params["learning_rate"], momentum=0.9, nesterov=True) model.compile( loss=self.params["loss"], metrics=self.params["metrics"], optimizer=opt, ) self.model = model
def generator(image_shape, n_resnets): ''' Builds a CNN based generator network with n_resnets resnet blocks and input of size image_shape ''' input_image = Input(shape=image_shape) g = Conv2D(64, (3, 3), strides=(1, 1), padding='same')(input_image) g = PReLU()(g) g_res = resnet_block(64, g) for i in range(n_resnets - 1): g_res = resnet_block(64, g_res) g_res = Conv2D(64, (3, 3), strides=(1, 1), padding='same')(g_res) g_res = BatchNormalization()(g_res) g = Add()([g, g_res]) g = Conv2D(256, (3, 3), strides=(1, 1), padding='same')(g) g = tf.nn.depth_to_space(g, 2) g = PReLU()(g) g = Conv2D(256, (3, 3), strides=(1, 1), padding="same")(g) g = tf.nn.depth_to_space(g, 2) g = PReLU()(g) g = Conv2D(3, (9, 9), strides=(1, 1), padding="same")(g) output_image = Activation("tanh")(g) generator = Model(input_image, output_image) return generator
def CNN3(input_shape=(48, 48, 1), n_classes=8): # input input_layer = Input(shape=input_shape) x = Conv2D(32, (1, 1), strides=1, padding='same', activation='relu')(input_layer) # block1 x = Conv2D(64, (3, 3), strides=1, padding='same')(x) x = PReLU()(x) x = Conv2D(64, (5, 5), strides=1, padding='same')(x) x = PReLU()(x) x = MaxPooling2D(pool_size=(2, 2), strides=2)(x) # block2 x = Conv2D(64, (3, 3), strides=1, padding='same')(x) x = PReLU()(x) x = Conv2D(64, (5, 5), strides=1, padding='same')(x) x = PReLU()(x) x = MaxPooling2D(pool_size=(2, 2), strides=2)(x) # fc x = Flatten()(x) x = Dense(2048, activation='relu')(x) x = Dropout(0.5)(x) x = Dense(1024, activation='relu')(x) x = Dropout(0.5)(x) x = Dense(n_classes, activation='softmax')(x) model = Model(inputs=input_layer, outputs=x) return model
def __init__(self, imageWidth, imageHeight, isColour=True): # supports three channels for rgb else one for greyscale colourChannels = 3 if isColour else 1 # we can infer our input tensor shape from the data. inputShape = (imageWidth, imageHeight, colourChannels) self.Layers = [ ZeroPadding2D(padding=(0, 0), data_format=None, name="generativeNetwork"), Conv2D(5, (5, 5), padding="same"), #input_shape=inputShape), PReLU(alpha_initializer="zeros"), ZeroPadding2D(padding=(0, 0), data_format=None), Conv2D(3, (5, 5), padding="same", name="generative_ouput"), PReLU(alpha_initializer="zeros"), ] self.model = Sequential(self.Layers) self.compile() def compile(self): self.model.compile(optimizer="adam", loss=["mean_squared_error"], metrics=["accuracy"])
def model_generator(input_shape=(64, 64, 3)): x_input = Input(shape=input_shape, name='Generator_Input') conv_1 = Conv2D(64, kernel_size=9, strides=1, padding='same', name='G_Conv_1')(x_input) conv_1 = PReLU(shared_axes=[1, 2])(conv_1) # This Copy Need For Layers After Residual Block x_copy = conv_1 ### RESIDUAL BLOCKS * 5 conv_2 = _residual_block(conv_1) conv_3 = _residual_block(conv_2) conv_4 = _residual_block(conv_3) conv_5 = _residual_block(conv_4) conv_6 = _residual_block(conv_5) conv_7 = Conv2D(64, kernel_size=3, strides=1, padding='same', name='G_Conv_7')(conv_6) conv_7 = BatchNormalization()(conv_7) conv_7 = Add()([x_copy, conv_7]) # Last Two Layers k=3, n=256, s=1 conv_8 = Conv2D(256, kernel_size=3, strides=1, padding='same', name='G_Conv_8')(conv_7) conv_8 = keras.layers.Lambda(_pixel_with_lambda(scale=2))(conv_8) conv_8 = PReLU(shared_axes=[1, 2])(conv_8) conv_9 = Conv2D(256, kernel_size=3, strides=1, padding='same', name='G_Conv_9')(conv_8) conv_9 = keras.layers.Lambda(_pixel_with_lambda(scale=2))(conv_9) conv_9 = PReLU(shared_axes=[1, 2])(conv_9) conv_10 = Conv2D(3, kernel_size=9, strides=1, padding='same', activation='tanh', name='G_Conv_10')(conv_9) return keras.Model(x_input, conv_10, name='Generator')
def get_generator(input_shape): """ generator model.""" nin = Input(input_shape) n = Conv2D(64, 9, 1, padding='SAME', kernel_initializer='he_normal')(nin) n = PReLU(shared_axes=[1, 2])(n) temp = n # B residual blocks for i in range(16): nn = Conv2D(64, 3, 1, padding='SAME', use_bias=False, kernel_initializer='he_normal')(n) nn = BatchNormalization()(nn) nn = PReLU(shared_axes=[1, 2])(nn) nn = Conv2D(64, 3, 1, padding='SAME', use_bias=False, kernel_initializer='he_normal')(nn) nn = BatchNormalization()(nn) nn = Add()([n, nn]) n = nn n = Conv2D(64, 3, 1, padding='SAME', use_bias=False, kernel_initializer='he_normal')(n) n = BatchNormalization()(n) n = Add()([n, temp]) # B residual blacks end n = Conv2D(256, 3, 1, padding='SAME', kernel_initializer='he_normal')(n) n = SubPixelConv2D(upsample_factor=2, nchannels=64)(n) n = PReLU(shared_axes=[1, 2])(n) n = Conv2D(256, 3, 1, padding='SAME', kernel_initializer='he_normal')(n) n = SubPixelConv2D(upsample_factor=2, nchannels=64)(n) n = PReLU(shared_axes=[1, 2])(n) nn = Conv2D(3, 9, 1, padding='SAME', kernel_initializer='he_normal')(n) return Model(inputs=nin, outputs=nn, name="generator")
def down_trans(inputs, nf, nconvs, bn, dr, ty='v', name='block'): # inputs = Input((None, None, None, nch)) downconv = Conv3D(nf, 2, padding='valid', strides=(2, 2, 2), name=name + '_Conv3D_0')(inputs) downconv = PReLU(shared_axes=[1, 2, 3], name=name + '_PReLU_0')(downconv) if bn: downconv = BatchNormalization(name=name + '_bn_0')(downconv) if dr: downconv = Dropout(0.5, name=name + '_dr_0')(downconv) conv = downconv for i in range(nconvs): conv = Conv3D(nf, 3, padding='same', name=name + '_Conv3D_' + str(i + 1))(conv) conv = PReLU(shared_axes=[1, 2, 3], name=name + '_PReLU_' + str(i + 1))(conv) if bn: conv = BatchNormalization(name=name + '_bn_' + str(i + 1))(conv) if ty == 'v': # V-Net d = add([conv, downconv]) elif ty == 'u': # U-Net d = conv else: raise Exception("please assign the model net_type: 'v' or 'u'.") # m = Model(inputs=inputs, outputs=d) return d
def build_rnet(self, input_shape=None): if input_shape is None: input_shape = (24, 24, 3) r_inp = Input(input_shape) r_layer = Conv2D(28, kernel_size=(3, 3), strides=(1, 1), padding="valid")(r_inp) r_layer = PReLU(shared_axes=[1, 2])(r_layer) r_layer = MaxPooling2D(pool_size=(3, 3), strides=(2, 2), padding="same")(r_layer) r_layer = Conv2D(48, kernel_size=(3, 3), strides=(1, 1), padding="valid")(r_layer) r_layer = PReLU(shared_axes=[1, 2])(r_layer) r_layer = MaxPooling2D(pool_size=(3, 3), strides=(2, 2), padding="valid")(r_layer) r_layer = Conv2D(64, kernel_size=(2, 2), strides=(1, 1), padding="valid")(r_layer) r_layer = PReLU(shared_axes=[1, 2])(r_layer) r_layer = Flatten()(r_layer) r_layer = Dense(128)(r_layer) r_layer = PReLU()(r_layer) r_layer_out1 = Dense(2)(r_layer) r_layer_out1 = Softmax(axis=1)(r_layer_out1) r_layer_out2 = Dense(4)(r_layer) r_net = Model(r_inp, [r_layer_out2, r_layer_out1]) return r_net
def new_attention_3d_block( slt_api_num, feature_dim, name='', ): """ :param query: (None,D) :param key: (None,slt_api_num,D) :param value: (None,slt_api_num,D) 一般等于key :return: """ query = Input(shape=(feature_dim, ), name=name + 'query_input') key = Input(shape=( slt_api_num, feature_dim, ), name=name + 'key_input') value = Input(shape=( slt_api_num, feature_dim, ), name=name + 'value_input') Repeat_query = RepeatVector(slt_api_num)(query) # (None,slt_api_num,D) att_score = Concatenate(name=name + 'att_info_concate')( [Repeat_query, key]) # (None,slt_api_num,2*D) 不加入外积和差效果较好? # outer_prod = Multiply()([Repeat_query,key]) # sub = Subtract()([Repeat_query,key]) # att_score = Concatenate(name=name+'att_info_concate')([Repeat_query,key,outer_prod,sub]) # (None,slt_api_num,4*D) att_score = Dense(36)(att_score) # (None,slt_api_num,36) att_score = PReLU()(att_score) if 'new_3layer' in new_Para.param.CI_handle_slt_apis_mode: att_score = Dense(16)(att_score) # (None,slt_api_num,16) att_score = PReLU()(att_score) # att_score = Dense(1, activation='linear')(att_score) # (None,slt_api_num,1) att_score = Dense(1)(att_score) # (None,slt_api_num,1) # 最后非线性 att_score = PReLU()(att_score) att_score = Reshape((slt_api_num, ), )(att_score) # (None,slt_api_num) a_probs = Dense(slt_api_num, activation='softmax')( att_score ) # (None,slt_api_num) 不需要加这一层dense???加上效果好。 一般softmax层也会加上dense参数 # a_probs = Activation('softmax')(att_score) # a_probs = Reshape((slt_api_num, 1), )(a_probs) # (None,slt_api_num,1) # # 直接全连接+softmax层,有问题! # a_probs = Dense(slt_api_num, activation='softmax')(att_score) # (None,slt_api_num,16) # a_probs = Permute((2, 1))(a_probs) output_attention_mul = Multiply(name=name + 'attention_mul')( [a_probs, value]) # shape=(?,slt_api_num, D) att_result = Lambda(lambda x: tf.reduce_sum(x, axis=1))( output_attention_mul) # (None,D) model = Model(inputs=[query, key, value], outputs=[att_result], name=name + 'attBlock') return model
def build_onet(self, input_shape=None): if input_shape is None: input_shape = (48, 48, 3) o_inp = Input(input_shape) o_layer = Conv2D(32, kernel_size=(3, 3), strides=(1, 1), padding="valid")(o_inp) o_layer = PReLU(shared_axes=[1, 2])(o_layer) o_layer = MaxPooling2D(pool_size=(3, 3), strides=(2, 2), padding="same")(o_layer) o_layer = Conv2D(64, kernel_size=(3, 3), strides=(1, 1), padding="valid")(o_layer) o_layer = PReLU(shared_axes=[1, 2])(o_layer) o_layer = MaxPooling2D(pool_size=(3, 3), strides=(2, 2), padding="valid")(o_layer) o_layer = Conv2D(64, kernel_size=(3, 3), strides=(1, 1), padding="valid")(o_layer) o_layer = PReLU(shared_axes=[1, 2])(o_layer) o_layer = MaxPooling2D(pool_size=(2, 2), strides=(2, 2), padding="same")(o_layer) o_layer = Conv2D(128, kernel_size=(2, 2), strides=(1, 1), padding="valid")(o_layer) o_layer = PReLU(shared_axes=[1, 2])(o_layer) o_layer = Flatten()(o_layer) o_layer = Dense(256)(o_layer) o_layer = PReLU()(o_layer) o_layer_out1 = Dense(2)(o_layer) o_layer_out1 = Softmax(axis=1)(o_layer_out1) o_layer_out2 = Dense(4)(o_layer) o_layer_out3 = Dense(10)(o_layer) o_net = Model(o_inp, [o_layer_out2, o_layer_out3, o_layer_out1]) return o_net
def encode_block_lstm(size, inputs, kernel, stride, activation, kinit, padding, max_pool=True, batch_normalization=False, mask=None): result = [] use_bias = not batch_normalization x, state_h, state_c = ConvLSTM2D(size, kernel_size=kernel, strides=stride, kernel_initializer=kinit, use_bias=use_bias, activation='linear', padding=padding, return_sequences=True, return_state=True)(inputs, mask=mask) x = BatchNormalization()(x) if batch_normalization else x x = PReLU()(x) # In theory this should avoid the vanishing gradient situation that is, arguably more accute with RNNs x, state_h, state_c = ConvLSTM2D(size, kernel_size=kernel, strides=stride, kernel_initializer=kinit, use_bias=use_bias, activation='linear', padding=padding, return_sequences=True, return_state=True)(x, mask=mask) # can't set initial_state=(state_h, state_c) due to a bug in keras x = BatchNormalization()(x) if batch_normalization else x x = PReLU()(x) # result.append(x) result.append(state_c) if max_pool: pool1 = MaxPooling3D(pool_size=(2, 2, 2))(x) result.append(pool1) else: result.append(None) return result
def add_residual_block(cls, residual_input): ''' Builds a single residual block with 2 Conv2D layers (with batch normalization and ReLU) and attachs to previous layers :param residual_input: tf.keras.layers.* - layer to perform a skip on :return: tf.keras.layers.PReLU - output layer for the residual block ''' conv1 = Conv2D(filters=64, kernel_size=(3, 3), strides=1, padding='same', kernel_initializer=KERNEL_INIT)(residual_input) bn1 = BatchNormalization()(conv1) rec1 = PReLU()(bn1) conv2 = Conv2D(filters=64, kernel_size=(3, 3), strides=1, padding='same', kernel_initializer=KERNEL_INIT)(rec1) bn2 = BatchNormalization()(conv2) add1 = Add()([bn2, residual_input]) rec2 = PReLU()(add1) return rec2
def onet(training = False): X = Input(shape = (48, 48, 3), name = 'Onet_input') M = Conv2D(32, 3, strides = 1, padding = 'valid', name = 'Onet_conv1')(X) M = PReLU(shared_axes = [1, 2], name = 'Onet_prelu1')(M) M = MaxPooling2D(pool_size = 3, strides = 2, padding = 'same', name = 'Onet_maxpool1')(M) M = Conv2D(64, 3, strides = 1, padding = 'valid', name = 'Onet_conv2')(M) M = PReLU(shared_axes = [1, 2], name = 'Onet_prelu2')(M) M = MaxPooling2D(pool_size = 3, strides = 2, padding = 'valid', name = 'Onet_maxpool2')(M) M = Conv2D(64, 3, strides = 1, padding = 'valid', name = 'Onet_conv3')(M) M = PReLU(shared_axes = [1,2], name = 'Onet_prelu3')(M) M = MaxPooling2D(pool_size = 2, padding = 'valid', name = 'Onet_maxpool3')(M) M = Conv2D(128, 2, strides = 1, padding = 'valid', name = 'Onet_conv4')(M) M = PReLU(shared_axes = [1, 2], name='Onet_prelu4')(M) M = Flatten(name = 'Onet_flatten')(M) M = Dense(256, name = 'Onet_fc') (M) M = PReLU(name = 'Onet_prelu5')(M) Classifier = Dense(2, activation = 'softmax', name='Onet_classifier')(M) Bbox_regressor = Dense(4, name = 'Onet_bbox_regressor')(M) Landmark_regressor = Dense(12, name = 'Onet_landmark_regressor')(M) if training: Onet_output = Concatenate()([Classifier, Bbox_regressor, Landmark_regressor]) model = Model(X, Onet_output) else: model = Model(X, [Classifier, Bbox_regressor, Landmark_regressor]) return model
def build_pnet(self, input_shape=None): if input_shape is None: input_shape = (None, None, 3) p_inp = Input(input_shape) p_layer = Conv2D(10, kernel_size=(3, 3), strides=(1, 1), padding="valid")(p_inp) p_layer = PReLU(shared_axes=[1, 2])(p_layer) p_layer = MaxPooling2D(pool_size=(2, 2), strides=(2, 2), padding="same")(p_layer) p_layer = Conv2D(16, kernel_size=(3, 3), strides=(1, 1), padding="valid")(p_layer) p_layer = PReLU(shared_axes=[1, 2])(p_layer) p_layer = Conv2D(32, kernel_size=(3, 3), strides=(1, 1), padding="valid")(p_layer) p_layer = PReLU(shared_axes=[1, 2])(p_layer) p_layer_out1 = Conv2D(2, kernel_size=(1, 1), strides=(1, 1))(p_layer) p_layer_out1 = Softmax(axis=3)(p_layer_out1) p_layer_out2 = Conv2D(4, kernel_size=(1, 1), strides=(1, 1))(p_layer) p_net = Model(p_inp, [p_layer_out2, p_layer_out1]) return p_net
def RNet(input_shape=None): if input_shape is None: input_shape = (24, 24, 3) input_ = Input(input_shape) # Conv2D --- 1 x = Conv2D(28, kernel_size=(3, 3), strides=(1, 1), padding="valid")(input_) x = PReLU(shared_axes=[1, 2])(x) x = MaxPooling2D(pool_size=(3, 3), strides=(2, 2), padding="same")(x) # Conv2D --- 2 x = Conv2D(48, kernel_size=(3, 3), strides=(1, 1), padding="valid")(x) x = PReLU(shared_axes=[1, 2])(x) x = MaxPooling2D(pool_size=(3, 3), strides=(2, 2), padding="valid")(x) # Conv2D --- 3 x = Conv2D(64, kernel_size=(2, 2), strides=(1, 1), padding="valid")(x) x = PReLU(shared_axes=[1, 2])(x) x = Flatten()(x) x = Dense(128)(x) x = PReLU()(x) output_1 = Dense(2)(x) output_1 = Softmax(axis=1)(output_1) output_2 = Dense(4)(x) rnet = Model(input_, [output_2, output_1]) return rnet
def create_Pnet(weight_path): # h,w input = Input(shape=[None, None, 3]) # h,w,3 -> h/2,w/2,10 x = Conv2D(10, (3, 3), strides=1, padding='valid', name='conv1')(input) x = PReLU(shared_axes=[1, 2], name='PReLU1')(x) x = MaxPool2D(pool_size=2)(x) # h/2,w/2,10 -> h/2,w/2,16 x = Conv2D(16, (3, 3), strides=1, padding='valid', name='conv2')(x) x = PReLU(shared_axes=[1, 2], name='PReLU2')(x) # h/2,w/2,32 x = Conv2D(32, (3, 3), strides=1, padding='valid', name='conv3')(x) x = PReLU(shared_axes=[1, 2], name='PReLU3')(x) # h/2, w/2, 2 classifier = Conv2D(2, (1, 1), activation='softmax', name='conv4-1')(x) # 无激活函数,线性。 # h/2, w/2, 4 bbox_regress = Conv2D(4, (1, 1), name='conv4-2')(x) model = Model([input], [classifier, bbox_regress]) model.load_weights(weight_path, by_name=True) return model
def DenseDownProj(x_in, num_filters, kernel_size=12): h_in = Conv2D(num_filters, kernel_size=1, strides=1, padding='same', kernel_initializer=test_initializer, kernel_regularizer=l2(reg_scale))(x_in) h_in = PReLU(alpha_initializer='zero', shared_axes=[1, 2])(h_in) l0 = Conv2D(num_filters, kernel_size=kernel_size, strides=(8,8), padding='same', kernel_initializer=test_initializer, kernel_regularizer=l2(reg_scale))(h_in) l0 = PReLU(alpha_initializer='zero', shared_axes=[1, 2])(l0) h0 = Conv2DTranspose(num_filters, kernel_size=kernel_size, strides=(8, 8), padding='same', kernel_initializer=test_initializer, kernel_regularizer=l2(reg_scale))(l0) h0 = PReLU(alpha_initializer='zero', shared_axes=[1, 2])(h0) e0 = subtract([h0, h_in]) l1 = Conv2D(num_filters, kernel_size=kernel_size, strides=(8,8), padding='same', kernel_initializer=test_initializer, kernel_regularizer=l2(reg_scale))(e0) l1 = PReLU(alpha_initializer='zero', shared_axes=[1, 2])(l1) out = add([l1, l0]) return out
def create_Rnet(weight_path): input = Input(shape=[24, 24, 3]) # 24,24,3 -> 11,11,28 x = Conv2D(28, (3, 3), strides=1, padding='valid', name='conv1')(input) x = PReLU(shared_axes=[1, 2], name='prelu1')(x) x = MaxPool2D(pool_size=3, strides=2, padding='same')(x) # 11,11,28 -> 4,4,48 x = Conv2D(48, (3, 3), strides=1, padding='valid', name='conv2')(x) x = PReLU(shared_axes=[1, 2], name='prelu2')(x) x = MaxPool2D(pool_size=3, strides=2)(x) # 4,4,48 -> 3,3,64 x = Conv2D(64, (2, 2), strides=1, padding='valid', name='conv3')(x) x = PReLU(shared_axes=[1, 2], name='prelu3')(x) # 3,3,64 -> 64,3,3 x = Permute((3, 2, 1))(x) x = Flatten()(x) # 576 -> 128 x = Dense(128, name='conv4')(x) x = PReLU(name='prelu4')(x) # 128 -> 2 128 -> 4 classifier = Dense(2, activation='softmax', name='conv5-1')(x) bbox_regress = Dense(4, name='conv5-2')(x) model = Model([input], [classifier, bbox_regress]) model.load_weights(weight_path, by_name=True) return model
def get_model( input_len, reg, hidden1, hidden2, hidden3, ): model = Sequential() model.add(BatchNormalization()) model.add( Dense(hidden1, kernel_regularizer=regularizers.l2(reg), activity_regularizer=regularizers.l2(reg), input_shape=(input_len, ))) model.add(PReLU()) model.add( Dense(hidden2, kernel_regularizer=regularizers.l2(reg), activity_regularizer=regularizers.l2(reg))) model.add(PReLU()) model.add( Dense(hidden3, kernel_regularizer=regularizers.l2(reg), activity_regularizer=regularizers.l2(reg))) model.add(PReLU()) model.add(Dense(1, activation="sigmoid")) model.compile(loss="binary_crossentropy", optimizer=Adam(), metrics=tensorflow.keras.metrics.AUC()) return model
def create_Onet(weight_path): input = Input(shape=[48, 48, 3]) # 48,48,3 -> 23,23,32 x = Conv2D(32, (3, 3), strides=1, padding='valid', name='conv1')(input) x = PReLU(shared_axes=[1, 2], name='prelu1')(x) x = MaxPool2D(pool_size=3, strides=2, padding='same')(x) # 23,23,32 -> 10,10,64 x = Conv2D(64, (3, 3), strides=1, padding='valid', name='conv2')(x) x = PReLU(shared_axes=[1, 2], name='prelu2')(x) x = MaxPool2D(pool_size=3, strides=2)(x) # 8,8,64 -> 4,4,64 x = Conv2D(64, (3, 3), strides=1, padding='valid', name='conv3')(x) x = PReLU(shared_axes=[1, 2], name='prelu3')(x) x = MaxPool2D(pool_size=2)(x) # 4,4,64 -> 3,3,128 x = Conv2D(128, (2, 2), strides=1, padding='valid', name='conv4')(x) x = PReLU(shared_axes=[1, 2], name='prelu4')(x) # 3,3,128 -> 128,3,3 x = Permute((3, 2, 1))(x) # 1152 -> 256 x = Flatten()(x) x = Dense(256, name='conv5')(x) x = PReLU(name='prelu5')(x) # 鉴别 # 256 -> 2 256 -> 4 256 -> 10 classifier = Dense(2, activation='softmax', name='conv6-1')(x) bbox_regress = Dense(4, name='conv6-2')(x) landmark_regress = Dense(10, name='conv6-3')(x) model = Model([input], [classifier, bbox_regress, landmark_regress]) model.load_weights(weight_path, by_name=True) return model
def inception_resnet_B(x, scope="inception_b", training=True): with tf.name_scope(scope): init = x split_conv_x1 = Conv2D(filters=64, kernel_size=1, padding='same')(x) split_conv_x1 = BatchNormalization()(split_conv_x1, training=training) split_conv_x1 = PReLU()(split_conv_x1) split_conv_x2 = Conv2D(filters=32, kernel_size=1, padding='same')(x) split_conv_x2 = BatchNormalization()(split_conv_x2, training=training) split_conv_x2 = PReLU()(split_conv_x2) split_conv_x2 = Conv2D(filters=32, kernel_size=(7, 1), padding='same')(split_conv_x2) split_conv_x2 = BatchNormalization()(split_conv_x2, training=training) split_conv_x2 = PReLU()(split_conv_x2) split_conv_x2 = Conv2D(filters=64, kernel_size=(1, 7), padding='same')(split_conv_x2) split_conv_x2 = PReLU()(split_conv_x2) x = concatenate([split_conv_x1, split_conv_x2], axis=-1) x = Conv2D(filters=256, kernel_size=1, padding='same')(x) x = tf.math.scalar_mul(0.1, x) x = add([init, x]) x = BatchNormalization()(x, training=training) x = PReLU()(x) return x
def EMB_ECODER_BACILLUS_02(input_shape, n_class): # Input layer x = Input(shape=input_shape) emb = Embedding(4, 9, input_length=input_shape[0])(x) # Block 01 block1 = Conv1D( filters=128, kernel_size=5, padding='same', strides=1)(emb) block1 = keras_contrib.InstanceNormalization()(block1) block1 = PReLU(shared_axes=[1])(block1) block1 = Dropout(rate=0.2)(block1) block1 = MaxPooling1D(pool_size=2)(block1) # Block 02 block2 = Conv1D( filters=256, kernel_size=11, padding='same', strides=1)(emb) block2 = keras_contrib.InstanceNormalization()(block1) block2 = PReLU(shared_axes=[1])(block2) block2 = Dropout(rate=0.2)(block2) block2 = MaxPooling1D(pool_size=2)(block2) # # Block 03 # block3 = Conv1D( # filters=256, # kernel_size=21, # padding='same', # strides=1)(emb) # block3 = keras_contrib.InstanceNormalization()(block2) # block3 = PReLU(shared_axes=[1])(block3) # block3 = Dropout(rate=0.2)(block3) # block3 = MaxPooling1D(pool_size=2)(block3) # split for attention attention_data = Lambda(lambda x: x)(block2) attention_softmax = Lambda(lambda x: x)(block2) # attention mechanism attention_softmax = Softmax()(attention_softmax) multiply_layer = Multiply()([attention_softmax, attention_data]) # Fully connected layers dense_layer = Dense(units=256, activation='sigmoid')(multiply_layer) dense_layer = keras_contrib.InstanceNormalization()(dense_layer) # Classification layer flatten_layer = Flatten()(dense_layer) output_layer = Dense(units=n_class, activation='sigmoid')(flatten_layer) # Create model object model = models.Model(inputs=[x], outputs=[output_layer]) return model