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 forward(self, left, right):
"""
Forward network
"""
# embedding layer
left_emb = self.emb_layer(left)
right_emb = self.emb_layer(right)
left_emb = fluid.layers.reshape(left_emb,
shape=[-1, self.seq_len, self.bow_dim])
right_emb = fluid.layers.reshape(
right_emb, shape=[-1, self.seq_len, self.bow_dim])
bow_left = fluid.layers.reduce_sum(left_emb, dim=1)
bow_right = fluid.layers.reduce_sum(right_emb, dim=1)
softsign_layer = layers.SoftsignLayer()
left_soft = softsign_layer.ops(bow_left)
right_soft = softsign_layer.ops(bow_right)
# matching layer
if self.task_mode == "pairwise":
left_bow = self.bow_layer(left_soft)
right_bow = self.bow_layer(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])
concat_fc = self.bow_layer_po(concat)
pred = self.softmax_layer(concat_fc)
return left_soft, 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
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
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 forward(self, left, right):
"""
Forward network
"""
# embedding layer
left_emb = self.emb_layer(left)
right_emb = self.emb_layer(right)
# Presentation context
left_emb = fluid.layers.reshape(
left_emb, shape=[-1, self.channels, self.seq_len, self.hidden_dim])
right_emb = fluid.layers.reshape(
right_emb, shape=[-1, self.channels, self.seq_len, self.hidden_dim])
left_cnn = self.cnn_layer(left_emb)
right_cnn = self.cnn_layer(right_emb)
# matching layer
if self.task_mode == "pairwise":
left_fc = self.fc_layer(left_cnn)
right_fc = self.fc_layer(right_cnn)
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_cnn, right_cnn])
concat_fc = self.fc_layer(concat)
pred = self.softmax_layer(concat_fc)
return left_cnn, pred
def forward(self, left, right):
"""
Forward network
"""
# embedding layer
left_emb = self.emb_layer(left)
right_emb = self.emb_layer(right)
# Presentation context
left_proj = self.proj_layer(left_emb)
right_proj = self.proj_layer(right_emb)
left_lstm, _ = self.lstm_layer(left_proj)
right_lstm, _ = self.lstm_layer(right_proj)
left_emb = fluid.layers.reduce_max(left_lstm, dim=1)
right_emb = fluid.layers.reduce_max(right_lstm, dim=1)
left_emb = fluid.layers.reshape(
left_emb, shape=[-1, self.seq_len, self.hidden_dim])
right_emb = fluid.layers.reshape(
right_emb, shape=[-1, self.seq_len, self.hidden_dim])
left_emb = fluid.layers.reduce_sum(left_emb, dim=1)
right_emb = fluid.layers.reduce_sum(right_emb, dim=1)
left_last = fluid.layers.tanh(left_emb)
right_last = fluid.layers.tanh(right_emb)
# matching layer
if self.task_mode == "pairwise":
left_fc = self.fc_layer(left_last)
right_fc = self.fc_layer(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])
concat_fc = self.fc_layer(concat)
pred = self.softmax_layer(concat_fc)
return left_last, pred
def forward(self, left, right):
"""
Forward network
"""
# embedding layer
left_emb = self.emb_layer(left)
right_emb = self.emb_layer(right)
# Presentation context
left_emb = self.proj_layer(left_emb)
right_emb = self.proj_layer(right_emb)
h_0 = np.zeros((left_emb.shape[0], self.hidden_dim), dtype="float32")
h_0 = to_variable(h_0)
left_gru = self.gru_layer(left_emb, h_0=h_0)
right_gru = self.gru_layer(right_emb, h_0=h_0)
left_emb = fluid.layers.reduce_max(left_gru, dim=1)
right_emb = fluid.layers.reduce_max(right_gru, dim=1)
left_emb = fluid.layers.reshape(
left_emb, shape=[-1, self.seq_len, self.hidden_dim])
right_emb = fluid.layers.reshape(
right_emb, shape=[-1, self.seq_len, self.hidden_dim])
left_emb = fluid.layers.reduce_sum(left_emb, dim=1)
right_emb = fluid.layers.reduce_sum(right_emb, dim=1)
left_last = fluid.layers.tanh(left_emb)
right_last = fluid.layers.tanh(right_emb)
if self.task_mode == "pairwise":
left_fc = self.fc_layer(left_last)
right_fc = self.fc_layer(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])
concat_fc = self.fc_layer(concat)
pred = self.softmax_layer(concat_fc)
return left_last, pred
