def onet(self, input_shape=None): if input_shape is None: input_shape = (48, 48, 3) net = Input(input_shape) onet_layer = Conv2D(32, (3, 3), strides=(1, 1), padding='valid')(net) onet_layer = PReLU(shared_axes=[1, 2])(onet_layer) onet_layer = MaxPooling2D((3, 3), strides=(2, 2), padding='same')(onet_layer) onet_layer = Conv2D(64, (3, 3), strides=(1, 1), padding='valid')(onet_layer) onet_layer = PReLU(shared_axes=[1, 2])(onet_layer) onet_layer = MaxPooling2D((3, 3), strides=(2, 2), padding='valid')(onet_layer) onet_layer = Conv2D(64, (3, 3), strides=(1, 1), padding='valid')(onet_layer) onet_layer = PReLU(shared_axes=[1, 2])(onet_layer) onet_layer = MaxPooling2D((2, 2), strides=(2, 2), padding='same')(onet_layer) onet_layer = Conv2D(128, (2, 2), strides=(1, 1), padding='valid')(onet_layer) onet_layer = PReLU(shared_axes=[1, 2])(onet_layer) onet_layer = Flatten()(onet_layer) onet_layer = Dense(256)(onet_layer) onet_layer = PReLU()(onet_layer) onet_out1 = Dense(2)(onet_layer) onet_out1 = Softmax(axis=1)(onet_out1) onet_out2 = Dense(4)(onet_layer) onet_out3 = Dense(10)(onet_layer) onet = Model(net, [onet_out2, onet_out3, onet_out1]) return onet
def recall_net(input): wn = Lambda(white_norm, name="white_norm")(input) conv1 = PReLU(shared_axes=[1, 2])(Conv2D(28, (3, 3), padding="valid", strides=(1, 1), name="conv1")(wn)) block1 = MaxPooling2D(pool_size=(3, 3), strides=(2, 2), padding="same")(conv1) conv2 = PReLU(shared_axes=[1, 2])(Conv2D(48, (3, 3), padding="valid", strides=(1, 1), name="conv2")(block1)) block2 = MaxPooling2D(pool_size=(3, 3), strides=(2, 2), padding="valid")(conv2) block3 = PReLU(shared_axes=[1, 2])(Conv2D(64, (2, 2), padding="valid", strides=(1, 1), name="conv3")(block2)) block3 = Flatten()(block3) dense = PReLU()(Dense(128, name="r_feat")(block3)) cate = Dense(2, activation=softmax, name="class")(dense) boxes = Dense(4, activity_regularizer=regularizers.l2(0.0005), name="box")(dense) landmark = Dense(14, activity_regularizer=regularizers.l2(0.0005), name="landmark")(dense) model = Model(inputs=input, outputs=[cate, boxes, landmark]) return model
def pnet(self, input_shape=None): if input_shape is None: input_shape = (None, None, 3) net = Input(input_shape) pnet_layer = Conv2D(10, (3, 3), strides=(1, 1), padding='valid')(net) pnet_layer = PReLU(shared_axes=[1, 2])(pnet_layer) pnet_layer = MaxPooling2D((2, 2), strides=(2, 2), padding='same')(pnet_layer) pnet_layer = Conv2D(16, (3, 3), strides=(1, 1), padding='valid')(pnet_layer) pnet_layer = PReLU(shared_axes=[1, 2])(pnet_layer) pnet_layer = Conv2D(32, (3, 3), strides=(1, 1), padding='valid')(pnet_layer) pnet_layer = PReLU(shared_axes=[1, 2])(pnet_layer) pnet_out1 = Conv2D(2, (1, 1), strides=(1, 1))(pnet_layer) pnet_out1 = Softmax(axis=3)(pnet_out1) pnet_out2 = Conv2D(4, (1, 1), strides=(1, 1))(pnet_layer) p_net = Model(net, [pnet_out2, pnet_out1]) return p_net
def demo_create_encoder(latent_dim, cat_dim, window_size, input_dim): input_layer = Input(shape=(window_size, input_dim)) code = TimeDistributed(Dense(64, activation='linear'))(input_layer) code = Bidirectional(LSTM(128, return_sequences=True))(code) code = BatchNormalization()(code) code = ELU()(code) code = Bidirectional(LSTM(64))(code) code = BatchNormalization()(code) code = ELU()(code) cat = Dense(64)(code) cat = BatchNormalization()(cat) cat = PReLU()(cat) cat = Dense(cat_dim, activation='softmax')(cat) latent_repr = Dense(64)(code) latent_repr = BatchNormalization()(latent_repr) latent_repr = PReLU()(latent_repr) latent_repr = Dense(latent_dim, activation='linear')(latent_repr) decode = Concatenate()([latent_repr, cat]) decode = RepeatVector(window_size)(decode) decode = Bidirectional(LSTM(64, return_sequences=True))(decode) decode = ELU()(decode) decode = Bidirectional(LSTM(128, return_sequences=True))(decode) decode = ELU()(decode) decode = TimeDistributed(Dense(64))(decode) decode = ELU()(decode) decode = TimeDistributed(Dense(input_dim, activation='linear'))(decode) error = Subtract()([input_layer, decode]) return Model(input_layer, [decode, latent_repr, cat, error])
def rnet(self, input_shape=None): if input_shape is None: input_shape = (24, 24, 3) net = Input(input_shape) rnet_layer = Conv2D(28, (3, 3), strides=(1, 1), padding='valid')(net) rnet_layer = PReLU(shared_axes=[1, 2])(rnet_layer) rnet_layer = MaxPooling2D((3, 3), strides=(2, 2), padding='same')(rnet_layer) rnet_layer = Conv2D(48, (3, 3), strides=(1, 1), padding='valid')(rnet_layer) rnet_layer = PReLU(shared_axes=[1, 2])(rnet_layer) rnet_layer = MaxPooling2D((3, 3), strides=(2, 2), padding='valid')(rnet_layer) rnet_layer = Conv2D(64, (2, 2), strides=(1, 1), padding='valid')(rnet_layer) rnet_layer = PReLU(shared_axes=[1, 2])(rnet_layer) rnet_layer = Flatten()(rnet_layer) rnet_layer = Dense(128)(rnet_layer) rnet_layer = PReLU()(rnet_layer) rnet_out1 = Dense(2)(rnet_layer) rnet_out1 = Softmax(axis=1)(rnet_out1) rnet_out2 = Dense(4)(rnet_layer) rnet = Model(net, [rnet_out2, rnet_out1]) return rnet
def bottleneck_decoder(tensor, nfilters, upsampling=False, normal=False, name=''): y = tensor skip = tensor if upsampling: skip = Conv2D(filters=nfilters, kernel_size=(1, 1), kernel_initializer='he_normal', strides=(1, 1), padding='same', use_bias=False, name=f'1x1_conv_skip_{name}')(skip) skip = UpSampling2D(size=(2, 2), name=f'upsample_skip_{name}')(skip) y = Conv2D(filters=nfilters // 4, kernel_size=(1, 1), kernel_initializer='he_normal', strides=(1, 1), padding='same', use_bias=False, name=f'1x1_conv_{name}')(y) y = BatchNormalization(momentum=0.1, name=f'bn_1x1_{name}')(y) y = PReLU(shared_axes=[1, 2], name=f'prelu_1x1_{name}')(y) if upsampling: y = Conv2DTranspose(filters=nfilters // 4, kernel_size=(3, 3), kernel_initializer='he_normal', strides=(2, 2), padding='same', name=f'3x3_deconv_{name}')(y) elif normal: Conv2D(filters=nfilters // 4, kernel_size=(3, 3), strides=(1, 1), kernel_initializer='he_normal', padding='same', name=f'3x3_conv_{name}')(y) y = BatchNormalization(momentum=0.1, name=f'bn_main_{name}')(y) y = PReLU(shared_axes=[1, 2], name=f'prelu_{name}')(y) y = Conv2D(filters=nfilters, kernel_size=(1, 1), kernel_initializer='he_normal', use_bias=False, name=f'final_1x1_{name}')(y) y = BatchNormalization(momentum=0.1, name=f'bn_final_{name}')(y) y = Add(name=f'add_{name}')([y, skip]) y = ReLU(name=f'relu_out_{name}')(y) return y
def up_projection(lt_, nf, s, block): with tf.name_scope('up_' + str(block)): if s == 2: ht = Conv2DTranspose(nf, 2, strides=2)(lt_) ht = PReLU()(ht) lt = ZeroPadding2D(2)(ht) lt = Conv2D(nf, 6, 2)(lt) lt = PReLU()(lt) et = Subtract()([lt, lt_]) ht1 = Conv2DTranspose(nf, 2, strides=2)(et) ht1 = PReLU()(ht1) ht1 = Add()([ht, ht1]) return (ht1) if s == 4: ht = Conv2DTranspose(nf, 4, strides=4)(lt_) ht = PReLU()(ht) lt = ZeroPadding2D(2)(ht) lt = Conv2D(nf, 8, strides=4)(lt) lt = PReLU()(lt) et = Subtract()([lt, lt_]) ht1 = Conv2DTranspose(nf, 4, strides=4)(et) ht1 = PReLU()(ht1) ht1 = Add()([ht, ht1]) return (ht1) if s == 8: ht = Conv2DTranspose(nf, 8, strides=8)(lt_) ht = PReLU()(ht) lt = ZeroPadding2D(2)(ht) lt = Conv2D(nf, 12, strides=8)(lt) lt = PReLU()(lt) et = Subtract()([lt, lt_]) ht1 = Conv2DTranspose(nf, 8, strides=8)(et) ht1 = PReLU()(ht1) ht1 = Add()([ht, ht1]) return (ht1)
def __init__(self, act='', lrelu_alpha=0.1, **kwargs): super(_Act, self).__init__(**kwargs) if act == 'prelu': self.func = PReLU() else: self.func = LeakyReLU(alpha=lrelu_alpha)
def conv_batch_prelu(name, tensor, num_filters, kernel_size=(3, 3), strides=(1, 1), padding="same"): """ This function combines conv2d layer, batch normalization layer and prelu activation. Args: name (str): layer's name ('conv_', 'batchnorm' and 'prelu' are added to the name) tensor (tf.Tensor): the input tensor num_filters (int): number of filters used in the convolution layer kernel_size (tuple or list): size of each kernel in the convolution strides (tuple or list): strides used in the convolution padding (str): one of 'same' or 'valid' Return: tensor (tf.Tensor): the output tensor """ tensor = Conv2D(filters=num_filters, kernel_size=kernel_size, strides=strides, kernel_initializer="he_uniform", bias_initializer="zeros", kernel_regularizer=L1L2(regularizers[0], regularizers[1]), padding=padding, name=f"{prefix}_conv_{name}")(tensor) tensor = BatchNormalization(momentum=0.1, name=f"{prefix}_batchnorm_{name}")(tensor) tensor = PReLU(shared_axes=[1, 2], name=f"{prefix}_prelu_{name}")(tensor) return tensor
def generator(x_in, mode, weight_decay=2.5e-5, num_filters=64, num_res_blocks=16): is_training = (mode == tf.estimator.ModeKeys.TRAIN) if isinstance(x_in, dict): # For serving x_in = x_in['feature'] x = Conv2D(num_filters, kernel_size=9, padding='same')(x_in) x = x_1 = PReLU(shared_axes=[1, 2])(x) for _ in range(num_res_blocks): x = res_block(x, num_filters, is_training=is_training) x = Conv2D(num_filters, kernel_size=3, padding='same')(x) x = BatchNormalization()(x) x = Add()([x_1, x]) x = upsample(x, num_filters * 4) x = upsample(x, num_filters * 4) x = Conv2D(3, kernel_size=9, padding='same', activation='tanh')(x) # return Model(x_in, x) return x
def build(self): # Input shape selection depending on if data_format is 'channels_last' or 'channels_first'. # If input_shape is None, the Generator won't have any defined input shape. if self.input_shape is None: input_generator = Input( shape=(None, None, 3) if self.data_format == 'channels_last' else (3, None, None)) else: input_generator = Input(shape=self.input_shape) x = Conv2D(filters=64, kernel_size=(9, 9), strides=(1, 1), padding='same', activation=None)(input_generator) x_input_res_block = PReLU(alpha_initializer='zeros', alpha_regularizer=None, alpha_constraint=None, shared_axes=self.shared_axis)(x) x = x_input_res_block # Add B = 16 residual blocks. for _ in range(self.B): x = res_block(x, self.axis, self.shared_axis) x = Conv2D(64, kernel_size=(3, 3), strides=(1, 1), padding='same', activation=None, use_bias=False)(x) x = BatchNormalization(axis=self.axis)(x) x = add([x, x_input_res_block]) # Upsampling blocks. x = up_block(x, self.shared_axis) x = up_block(x, self.shared_axis) # Output of the generator. Convolution layer with tanh activation ([-1, 1] image values). output_generator = Conv2D(3, kernel_size=(9, 9), strides=(1, 1), activation='tanh', use_bias=False, padding='same', dtype=tf.float32)(x) # Model creation. generator = Model(inputs=input_generator, outputs=output_generator, name="Generator") # tf.keras.utils.plot_model(generator, 'E:\\TFM\\outputs\\model_imgs\\generator_model.png', # show_shapes=True) return generator
def res_block(x_in, num_filters, momentum=0.8): x = Conv2D(num_filters, kernel_size=3, padding='same')(x_in) x = BatchNormalization(momentum=momentum)(x) x = PReLU(shared_axes=[1, 2])(x) x = Conv2D(num_filters, kernel_size=3, padding='same')(x) x = BatchNormalization(momentum=momentum)(x) x = Add()([x_in, x]) return x
def residual(inputs, n_filters, momentum=0.8): x = Conv2D(n_filters, kernel_size=3, padding='same')(inputs) x = BatchNormalization(momentum=momentum)(x) x = PReLU(shared_axes=[1, 2])(x) x = Conv2D(n_filters, kernel_size=3, padding='same')(x) x = BatchNormalization(momentum=momentum)(x) x = Add()([inputs, x]) return x
def __init__(self, att_hidden_units, activation='prelu'): ''' :param att_hidden_units: :param activation: ''' super().__init__() self.attention_dense = [Dense(units=unit, activation=PReLU() if activation == 'prelu' else Dice()) for unit in att_hidden_units] self.output_layer = Dense(units=1)
def conv_RRDB(self, x_in, out_channel, activate=True): x = Conv2D(out_channel, kernel_size=3, strides=1, padding='same', kernel_initializer=self.init_kernel)(x_in) if activate: x = PReLU(shared_axes=[1, 2])(x) return x
def upsample(self, x_in): x = Conv2D(self.n_filters, kernel_size=3, kernel_initializer=self.init_kernel, padding='same')(x_in) x = Lambda(self.pixel_shuffle(scale=2))(x) x = PReLU(shared_axes=[1, 2])(x) return x
def __init__(self,feature_columns, behavior_feature_list, attention_hidden_units=(80, 40), ffn_hidden_units=(80, 40), attention_activation='prelu', ffn_activation='prelu', max_len=40, dnn_dropout=0.,embed_reg=1e-4): ''' :param feature_columns: :param behavior_feature_list: :param attention_hidden_units: :param ffn_hidden_units: :param attention_activation: :param ffn_activation: :param max_len: :param dnn_droupout: :param embed_reg: ''' super().__init__() self.max_len = max_len self.dense_feature_column, self.sparse_feature_column = feature_columns # len self.other_sparse_len = len(self.sparse_feature_column) - len(behavior_feature_list) self.dense_len = len(self.dense_feature_column) self.behavior_num = len(behavior_feature_list) # other embedding layers self.sparse_feature_embedding = [ Embedding( input_dim=feat['feat_dim'], input_length=1, output_dim=feat['embed_dim'], embeddings_initializer='random_uniform', embeddings_regularizer=l2(embed_reg) ) for index, feat in enumerate(self.sparse_feature_column) if feat['feat'] not in behavior_feature_list ] self.behavior_seq_embedding = [ Embedding( input_dim=feat['feat_dim'], input_length=1, output_dim=feat['embed_dim'], embeddings_initializer='random_uniform', embeddings_regularizer=l2(embed_reg) ) for index, feat in enumerate(self.sparse_feature_column) if feat['feat'] in behavior_feature_list ] # Attention Layer self.attention_layer = AttentionLayer(activation=attention_activation, att_hidden_units=attention_hidden_units) self.bn = BatchNormalization(trainable=True) self.ffn = [Dense(unit, activation=PReLU() if ffn_activation == 'prelu' else Dice()) for unit in ffn_hidden_units] self.dropout = Dropout(dnn_dropout) self.output_layer = Dense(1)
def upsample(x, number): x = Conv2D(256, kernel_size=3, strides=1, padding='same', name='upSampleConv2d_' + str(number))(x) x = SubpixelConv2D(name=str('upSampleSubPixel_') + str(number), scale=2)(x) x = PReLU(shared_axes=[1, 2], name='upSamplePReLU_' + str(number))(x) return x
def get_activation(self, x): if self.activation_type == 'elu': activate = ELU()(x) elif self.activation_type == 'relu': activate = ReLU()(x) elif self.activation_type == 'prelu': activate = PReLU()(x) elif self.activation_type == 'leakyrelu': activate = LeakyReLU()(x) else: raise ValueError('Undefined ACTIVATION_TYPE!') return activate
def up_block(x, shared_axis): x = Conv2D(256, kernel_size=(3, 3), strides=(1, 1), padding='same', activation=None, use_bias=False)(x) x = UpSampling2D(size=(2, 2))(x) x = PReLU(alpha_initializer='zeros', alpha_regularizer=None, alpha_constraint=None, shared_axes=shared_axis)(x) return x
def get_activation(self): activation_type = self.activation_type if activation_type ==1: activation = LeakyReLU(alpha=0.1) elif activation_type == 2: activation = ReLU() elif activation_type == 3: activation = PReLU(alpha_initializer='zeros', alpha_regularizer=None, alpha_constraint=None, shared_axes=None) elif activation_type == 4: activation=ELU(alpha=1.0) else: raise Exception('Not a valid activation type') return activation
def KerasModelSmallNet50(self, imgInput): """ Construct small net. The image size is 50*50, which is suitable for map. """ x = Conv2D(16, (3, 3), activation='tanh')(imgInput) x = Conv2D(32, (3, 3), activation='relu')(x) x = MaxPooling2D(pool_size=(2, 2))(x) x = Conv2D(32, (3, 3), activation='relu')(x) x = Conv2D(32, (3, 3), activation='relu')(x) x = MaxPooling2D(pool_size=(2, 2))(x) x = Conv2D(32, (3, 3), activation='relu')(x) x = Conv2D(32, (3, 3), activation='relu')(x) x = Flatten()(x) x = Dense(self.featureDim, kernel_regularizer=regularizers.l2(0.0002), activity_regularizer=regularizers.l1(0.0002), name='fc_feature')(x) x = PReLU()(x) return x
def down_projection(ht_, nf, s, block, act='prelu'): with tf.name_scope('down_' + str(block)): if s == 2: ht = ZeroPadding2D(2)(ht_) lt = Conv2D(nf, 6, strides=2)(ht) lt = PReLU()(lt) ht = Conv2DTranspose(nf, 2, strides=2)(lt) ht = PReLU()(ht) et = Subtract()([ht, ht_]) lt1 = ZeroPadding2D(2)(et) lt1 = Conv2D(nf, 6, strides=2)(lt1) lt1 = PReLU()(lt1) lt1 = Add()([lt1, lt]) return lt1 if s == 4: ht = ZeroPadding2D(2)(ht_) lt = Conv2D(nf, 8, strides=4)(ht) lt = PReLU()(lt) ht = Conv2DTranspose(nf, 4, strides=4)(lt) ht = PReLU()(ht) et = Subtract()([ht, ht_]) lt1 = ZeroPadding2D(2)(et) lt1 = Conv2D(nf, 8, strides=4)(lt1) lt1 = PReLU()(lt1) lt1 = Add()([lt1, lt]) return lt1 if s == 8: ht = ZeroPadding2D(2)(ht_) lt = Conv2D(nf, 12, strides=8)(ht) lt = PReLU()(lt) ht = Conv2DTranspose(nf, 8, strides=8)(lt) ht = PReLU()(ht) et = Subtract()([ht, ht_]) lt1 = ZeroPadding2D(2)(et) lt1 = Conv2D(nf, 12, strides=8)(lt1) lt1 = PReLU()(lt1) lt1 = Add()([lt1, lt]) return lt1
def create_keras_model(inputShape, nClasses, scale=2, n_filters=64, depth=16): def residual(inputs, n_filters, momentum=0.8): x = Conv2D(n_filters, kernel_size=3, padding='same')(inputs) x = BatchNormalization(momentum=momentum)(x) x = PReLU(shared_axes=[1, 2])(x) x = Conv2D(n_filters, kernel_size=3, padding='same')(x) x = BatchNormalization(momentum=momentum)(x) x = Add()([inputs, x]) return x def upsample(inputs, n_filters, scale): x = Conv2D(n_filters * (scale ** 2), kernel_size=3, padding='same')(inputs) x = Lambda(lambda x: tf.nn.depth_to_space(x, scale))(x) x = PReLU(shared_axes=[1, 2])(x) return x inputs = Input(shape=inputShape) x = Conv2D(n_filters, kernel_size=9, padding='same')(inputs) x0 = PReLU(shared_axes=[1, 2])(x) x = residual(x0, n_filters) for i in range(depth-1): x = residual(x, n_filters) x = Conv2D(n_filters, kernel_size=3, padding='same')(x) x = BatchNormalization()(x) x = Add()([x0, x]) # Upsampling for super-resolution if scale == 2: x = upsample(x, n_filters, scale) elif scale == 3: x = upsample(x, n_filters, scale) elif scale == 4: x = upsample(x, n_filters, (scale-2)) x = upsample(x, n_filters, (scale-2)) outputs = Conv2D(nClasses, kernel_size=9, padding='same', activation='sigmoid')(x) model = Model(inputs, outputs, name="srgan") return model
def KerasModelResNet(self, imgInput): """ Construct resNet. The image size is 150*150, which is suitable for image. """ bn_axis = 3 x = ZeroPadding2D((3, 3))(imgInput) x = Convolution2D(8, 7, strides=(2, 2), name='conv1')(x) x = BatchNormalization(axis=bn_axis, name='bn_conv1')(x) x = Activation('relu')(x) x = MaxPooling2D((3, 3), strides=(2, 2))(x) x = conv_block(x, 3, [8, 8, 16], stage=2, block='a', strides=(1, 1)) x = identity_block(x, 3, [8, 8, 16], stage=2, block='b') x = identity_block(x, 3, [8, 8, 16], stage=2, block='c') x = conv_block(x, 3, [16, 16, 32], stage=3, block='a') x = identity_block(x, 3, [16, 16, 32], stage=3, block='b') x = identity_block(x, 3, [16, 16, 32], stage=3, block='c') x = identity_block(x, 3, [16, 16, 32], stage=3, block='d') x = conv_block(x, 3, [32, 32, 64], stage=4, block='a') x = identity_block(x, 3, [32, 32, 64], stage=4, block='b') x = identity_block(x, 3, [32, 32, 64], stage=4, block='c') x = identity_block(x, 3, [32, 32, 64], stage=4, block='d') x = identity_block(x, 3, [32, 32, 64], stage=4, block='e') x = identity_block(x, 3, [32, 32, 64], stage=4, block='f') x = conv_block(x, 3, [64, 64, 128], stage=5, block='a') x = identity_block(x, 3, [64, 64, 128], stage=5, block='b') x = identity_block(x, 3, [64, 64, 128], stage=5, block='c') x = conv_block(x, 3, [64, 64, 256], stage=6, block='a') x = identity_block(x, 3, [64, 64, 256], stage=6, block='b') x = identity_block(x, 3, [64, 64, 256], stage=6, block='c') x = GlobalAveragePooling2D()(x) # x = Flatten()(x) x = Dense(self.featureDim, kernel_regularizer=regularizers.l2(0.0002), activity_regularizer=regularizers.l1(0.0002), name='fc_feature')(x) x = PReLU()(x) return x
def feature_extracter_from_texts(self,mashup_api=None): """ # 更改:把MLP去掉 对mashup,service的description均需要提取特征,右路的文本的整个特征提取过程 公用的话应该封装成新的model! :param x: :return: 输出的是一个封装好的model,所以可以被mashup和api公用 """ if new_Para.param.text_extracter_mode=='HDP' and mashup_api is not None: return self.HDP_feature_extracter_from_texts(mashup_api) if self.text_feature_extracter is None: #没求过时 text_input = Input(shape=(MAX_SEQUENCE_LENGTH,), dtype='int32') text_embedding_layer = self.get_text_embedding_layer() # 参数还需设为外部输入! text_embedded_sequences = text_embedding_layer(text_input) # 转化为2D if new_Para.param.text_extracter_mode in ('inception','textCNN'): # 2D转3D,第三维是channel # print(text_embedded_sequences.shape) text_embedded_sequences = Lambda(lambda x: tf.expand_dims(x, axis=3))(text_embedded_sequences) # tf 和 keras的tensor 不同!!! print(text_embedded_sequences.shape) if new_Para.param.text_extracter_mode=='inception': x = inception_layer(text_embedded_sequences, self.word_embedding_dim, self.inception_channels, self.inception_pooling) # inception处理 print('built inception layer, done!') elif new_Para.param.text_extracter_mode=='textCNN': x = self.textCNN_feature_extracter_from_texts(text_embedded_sequences) elif new_Para.param.text_extracter_mode=='LSTM': x = self.LSTM_feature_extracter_from_texts(text_embedded_sequences) else: raise ValueError('wrong extracter!') print('text feature after inception/textCNN/LSTM model,',x) # 观察MLP转化前,模块输出的特征 for FC_unit_num in self.inception_fc_unit_nums: x = Dense(FC_unit_num, kernel_regularizer=l2(new_Para.param.l2_reg))(x) # , activation='relu' if new_Para.param.inception_MLP_BN: x = BatchNormalization(scale=False)(x) x = PReLU()(x) # if new_Para.param.inception_MLP_dropout: x = tf.keras.layers.Dropout(0.5)(x) self.text_feature_extracter=Model(text_input, x,name='text_feature_extracter') return self.text_feature_extracter
def dense_batch_prelu(name, tensor, n_units): """ This function combines dense layer, batch normalization layer and prelu activation. Args: name (str): layer's name ('dense_', 'batchnorm' and 'prelu' are added to the name) tensor (tf.Tensor): the input tensor n_units (int): number of units in the dense layer Return: tensor (tf.Tensor): the output tensor """ tensor = Dense(n_units, name=f"{prefix}_dense_{name}", kernel_initializer="he_uniform", bias_initializer="zeros")(tensor) tensor = BatchNormalization(momentum=0.1, name=f"{prefix}_batchnorm_{name}")(tensor) tensor = PReLU(name=f"{prefix}_prelu_{name}")(tensor) return tensor
def get_inception_MLP_layer(self, channel_num,name = ''): """ textCNN/inception后面加MLP的处理,结构之后的最后一个层命名name='text_feature_extracter' :param channel_num: 输入形状的最后一维, :param name: 可以使用不同的MLP对mashup,api和slt_apis分别进行转化,声明name即可 :return: """ if self.inception_MLP_layer is None: if new_Para.param.text_extracter_mode != 'LSTM' and new_Para.param.if_inception_MLP: input = Input(shape=(channel_num,), dtype='float32') x = input for FC_unit_num in self.inception_fc_unit_nums: x = Dense(FC_unit_num, kernel_regularizer=l2(new_Para.param.l2_reg))(x) # 默认activation=None if new_Para.param.inception_MLP_BN: x = BatchNormalization(scale=False)(x) x = PReLU()(x) # if new_Para.param.inception_MLP_dropout: x = tf.keras.layers.Dropout(0.5)(x) self.inception_MLP_layer = Model(input, x, name='text_feature_extracter'+name) return self.inception_MLP_layer
def sr_resnet(num_filters=64, num_res_blocks=16): x_in = Input(shape=(None, None, 3)) x = Lambda(normalize_01)(x_in) x = Conv2D(num_filters, kernel_size=9, padding='same')(x) x = x_1 = PReLU(shared_axes=[1, 2])(x) for _ in range(num_res_blocks): x = res_block(x, num_filters) x = Conv2D(num_filters, kernel_size=3, padding='same')(x) x = BatchNormalization()(x) x = Add()([x_1, x]) x = upsample(x, num_filters * 4) x = upsample(x, num_filters * 4) x = Conv2D(3, kernel_size=9, padding='same', activation='tanh')(x) x = Lambda(denormalize_m11)(x) return Model(x_in, x)
def res_block(inputs, axis, shared_axis): x = Conv2D(64, kernel_size=(3, 3), strides=(1, 1), padding='same', activation=None, use_bias=False)(inputs) x = BatchNormalization(axis=axis)(x) x = PReLU(alpha_initializer='zeros', alpha_regularizer=None, alpha_constraint=None, shared_axes=shared_axis)(x) x = Conv2D(64, kernel_size=(3, 3), strides=(1, 1), padding='same', activation=None, use_bias=False)(x) x = BatchNormalization(axis=axis)(x) return add([x, inputs])