def define_network(self, l_src_ids, l_position_ids, l_sentence_ids, l_input_mask, r_src_ids, r_position_ids, r_sentence_ids, r_input_mask): conf = ErnieConfig(self.conf_path) l_model = ErnieModel(l_src_ids, l_position_ids, l_sentence_ids, task_ids=None, input_mask=l_input_mask, config=conf) l_pool_feature = l_model.get_pooled_output() r_model = ErnieModel(r_src_ids, r_position_ids, r_sentence_ids, task_ids=None, input_mask=r_input_mask, config=conf) r_pool_feature = r_model.get_pooled_output() l_pool_feature.stop_gradient = self.clock r_pool_feature.stop_gradient = self.clock # l_pool_feature = layers.fc(l_pool_feature,128) # r_pool_feature = layers.fc(r_pool_feature,128) self.confidence = layers.cos_sim(l_pool_feature, r_pool_feature) out = layers.fc([l_pool_feature, r_pool_feature], 128) out = layers.fc(out, 32) self.layers_out = layers.fc(out, 11, name="kea_out") # self.confidence = layers.softmax(self.layers_out) layers_out = layers.argmax(self.layers_out, axis=1) return layers_out
def inference_program(): usr_combined_features = get_usr_combined_features() mov_combined_features = get_mov_combined_features() inference = layers.cos_sim(X=usr_combined_features, Y=mov_combined_features) scale_infer = layers.scale(x=inference, scale=5.0) return scale_infer
def __init__(self, label, pred): """doc""" if label.shape != pred.shape: raise ValueError( 'expect label shape == pred shape, got: label.shape=%s, pred.shape = %s' % (repr(label), repr(pred))) self.cos = L.cos_sim(label, pred) self.reset()
def pairwise_hinge(self): """pairwise model""" poi_repr = L.split(self.poi_repr, 2, dim=0) pos_repr, neg_repr = poi_repr pos_pred = L.cos_sim(self.query_repr, pos_repr) neg_pred = L.cos_sim(self.query_repr, neg_repr) mode = 'hinge_loss' # log(1 + e-z), max(0, 1 - z) if 'hinge_loss' == mode: theta_z = L.relu(1 + neg_pred - pos_pred) elif 'logistic_loss' == mode: theta_z = L.log(1 + L.exp(neg_pred - pos_pred)) self.loss = L.reduce_mean(theta_z) pos_cnt = L.reduce_sum(L.cast(L.greater_than(pos_pred, neg_pred), dtype="float32")) neg_cnt = L.reduce_sum(L.cast(L.less_than(pos_pred, neg_pred), dtype="float32")) self.order = pos_cnt / (1e-5 + neg_cnt) self.metrics = [self.loss, self.order]
def inference_program(): usr_combined_features = get_usr_combined_features() mov_combined_features = get_mov_combined_features() inference = layers.cos_sim(X=usr_combined_features, Y=mov_combined_features) scale_infer = layers.scale(x=inference, scale=5.0) label = layers.data(name='score', shape=[1], dtype='float32') square_cost = layers.square_error_cost(input=scale_infer, label=label) avg_cost = layers.mean(square_cost) return usr_combined_features, mov_combined_features, scale_infer, avg_cost
def model(): usr_combined_features = get_usr_combined_features() mov_combined_features = get_mov_combined_features() # need cos sim inference = layers.cos_sim(X=usr_combined_features, Y=mov_combined_features) scale_infer = layers.scale(x=inference, scale=5.0) label = layers.data(name='score', shape=[1], dtype='float32') square_cost = layers.square_error_cost(input=scale_infer, label=label) avg_cost = layers.mean(square_cost) return scale_infer, avg_cost
def __model_dataflow(self): user_id = layers.data(name='user_id', shape=[1], dtype='int64') user_gender_id = layers.data(name='user_gender_id', shape=[1], dtype='int64') user_age_id = layers.data(name='user_age_id', shape=[1], dtype='int64') user_occupation_id = layers.data(name='user_occupation_id', shape=[1], dtype='int64') item_id = layers.data(name='item_id', shape=[1], dtype='int64') item_category_one_hot = layers.data(name='item_category_one_hot', shape=[19], dtype='float32') user_emb = layers.embedding(input=user_id, dtype='float32', size=[self.user_num + 1, 16], param_attr='user_table', is_sparse=True) user_gender_emb = layers.embedding(input=user_gender_id, dtype='float32', size=[2, 16], param_attr='user_gender_table', is_sparse=True) user_age_emb = layers.embedding(input=user_age_id, dtype='float32', size=[10, 16], param_attr='user_age_table', is_sparse=True) user_occupation_emb = layers.embedding(input=user_occupation_id, dtype='float32', size=[self.user_occupation_num, 16], param_attr='user_occupation_table', is_sparse=True) item_emb = layers.embedding(input=item_id, dtype='float32', size=[self.item_num + 1, 16], param_attr='item_table', is_sparse=True) item_category_emb = layers.fc(input=item_category_one_hot, size=16) user_fc = layers.fc(input=user_emb, size=32) user_gender_fc = layers.fc(input=user_gender_emb, size=16) user_age_fc = layers.fc(input=user_age_emb, size=16) user_occupation_fc = layers.fc(input=user_occupation_emb, size=16) item_fc = layers.fc(input=item_emb, size=32) item_category_fc = layers.fc(input=item_category_emb, size=16) user_concat_embed = layers.concat( input=[user_fc, user_gender_fc, user_age_fc, user_occupation_fc], axis=1) item_concat_embed = layers.concat( input=[item_fc, item_category_fc], axis=1) user_conbined_features = layers.fc(input=user_concat_embed, size=200, act="tanh") item_conbined_features = layers.fc(input=item_concat_embed, size=200, act="tanh") inference = layers.cos_sim(X=user_conbined_features, Y=item_conbined_features) scale_infer = layers.scale(x=inference, scale=5.0) rating = layers.data(name='rating', shape=[1], dtype='float32') square_cost = layers.square_error_cost(input=scale_infer, label=rating) avg_cost = layers.mean(square_cost) return scale_infer, avg_cost
def __init__(self, label, pred): """doc""" self.cos = L.cos_sim(label, pred) self.reset()