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 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()
