def not_equal(f, other): """Element-wise comparison applied to the `Functional` objects. # Arguments f: Functional object. other: A python number or a tensor or a functional object. # Returns A Functional. """ validate_functional(f) inputs = f.inputs.copy() if is_functional(other): inputs += to_list(other.inputs) lmbd = [ Lambda(lambda x: K.cast_to_floatx(K.not_equal(x[0], x[1])), name=graph_unique_name("not_equal")) for X in f.outputs ] else: _warn_for_ndarray(other) lmbd = [ Lambda(lambda x: K.cast_to_floatx(K.not_equal(x, other)), name=graph_unique_name("not_equal")) for X in f.outputs ] Functional = f.get_class() res = Functional(inputs=unique_tensors(inputs), outputs=_apply_operation(lmbd, f, other), layers=lmbd) return res
def accuracy_ignore_padding(y_true, y_pred): prediction = backend.argmax(y_pred, axis=-1) target = backend.argmax(y_true, axis=-1) accuracy = backend.equal( backend.array_ops.boolean_mask(prediction, backend.not_equal(target, 0)), backend.array_ops.boolean_mask(target, backend.not_equal(target, 0))) return backend.mean(accuracy)
def call(self, inputs, **kwargs): inputs_shape = K.shape(inputs) mask = K.cast(K.squeeze(K.any(K.not_equal(inputs, 0.), axis=(-2, -1), keepdims=True), axis=-1), dtype=inputs.dtype) inputs_to_lstm = K.reshape(inputs, (-1, inputs.shape[-2], inputs.shape[-1])) inputs_embed = super(InferenceSpeakerEmbedding, self).call(inputs_to_lstm) inputs_embed = K.reshape( inputs_embed, (inputs_shape[0], inputs_shape[1], inputs_embed.shape[-1])) inputs_embed = inputs_embed * mask n = K.sum(mask, axis=1) inputs_embed = K.sum(inputs_embed, axis=1) / n return inputs_embed
def masked_vgg_loss(y_true, y_pred): mask_value = K.constant([[[-1.0, -1.0, 1.0]]]) mask_true = K.cast(K.not_equal(y_true, mask_value), K.floatx()) masked = K.mean(K.square((features_extractor(preprocess_vgg(mask_true * y_pred)) - features_extractor(preprocess_vgg(mask_true * y_true)))), axis=-1) return 0.006 * masked
def fractional_accuracy(y_true, y_pred): equal = K.equal(K.argmax(y_true, axis=-1), K.argmax(y_pred, axis=-1)) X = K.mean(K.sum(K.cast(equal, tf.float32), axis=-1)) not_equal = K.not_equal(K.argmax(y_true, axis=-1), K.argmax(y_pred, axis=-1)) Y = K.mean(K.sum(K.cast(not_equal, tf.float32), axis=-1)) return X / (X + Y)
def masked_mse(y_true, y_pred): # masked function mask_true = K.cast(K.not_equal(y_true, 0), K.floatx()) # masked squared error masked_squared_error = K.square(mask_true * (y_true - y_pred)) masked_mse = K.sum(masked_squared_error, axis=-1) / K.maximum( K.sum(mask_true, axis=-1), 1) return masked_mse
def mask_acc(y_true, y_pred): y_true_class = K.argmax(y_true, axis=-1) y_pred_class = K.argmax(y_pred, axis=-1) ignore_mask = K.cast(K.not_equal(y_true_class, 0), "int32") matches = K.cast(K.equal(y_true_class, y_pred_class), "int32") * ignore_mask accuracy = K.sum(matches) / K.maximum(K.sum(ignore_mask), 1) return accuracy
def getMask(inputs): # 这里输入的还是np矩阵 src_mask = k.not_equal(inputs, 0) # 0->False src_mask = k.expand_dims(src_mask, 1) # None, 1, length # self.src_mask = tf.tile(self.src_mask, [1, src.shape[1], 1]) # None, length, length src_mask2 = tf.transpose(src_mask, [0, 2, 1]) # None, 1, length src_mask = src_mask & src_mask2 # None, length, length src_mask = tf.cast(src_mask, dtype=tf.float32) # self.src_mask = tf.reshape(self.src_mask, [-1, src.shape[1], src.shape[1]]) # None, length, length, return src_mask
def top_k_accuracy(y_true, y_pred, mask_value=-1, k=5): """ Top-K Accuracy with Masking """ mask = K.squeeze(K.not_equal(y_true, mask_value), axis=-1) acc = sparse_top_k_categorical_accuracy(tf.boolean_mask(y_true, mask), tf.boolean_mask(y_pred, mask), k=k) # return 0 if result is nan acc_filtered = tf.cond(tf.is_nan(acc), lambda: tf.constant(0, tf.float32), lambda: acc) return acc_filtered
def call(self, inputs, **kwargs): pair1, pair2 = inputs pair1_shape, pair2_shape = K.shape(pair1), K.shape(pair2) pair1_mask = K.cast(K.squeeze(K.any(K.not_equal(pair1, 0.), axis=(-2, -1), keepdims=True), axis=-1), dtype=pair1.dtype) pair2_mask = K.cast(K.squeeze(K.any(K.not_equal(pair2, 0.), axis=(-2, -1), keepdims=True), axis=-1), dtype=pair2.dtype) pair1_to_lstm = K.reshape(pair1, (-1, pair1.shape[-2], pair1.shape[-1])) pair2_to_lstm = K.reshape(pair2, (-1, pair2.shape[-2], pair2.shape[-1])) batch = K.concatenate([pair1_to_lstm, pair2_to_lstm], axis=0) embedded = super(TestSpeakerEmbedding, self).call(batch) pair1_embed = embedded[:K.shape(pair1_to_lstm)[0]] pair2_embed = embedded[K.shape(pair1_to_lstm)[0]:] pair1_embed = K.reshape(pair1_embed, (pair1_shape[0], pair1_shape[1], -1)) pair2_embed = K.reshape(pair2_embed, (pair2_shape[0], pair2_shape[1], -1)) pair1_embed = pair1_embed * pair1_mask pair2_embed = pair2_embed * pair2_mask pair1_n = K.sum(pair1_mask, axis=1) pair2_n = K.sum(pair2_mask, axis=1) pair1_embed = K.sum(pair1_embed, axis=1) / pair1_n pair2_embed = K.sum(pair2_embed, axis=1) / pair2_n return pair1_embed, pair2_embed
def accuracy(y_true, y_pred, mask_value=-1): """ Accuracy with Masking """ # mask = K.not_equal(y_true, mask_value) mask = K.squeeze(K.not_equal(y_true, mask_value), axis=-1) acc = sparse_categorical_accuracy(tf.boolean_mask(y_true, mask), tf.boolean_mask(y_pred, mask)) # return 0 if result is empty res_size = tf.shape(acc)[0] acc_filtered = tf.cond(tf.equal(res_size, 0), lambda: tf.constant(0, tf.float32), lambda: acc) return acc_filtered
def not_equal(f, other, tol=None): """Element-wise comparison applied to the `Functional` objects. # Arguments f: Functional object. other: A python number or a tensor or a functional object. tol: (float) If you need a tolerance measure. # Returns A Functional. """ validate_functional(f) assert isinstance( tol, (type(None), float)), 'Expected a floating value for `tol`.' inputs = f.inputs.copy() if is_functional(other): inputs += to_list(other.inputs) if tol is None: lambda_opr = lambda x: K.cast_to_floatx(K.not_equal(x[0], x[1])) else: lambda_opr = lambda x: K.cast_to_floatx( K.greater(K.abs(x[0] - x[1]), tol)) else: _warn_for_ndarray(other) if tol is None: lambda_opr = lambda x: K.cast_to_floatx(K.not_equal(x, other)) else: lambda_opr = lambda x: K.cast_to_floatx( K.greater(K.abs(x - other), tol)) lmbd = [ Lambda(lambda_opr, name=graph_unique_name("not_equal")) for X in f.outputs ] Functional = f.get_class() res = Functional(inputs=unique_tensors(inputs), outputs=_apply_operation(lmbd, f, other), layers=lmbd) return res
def masked_se(y_true, y_pred): """ Function to define the masked squared error :param y_true: true label :param y_pred: predicted label :return: masked squared error """ # Masked function mask_true = K.cast(K.not_equal(y_true, 0), K.floatx()) # Masked squared error masked_squared_error = K.square(mask_true * (y_true - y_pred)) masked_mse = K.sum(masked_squared_error, axis=-1) return masked_mse
def mbce(y_true, y_pred): """ Balanced sigmoid cross-entropy loss with masking """ mask = K.not_equal(y_true, -1.0) mask = K.cast(mask, dtype=np.float32) num_examples = K.sum(mask, axis=1) pos = K.cast(K.equal(y_true, 1.0), dtype=np.float32) num_pos = K.sum(pos, axis=None) neg = K.cast(K.equal(y_true, 0.0), dtype=np.float32) num_neg = K.sum(neg, axis=None) pos_ratio = 1.0 - num_pos / num_neg mbce = mask * tf.nn.weighted_cross_entropy_with_logits( targets=y_true, logits=y_pred, pos_weight=pos_ratio) mbce = K.sum(mbce, axis=1) / num_examples return K.mean(mbce, axis=-1)
def masked_rmse_clip(y_true, y_pred): """ Function to define the masked root mean squared error with clipping :param y_true: true label :param y_pred: predicted label :return: masked root mean squared error with clipping """ # Masked function mask_true = K.cast(K.not_equal(y_true, 0), K.floatx()) y_pred = K.clip(y_pred, 1, 5) # Masked squared error masked_squared_error = K.square(mask_true * (y_true - y_pred)) masked_rmse_clip = K.sqrt( K.sum(masked_squared_error, axis=-1) / K.maximum(K.sum(mask_true, axis=-1), 1)) return masked_rmse_clip
def call(self, x, mask=None): '''mask是上一层的''' '''# using 'mask' you can access the mask passed from the previous layer''' # x [batch_size, seq_len, embedding_size] if self.supports_masking: # mask [batch_size, seq_len] if mask is None: # 先判断是否非零,然后执行OR运算,计算每个序列的有效长度 mask = K.any(K.not_equal(x, 0), -1) # [batch_size, seq_len] mask = K.cast(mask, K.floatx()) return K.sum(x, axis=1) / K.sum(mask, axis=1, keepdims=True) if mask is not None: mask = K.cast(mask, K.floatx()) # [batch_size, embedding_size, seq_len] mask = K.repeat(mask, x.shape[-1].value) # [batch_size, seq_len, embedding_size] mask = tf.transpose(mask, [0, 2, 1]) x = x * mask return K.sum(x, axis=1) / K.sum(mask, axis=1)
def classification_loss(self, y_true, y_pred): # TODO: try weighted_categorical_crossentropy labels = y_true[..., :-1] # -1 for ignore, 0 for background, 1 for object anchor_state = y_true[..., -1] classification = y_pred # filter out "ignore" anchors indices = tf.where(K.not_equal(anchor_state, -1)) labels = tf.gather_nd(labels, indices) classification = tf.gather_nd(classification, indices) # compute the loss loss = focal(labels, classification, alpha=self.alpha, gamma=self.gamma) # compute the normalizer: the number of positive anchors normalizer = tf.where(K.equal(anchor_state, 1)) normalizer = K.cast(K.shape(normalizer)[0], K.floatx()) normalizer = K.maximum(K.cast_to_floatx(1.0), normalizer) return K.sum(loss) / normalizer
def rpn_class_loss_graph(rpn_match, rpn_class_logits): """RPN anchor classifier loss. rpn_match: [batch, anchors, 1]. Anchor match type. 1=positive, -1=negative, 0=neutral anchor. rpn_class_logits: [batch, anchors, 2]. RPN classifier logits for BG/FG. """ # Squeeze last dim to simplify rpn_match = tf.squeeze(rpn_match, -1) # Get anchor classes. Convert the -1/+1 match to 0/1 values. anchor_class = K.cast(K.equal(rpn_match, 1), tf.int32) # Positive and Negative anchors contribute to the loss, # but neutral anchors (match value = 0) don't. indices = tf.where(K.not_equal(rpn_match, 0)) # Pick rows that contribute to the loss and filter out the rest. rpn_class_logits = tf.gather_nd(rpn_class_logits, indices) anchor_class = tf.gather_nd(anchor_class, indices) # Cross entropy loss loss = K.sparse_categorical_crossentropy(target=anchor_class, output=rpn_class_logits, from_logits=True) loss = K.switch(tf.size(loss) > 0, K.mean(loss), tf.constant(0.0)) return loss
def get_model(self): if not self.model: mashup_fea_input = Input(shape=(self.num_feat, ), dtype='float32', name='NI_mashup_fea_input') # (None,25) api_id_input = Input(shape=(1, ), dtype='int32', name='NI_api_id_input') inputs = [mashup_fea_input, api_id_input] self.prepare() api_implict_embs = self.api_implict_emb_layer( api_id_input) # (None,1,25) api_implict_embs_2D = Lambda(lambda x: tf.squeeze(x, axis=1))( api_implict_embs) # (None,25) feature_list = [mashup_fea_input, api_implict_embs_2D] if self.old_new == 'new' and self.NI_handle_slt_apis_mode: mashup_slt_apis_input = Input( shape=(new_Para.param.slt_item_num, ), dtype='int32', name='slt_apis_input') inputs.append(mashup_slt_apis_input) keys_slt_api_implict_embs = self.api_implict_emb_layer( mashup_slt_apis_input) # (None,3,25) if self.NI_handle_slt_apis_mode in ('attention', 'average'): mask = Lambda(lambda x: K.not_equal(x, self.all_api_num))( mashup_slt_apis_input) # (?, 3) !!! if self.NI_handle_slt_apis_mode == 'attention': slt_api_implict_embs_hist = AttentionSequencePoolingLayer( supports_masking=True)( [api_implict_embs, keys_slt_api_implict_embs], mask=mask) else: # 'average' slt_api_implict_embs_hist = SequencePoolingLayer( 'mean', supports_masking=True)(keys_slt_api_implict_embs, mask=mask) slt_api_implict_embs_hist = Lambda( lambda x: tf.squeeze(x, axis=1))( slt_api_implict_embs_hist) # (?, 1, 25)->(?, 25) elif self.NI_handle_slt_apis_mode == 'full_concate': slt_api_implict_embs_hist = Reshape( (new_Para.param.slt_item_num * self.num_feat, ))( keys_slt_api_implict_embs) # (?,75) else: raise ValueError('wrong NI_handle_slt_apis_mode!') feature_list.append(slt_api_implict_embs_hist) feature_list = list(map(NoMask(), feature_list)) # DNN不支持mak,所以不能再传递mask all_features = Concatenate( name='all_emb_concatenate')(feature_list) output = DNN(self.cf_unit_nums[:-1])(all_features) output = Dense(self.cf_unit_nums[-1], activation='relu', kernel_regularizer=l2(new_Para.param.l2_reg), name='implict_dense_{}'.format( len(self.cf_unit_nums)))(output) # 输出层 if new_Para.param.final_activation == 'softmax': predict_result = Dense(2, activation='softmax', name="prediction")(output) elif new_Para.param.final_activation == 'sigmoid': predict_result = Dense(1, activation='sigmoid', kernel_initializer='lecun_uniform', name="prediction")(output) self.model = Model(inputs=inputs, outputs=[predict_result], name='predict_model') for layer in self.model.layers: print(layer.name) if not os.path.exists(self.model_name_path): with open(self.model_name_path, 'w+') as f: f.write(self.get_name()) return self.model
def compute_mask(self, inputs, mask=None): return K.not_equal(inputs, '--PAD--')
def get_model(self): if not self.model: mashup_id_input = Input(shape=(1, ), dtype='int32', name='mashup_id_input') api_id_input = Input(shape=(1, ), dtype='int32', name='api_id_input') inputs = [mashup_id_input, api_id_input] user_text_vec = self.user_text_feature_extractor()(mashup_id_input) item_text_vec = self.item_text_feature_extractor()(api_id_input) user_tag_vec = self.user_tag_feature_extractor()(mashup_id_input) item_tag_vec = self.item_tag_feature_extractor()(api_id_input) feature_list = [ user_text_vec, item_text_vec, user_tag_vec, item_tag_vec ] if self.old_new == 'LR_PNCF': # 旧场景,使用GMF形式的双塔模型 x = Concatenate(name='user_concatenate')( [user_text_vec, user_tag_vec]) y = Concatenate(name='item_concatenate')( [item_text_vec, item_tag_vec]) output = Multiply()([x, y]) predict_result = Dense(1, activation='sigmoid', use_bias=False, kernel_initializer='lecun_uniform', name="prediction")(output) # 参数学习权重,非线性 self.model = Model(inputs=inputs, outputs=[predict_result], name='predict_model') return self.model elif self.old_new == 'new' and self.CI_handle_slt_apis_mode: # 已选择的服务 mashup_slt_apis_input = Input( shape=(new_Para.param.slt_item_num, ), dtype='int32', name='slt_api_ids_input') mashup_slt_apis_input_3D = Reshape( (new_Para.param.slt_item_num, 1))(mashup_slt_apis_input) # mashup_slt_apis_num_input = Input(shape=(1,), dtype='int32', name='mashup_slt_apis_num_input') inputs.append(mashup_slt_apis_input) mask = Lambda(lambda x: K.not_equal(x, self.all_api_num))( mashup_slt_apis_input) # (?, 3) !!! # 已选择的服务直接复用item_feature_extractor slt_text_vec_list, slt_tag_vec_list = [], [] for i in range(new_Para.param.slt_item_num): x = Lambda(slice, arguments={'index': i})( mashup_slt_apis_input_3D) # (?,1,1) x = Reshape((1, ))(x) temp_item_text_vec = self.item_text_feature_extractor()(x) temp_item_tag_vec = self.item_tag_feature_extractor()(x) slt_text_vec_list.append(temp_item_text_vec) slt_tag_vec_list.append(temp_item_tag_vec) if self.CI_handle_slt_apis_mode in ('attention', 'average'): # text和tag使用各自的attention block slt_text_vec_list = [ Reshape((1, new_Para.param.embedding_dim))(key_2D) for key_2D in slt_text_vec_list ] slt_tag_vec_list = [ Reshape((1, new_Para.param.embedding_dim))(key_2D) for key_2D in slt_tag_vec_list ] # 增加了一维 eg:[None,50]->[None,1,50] text_keys_embs = Concatenate(axis=1)( slt_text_vec_list) # [?,3,50] tag_keys_embs = Concatenate(axis=1)( slt_tag_vec_list) # [?,3,50] if self.CI_handle_slt_apis_mode == 'attention': query_item_text_vec = Lambda( lambda x: tf.expand_dims(x, axis=1))( item_text_vec) # (?, 50)->(?, 1, 50) query_item_tag_vec = Lambda( lambda x: tf.expand_dims(x, axis=1))(item_tag_vec) # 压缩历史,得到向量 text_hist = AttentionSequencePoolingLayer( supports_masking=True)( [query_item_text_vec, text_keys_embs], mask=mask) tag_hist = AttentionSequencePoolingLayer( supports_masking=True)( [query_item_tag_vec, tag_keys_embs], mask=mask) else: # 'average' text_hist = SequencePoolingLayer( 'mean', supports_masking=True)(text_keys_embs, mask=mask) tag_hist = SequencePoolingLayer('mean', supports_masking=True)( tag_keys_embs, mask=mask) text_hist = Lambda(lambda x: tf.squeeze(x, axis=1))( text_hist) # (?, 1, 50)->(?, 50) tag_hist = Lambda(lambda x: tf.squeeze(x, axis=1))( tag_hist) elif self.CI_handle_slt_apis_mode == 'full_concate': text_hist = Concatenate(axis=1)( slt_text_vec_list) # [?,150] tag_hist = Concatenate(axis=1)(slt_tag_vec_list) # [?,150] else: raise ValueError('wrong CI_handle_slt_apis_mode!') feature_list.extend([text_hist, tag_hist]) else: # 包括新模型不处理已选择服务和旧模型 pass feature_list = list(map(NoMask(), feature_list)) # DNN不支持mak,所以不能再传递mask all_features = Concatenate( name='all_content_concatenate')(feature_list) output = DNN(self.content_fc_unit_nums[:-1])(all_features) output = Dense(self.content_fc_unit_nums[-1], activation='relu', kernel_regularizer=l2(new_Para.param.l2_reg), name='text_tag_feature_extracter')(output) # 输出层 if new_Para.param.final_activation == 'softmax': predict_result = Dense(2, activation='softmax', name="prediction")(output) elif new_Para.param.final_activation == 'sigmoid': predict_result = Dense(1, activation='sigmoid', kernel_initializer='lecun_uniform', name="prediction")(output) # Model # if self.IfUniteNI: # inputs.append(user_NI_input) self.model = Model(inputs=inputs, outputs=[predict_result], name='predict_model') for layer in self.model.layers: print(layer.name) print('built CI model, done!') return self.model
def masked_loss_function(y_true, y_pred, mask_value=mask_value): mask = K.cast(K.not_equal(y_true, mask_value), K.floatx()) return loss_function(y_true * mask, y_pred * mask)
layer.trainable = False # CNNの出力 u = Flatten()(encoder.output) # LSTMの初期状態 h_0 = Dense(hid_dim)(u) c_0 = Dense(hid_dim)(u) # LSTMの入力 y = Input(shape=(None, ), dtype='int32') y_in = Lambda(lambda x: x[:, :-1])(y) y_out = Lambda(lambda x: x[:, 1:])(y) # 誤差関数のマスク mask = Lambda(lambda x: K.cast(K.not_equal(x, w2i['<pad>']), 'float32'))( y_out) # 層の定義 embedding = Embedding(vocab_size, emb_dim) lstm = LSTM(hid_dim, activation='tanh', return_sequences=True, return_state=True) dense = Dense(vocab_size) softmax = Activation('softmax') # 順伝播 y_emb = embedding(y_in) h, _, _ = lstm(y_emb, initial_state=[h_0, c_0]) # 第2,3戻り値(最終ステップのh, c)は無視 h = dense(h)
def get_model(self): if not self.model: mashup_id_input = Input(shape=(1, ), dtype='int32', name='mashup_id_input') api_id_input = Input(shape=(1, ), dtype='int32', name='api_id_input') inputs = [mashup_id_input, api_id_input] mashup_text_fea = self.mid2text_fea_layer( mashup_id_input) # (None,1,25) api_text_fea = self.aid2text_fea_layer(api_id_input) # (None,1,25) mashup_tag_fea = self.mid2tag_fea_layer( mashup_id_input) # (None,1,25) api_tag_fea = self.aid2tag_fea_layer(api_id_input) # (None,1,25) api_implict_emb = self.api_implict_emb_layer( api_id_input) # (None,1,25) feature_list = [ mashup_text_fea, api_text_fea, mashup_tag_fea, api_tag_fea, api_implict_emb ] if self.new_old == 'new' and new_Para.param.need_slt_apis: mashup_slt_apis_input = Input( shape=(new_Para.param.slt_item_num, ), dtype='int32', name='slt_api_ids_input') inputs.append(mashup_slt_apis_input) keys_slt_api_text_feas = self.aid2text_fea_layer( mashup_slt_apis_input) # (None,3,25) keys_slt_api_tag_feas = self.aid2tag_fea_layer( mashup_slt_apis_input) # (None,3,25) keys_slt_api_implict_embs = self.api_implict_emb_layer( mashup_slt_apis_input) # (None,3,25) mask = Lambda(lambda x: K.not_equal(x, self.all_api_num))( mashup_slt_apis_input) # (?, 3) !!! # query_api_text_vec = Lambda(lambda x: tf.expand_dims(x, axis=1))(api_text_fea) # (?, 50)->(?, 1, 50) # query_api_tag_vec = Lambda(lambda x: tf.expand_dims(x, axis=1))(api_tag_fea) # query_api_implict_emb = Lambda(lambda x: tf.expand_dims(x, axis=1))(api_implict_emb) # 压缩历史,得到向量 ->(?, 1, 50) text_hist = AttentionSequencePoolingLayer( supports_masking=True)( [api_text_fea, keys_slt_api_text_feas], mask=mask) tag_hist = AttentionSequencePoolingLayer( supports_masking=True)( [api_tag_fea, keys_slt_api_tag_feas], mask=mask) implict_emb_hist = AttentionSequencePoolingLayer( supports_masking=True)( [api_implict_emb, keys_slt_api_implict_embs], mask=mask) feature_list = [ mashup_text_fea, api_text_fea, text_hist, mashup_tag_fea, api_tag_fea, tag_hist, api_implict_emb, implict_emb_hist ] feature_list = list(map(NoMask(), feature_list)) # DNN不支持mak,所以不能再传递mask all_features = Concatenate( name='all_content_concatenate')(feature_list) all_features = Lambda(lambda x: tf.squeeze(x, axis=1))( all_features) output = DNN(self.predict_fc_unit_nums[:-1])(all_features) output = Dense(self.predict_fc_unit_nums[-1], activation='relu', kernel_regularizer=l2( new_Para.param.l2_reg))(output) # 输出层 if new_Para.param.final_activation == 'softmax': predict_result = Dense(2, activation='softmax', name="prediction")(output) elif new_Para.param.final_activation == 'sigmoid': predict_result = Dense(1, activation='sigmoid', kernel_initializer='lecun_uniform', name="prediction")(output) self.model = Model(inputs=inputs, outputs=[predict_result], name='predict_model') return self.model