def _get_loss_train_op(self):
# Aggregates loss
loss_rephraser = (tf.get_collection('loss_rephraser_list')[0] +
tf.get_collection('loss_rephraser_list')[1] +
tf.get_collection('loss_rephraser_list')[2]) / 3.
self.loss = loss_rephraser
# Creates optimizers
self.vars = collect_trainable_variables([
self.bert_encoder, self.word_embedder, self.downmlp,
self.rephrase_encoder, self.rephrase_decoder
])
# Train Op
self.train_op_pre = get_train_op(self.loss,
self.vars,
learning_rate=self.lr,
hparams=self._hparams.opt)
# Interface tensors
self.losses = {
"loss": self.loss,
"loss_rephraser": loss_rephraser,
}
self.metrics = {}
self.train_ops = {
"train_op_pre": self.train_op_pre,
}
self.samples = {
"transferred_yy1_gt": self.text_ids_yy1,
"transferred_yy1_pred": tf.get_collection('yy_pred_list')[0],
"transferred_yy2_gt": self.text_ids_yy2,
"transferred_yy2_pred": tf.get_collection('yy_pred_list')[1],
"transferred_yy3_gt": self.text_ids_yy3,
"transferred_yy3_pred": tf.get_collection('yy_pred_list')[2],
"origin_y1": self.text_ids_y1,
"origin_y2": self.text_ids_y2,
"origin_y3": self.text_ids_y3,
"x1x2": self.x1x2,
"x1xx2": self.x1xx2
}
tf.summary.scalar("loss", self.loss)
tf.summary.scalar("loss_rephraser", loss_rephraser)
self.merged = tf.summary.merge_all()
self.fetches_train_pre = {
"loss": self.train_ops["train_op_pre"],
"loss_rephraser": self.losses["loss_rephraser"],
"merged": self.merged,
}
fetches_eval = {
"batch_size": get_batch_size(self.x1x2yx1xx2_ids),
"merged": self.merged,
}
fetches_eval.update(self.losses)
fetches_eval.update(self.metrics)
fetches_eval.update(self.samples)
self.fetches_eval = fetches_eval
def _get_loss_train_op(self):
# Aggregates losses
self.loss_g = self.loss_g_ae + self.lambda_g_hidden * self.loss_g_clas_hidden + self.lambda_g_sentence * self.loss_g_clas_sentence
self.loss_d = self.loss_d_clas_hidden + self.loss_d_clas_sentence
# Creates optimizers
self.g_vars = collect_trainable_variables([
self.embedder, self.self_graph_encoder, self.label_connector,
self.rephrase_encoder, self.rephrase_decoder
])
self.d_vars = collect_trainable_variables([
self.clas_embedder, self.classifier_hidden,
self.classifier_sentence
])
self.train_op_g = get_train_op(self.loss_g,
self.g_vars,
hparams=self._hparams.opt)
self.train_op_g_ae = get_train_op(self.loss_g_ae,
self.g_vars,
hparams=self._hparams.opt)
self.train_op_d = get_train_op(self.loss_d,
self.d_vars,
hparams=self._hparams.opt)
# Interface tensors
self.losses = {
"loss_g": self.loss_g,
"loss_d": self.loss_d,
"loss_g_ae": self.loss_g_ae,
"loss_g_clas_hidden": self.loss_g_clas_hidden,
"loss_g_clas_sentence": self.loss_g_clas_sentence,
"loss_d_clas_hidden": self.loss_d_clas_hidden,
"loss_d_clas_sentence": self.loss_d_clas_sentence,
}
self.metrics = {
"accu_d_hidden": self.accu_d_hidden,
"accu_d_sentence": self.accu_d_sentence,
"accu_g_hidden": self.accu_g_hidden,
"accu_g_sentence": self.accu_g_sentence,
"accu_g_gdy_sentence": self.accu_g_gdy_sentence,
}
self.train_ops = {
"train_op_g": self.train_op_g,
"train_op_g_ae": self.train_op_g_ae,
"train_op_d": self.train_op_d
}
self.samples = {
"original": self.text_ids[:, 1:],
"transferred": self.rephrase_outputs_.sample_id
}
self.fetches_train_d = {
"loss_d": self.train_ops["train_op_d"],
"loss_d_clas_hidden": self.losses["loss_d_clas_hidden"],
"loss_d_clas_sentence": self.losses["loss_d_clas_sentence"],
"accu_d_hidden": self.metrics["accu_d_hidden"],
"accu_d_sentence": self.metrics["accu_d_sentence"],
}
tf.summary.scalar("loss_d", self.loss_d)
tf.summary.scalar("loss_d_clas_hidden", self.loss_d_clas_hidden)
tf.summary.scalar("loss_d_clas_sentence", self.loss_d_clas_sentence)
tf.summary.scalar("accu_d_hidden", self.accu_d_hidden)
tf.summary.scalar("accu_d_sentence", self.accu_d_sentence)
tf.summary.scalar("loss_g", self.loss_g)
tf.summary.scalar("loss_g_ae", self.loss_g_ae)
tf.summary.scalar("loss_g_clas_hidden", self.loss_g_clas_hidden)
tf.summary.scalar("loss_g_clas_sentence", self.loss_g_clas_sentence)
tf.summary.scalar("accu_g_hidden", self.accu_g_hidden)
tf.summary.scalar("accu_g_sentence", self.accu_g_sentence)
tf.summary.scalar("accu_g_gdy_sentence", self.accu_g_gdy_sentence)
self.merged = tf.summary.merge_all()
self.fetches_train_g = {
"loss_g": self.train_ops["train_op_g"],
"loss_g_ae": self.losses["loss_g_ae"],
"loss_g_clas_hidden": self.losses["loss_g_clas_hidden"],
"loss_g_clas_sentence": self.losses["loss_g_clas_sentence"],
"accu_g_hidden": self.metrics["accu_g_hidden"],
"accu_g_sentence": self.metrics["accu_g_sentence"],
"accu_g_gdy_sentence": self.metrics["accu_g_gdy_sentence"],
"merged": self.merged,
}
fetches_eval = {
"batch_size": get_batch_size(self.text_ids),
"merged": self.merged,
}
fetches_eval.update(self.losses)
fetches_eval.update(self.metrics)
fetches_eval.update(self.samples)
self.fetches_eval = fetches_eval
def _build_model(self, inputs, vocab, gamma, lambda_g):
"""Builds the model.
"""
embedder = WordEmbedder(
vocab_size=vocab.size,
hparams=self._hparams.embedder)
encoder = UnidirectionalRNNEncoder(hparams=self._hparams.encoder)
# text_ids for encoder, with BOS token removed
enc_text_ids = inputs['text_ids'][:, 1:]
enc_outputs, final_state = encoder(embedder(enc_text_ids),
sequence_length=inputs['length']-1)
z = final_state[:, self._hparams.dim_c:]
# Encodes label
label_connector = MLPTransformConnector(self._hparams.dim_c)
# Gets the sentence representation: h = (c, z)
labels0 = tf.to_float(tf.reshape(inputs['labels0'], [-1, 1]))
labels1 = tf.to_float(tf.reshape(inputs['labels1'], [-1, 1]))
labels2 = tf.to_float(tf.reshape(inputs['labels2'], [-1, 1]))
labels3 = tf.to_float(tf.reshape(inputs['labels3'], [-1, 1]))
labels = tf.concat([labels0, labels1, labels2, labels3], axis = 1)
print('labels', labels)
sys.stdout.flush()
c = label_connector(labels)
c_ = label_connector(1 - labels)
h = tf.concat([c, z], 1)
h_ = tf.concat([c_, z], 1)
# Teacher-force decoding and the auto-encoding loss for G
decoder = AttentionRNNDecoder(
memory=enc_outputs,
memory_sequence_length=inputs['length']-1,
cell_input_fn=lambda inputs, attention: inputs,
vocab_size=vocab.size,
hparams=self._hparams.decoder)
connector = MLPTransformConnector(decoder.state_size)
g_outputs, _, _ = decoder(
initial_state=connector(h), inputs=inputs['text_ids'],
embedding=embedder, sequence_length=inputs['length']-1)
print('labels shape', inputs['text_ids'][:, 1:], 'logits shape', g_outputs.logits)
print(inputs['length'] - 1)
loss_g_ae = tx.losses.sequence_sparse_softmax_cross_entropy(
labels=inputs['text_ids'][:, 1:],
logits=g_outputs.logits,
sequence_length=inputs['length']-1,
average_across_timesteps=True,
sum_over_timesteps=False)
# Gumbel-softmax decoding, used in training
start_tokens = tf.ones_like(inputs['labels0']) * vocab.bos_token_id
end_token = vocab.eos_token_id
gumbel_helper = GumbelSoftmaxEmbeddingHelper(
embedder.embedding, start_tokens, end_token, gamma)
soft_outputs_, _, soft_length_, = decoder(
helper=gumbel_helper, initial_state=connector(h_))
print(g_outputs, soft_outputs_)
# Greedy decoding, used in eval
outputs_, _, length_ = decoder(
decoding_strategy='infer_greedy', initial_state=connector(h_),
embedding=embedder, start_tokens=start_tokens, end_token=end_token)
# Creates classifier
classifier0 = Conv1DClassifier(hparams=self._hparams.classifier)
classifier1 = Conv1DClassifier(hparams=self._hparams.classifier)
classifier2 = Conv1DClassifier(hparams=self._hparams.classifier)
classifier3 = Conv1DClassifier(hparams=self._hparams.classifier)
clas_embedder = WordEmbedder(vocab_size=vocab.size,
hparams=self._hparams.embedder)
clas_logits, clas_preds = self._high_level_classifier([classifier0, classifier1, classifier2, classifier3],
clas_embedder, inputs, vocab, gamma, lambda_g, inputs['text_ids'][:, 1:], None, inputs['length']-1)
loss_d_clas = tf.nn.sigmoid_cross_entropy_with_logits(
labels=tf.to_float(labels), logits=clas_logits)
loss_d_clas = tf.reduce_mean(loss_d_clas)
accu_d = tx.evals.accuracy(labels, preds=clas_preds)
# Classification loss for the generator, based on soft samples
# soft_logits, soft_preds = classifier(
# inputs=clas_embedder(soft_ids=soft_outputs_.sample_id),
# sequence_length=soft_length_)
soft_logits, soft_preds = self._high_level_classifier([classifier0, classifier1, classifier2, classifier3],
clas_embedder, inputs, vocab, gamma, lambda_g, None, soft_outputs_.sample_id, soft_length_)
print(soft_logits.shape, soft_preds.shape)
loss_g_clas = tf.nn.sigmoid_cross_entropy_with_logits(
labels=tf.to_float(1-labels), logits=soft_logits)
loss_g_clas = tf.reduce_mean(loss_g_clas)
# Accuracy on soft samples, for training progress monitoring
accu_g = tx.evals.accuracy(labels=1-labels, preds=soft_preds)
# Accuracy on greedy-decoded samples, for training progress monitoring
# _, gdy_preds = classifier(
# inputs=clas_embedder(ids=outputs_.sample_id),
# sequence_length=length_)
_, gdy_preds = self._high_level_classifier([classifier0, classifier1, classifier2, classifier3],
clas_embedder, inputs, vocab, gamma, lambda_g, outputs_.sample_id, None, length_)
print(gdy_preds.shape)
accu_g_gdy = tx.evals.accuracy(
labels=1-labels, preds=gdy_preds)
# Aggregates losses
loss_g = loss_g_ae + lambda_g * loss_g_clas
loss_d = loss_d_clas
# Creates optimizers
g_vars = collect_trainable_variables(
[embedder, encoder, label_connector, connector, decoder])
d_vars = collect_trainable_variables([clas_embedder, classifier0, classifier1, classifier2, classifier3])
train_op_g = get_train_op(
loss_g, g_vars, hparams=self._hparams.opt)
train_op_g_ae = get_train_op(
loss_g_ae, g_vars, hparams=self._hparams.opt)
train_op_d = get_train_op(
loss_d, d_vars, hparams=self._hparams.opt)
# Interface tensors
self.predictions = {
"predictions": clas_preds,
"ground_truth": labels
}
self.losses = {
"loss_g": loss_g,
"loss_g_ae": loss_g_ae,
"loss_g_clas": loss_g_clas,
"loss_d": loss_d_clas
}
self.metrics = {
"accu_d": accu_d,
"accu_g": accu_g,
"accu_g_gdy": accu_g_gdy,
}
self.train_ops = {
"train_op_g": train_op_g,
"train_op_g_ae": train_op_g_ae,
"train_op_d": train_op_d
}
self.samples = {
"original": inputs['text_ids'][:, 1:],
"transferred": outputs_.sample_id
}
self.fetches_train_g = {
"loss_g": self.train_ops["train_op_g"],
"loss_g_ae": self.losses["loss_g_ae"],
"loss_g_clas": self.losses["loss_g_clas"],
"accu_g": self.metrics["accu_g"],
"accu_g_gdy": self.metrics["accu_g_gdy"],
}
self.fetches_train_d = {
"loss_d": self.train_ops["train_op_d"],
"accu_d": self.metrics["accu_d"]
}
fetches_eval = {"batch_size": get_batch_size(inputs['text_ids'])}
fetches_eval.update(self.losses)
fetches_eval.update(self.metrics)
fetches_eval.update(self.samples)
fetches_eval.update(self.predictions)
self.fetches_eval = fetches_eval
def _build_model(self, inputs, vocab, finputs, minputs, gamma):
"""Builds the model.
"""
self.inputs = inputs
self.finputs = finputs
self.minputs = minputs
self.vocab = vocab
self.embedder = WordEmbedder(vocab_size=self.vocab.size,
hparams=self._hparams.embedder)
# maybe later have to try BidirectionalLSTMEncoder
self.encoder = UnidirectionalRNNEncoder(
hparams=self._hparams.encoder) #GRU cell
# text_ids for encoder, with BOS(begin of sentence) token removed
self.enc_text_ids = self.inputs['text_ids'][:, 1:]
self.enc_outputs, self.final_state = self.encoder(
self.embedder(self.enc_text_ids),
sequence_length=self.inputs['length'] - 1)
h = self.final_state
# Teacher-force decoding and the auto-encoding loss for G
self.decoder = AttentionRNNDecoder(
memory=self.enc_outputs,
memory_sequence_length=self.inputs['length'] - 1,
cell_input_fn=lambda inputs, attention: inputs,
#default: lambda inputs, attention: tf.concat([inputs, attention], -1), which cancats regular RNN cell inputs with attentions.
vocab_size=self.vocab.size,
hparams=self._hparams.decoder)
self.connector = MLPTransformConnector(self.decoder.state_size)
self.g_outputs, _, _ = self.decoder(
initial_state=self.connector(h),
inputs=self.inputs['text_ids'],
embedding=self.embedder,
sequence_length=self.inputs['length'] - 1)
self.loss_g_ae = tx.losses.sequence_sparse_softmax_cross_entropy(
labels=self.inputs['text_ids'][:, 1:],
logits=self.g_outputs.logits,
sequence_length=self.inputs['length'] - 1,
average_across_timesteps=True,
sum_over_timesteps=False)
# Greedy decoding, used in eval (and RL training)
start_tokens = tf.ones_like(
self.inputs['labels']) * self.vocab.bos_token_id
end_token = self.vocab.eos_token_id
self.outputs, _, length = self.decoder(
#也许可以尝试之后把这个换成 "infer_sample"看效果
decoding_strategy='infer_greedy',
initial_state=self.connector(h),
embedding=self.embedder,
start_tokens=start_tokens,
end_token=end_token)
# Creates optimizers
self.g_vars = collect_trainable_variables(
[self.embedder, self.encoder, self.connector, self.decoder])
self.train_op_g_ae = get_train_op(self.loss_g_ae,
self.g_vars,
hparams=self._hparams.opt)
# Interface tensors
self.samples = {
"batch_size": get_batch_size(self.inputs['text_ids']),
"original": self.inputs['text_ids'][:, 1:],
"transferred": self.outputs.sample_id #outputs 是infer_greedy的结果
}
############################ female sentiment regression model
#现在只用了convnet不知道效果，之后可以试试RNN decoding看regression的准确度，或者把两个结合一下（concat成一个向量）
self.fconvnet = Conv1DNetwork(
hparams=self._hparams.convnet
) #[batch_size, time_steps, embedding_dim] (default input)
#convnet = Conv1DNetwork()
self.freg_embedder = WordEmbedder(
vocab_size=self.vocab.size, hparams=self._hparams.embedder
) #(64, 26, 100) (output shape of clas_embedder(ids=inputs['text_ids'][:, 1:]))
self.fconv_output = self.fconvnet(inputs=self.freg_embedder(
ids=self.finputs['text_ids'][:, 1:])) #(64, 128) 等一会做一下finputs!!!
p = {"type": "Dense", "kwargs": {'units': 1}}
self.fdense_layer = tx.core.layers.get_layer(hparams=p)
self.freg_output = self.fdense_layer(inputs=self.fconv_output)
'''
#考虑
self.fenc_text_ids = self.finputs['text_ids'][:, 1:]
self.fencoder = UnidirectionalRNNEncoder(hparams=self._hparams.encoder) #GRU cell
self.fenc_outputs, self.ffinal_state = self.fencoder(self.freg_embedder(self.fenc_text_ids),sequence_length=self.finputs['length']-1)
self.freg_output = self.fdense_layer(inputs = tf.concat([self.fconv_output, self.ffinal_state], -1))
'''
self.fprediction = tf.reshape(self.freg_output, [-1])
self.fground_truth = tf.to_float(self.finputs['labels'])
self.floss_reg_single = tf.pow(
self.fprediction - self.fground_truth,
2) #这样得到的是单个的loss,可以之后在RL里面对一整个batch进行update
self.floss_reg_batch = tf.reduce_mean(
self.floss_reg_single) #对一个batch求和平均的loss
#self.freg_vars = collect_trainable_variables([self.freg_embedder, self.fconvnet, self.fencoder, self.fdense_layer])
self.freg_vars = collect_trainable_variables(
[self.freg_embedder, self.fconvnet, self.fdense_layer])
self.ftrain_op_d = get_train_op(self.floss_reg_batch,
self.freg_vars,
hparams=self._hparams.opt)
self.freg_sample = {
"fprediction": self.fprediction,
"fground_truth": self.fground_truth,
"fsent": self.finputs['text_ids'][:, 1:]
}
############################ male sentiment regression model
self.mconvnet = Conv1DNetwork(
hparams=self._hparams.convnet
) #[batch_size, time_steps, embedding_dim] (default input)
#convnet = Conv1DNetwork()
self.mreg_embedder = WordEmbedder(
vocab_size=self.vocab.size, hparams=self._hparams.embedder
) #(64, 26, 100) (output shape of clas_embedder(ids=inputs['text_ids'][:, 1:]))
self.mconv_output = self.mconvnet(inputs=self.mreg_embedder(
ids=self.minputs['text_ids'][:, 1:])) #(64, 128)
p = {"type": "Dense", "kwargs": {'units': 1}}
self.mdense_layer = tx.core.layers.get_layer(hparams=p)
self.mreg_output = self.mdense_layer(inputs=self.mconv_output)
'''
#考虑
self.menc_text_ids = self.minputs['text_ids'][:, 1:]
self.mencoder = UnidirectionalRNNEncoder(hparams=self._hparams.encoder) #GRU cell
self.menc_outputs, self.mfinal_state = self.mencoder(self.mreg_embedder(self.menc_text_ids),sequence_length=self.minputs['length']-1)
self.mreg_output = self.mdense_layer(inputs = tf.concat([self.mconv_output, self.mfinal_state], -1))
'''
self.mprediction = tf.reshape(self.mreg_output, [-1])
self.mground_truth = tf.to_float(self.minputs['labels'])
self.mloss_reg_single = tf.pow(
self.mprediction - self.mground_truth,
2) #这样得到的是单个的loss,可以之后在RL里面对一整个batch进行update
self.mloss_reg_batch = tf.reduce_mean(
self.mloss_reg_single) #对一个batch求和平均的loss
#self.mreg_vars = collect_trainable_variables([self.mreg_embedder, self.mconvnet, self.mencoder, self.mdense_layer])
self.mreg_vars = collect_trainable_variables(
[self.mreg_embedder, self.mconvnet, self.mdense_layer])
self.mtrain_op_d = get_train_op(self.mloss_reg_batch,
self.mreg_vars,
hparams=self._hparams.opt)
self.mreg_sample = {
"mprediction": self.mprediction,
"mground_truth": self.mground_truth,
"msent": self.minputs['text_ids'][:, 1:]
}
###### get self.pre_dif when doing RL training (for transferred sents)
### pass to female regression model
self.RL_fconv_output = self.fconvnet(inputs=self.freg_embedder(
ids=self.outputs.sample_id)) #(64, 128) 等一会做一下finputs!!!
self.RL_freg_output = self.fdense_layer(inputs=self.RL_fconv_output)
self.RL_fprediction = tf.reshape(self.RL_freg_output, [-1])
### pass to male regression model
self.RL_mconv_output = self.mconvnet(inputs=self.mreg_embedder(
ids=self.outputs.sample_id)) #(64, 128) 等一会做一下finputs!!!
self.RL_mreg_output = self.mdense_layer(inputs=self.RL_mconv_output)
self.RL_mprediction = tf.reshape(self.RL_mreg_output, [-1])
self.pre_dif = tf.abs(self.RL_fprediction - self.RL_mprediction)
###### get self.Ypre_dif for original sents
### pass to female regression model
self.YRL_fconv_output = self.fconvnet(inputs=self.freg_embedder(
ids=self.inputs['text_ids'][:, 1:])) #(64, 128) 等一会做一下finputs!!!
self.YRL_freg_output = self.fdense_layer(inputs=self.YRL_fconv_output)
self.YRL_fprediction = tf.reshape(self.YRL_freg_output, [-1])
### pass to male regression model
self.YRL_mconv_output = self.mconvnet(inputs=self.mreg_embedder(
ids=self.inputs['text_ids'][:, 1:])) #(64, 128) 等一会做一下finputs!!!
self.YRL_mreg_output = self.mdense_layer(inputs=self.YRL_mconv_output)
self.YRL_mprediction = tf.reshape(self.YRL_mreg_output, [-1])
self.Ypre_dif = tf.abs(self.YRL_fprediction - self.YRL_mprediction)
######################## RL training
'''
def fil(elem):
return tf.where(elem > 1.3, tf.minimum(elem,3), 0)
def fil_pushsmall(elem):
return tf.add(tf.where(elem <0.5, 1, 0),tf.where(elem>1.5,-0.5*elem,0))
'''
'''
#缩小prediction差异
def fil1(elem):
return tf.where(elem<0.5,1.0,0.0)
def fil2(elem):
return tf.where(elem>1.5,-0.5*elem,0.0)
'''
#扩大prediction差异
def fil1(elem):
return tf.where(elem < 0.5, -0.01, 0.0)
def fil2(elem):
return tf.where(elem > 1.3, elem, 0.0)
# 维数是(batch_size,time_step),对应的是一个batch中每一个sample的每一个timestep的loss
self.beginning_loss_g_RL2 = tf.nn.sparse_softmax_cross_entropy_with_logits(
_sentinel=None,
labels=self.outputs.sample_id,
logits=self.outputs.logits,
name=None)
self.middle_loss_g_RL2 = tf.reduce_sum(
self.beginning_loss_g_RL2, axis=1
) #(batch_size,),这样得到的loss是每一个句子的loss(对time_steps求和，对batch不求和)
#trivial "RL" training with all weight set to 1
#final_loss_g_RL2 = tf.reduce_sum(self.middle_loss_g_RL2)
#RL training
self.filtered = tf.add(tf.map_fn(fil1, self.pre_dif),
tf.map_fn(fil2, self.pre_dif))
self.updated_loss_per_sent = tf.multiply(
self.filtered,
self.middle_loss_g_RL2) #haven't set threshold for weight update
self.updated_loss_per_batch = tf.reduce_sum(
self.updated_loss_per_sent) #############！！有一个问题：
# 我想update每一个句子的loss,但是train_updated那里会报错，所以好像只能updateloss的求和，这样是相当于update每一个句子的loss吗？
self.vars_updated = collect_trainable_variables(
[self.connector, self.decoder])
self.train_updated = get_train_op(self.updated_loss_per_batch,
self.vars_updated,
hparams=self._hparams.opt)
self.train_updated_interface = {
"pre_dif": self.pre_dif,
"updated_loss_per_sent": self.updated_loss_per_sent,
"updated_loss_per_batch": self.updated_loss_per_batch,
}
### Train AE and RL together
self.loss_AERL = gamma * self.updated_loss_per_batch + self.loss_g_ae
self.vars_AERL = collect_trainable_variables(
[self.connector, self.decoder])
self.train_AERL = get_train_op(self.loss_AERL,
self.vars_AERL,
hparams=self._hparams.opt)
def _get_loss_train_op(self):
# Aggregates losses
self.loss_g = self.loss_g_ae + self.lambda_t_graph * self.loss_g_clas_graph + self.lambda_t_sentence * self.loss_g_clas_sentence
# possible ablation: SGT-I, CGT-I, SGT-CGT-I, c-clas-g-only, c-clas-s-only
if self.ablation == 'c-clas-g-only':
self.loss_d = self.loss_d_clas_graph
elif self.ablation == 'c-clas-s-only':
self.loss_d = self.loss_d_clas_sentence
else:
self.loss_d = self.loss_d_clas_graph + self.loss_d_clas_sentence
# Creates optimizers
self.g_vars = collect_trainable_variables([
self.embedder, self.self_graph_encoder, self.label_connector,
self.cross_graph_encoder, self.rephrase_encoder,
self.rephrase_decoder
])
self.d_vars = collect_trainable_variables([
self.clas_embedder, self.classifier_graph, self.classifier_sentence
])
self.train_op_g = get_train_op(self.loss_g,
self.g_vars,
hparams=self._hparams.opt)
self.train_op_g_ae = get_train_op(self.loss_g_ae,
self.g_vars,
hparams=self._hparams.opt)
self.train_op_d = get_train_op(self.loss_d,
self.d_vars,
hparams=self._hparams.opt)
# Interface tensors
self.losses = {
"loss_g": self.loss_g,
"loss_d": self.loss_d,
"loss_g_ae": self.loss_g_ae,
"loss_g_clas_graph": self.loss_g_clas_graph,
"loss_g_clas_sentence": self.loss_g_clas_sentence,
"loss_d_clas_graph": self.loss_d_clas_graph,
"loss_d_clas_sentence": self.loss_d_clas_sentence,
}
self.metrics = {
"accu_d_graph": self.accu_d_graph,
"accu_d_sentence": self.accu_d_sentence,
"accu_g_graph": self.accu_g_graph,
"accu_g_sentence": self.accu_g_sentence,
"accu_g_gdy_sentence": self.accu_g_gdy_sentence
}
self.train_ops = {
"train_op_g": self.train_op_g,
"train_op_g_ae": self.train_op_g_ae,
"train_op_d": self.train_op_d
}
self.samples = {
"original": self.text_ids[:, 1:],
"transferred": self.rephrase_outputs_.sample_id
}
self.fetches_train_g = {
"loss_g": self.train_ops["train_op_g"],
"loss_g_ae": self.losses["loss_g_ae"],
"loss_g_clas_graph": self.losses["loss_g_clas_graph"],
"loss_g_clas_sentence": self.losses["loss_g_clas_sentence"],
"accu_g_graph": self.metrics["accu_g_graph"],
"accu_g_sentence": self.metrics["accu_g_sentence"],
"accu_g_gdy_sentence": self.metrics["accu_g_gdy_sentence"]
# 'adjs': self.adjs,
# 'identities': self.identities
}
self.fetches_train_d = {
"loss_d": self.train_ops["train_op_d"],
"loss_d_clas_graph": self.losses["loss_d_clas_graph"],
"loss_d_clas_sentence": self.losses["loss_d_clas_sentence"],
"accu_d_graph": self.metrics["accu_d_graph"],
"accu_d_sentence": self.metrics["accu_d_sentence"]
# 'adjs': self.adjs,
# 'identities': self.identities
}
fetches_eval = {"batch_size": get_batch_size(self.text_ids)}
fetches_eval.update(self.losses)
fetches_eval.update(self.metrics)
fetches_eval.update(self.samples)
self.fetches_eval = fetches_eval
def _get_loss_train_op(self):
# Aggregates loss
loss_rephraser = (tf.get_collection('loss_rephraser_list')[0] + tf.get_collection('loss_rephraser_list')[1] + tf.get_collection('loss_rephraser_list')[2])/3.
w_recon = 1.0
w_fine = 0.5
w_xx2 = 0.0
self.loss = loss_rephraser + w_fine*self.loss_fine + w_recon*self.loss_mask_recon #+ w_xx2*self.loss_xx2###check逐量级修改
# Creates optimizers
self.vars = collect_trainable_variables([self.transformer_encoder, self.word_embedder, self.self_graph_encoder,
self.downmlp, self.PRelu, self.rephrase_encoder, self.rephrase_decoder])
# Train Op
self.train_op_pre = get_train_op(
self.loss, self.vars, hparams=self._hparams.opt)#learning_rate=self.lr
# Interface tensors
self.losses = {
"loss": self.loss,
"loss_rephraser": loss_rephraser,
"loss_fine":self.loss_fine,
"loss_mask_recon":self.loss_mask_recon,
"loss_xx2": self.loss_xx2,
}
self.metrics = {
}
self.train_ops = {
"train_op_pre": self.train_op_pre,
}
self.samples = {
"transferred_yy1_gt": self.text_ids_yy1,
"transferred_yy1_pred": tf.get_collection('yy_pred_list')[0],
"transferred_yy2_gt": self.text_ids_yy2,
"transferred_yy2_pred": tf.get_collection('yy_pred_list')[1],
"transferred_yy3_gt": self.text_ids_yy3,
"transferred_yy3_pred": tf.get_collection('yy_pred_list')[2],
"origin_y1":self.text_ids_y1,
"origin_y2":self.text_ids_y2,
"origin_y3":self.text_ids_y3,
"x1x2":self.x1x2,
"x1xx2":self.x1xx2
}
tf.summary.scalar("loss", self.loss)
tf.summary.scalar("loss_rephraser", loss_rephraser)
tf.summary.scalar("loss_fine", self.loss_fine)
tf.summary.scalar("loss_mask_recon", self.loss_mask_recon)
tf.summary.scalar("loss_xx2", self.loss_xx2)
self.merged = tf.summary.merge_all()
self.fetches_train_pre = {
"loss": self.train_ops["train_op_pre"],
"loss_rephraser": self.losses["loss_rephraser"],
"loss_fine": self.losses["loss_fine"],
"loss_mask_recon": self.losses["loss_mask_recon"],
"loss_xx2": self.losses["loss_xx2"],
"merged": self.merged,
}
fetches_eval = {"batch_size": get_batch_size(self.x1x2yx1xx2_ids),
"merged": self.merged,
}
fetches_eval.update(self.losses)
fetches_eval.update(self.metrics)
fetches_eval.update(self.samples)
self.fetches_eval = fetches_eval
def _get_loss_train_op(self):
# Aggregates losses
self.loss_g = self.loss_g_ae + self.lambda_g_graph * self.loss_g_clas_graph + self.lambda_g_sentence * self.loss_g_clas_sentence + self.loss_trans_adj + self.loss_ori_adj
self.loss_d = self.loss_d_clas_graph + self.loss_d_clas_sentence + self.loss_ori_adj
# Creates optimizers
self.g_vars = collect_trainable_variables([
self.embedder, self.self_graph_encoder, self.label_connector,
self.cross_graph_encoder, self.rephrase_encoder,
self.rephrase_decoder
])
self.d_vars = collect_trainable_variables([
self.clas_embedder, self.classifier_graph,
self.classifier_sentence, self.adj_embedder, self.adj_encoder,
self.conv1d_1, self.conv1d_2, self.bn1, self.conv1d_3, self.bn2,
self.conv1d_4, self.bn3, self.conv1d_5
])
self.train_op_g = get_train_op(self.loss_g,
self.g_vars,
hparams=self._hparams.opt)
self.train_op_g_ae = get_train_op(self.loss_g_ae,
self.g_vars,
hparams=self._hparams.opt)
self.train_op_d = get_train_op(self.loss_d,
self.d_vars,
hparams=self._hparams.opt)
# Interface tensors
self.losses = {
"loss_g": self.loss_g,
"loss_d": self.loss_d,
"loss_g_ae": self.loss_g_ae,
"loss_g_clas_graph": self.loss_g_clas_graph,
"loss_g_clas_sentence": self.loss_g_clas_sentence,
"loss_d_clas_graph": self.loss_d_clas_graph,
"loss_d_clas_sentence": self.loss_d_clas_sentence,
"loss_ori_adj": self.loss_ori_adj,
"loss_trans_adj": self.loss_trans_adj,
}
self.metrics = {
"accu_d_graph": self.accu_d_graph,
"accu_d_sentence": self.accu_d_sentence,
"accu_g_graph": self.accu_g_graph,
"accu_g_sentence": self.accu_g_sentence,
"accu_g_gdy_sentence": self.accu_g_gdy_sentence,
"accu_ori_adj": self.accu_ori_adj,
"accu_trans_adj": self.accu_trans_adj
}
self.train_ops = {
"train_op_g": self.train_op_g,
"train_op_g_ae": self.train_op_g_ae,
"train_op_d": self.train_op_d
}
self.samples = {
"original": self.text_ids[:, 1:],
"transferred": self.rephrase_outputs_.sample_id
}
self.fetches_train_g = {
"loss_g": self.train_ops["train_op_g"],
"loss_g_ae": self.losses["loss_g_ae"],
"loss_g_clas_graph": self.losses["loss_g_clas_graph"],
"loss_g_clas_sentence": self.losses["loss_g_clas_sentence"],
"loss_ori_adj": self.losses["loss_ori_adj"],
"loss_trans_adj": self.losses["loss_trans_adj"],
"accu_g_graph": self.metrics["accu_g_graph"],
"accu_g_sentence": self.metrics["accu_g_sentence"],
"accu_ori_adj": self.metrics["accu_ori_adj"],
"accu_trans_adj": self.metrics["accu_trans_adj"],
"adjs_truth": self.adjs[:, 1:, 1:],
"adjs_preds": self.pred_trans_adjs_binary,
}
self.fetches_train_d = {
"loss_d": self.train_ops["train_op_d"],
"loss_d_clas_graph": self.losses["loss_d_clas_graph"],
"loss_d_clas_sentence": self.losses["loss_d_clas_sentence"],
"loss_ori_adj": self.losses["loss_ori_adj"],
"accu_d_graph": self.metrics["accu_d_graph"],
"accu_d_sentence": self.metrics["accu_d_sentence"],
"accu_ori_adj": self.metrics["accu_ori_adj"],
"adjs_truth": self.adjs[:, 1:, 1:],
"adjs_preds": self.pred_ori_adjs_binary,
}
fetches_eval = {"batch_size": get_batch_size(self.text_ids)}
fetches_eval.update(self.losses)
fetches_eval.update(self.metrics)
fetches_eval.update(self.samples)
self.fetches_eval = fetches_eval
def _build_model(self, inputs, vocab, gamma, lambda_g, lambda_z, lambda_z1,
lambda_z2, lambda_ae):
embedder = WordEmbedder(vocab_size=vocab.size,
hparams=self._hparams.embedder)
encoder = UnidirectionalRNNEncoder(hparams=self._hparams.encoder)
enc_text_ids = inputs['text_ids'][:, 1:]
enc_outputs, final_state = encoder(embedder(enc_text_ids),
sequence_length=inputs['length'] -
1)
z = final_state[:, self._hparams.dim_c:]
# -------------------- CLASSIFIER ---------------------
n_classes = self._hparams.num_classes
z_classifier_l1 = MLPTransformConnector(
256, hparams=self._hparams.z_classifier_l1)
z_classifier_l2 = MLPTransformConnector(
64, hparams=self._hparams.z_classifier_l2)
z_classifier_out = MLPTransformConnector(
n_classes if n_classes > 2 else 1)
z_logits = z_classifier_l1(z)
z_logits = z_classifier_l2(z_logits)
z_logits = z_classifier_out(z_logits)
z_pred = tf.greater(z_logits, 0)
z_logits = tf.reshape(z_logits, [-1])
z_pred = tf.to_int64(tf.reshape(z_pred, [-1]))
loss_z_clas = tf.nn.sigmoid_cross_entropy_with_logits(
labels=tf.to_float(inputs['labels']), logits=z_logits)
loss_z_clas = tf.reduce_mean(loss_z_clas)
accu_z_clas = tx.evals.accuracy(labels=inputs['labels'], preds=z_pred)
# -------------------________________---------------------
label_connector = MLPTransformConnector(self._hparams.dim_c)
labels = tf.to_float(tf.reshape(inputs['labels'], [-1, 1]))
c = label_connector(labels)
c_ = label_connector(1 - labels)
h = tf.concat([c, z], 1)
h_ = tf.concat([c_, z], 1)
# Teacher-force decoding and the auto-encoding loss for G
decoder = AttentionRNNDecoder(
memory=enc_outputs,
memory_sequence_length=inputs['length'] - 1,
cell_input_fn=lambda inputs, attention: inputs,
vocab_size=vocab.size,
hparams=self._hparams.decoder)
connector = MLPTransformConnector(decoder.state_size)
g_outputs, _, _ = decoder(initial_state=connector(h),
inputs=inputs['text_ids'],
embedding=embedder,
sequence_length=inputs['length'] - 1)
loss_g_ae = tx.losses.sequence_sparse_softmax_cross_entropy(
labels=inputs['text_ids'][:, 1:],
logits=g_outputs.logits,
sequence_length=inputs['length'] - 1,
average_across_timesteps=True,
sum_over_timesteps=False)
# Gumbel-softmax decoding, used in training
start_tokens = tf.ones_like(inputs['labels']) * vocab.bos_token_id
end_token = vocab.eos_token_id
gumbel_helper = GumbelSoftmaxEmbeddingHelper(embedder.embedding,
start_tokens, end_token,
gamma)
soft_outputs_, _, soft_length_, = decoder(helper=gumbel_helper,
initial_state=connector(h_))
soft_outputs, _, soft_length, = decoder(helper=gumbel_helper,
initial_state=connector(h))
# ---------------------------- SHIFTED LOSS -------------------------------------
_, encoder_final_state_ = encoder(
embedder(soft_ids=soft_outputs_.sample_id),
sequence_length=inputs['length'] - 1)
_, encoder_final_state = encoder(
embedder(soft_ids=soft_outputs.sample_id),
sequence_length=inputs['length'] - 1)
new_z_ = encoder_final_state_[:, self._hparams.dim_c:]
new_z = encoder_final_state[:, self._hparams.dim_c:]
cos_distance_z_ = tf.abs(
tf.losses.cosine_distance(tf.nn.l2_normalize(z, axis=1),
tf.nn.l2_normalize(new_z_, axis=1),
axis=1))
cos_distance_z = tf.abs(
tf.losses.cosine_distance(tf.nn.l2_normalize(z, axis=1),
tf.nn.l2_normalize(new_z, axis=1),
axis=1))
# ----------------------------______________-------------------------------------
# Greedy decoding, used in eval
outputs_, _, length_ = decoder(decoding_strategy='infer_greedy',
initial_state=connector(h_),
embedding=embedder,
start_tokens=start_tokens,
end_token=end_token)
# Creates classifier
classifier = Conv1DClassifier(hparams=self._hparams.classifier)
clas_embedder = WordEmbedder(vocab_size=vocab.size,
hparams=self._hparams.embedder)
# Classification loss for the classifier
clas_logits, clas_preds = classifier(
inputs=clas_embedder(ids=inputs['text_ids'][:, 1:]),
sequence_length=inputs['length'] - 1)
loss_d_clas = tf.nn.sigmoid_cross_entropy_with_logits(
labels=tf.to_float(inputs['labels']), logits=clas_logits)
loss_d_clas = tf.reduce_mean(loss_d_clas)
accu_d = tx.evals.accuracy(labels=inputs['labels'], preds=clas_preds)
# Classification loss for the generator, based on soft samples
soft_logits, soft_preds = classifier(
inputs=clas_embedder(soft_ids=soft_outputs_.sample_id),
sequence_length=soft_length_)
loss_g_clas = tf.nn.sigmoid_cross_entropy_with_logits(
labels=tf.to_float(1 - inputs['labels']), logits=soft_logits)
loss_g_clas = tf.reduce_mean(loss_g_clas)
# Accuracy on soft samples, for training progress monitoring
accu_g = tx.evals.accuracy(labels=1 - inputs['labels'],
preds=soft_preds)
# Accuracy on greedy-decoded samples, for training progress monitoring
_, gdy_preds = classifier(inputs=clas_embedder(ids=outputs_.sample_id),
sequence_length=length_)
accu_g_gdy = tx.evals.accuracy(labels=1 - inputs['labels'],
preds=gdy_preds)
# Aggregates losses
loss_g = lambda_ae * loss_g_ae + \
lambda_g * loss_g_clas + \
lambda_z1 * cos_distance_z + cos_distance_z_ * lambda_z2 \
- lambda_z * loss_z_clas
loss_d = loss_d_clas
loss_z = loss_z_clas
# Creates optimizers
g_vars = collect_trainable_variables(
[embedder, encoder, label_connector, connector, decoder])
d_vars = collect_trainable_variables([clas_embedder, classifier])
z_vars = collect_trainable_variables(
[z_classifier_l1, z_classifier_l2, z_classifier_out])
train_op_g = get_train_op(loss_g, g_vars, hparams=self._hparams.opt)
train_op_g_ae = get_train_op(loss_g_ae,
g_vars,
hparams=self._hparams.opt)
train_op_d = get_train_op(loss_d, d_vars, hparams=self._hparams.opt)
train_op_z = get_train_op(loss_z, z_vars, hparams=self._hparams.opt)
# Interface tensors
self.losses = {
"loss_g": loss_g,
"loss_g_ae": loss_g_ae,
"loss_g_clas": loss_g_clas,
"loss_d": loss_d_clas,
"loss_z_clas": loss_z_clas,
"loss_cos_": cos_distance_z_,
"loss_cos": cos_distance_z
}
self.metrics = {
"accu_d": accu_d,
"accu_g": accu_g,
"accu_g_gdy": accu_g_gdy,
"accu_z_clas": accu_z_clas
}
self.train_ops = {
"train_op_g": train_op_g,
"train_op_g_ae": train_op_g_ae,
"train_op_d": train_op_d,
"train_op_z": train_op_z
}
self.samples = {
"original": inputs['text_ids'][:, 1:],
"transferred": outputs_.sample_id,
"z_vector": z,
"labels_source": inputs['labels'],
"labels_target": 1 - inputs['labels'],
"labels_predicted": gdy_preds
}
self.fetches_train_g = {
"loss_g": self.train_ops["train_op_g"],
"loss_g_ae": self.losses["loss_g_ae"],
"loss_g_clas": self.losses["loss_g_clas"],
"loss_shifted_ae1": self.losses["loss_cos"],
"loss_shifted_ae2": self.losses["loss_cos_"],
"accu_g": self.metrics["accu_g"],
"accu_g_gdy": self.metrics["accu_g_gdy"],
"accu_z_clas": self.metrics["accu_z_clas"]
}
self.fetches_train_z = {
"loss_z": self.train_ops["train_op_z"],
"accu_z": self.metrics["accu_z_clas"]
}
self.fetches_train_d = {
"loss_d": self.train_ops["train_op_d"],
"accu_d": self.metrics["accu_d"]
}
fetches_eval = {"batch_size": get_batch_size(inputs['text_ids'])}
fetches_eval.update(self.losses)
fetches_eval.update(self.metrics)
fetches_eval.update(self.samples)
self.fetches_eval = fetches_eval
