def predict(self, left, right):
"""
Forward network
"""
# embedding layer
emb_layer = layers.EmbeddingLayer(self.dict_size, self.emb_dim, "emb")
left_emb = emb_layer.ops(left)
right_emb = emb_layer.ops(right)
# Presentation context
lstm_layer = layers.DynamicLSTMLayer(self.lstm_dim, "lstm")
left_lstm = lstm_layer.ops(left_emb)
right_lstm = lstm_layer.ops(right_emb)
last_layer = layers.SequenceLastStepLayer()
left_last = last_layer.ops(left_lstm)
right_last = last_layer.ops(right_lstm)
# matching layer
if self.task_mode == "pairwise":
fc_layer = layers.FCLayer(self.hidden_dim, None, "fc")
left_fc = fc_layer.ops(left_last)
right_fc = fc_layer.ops(right_last)
cos_sim_layer = layers.CosSimLayer()
pred = cos_sim_layer.ops(left_fc, right_fc)
return left_fc, pred
else:
concat_layer = layers.ConcatLayer(1)
concat = concat_layer.ops([left_last, right_last])
fc_layer = layers.FCLayer(self.hidden_dim, None, "fc")
concat_fc = fc_layer.ops(concat)
softmax_layer = layers.FCLayer(2, "softmax", "cos_sim")
pred = softmax_layer.ops(concat_fc)
return left_last, pred
def predict(self, left, right):
"""
Forward network
"""
# embedding layer
emb_layer = layers.EmbeddingLayer(self.dict_size, self.emb_dim, "emb")
left_emb = emb_layer.ops(left)
right_emb = emb_layer.ops(right)
# Presentation context
gru_layer = layers.DynamicGRULayer(self.gru_dim, "gru")
left_gru = gru_layer.ops(left_emb)
right_gru = gru_layer.ops(right_emb)
last_layer = layers.SequenceLastStepLayer()
left_last = last_layer.ops(left_gru)
right_last = last_layer.ops(right_gru)
# matching layer
if self.task_mode == "pairwise":
relu_layer = layers.FCLayer(self.hidden_dim, "relu", "relu")
left_relu = relu_layer.ops(left_last)
right_relu = relu_layer.ops(right_last)
cos_sim_layer = layers.CosSimLayer()
pred = cos_sim_layer.ops(left_relu, right_relu)
return left_relu, pred
else:
concat_layer = layers.ConcatLayer(1)
concat = concat_layer.ops([left_last, right_last])
relu_layer = layers.FCLayer(self.hidden_dim, "relu", "relu")
concat_fc = relu_layer.ops(concat)
softmax_layer = layers.FCLayer(2, "softmax", "cos_sim")
pred = softmax_layer.ops(concat_fc)
return left_last, pred
def predict(self, left, right):
"""
Forward network
"""
# embedding layer
emb_layer = layers.EmbeddingLayer(self.dict_size, self.emb_dim, "emb")
left_emb = emb_layer.ops(left)
right_emb = emb_layer.ops(right)
# Presentation context
cnn_layer = layers.SequenceConvPoolLayer(self.filter_size,
self.num_filters, "conv")
left_cnn = cnn_layer.ops(left_emb)
right_cnn = cnn_layer.ops(right_emb)
# matching layer
if self.task_mode == "pairwise":
relu_layer = layers.FCLayer(self.hidden_dim, "relu", "relu")
left_relu = relu_layer.ops(left_cnn)
right_relu = relu_layer.ops(right_cnn)
cos_sim_layer = layers.CosSimLayer()
pred = cos_sim_layer.ops(left_relu, right_relu)
return left_relu, pred
else:
concat_layer = layers.ConcatLayer(1)
concat = concat_layer.ops([left_cnn, right_cnn])
relu_layer = layers.FCLayer(self.hidden_dim, "relu", "relu")
concat_fc = relu_layer.ops(concat)
softmax_layer = layers.FCLayer(2, "softmax", "cos_sim")
pred = softmax_layer.ops(concat_fc)
return left_cnn, pred
def predict(self, left, right):
"""
Forward network
"""
# embedding layer
emb_layer = layers.EmbeddingLayer(self.dict_size, self.emb_dim, "emb")
left_emb = emb_layer.ops(left)
right_emb = emb_layer.ops(right)
# Presentation context
pool_layer = layers.SequencePoolLayer("sum")
left_pool = pool_layer.ops(left_emb)
right_pool = pool_layer.ops(right_emb)
softsign_layer = layers.SoftsignLayer()
left_soft = softsign_layer.ops(left_pool)
right_soft = softsign_layer.ops(right_pool)
# matching layer
if self.task_mode == "pairwise":
bow_layer = layers.FCLayer(self.bow_dim, "relu", "fc")
print(left.shape)
left_bow = bow_layer.ops(left_soft)
print(left_bow.shape)
right_bow = bow_layer.ops(right_soft)
cos_sim_layer = layers.CosSimLayer()
pred = cos_sim_layer.ops(left_bow, right_bow)
return left_bow, pred
else:
concat_layer = layers.ConcatLayer(1)
concat = concat_layer.ops([left_soft, right_soft])
bow_layer = layers.FCLayer(self.bow_dim, "relu", "fc")
concat_fc = bow_layer.ops(concat)
softmax_layer = layers.FCLayer(2, "softmax", "cos_sim")
pred = softmax_layer.ops(concat_fc)
return left_soft, pred
def __init__(self, conf_dict):
"""
initialize
"""
super(BOW, self).__init__()
self.dict_size = conf_dict["dict_size"]
self.task_mode = conf_dict["task_mode"]
self.emb_dim = conf_dict["net"]["emb_dim"]
self.bow_dim = conf_dict["net"]["bow_dim"]
self.seq_len = conf_dict["seq_len"]
self.emb_layer = layers.EmbeddingLayer(self.dict_size, self.emb_dim, "emb").ops()
self.bow_layer = Linear(self.bow_dim, self.bow_dim)
self.bow_layer_po = layers.FCLayer(self.bow_dim, None, "fc").ops()
self.softmax_layer = layers.FCLayer(2, "softmax", "cos_sim").ops()
def __init__(self, conf_dict):
"""
initialize
"""
super(LSTM,self).__init__()
self.dict_size = conf_dict["dict_size"]
self.task_mode = conf_dict["task_mode"]
self.emb_dim = conf_dict["net"]["emb_dim"]
self.lstm_dim = conf_dict["net"]["lstm_dim"]
self.hidden_dim = conf_dict["net"]["hidden_dim"]
self.emb_layer = layers.EmbeddingLayer(self.dict_size, self.emb_dim, "emb").ops()
self.lstm_layer = layers.DynamicLSTMLayer(self.lstm_dim, "lstm").ops()
self.fc_layer = layers.FCLayer(self.hidden_dim, None, "fc").ops()
self.softmax_layer = layers.FCLayer(2, "softmax", "cos_sim").ops()
self.proj_layer = Linear(input_dim = self.hidden_dim, output_dim=self.lstm_dim*4)
self.seq_len = conf_dict["seq_len"]
def __init__(self, conf_dict):
"""
initialize
"""
super(CNN, self).__init__()
self.dict_size = conf_dict["dict_size"]
self.task_mode = conf_dict["task_mode"]
self.emb_dim = conf_dict["net"]["emb_dim"]
self.filter_size = conf_dict["net"]["filter_size"]
self.num_filters = conf_dict["net"]["num_filters"]
self.hidden_dim = conf_dict["net"]["hidden_dim"]
self.seq_len = conf_dict["seq_len"]
self.channels = 1
# layers
self.emb_layer = layers.EmbeddingLayer(self.dict_size, self.emb_dim, "emb").ops()
self.fc_layer = layers.FCLayer(self.hidden_dim, None, "fc").ops()
self.softmax_layer = layers.FCLayer(2, "softmax", "cos_sim").ops()
self.cnn_layer = layers.SimpleConvPool(
self.channels,
self.num_filters,
self.filter_size)
def __init__(self, config):
"""
initialize
"""
super(MMDNN, self).__init__()
self.vocab_size = int(config['dict_size'])
self.emb_size = int(config['net']['embedding_dim'])
self.lstm_dim = int(config['net']['lstm_dim'])
self.kernel_size = int(config['net']['num_filters'])
self.win_size1 = int(config['net']['window_size_left'])
self.win_size2 = int(config['net']['window_size_right'])
self.dpool_size1 = int(config['net']['dpool_size_left'])
self.dpool_size2 = int(config['net']['dpool_size_right'])
self.hidden_size = int(config['net']['hidden_size'])
self.seq_len = int(config["seq_len"])
self.seq_len1 = self.seq_len
#int(config['max_len_left'])
self.seq_len2 = self.seq_len
#int(config['max_len_right'])
self.task_mode = config['task_mode']
self.zero_pad = True
self.scale = False
if int(config['match_mask']) != 0:
self.match_mask = True
else:
self.match_mask = False
if self.task_mode == "pointwise":
self.n_class = int(config['n_class'])
self.out_size = self.n_class
elif self.task_mode == "pairwise":
self.out_size = 1
else:
logging.error("training mode not supported")
# layers
self.emb_layer = pd_layers.EmbeddingLayer(
self.vocab_size,
self.emb_size,
name="word_embedding",
padding_idx=(0 if self.zero_pad else None)).ops()
self.fw_in_proj = Linear(input_dim=self.emb_size,
output_dim=4 * self.lstm_dim,
param_attr=fluid.ParamAttr(name="fw_fc.w"),
bias_attr=False)
self.lstm_layer = pd_layers.DynamicLSTMLayer(self.lstm_dim,
"lstm").ops()
self.rv_in_proj = Linear(input_dim=self.emb_size,
output_dim=4 * self.lstm_dim,
param_attr=fluid.ParamAttr(name="rv_fc.w"),
bias_attr=False)
self.reverse_layer = pd_layers.DynamicLSTMLayer(self.lstm_dim,
is_reverse=True).ops()
self.conv = Conv2D(num_channels=1,
num_filters=self.kernel_size,
stride=1,
padding=(int(self.seq_len1 / 2),
int(self.seq_len2 // 2)),
filter_size=(self.seq_len1, self.seq_len2),
bias_attr=fluid.ParamAttr(
initializer=fluid.initializer.Constant(0.1)))
self.pool_layer = Pool2D(pool_size=[
int(self.seq_len1 / self.dpool_size1),
int(self.seq_len2 / self.dpool_size2)
],
pool_stride=[
int(self.seq_len1 / self.dpool_size1),
int(self.seq_len2 / self.dpool_size2)
],
pool_type="max")
self.fc_layer = pd_layers.FCLayer(self.hidden_size, "tanh", "fc").ops()
self.fc1_layer = pd_layers.FCLayer(self.out_size, "softmax",
"fc1").ops()
