def override_parameters(params, args):
params.dev_params = args.dev_params
params.model = args.model
params.input = args.input or params.input
params.output = args.output or params.output
params.vocab = args.vocab or params.vocab
params.validation = args.validation or params.validation
params.references = args.references or params.references
params.parse(args.parameters)
vocab_dir = os.path.dirname(params.vocab[0])
params.vocabulary = {
"source":
vocab.load_vocab(params.vocab[0], params),
"target":
vocab.load_vocab(params.vocab[1], params),
"lf":
vocab.load_vocab(os.path.join(vocab_dir, 'vocab-lf.txt'), params),
"sketch":
vocab.load_vocab(os.path.join(vocab_dir, 'vocab-sketch.txt'), params)
}
if params.use_pretrained_embedding:
params.init_word_matrix = vocab.load_word_matrix(args.vocab[0])
return params
def override_parameters(params, args):
params.input = args.input or params.input
params.output = args.output or params.output
params.vocab = args.vocab
params.parse(args.parameters)
params.vocabulary = {
"source": vocab.load_vocab(args.vocab[0]),
"target": vocab.load_vocab(args.vocab[1])
}
return params
def override_parameters(params, args):
params.model = args.model
params.input = args.input or params.input
params.output = args.output or params.output
params.vocab = args.vocab or params.vocab
params.validation = args.validation or params.validation
params.references = args.references or params.references
params.parse(args.parameters)
params.vocabulary = {
"source": vocab.load_vocab(params.vocab[0]),
"target": vocab.load_vocab(params.vocab[1])
}
return params
def override_parameters(params, args):
params.input = args.input or params.input
params.output = args.output or params.output
params.vocab = args.vocab
if params.use_pretrained_embedding:
params.embeddings = args.embeddings or params.embeddings
params.parse(args.parameters)
params.vocabulary = {
"source": vocab.load_vocab(args.vocab[0]),
"memory": vocab.load_vocab(args.vocab[1]),
"target": vocab.load_vocab(args.vocab[2])
}
return params
def main(input_file, vocab):
token2idx, idx2token = load_vocab(vocab)
with open(input_file) as f:
for line in f:
line = line.strip().split()
for token in line:
if token not in token2idx.keys():
print(token)
sys.exit()
def main():
from utils.vocab import load_vocab
from utils.math_numpy import softmax
token2idx, idx2token = load_vocab(
'/Users/easton/Documents/vocab_3673+1.txt')
vocab = token2idx.keys()
table_value = homophone_table(vocab)
# print(table_value, table_value.shape)
target_distributions = softmax(table_value)
m = target_distributions[10]
print(m[m > 0])
# import pdb; pdb.set_trace()
print('asd')
def testRNADecode():
import pickle
from utils.vocab import load_vocab
_, idx2token = load_vocab(
'/Users/easton/Projects/eastonCode/examples/decode/vocab_3673+1.txt')
with open('/Users/easton/Projects/eastonCode/examples/decode/distribution.txt', 'rb') as f,\
open('/Users/easton/Projects/eastonCode/examples/decode/dev_rna_res.txt', 'w') as fw:
while True:
try:
res, _ = rna_decode(pickle.load(f),
beam_size=10,
prune=0.0002,
alpha=0.30,
beta=5)
# res, _ = ctc_decode(pickle.load(f), beam_size=1)
res = ' '.join(idx2token[id] for id in res)
print(res)
fw.write(res + '\n')
except EOFError:
break
intent_train_set = IntentDataset(train_file)
# get initial samples
initial_samples = active_learning.get_balanced_sample_indices(
intent_train_set.targets,
num_classes=num_classes,
n_per_digit=num_initial_samples // num_classes)
# build active learning data
active_learning_data = active_learning.ActiveLearningData(intent_train_set)
active_learning_data.acquire(initial_samples)
# build train generator
if model_type == 'bert':
vocabulary = load_vocab()
train_generator = data_generator_2.DataGenerator(
active_learning_data.training_dataset,
training_args.batch_size,
data_args,
vocabulary,
intent_labels,
shuffle=True)
pool_generator = data_generator_2.DataGenerator(
active_learning_data.pool_dataset, pool_batch_size, data_args,
vocabulary, intent_labels)
train_2.train_main(train_generator)
else:
vocabulary, id2embeddings = load_vocab_w2v()
train_generator = data_generator_2.DataGeneratorW2V(
int(i) for i in args.bucket_boundaries.split(',')
]
else:
args.list_bucket_boundaries = [
i for i in range(args.size_bucket_start, args.size_bucket_end,
args.size_bucket_gap)
]
assert args.num_batch_tokens
args.list_batch_size = ([
int(args.num_batch_tokens / boundary) * args.num_gpus
for boundary in (args.list_bucket_boundaries)
] + [args.num_gpus])
logging.info('\nbucket_boundaries: {} \nbatch_size: {}'.format(
args.list_bucket_boundaries, args.list_batch_size))
# vocab
args.token2idx, args.idx2token = load_vocab(args.dirs.vocab)
args.dim_output = len(args.token2idx)
if '<eos>' in args.token2idx.keys():
args.eos_idx = args.token2idx['<eos>']
else:
args.eos_idx = None
if '<sos>' in args.token2idx.keys():
args.sos_idx = args.token2idx['<sos>']
elif '<blk>' in args.token2idx.keys():
args.sos_idx = args.token2idx['<blk>']
else:
args.sos_idx = None
if result_dir is not None:
dst_f1.close()
dst_f2.close()
return [result_save_path1, result_save_path2]
if __name__ == "__main__":
args = load_s2ss_arguments()
# Step 1: build vocab and load data
print("Sharing vocabulary")
if not os.path.isfile(args.vocab_file):
build_vocab_from_file(args.train_data, args.vocab_file)
print("Build vocabulary")
vocab, vocab_size = load_vocab(args.vocab_file)
print('Vocabulary size:%s' % vocab_size)
vocab_rev = tf.contrib.lookup.index_to_string_table_from_file(
args.vocab_file, # target vocabulary file(each lines has a word)
vocab_size=vocab_size - constants.NUM_OOV_BUCKETS,
default_value=constants.UNKNOWN_TOKEN)
with tf.device(
"/cpu:0"): # Input pipeline should always be place on the CPU.
print("args.pseudo_data:", args.pseudo_data)
if args.mode == "train":
train_iterator = load_paired_dataset(args.pseudo_data,
vocab,
if args.dirs.lm_config:
from utils.configReader import AttrDict
import yaml
args.args_lm = AttrDict(yaml.load(open(args.dirs.lm_config)))
args.args_lm.dim_output = len(args.token2idx)
args.args_lm.list_gpus = args.list_gpus
from tfSeq2SeqModels.languageModel import LanguageModel
args.Model_LM = LanguageModel
# vocab
logging.info('using vocab: {}'.format(args.dirs.vocab))
if args.dirs.vocab_pinyin:
from utils.vocab import load_vocab
logging.info('using pinyin vocab: {}'.format(args.dirs.vocab_pinyin))
args.phone.token2idx, args.phone.idx2token = load_vocab(
args.dirs.vocab_pinyin)
args.phone.dim_output = len(args.phone.token2idx)
args.phone.eos_idx = None
args.phone.sos_idx = args.phone.token2idx['<blk>']
def read_tfdata_info(dir_tfdata):
data_info = {}
with open(dir_tfdata / 'tfdata.info') as f:
for line in f:
if 'dim_feature' in line or \
'num_tokens' in line or \
'size_dataset' in line:
line = line.strip().split(' ')
data_info[line[0]] = int(line[1])
def convert_data(train_PATH, valid_PATH, test_PATH, word_vocab_PATH,
position_vocab_PATH, tag_vocab_PATH, out_DIR):
train_ys, train_codes, train_times = pkl.load(open(train_PATH, 'rb'))
valid_ys, valid_codes, valid_times = pkl.load(open(valid_PATH, 'rb'))
test_ys, test_codes, test_times = pkl.load(open(test_PATH, 'rb'))
word_vocab = load_vocab(word_vocab_PATH)
position_vocab_PATH = load_vocab(position_vocab_PATH)
tag_vocab_PATH = load_vocab(tag_vocab_PATH, mode="tag")
print("Vocabuary size for word, position and tags are {}, {}, {}".format(
len(word_vocab), len(position_vocab_PATH), len(tag_vocab_PATH)))
train_visits, train_labels, train_days = [], [], []
valid_visits, valid_labels, valid_days = [], [], []
test_visits, test_labels, test_days = [], [], []
train_counter = {"case": 0, "control": 0}
valid_counter = {"case": 0, "control": 0}
test_counter = {"case": 0, "control": 0}
# traverse each train patient
for index, (y, patient_codes, patient_times) in enumerate(
zip(train_ys, train_codes, train_times)):
train_visits.append(make_visits(patient_codes, word_vocab))
train_labels.append(y)
key = "case" if y == 1 else "control"
train_counter[key] += 1
train_days.append(make_days(patient_times))
# valid
for index, (y, patient_codes, patient_times) in enumerate(
zip(valid_ys, valid_codes, valid_times)):
valid_visits.append(make_visits(patient_codes, word_vocab))
valid_labels.append(y)
key = "case" if y == 1 else "control"
valid_counter[key] += 1
valid_days.append(make_days(patient_times))
# test
for index, (y, patient_codes, patient_times) in enumerate(
zip(test_ys, test_codes, test_times)):
test_visits.append(make_visits(patient_codes, word_vocab))
test_labels.append(y)
key = "case" if y == 1 else "control"
test_counter[key] += 1
test_days.append(make_days(patient_times))
pkl_train_visit_file = open(out_DIR + 'visits.train', 'wb')
pkl_valid_visit_file = open(out_DIR + 'visits.valid', 'wb')
pkl_test_visit_file = open(out_DIR + 'visits.test', 'wb')
pkl_train_label_file = open(out_DIR + 'labels.train', 'wb')
pkl_valid_label_file = open(out_DIR + 'labels.valid', 'wb')
pkl_test_label_file = open(out_DIR + 'labels.test', 'wb')
pkl_train_day_file = open(out_DIR + 'days.train', 'wb')
pkl_valid_day_file = open(out_DIR + 'days.valid', 'wb')
pkl_test_day_file = open(out_DIR + 'days.test', 'wb')
print(
'In total converted {}, {}, {} train, valid, and test samples'.format(
len(train_labels), len(valid_labels), len(test_labels)))
print(
'In which the distributions of cases and controls for train, valid and test are\n\t{}\t{}\t{}\t{}\t{}\t{}'
.format(train_counter['case'], train_counter['control'],
valid_counter['case'], valid_counter['control'],
test_counter['case'], test_counter['control']))
pkl.dump(train_visits, pkl_train_visit_file, protocol=2)
pkl.dump(valid_visits, pkl_valid_visit_file, protocol=2)
pkl.dump(test_visits, pkl_test_visit_file, protocol=2)
pkl.dump(train_labels, pkl_train_label_file, protocol=2)
pkl.dump(valid_labels, pkl_valid_label_file, protocol=2)
pkl.dump(test_labels, pkl_test_label_file, protocol=2)
pkl.dump(train_days, pkl_train_day_file, protocol=2)
pkl.dump(valid_days, pkl_valid_day_file, protocol=2)
pkl.dump(test_days, pkl_test_day_file, protocol=2)
def train_main(p):
in_file = Path(data_dir) / f'labeled_{p}.json' if isinstance(
p, int) else Path(common_data_path) / 'intent_data' / p
###############################################
# args
###############################################
@dataclass
class ModelArguments:
model_path_or_name: str = field(default=str(bert_model_path))
# model_path_or_name: str = field(default=str(roberta_model_path))
# model_path_or_name: str = field(default=str(Path(data_dir)/'checkpoints'/'checkpoint-6000'))
@dataclass
class DataTrainingArguments:
max_seq_length: int = field(default=200)
parser = HfArgumentParser(
(ModelArguments, DataTrainingArguments, TrainingArguments))
model_args, data_args, training_args = parser.parse_args_into_dataclasses()
global_step = 0
###############################################
# distant debug
###############################################
if training_args.server_ip and training_args.server_port:
import ptvsd
print('Waiting for debugger attach')
ptvsd.enable_attach(address='')
###############################################
# model
###############################################
num_labels = len(intent_labels)
config = AutoConfig.from_pretrained(
pretrained_model_name_or_path=model_args.model_path_or_name,
num_labels=num_labels)
model = BertForSequenceClassification.from_pretrained(
pretrained_model_name_or_path=model_args.model_path_or_name,
config=config,
num_labels=num_labels)
###############################################
# data process
###############################################
train = [(_['text'], _['label']) for _ in json.load(in_file.open())]
dev = [(_['text'], _['label'])
for _ in json.load((Path(common_data_path) / 'intent_data' /
'dev_data.json').open())]
vocabulary = load_vocab()
# vocabulary = load_vocab(vocab_file=(Path(roberta_model_path) / 'vocab.txt'))
train_loader = DataGenerator(train,
training_args,
data_args,
vocabulary,
intent_labels,
shuffle=True)
dev_loader = DataGenerator(dev, training_args, data_args, vocabulary,
intent_labels)
###############################################
# optimizer
###############################################
def get_optimizer(num_training_steps):
no_decay = ['bias', 'LayerNorm.weight']
optimize_group_params = [{
'params': [
p for n, p in model.named_parameters()
if not any(nd in n for nd in no_decay)
],
'weight_decay':
training_args.weight_decay
}, {
'params': [
p for n, p in model.named_parameters()
if any(nd in n for nd in no_decay)
],
'weight_decay':
0.0
}]
optimizer = AdamW(optimize_group_params,
lr=training_args.learning_rate,
weight_decay=training_args.weight_decay)
scheduler = get_linear_schedule_with_warmup(
optimizer,
num_warmup_steps=training_args.warmup_steps,
num_training_steps=num_training_steps)
return optimizer, scheduler
optimizer, scheduler = get_optimizer(num_training_steps=len(train_loader) *
training_args.epoch_num /
training_args.batch_size)
###############################################
# continue training from checkpoints
###############################################
if ('checkpoint' in model_args.model_path_or_name and os.path.isfile(
os.path.join(model_args.model_path_or_name, 'optimizer.pt'))
and os.path.isfile(
os.path.join(model_args.model_path_or_name, 'scheduler.pt'))):
optimizer.load_state_dict(
torch.load(
os.path.join(model_args.model_path_or_name, "optimizer.pt"),
map_location='cuda' if torch.cuda.is_available() else 'cpu'))
scheduler.load_state_dict(
torch.load(
os.path.join(model_args.model_path_or_name, "scheduler.pt"),
map_location='cuda' if torch.cuda.is_available() else 'cpu'))
epoch_trained = 0
step_trained_cur_epoch = 0
if 'checkpoint' in model_args.model_path_or_name:
global_step = int(
str(Path(
model_args.model_path_or_name)).split('-')[-1].split('/')[0])
epoch_trained = global_step // (
train_loader.steps // training_args.gradient_accumulation_steps)
step_trained_cur_epoch = global_step % (
train_loader.steps // training_args.gradient_accumulation_steps)
logger.info(
' Continuing Training from checkpoint, will skip to saved global_step'
)
logger.info(f' Continuing Training from epoch {epoch_trained}')
logger.info(f' Continuing Training from global step {global_step}')
logger.info(
f' Will skip the first {step_trained_cur_epoch} steps in the first epoch'
)
###############################################
# tensorboard
###############################################
tb_writer = SummaryWriter(log_dir=Path(data_dir) / 'logs')
def tb_log(logs):
for k_, v_ in logs.items():
tb_writer.add_scalar(k_, v_, global_step)
tb_writer.add_text('args', training_args.to_json_string())
tb_writer.add_hparams(training_args.to_sanitized_dict(), metric_dict={})
###############################################
# save
###############################################
def save_model(output_dir, model):
os.makedirs(output_dir, exist_ok=True)
logger.info(f'Saving model checkpoint to {output_dir}')
model_to_save = model.module if hasattr(model, 'module') else model
model_to_save.config.architectures = [
model_to_save.__class__.__name__
] # architectures是什么
output_model_file = os.path.join(output_dir, 'pytorch.bin')
torch.save(model_to_save.state_dict(), output_model_file)
logger.info(f'Model weights saved in {output_model_file}')
output_config_file = os.path.join(output_dir, 'config.json')
model_to_save.config.to_json_file(output_config_file)
logger.info(f'Configuration saved in {output_config_file}')
torch.save(training_args, os.path.join(output_dir,
'training_args.bin'))
def sorted_checkpoints(checkpoint_prefix="checkpoint", use_mtime=False):
ordering_and_checkpoint_path = []
glob_checkpoints = [
str(x) for x in Path(training_args.output_dir).glob(
f"{checkpoint_prefix}-*")
]
for path in glob_checkpoints:
if use_mtime:
ordering_and_checkpoint_path.append(
(os.path.getmtime(path), path))
else:
regex_match = re.match(f".*{checkpoint_prefix}-([0-9]+)", path)
if regex_match and regex_match.groups():
ordering_and_checkpoint_path.append(
(int(regex_match.groups()[0]), path))
checkpoints_sorted = sorted(ordering_and_checkpoint_path)
checkpoints_sorted = [
checkpoint[1] for checkpoint in checkpoints_sorted
]
return checkpoints_sorted
def rotate_checkpoints(use_mtime=False) -> None:
if training_args.save_total_limit is None or training_args.save_total_limit <= 0:
return
# Check if we should delete older checkpoint(s)
checkpoints_sorted = sorted_checkpoints(use_mtime=use_mtime)
if len(checkpoints_sorted) <= training_args.save_total_limit:
return
number_of_checkpoints_to_delete = max(
0,
len(checkpoints_sorted) - training_args.save_total_limit)
checkpoints_to_be_deleted = checkpoints_sorted[:
number_of_checkpoints_to_delete]
for checkpoint in checkpoints_to_be_deleted:
logger.info(
"Deleting older checkpoint [{}] due to args.save_total_limit".
format(checkpoint))
shutil.rmtree(checkpoint)
###############################################
# train
###############################################
model.to(training_args.device)
if training_args.n_gpu > 1:
model = nn.DataParallel(model)
best_acc = 0
best_epoch = 0
model.zero_grad()
for e in range(epoch_trained, training_args.epoch_num):
# for e in range(1): # debug
model.train()
t_loss = 0
logging_loss = 0
for step, batch in enumerate(train_loader):
# if step > 0: break # debug
if step_trained_cur_epoch > 0:
step_trained_cur_epoch -= 1
continue
raw_text = batch[-1]
batch = [_.to(training_args.device) for _ in batch[:-1]]
X_ids, Y_ids, Mask = batch
if step < 5: logger.info(f'batch_size: {X_ids.size()}')
loss, logits = model(X_ids, Y_ids, Mask)
if training_args.n_gpu > 1:
loss = loss.mean()
loss.backward()
t_loss += loss.item()
if training_args.gradient_accumulation_steps > 1:
loss = loss / training_args.gradient_accumulation_steps
if ((step + 1) % training_args.gradient_accumulation_steps == 0
or (train_loader.steps <=
training_args.gradient_accumulation_steps)
and step + 1 == train_loader.steps):
torch.nn.utils.clip_grad_norm_(
model.parameters(),
max_norm=training_args.max_gradient_norm)
optimizer.step()
scheduler.step()
model.zero_grad()
global_step += 1
epoch = e + (step + 1) / train_loader.steps
if global_step % training_args.logging_steps == 0:
train_logs = {
'loss':
(t_loss - logging_loss) / training_args.logging_steps,
'learning_rate': scheduler.get_lr()[0],
'epoch': epoch
}
logging_loss = t_loss
tb_log(train_logs)
logger.info(
f'epoch: {e} - batch: {step}/{train_loader.steps} - loss: {t_loss / (step + 1): 6f}'
)
# if global_step % training_args.saving_steps == 0:
# output_dir = os.path.join(training_args.output_dir, f'checkpoint-{global_step}')
#
# save_model(output_dir, model)
# rotate_checkpoints()
#
# torch.save(optimizer.state_dict(), Path(output_dir)/'optimizer.pt')
# torch.save(scheduler.state_dict(), Path(output_dir)/'scheduler.pt')
# logger.info(f'Saving optimizer and scheduler states to {output_dir}')
model.eval()
dev_acc = 0
eval_loss = 0
err = []
cat = defaultdict(lambda: 1e-10)
for k, batch in enumerate(dev_loader):
# if k > 0: break # debug
raw_text = batch[-1]
batch = [_.to(training_args.device) for _ in batch[:-1]]
X_ids, Y_ids, Mask = batch
with torch.no_grad():
loss, logits = model(X_ids, Y_ids, Mask)
if training_args.n_gpu > 1:
loss = loss.mean()
eval_loss += loss.item()
for logit, y_id, t in zip(logits, Y_ids, raw_text):
logit = logit.detach().cpu().numpy()
true_label = y_id.detach().cpu().numpy()
pred_label = np.argmax(logit)
# metric 1
if true_label == pred_label:
dev_acc += 1
else:
score = max(logit)
err.append({
'text': t,
'pred': intent_labels[pred_label],
'true': intent_labels[true_label],
'score': f'{score: .4f}'
})
# metric 2
cat[f'{intent_labels[true_label]}_A'] += int(
pred_label == true_label)
cat[f'{intent_labels[true_label]}_B'] += 1
cat[f'{intent_labels[pred_label]}_C'] += 1
acc = dev_acc / len(dev_loader)
eval_logs = {
'eval_acc': acc,
'eval_loss': eval_loss / dev_loader.steps,
}
tb_log(eval_logs)
if acc > best_acc:
# if acc >= best_acc: # debug
best_acc = acc
best_epoch = e
# save #
model_to_save = model.module if hasattr(model, 'module') else model
torch.save(model_to_save.state_dict(),
Path(data_dir) / f'cls_model_{p}.pt')
# save #
json.dump(err, (Path(data_dir) / 'err.json').open('w'),
ensure_ascii=False,
indent=4)
logger.info(
f'epoch: {e} - dev_acc: {acc:.5f} {dev_acc}/{len(dev_loader)} - best_score: {best_acc:.5f} - best_epoch: {best_epoch} '
)
for t in intent_labels:
logger.info(
f'cat: {t} - '
f'precision: {cat[t + "_A"] / cat[t + "_C"]:.5f} - '
f'recall: {cat[t + "_A"] / cat[t + "_B"]:.5f} - '
f'f1: {2 * cat[t + "_A"] / (cat[t + "_B"] + cat[t + "_C"]):.5f}'
)
tb_writer.close()
def infer_main(p):
###############################################
# args
###############################################
@dataclass
class ModelArguments:
model_path_or_name: str = field(default=str(bert_model_path))
# model_path_or_name: str = field(default=str(roberta_model_path))
# model_path_or_name: str = field(default=str(Path(data_dir)/'checkpoints'/'checkpoint-6000'))
@dataclass
class DataTrainingArguments:
max_seq_length: int = field(default=200)
parser = HfArgumentParser(
(ModelArguments, DataTrainingArguments, TrainingArguments))
model_args, data_args, training_args = parser.parse_args_into_dataclasses()
###############################################
# model
###############################################
num_labels = len(intent_labels)
config = AutoConfig.from_pretrained(
pretrained_model_name_or_path=model_args.model_path_or_name,
num_labels=num_labels)
model = BertForSequenceClassification(config, num_labels)
model.load_state_dict(
torch.load(
Path(data_dir) / f'cls_model_{100-p}.pt',
map_location='cuda' if torch.cuda.is_available() else "cpu"))
model.to(training_args.device)
###############################################
# data process
###############################################
try:
d_80 = [
(_['text'], _['label'])
for _ in json.load((Path(data_dir) / f'unlabeled_{p}.json').open())
]
except:
d_80 = [
(_['text'], _['true_label'])
for _ in json.load((Path(data_dir) / f'unlabeled_{p}.json').open())
]
vocabulary = load_vocab()
# vocabulary = load_vocab(vocab_file=(Path(roberta_model_path) / 'vocab.txt'))
d_80_loader = DataGenerator(d_80, training_args, data_args, vocabulary,
intent_labels)
###############################################
# train
###############################################
d_80_score = []
for k, batch in enumerate(d_80_loader):
# if k > 0: break # debug
raw_text = batch[-1]
batch = [_.to(training_args.device) for _ in batch[:-1]]
X_ids, Y_ids, Mask = batch
with torch.no_grad():
_, logits = model(X_ids, Y_ids, Mask)
for logit, y_id, t in zip(logits, Y_ids, raw_text):
logit = logit.detach().cpu().numpy()
true_label = y_id.detach().cpu().numpy()
pred_label = np.argmax(logit)
score = max(logit)
d_80_score.append({
'text': t,
'true_label': intent_labels[true_label],
'pred_label': intent_labels[pred_label],
'score': f'{score:.4f}',
})
json.dump(d_80_score, (Path(data_dir) / f'unlabeled_{p}.json').open('w'),
ensure_ascii=False,
indent=2)
print('Done')
def convert_data(train_PATH,
test_PATH,
word_vocab_PATH,
position_vocab_PATH,
tag_vocab_PATH,
out_DIR,
flag='notime'):
train_ys, train_codes, train_times = pkl.load(open(train_PATH, 'rb'))
test_ys, test_codes, test_times = pkl.load(open(test_PATH, 'rb'))
word_vocab = load_vocab(word_vocab_PATH)
position_vocab = load_vocab(position_vocab_PATH)
tag_vocab = load_vocab(tag_vocab_PATH, mode="tag")
print("Vocabuary size for word, position and tags are {}, {}, {}".format(
len(word_vocab), len(position_vocab), len(tag_vocab)))
feature_template = make_feature_template(word_vocab, position_vocab, flag)
print(f"the feature number for lr is {len(feature_template)}")
train_visits, train_labels, train_days = [], [], []
test_visits, test_labels, test_days = [], [], []
train_X, valid_X, test_X = [], [], []
train_Y, valid_Y, test_Y = [], [], []
# traverse each train patient
for index, (y, patient_codes, patient_times) in enumerate(
zip(train_ys, train_codes, train_times)):
x = make_patient(patient_codes, patient_times, feature_template, flag)
train_X.append(x)
train_Y.append(y)
for index, (y, patient_codes, patient_times) in enumerate(
zip(test_ys, test_codes, test_times)):
x = make_patient(patient_codes, patient_times, feature_template, flag)
test_X.append(x)
test_Y.append(y)
train_X = csr_matrix(np.asarray(train_X))
test_X = csr_matrix(np.asarray(test_X))
'''
train_visits.append(make_visits(patient_codes, word_vocab))
train_labels.append(y)
key = "case" if y == 1 else "control"
train_counter[key] += 1
train_days.append(make_days(patient_times))
# valid
for index, (y, patient_codes, patient_times) in enumerate(zip(valid_ys, valid_codes, valid_times)):
valid_visits.append(make_visits(patient_codes, word_vocab))
valid_labels.append(y)
key = "case" if y == 1 else "control"
valid_counter[key] += 1
valid_days.append(make_days(patient_times))
# test
for index, (y, patient_codes, patient_times) in enumerate(zip(test_ys, test_codes, test_times)):
test_visits.append(make_visits(patient_codes, word_vocab))
test_labels.append(y)
key = "case" if y == 1 else "control"
test_counter[key] += 1
test_days.append(make_days(patient_times))
'''
pkl.dump(train_X, open(out_DIR + 'lr_time_day.trainX', 'wb'))
pkl.dump(test_X, open(out_DIR + 'lr_time_day.testX', 'wb'))
#pkl.dump(train_X, open(out_DIR + 'lr_notime.trainX', 'wb'))
#pkl.dump(test_X, open(out_DIR + 'lr_notime.testX', 'wb'))
pkl.dump(np.asarray(train_Y), open(out_DIR + 'lr.trainY', 'wb'))
pkl.dump(np.asarray(test_Y), open(out_DIR + 'lr.testY', 'wb'))
print("output data finished")
def main():
# === Load arguments
args = load_cycle_arguments()
if args.task_suffix == 'beta':
final_model_save_path = args.final_model_save_dir + '-beta=' + str(args.beta) + '/'
final_tsf_result_dir = args.final_tsf_result_dir + '-beta=' + str(args.beta)
else:
final_model_save_path = args.final_model_save_dir + '-' + args.task_suffix + '/'
final_tsf_result_dir = args.final_tsf_result_dir + '-' + args.task_suffix
dump_args_to_yaml(args, final_model_save_path) #把参数记录到文件中
print(args)
s2ss_args = load_args_from_yaml(args.s2ss_model_save_dir)
s2ss_args.RL_learning_rate = args.RL_learning_rate # a smaller learning_rate for RL
s2ss_args.MLE_learning_rate = args.MLE_learning_rate # a smaller learning_rate for MLE
s2ss_args.batch_size = args.batch_size # a bigger batch_size for RL
min_seq_len = args.min_seq_len
max_seq_len = args.max_seq_len
# === Load global vocab 词到索引的映射表
vocab, vocab_size = load_vocab(args.vocab_file)
print("Vocabulary size: %s" % vocab_size)
vocab_rev = tf.contrib.lookup.index_to_string_table_from_file(
args.vocab_file, # target vocabulary file(each lines has a word)
vocab_size=vocab_size - constants.NUM_OOV_BUCKETS,
default_value=constants.UNKNOWN_TOKEN)
# === Load evaluator
bleu_evaluator = BLEUEvaluator()
# === Create session
tf_config = tf.ConfigProto()
tf_config.gpu_options.allow_growth = True
#tf_config.gpu_options.per_process_gpu_memory_fraction = 0.4
sess = tf.Session(config=tf_config) # limit gpu memory; don't pre-allocate memory; allocate as-needed
# === Load dataset
with tf.device("/cpu:0"): # Input pipeline should always be place on the CPU.
#Acquire samples from Ps
raml_train_data = args.raml_train_data + '-tau=' + str(args.tau) + '.txt'
if not os.path.exists(raml_train_data):
raml_data = sampling(args.train_template_data, args.vocab_file, raml_train_data, args.sample_size, args.tau)
else:
raml_data = load_raml_data(raml_train_data)
print('pre-sampling complete, len(raml_data) = ', len(raml_data))
train_data_iterator = load_paired_dataset(raml_train_data, vocab, batch_size=args.batch_size,
min_seq_len=min_seq_len, max_seq_len=max_seq_len)
test_data_iterator = load_dataset(args.test_data, vocab, mode=constants.TEST, batch_size=100,
min_seq_len=min_seq_len, max_seq_len=max_seq_len)
#paired_train_data_iterator = load_paired_dataset(args.pseudo_data, vocab, batch_size=args.batch_size,
#min_seq_len=min_seq_len, max_seq_len=max_seq_len)
train_data_next = train_data_iterator.get_next() # to avoid high number of `Iterator.get_next()` calls
test_data_next = test_data_iterator.get_next()
#paired_train_data_next = paired_train_data_iterator.get_next()
# === Initialize and build Seq2SentiSeq model 创建了三种模型 分别用于训练/测试_greedy/测试_random
load_model = False if args.no_pretrain else True
s2ss_train = s2ss_create_model(sess, s2ss_args, constants.TRAIN, vocab_size, load_pretrained_model=load_model) #load预训练模型
#decode_type_before = s2ss_args.decode_type
s2ss_args.decode_type = constants.GREEDY #不同的decode_type 对应不同的infer
s2ss_greedy_infer = s2ss_create_model(sess, s2ss_args, constants.INFER, vocab_size, reuse=True) # infer reuse表示
#s2ss_args.decode_type = constants.RANDOM
#s2ss_random_infer = s2ss_create_model(sess, s2ss_args, constants.INFER, vocab_size, reuse=True)
#s2ss_args.decode_type = decode_type_before
if args.task_suffix == 'beta':
disc_model_save_dir = args.disc_model_save_dir + '-beta=' + str(args.beta) + '/'
else:
disc_model_save_dir = args.disc_model_save_dir + '-' + args.task_suffix + '/'
if args.disc_pretrain and args.task_suffix != 'wo-RAT' and args.task_suffix != 'wo-disc':
# === Pre-train discriminator
src_fs = get_src_samples(args.first_sample_num, args.train_template_data, args.disc_data_dir)
first_sample_test_data_iterator = load_dataset(src_fs[0], vocab, mode=constants.TEST, batch_size=100,
min_seq_len=min_seq_len, max_seq_len=max_seq_len)
first_sample_test_data_next = first_sample_test_data_iterator.get_next()
dst_fs = inference(s2ss_greedy_infer, sess=sess, args=s2ss_args, decoder_s=constants.SENT_LIST,
src_test_iterator=first_sample_test_data_iterator, src_test_next=first_sample_test_data_next,
vocab_rev=vocab_rev, result_dir=args.disc_data_dir)
get_disc_train_data(src_fs[1], dst_fs[0], args.disc_data_dir)
if not os.path.exists(disc_model_save_dir):
os.makedirs(disc_model_save_dir)
_ = disc_model_bert.bert_main('train', args.disc_data_dir, disc_model_save_dir, args.disc_pretrain_n_epoch, args.disc_batch_size)
# === Start adversarial training
for adv_iter in range(args.adv_iters):
if args.task_suffix != 'wo-RAT':
# calculate bleu reward
raml_bleu_data = args.raml_bleu_data + '-tau=' + str(args.tau) + '.txt'
if not os.path.exists(raml_bleu_data):
# calculate bleu reward
cont_reward = get_sentence_bleu(raml_train_data)
cont_reward = sigmoid(cont_reward, x_trans=0.3, x_scale=8)
#print(cont_reward[:10])
#print(np.min(cont_reward), np.max(cont_reward), np.median(cont_reward), np.mean(cont_reward))
# to do: write bleu data
with open(raml_bleu_data, 'w') as f:
cont_reward_str = [str(r) for r in cont_reward]
f.write('\n'.join(cont_reward_str))
else:
#Load bleu data
with open(raml_bleu_data) as f:
cont_reward = np.array([float(line.strip()) for line in f])
print(np.min(cont_reward), np.max(cont_reward), np.median(cont_reward), np.mean(cont_reward))
print(len(cont_reward))
cont_reward += safe_divide_constant
if args.task_suffix == 'wo-disc':
reward = cont_reward
print('length of reward :%d' % len(reward))
else:
# calculate senti reward
sample_size = 1
if not os.path.exists(args.disc_data_dir):
os.makedirs(args.disc_data_dir)
get_disc_infer_data(args.disc_data_dir, raml_data, sample_size)
senti_rewards = disc_model_bert.bert_main('predict', args.disc_data_dir, disc_model_save_dir, predict_batch_size=args.disc_pred_batch_size)
senti_reward_per_sample = np.array(senti_rewards).reshape((-1,2*sample_size)).sum(axis=1)
senti_reward = sigmoid(senti_reward_per_sample, x_trans=0.5, x_scale=8)
print(np.min(senti_reward_per_sample), np.max(senti_reward_per_sample), np.median(senti_reward_per_sample), np.mean(senti_reward_per_sample))
print(np.min(senti_reward), np.max(senti_reward), np.median(senti_reward), np.mean(senti_reward))
assert len(cont_reward) == len(senti_reward)
senti_reward += safe_divide_constant
beta = args.beta #trade-off between two rewards
reward = (1 + beta * beta) * senti_reward * cont_reward / (beta * beta * senti_reward + cont_reward)
print('length of reward :%d' % len(reward))
'''
# calculate fluency reward
lm_scores = []
ppl_scores = []
for idx,data in enumerate(raml_data):
sent = data['src']
lm_scores.append(model.score(' '.join(sent), bos=True, eos=True))
ppl_scores.append(model.perplexity(' '.join(sent)))
#if idx<5:
#print(sent,' '.join(sent),lm_scores[idx])
fluency_reward = sigmoid(np.array(lm_scores), x_trans=-21, x_scale=0.4)
#print(np.min(np.array(lm_scores)), np.max(np.array(lm_scores)), np.median(np.array(lm_scores)), np.mean(np.array(lm_scores)))
#print(fluency_reward[:10])
print(np.min(np.array(ppl_scores)), np.max(np.array(ppl_scores)), np.median(np.array(ppl_scores)), np.mean(np.array(ppl_scores)))
print(np.min(np.array(lm_scores)), np.max(np.array(lm_scores)), np.median(np.array(lm_scores)), np.mean(np.array(lm_scores)))
print(np.min(fluency_reward), np.max(fluency_reward), np.median(fluency_reward), np.mean(fluency_reward))
#print(len(fluency_reward))
#break
'''
#assert len(cont_reward) == len(senti_reward) == len(fluency_reward)
#fluency_reward += safe_divide_constant
'''
#reward = (senti_reward + cont_reward + fluency_reward) / 3
w1 = w2 = w3 = 1
reward = (w1 + w2 + w3) * cont_reward * senti_reward * fluency_reward / (w1 * senti_reward * fluency_reward + w2 * cont_reward * fluency_reward + w3 * cont_reward * senti_reward)
print(np.min(reward), np.max(reward), np.median(reward), np.mean(reward))
print('length of reward :%d' % len(reward))
#break
'''
# === Start train G
n_batch = -1
global_step = -1
for i in range(args.n_epoch):
print("Epoch:%s" % i)
sess.run([train_data_iterator.initializer])
while True:
n_batch += 1
global_step += 1
if n_batch % args.eval_step == 0: #eval
print('\n================ N_batch / Global_step (%s / %s): Evaluate on test datasets ================\n'
% (n_batch, global_step))
dst_fs = inference(s2ss_greedy_infer, sess=sess, args=s2ss_args, decoder_s=constants.SENT_LIST,
src_test_iterator=test_data_iterator, src_test_next=test_data_next,
vocab_rev=vocab_rev, result_dir=final_tsf_result_dir,
step=global_step if args.save_each_step else global_step)
t0 = time.time()
bleu_scores = bleu_evaluator.score(args.reference, dst_fs[1], all_bleu=True)
print("Test(Batch:%d)\tBLEU-1:%.3f\tBLEU-2:%.3f\tBLEU:%.3f\tCost time:%.2f" %
(n_batch, bleu_scores[1], bleu_scores[2], bleu_scores[0], time.time() - t0))
if n_batch % args.save_per_step == 0:
print("Save model at dir:", final_model_save_path)
s2ss_train.saver.save(sess, final_model_save_path, global_step=global_step)
try:
t0 = time.time()
data = sess.run(train_data_next) # get real data!!
batch_size = np.shape(data["source_ids"])[0]
#decode_width = s2ss_args.decode_width
t0 = time.time()
if args.task_suffix != 'wo-RAT':
#batched_cont_reward = cont_reward[n_batch*batch_size:(n_batch+1)*batch_size]
batched_reward = reward[n_batch*batch_size:(n_batch+1)*batch_size]
feed_dict = {s2ss_train.encoder_input: data["source_ids"],
s2ss_train.encoder_input_len: data["source_length"],
s2ss_train.decoder_input: data["target_ids_in"],
s2ss_train.decoder_target: data["target_ids_out"],
s2ss_train.decoder_target_len: data["target_length"] + 1,
s2ss_train.decoder_s: data["target_senti"],
s2ss_train.reward: batched_reward}
res = sess.run([s2ss_train.rl_loss, s2ss_train.retrain_op], feed_dict=feed_dict)
#sess.run([s2ss_train.loss, s2ss_train.train_op], feed_dict=feed_dict)
if args.task_suffix != 'wo-bt':
# baseline #每个句子对应1个tgt_senti
greedy_predictions = sess.run(
s2ss_greedy_infer.predictions,
feed_dict={s2ss_greedy_infer.encoder_input: data["source_ids"],
s2ss_greedy_infer.encoder_input_len: data["source_length"],
s2ss_greedy_infer.decoder_s: data["target_senti"]})
mid_ids_bs, mid_ids_in_bs, mid_ids_out_bs, mid_ids_in_out_bs, mid_ids_length_bs = \
process_mid_ids(greedy_predictions, min_seq_len, max_seq_len, vocab_size) #处理一些符号
# Update Seq2SentiSeq with previous model generated data with noise
if global_step < 1 :
print('$$$Update B use back_trans_noise data')
noise_ids, noise_ids_length = add_noise(mid_ids_bs, mid_ids_length_bs)
feed_dict = {
s2ss_train.encoder_input: noise_ids,
s2ss_train.encoder_input_len: noise_ids_length,
s2ss_train.decoder_input: data["source_ids_in"],
s2ss_train.decoder_target: data["source_ids_out"],
s2ss_train.decoder_target_len: data["source_length"] + 1,
s2ss_train.decoder_s: data["source_senti"],
}
sess.run([s2ss_train.loss, s2ss_train.train_op], feed_dict=feed_dict)
except tf.errors.OutOfRangeError: # next epoch
print("Train---Total N batch:{}\tCost time:{}".format(n_batch, time.time() - t0))
n_batch = -1
break
if n_batch % args.eval_step == 0:
print('train loss: %.4f' % res[0])
if args.task_suffix != 'wo-RAT' and args.task_suffix != 'wo-disc':
# Train discriminator to distinguish real data and generated data
src_fs = get_src_samples(args.sample_num, args.train_template_data, args.disc_data_dir)
sample_test_data_iterator = load_dataset(src_fs[0], vocab, mode=constants.TEST, batch_size=100,
min_seq_len=min_seq_len, max_seq_len=max_seq_len)
sample_test_data_next = sample_test_data_iterator.get_next()
dst_fs = inference(s2ss_greedy_infer, sess=sess, args=s2ss_args, decoder_s=constants.SENT_LIST,
src_test_iterator=sample_test_data_iterator, src_test_next=sample_test_data_next,
vocab_rev=vocab_rev, result_dir=args.disc_data_dir)
get_disc_train_data(src_fs[1], dst_fs[0], args.disc_data_dir)
_ = disc_model_bert.bert_main('train', args.disc_data_dir, disc_model_save_dir, args.disc_n_epoch, args.disc_batch_size)
A = 1
B = 0
return A, B
if __name__ == "__main__":
args = load_nmt_arguments()
# === Get translation direction
A, B = get_nmt_direction(args.nmt_direction)
print("A=%s, B=%s" % (A, B))
# === Build vocab and load data
if not os.path.isfile(args.global_vocab_file):
build_vocab_from_file(args.train_data, args.global_vocab_file)
vocab, vocab_size = load_vocab(args.global_vocab_file)
src_vocab = tgt_vocab = vocab
src_vocab_size = tgt_vocab_size = vocab_size
print('Vocabulary size:src:%s' % vocab_size)
vocab_rev = tf.contrib.lookup.index_to_string_table_from_file(
args.
global_vocab_file, # target vocabulary file(each lines has a word)
vocab_size=vocab_size - constants.NUM_OOV_BUCKETS,
default_value=constants.UNKNOWN_TOKEN)
src_vocab_rev = tgt_vocab_rev = vocab_rev
with tf.device(
"/cpu:0"): # Input pipeline should always be placed on the CPU.
print("Use x'->y to update model f(x->y)")
train_iterator = load_paired_dataset(args.tsf_train_data[B],
def main():
# capture the config path from the runtime arguments
# then process the json configuration file
args = get_args()
print("Reading config from {}".format(args.config))
config, _ = get_config_from_json(args.config)
# add summary and model directory
config = update_config_by_summary(config)
# if to remove the previous results, set -d 1 as a parameter
print('Whether to del the previous saved model', args.delete)
if args.delete == '1':
# delete existing checkpoints and summaries
print('Deleting existing models and logs from:')
print(config.summary_dir, config.checkpoint_dir)
remove_dir(config.summary_dir)
remove_dir(config.checkpoint_dir)
# create the experiments dirs
create_dirs([config.summary_dir, config.checkpoint_dir])
"""Load data"""
# load global word, position and tag vocabularies
word_vocab = load_vocab(path=config.datadir + config.word_vocab_path,
mode='word')
position_vocab = load_vocab(path=config.datadir + config.pos_vocab_path,
mode='pos')
tag_vocab = load_vocab(path=config.datadir + config.tag_vocab_path,
mode='tag')
config.word_vocab_size = len(word_vocab)
config.pos_vocab_size = len(position_vocab)
config.tag_vocab_size = len(tag_vocab)
print('word vocab size:', config.word_vocab_size)
# create your data generator to load train data
x_path = config.datadir + config.train_path
train_loader = DataLoader(config, x_path, word_vocab, position_vocab,
tag_vocab)
train_loader.load_data()
# update the max length for each patient and each visit to be used in lstm
train_max_patient_len = train_loader.max_patient_len
train_max_visit_len = train_loader.max_visit_len
# create your data generator to load valid data
x_path = config.datadir + config.valid_path
valid_loader = DataLoader(config, x_path, word_vocab, position_vocab,
tag_vocab)
valid_loader.load_data()
valid_max_patient_len = valid_loader.max_patient_len
valid_max_visit_len = valid_loader.max_visit_len
# create your data generator to load test data
x_path = config.datadir + config.test_path
test_loader = DataLoader(config, x_path, word_vocab, position_vocab,
tag_vocab)
test_loader.load_data()
test_max_patient_len = test_loader.max_patient_len
test_max_visit_len = test_loader.max_visit_len
print("The max patient lengths for train, valid and test are {}, {}, {}".
format(train_max_patient_len, valid_max_patient_len,
test_max_patient_len))
print("The max visit lengths for train, valid and test are {}, {}, {}".
format(train_max_visit_len, valid_max_visit_len, test_max_visit_len))
# select the maximum lengths of visits and codes as the size of lstm
config.max_patient_len = max(
[train_max_patient_len, valid_max_patient_len, test_max_patient_len])
config.max_visit_len = max(
[train_max_visit_len, valid_max_visit_len, test_max_visit_len])
train_loader.pad_data(config.max_patient_len, config.max_visit_len)
valid_loader.pad_data(config.max_patient_len, config.max_visit_len)
test_loader.pad_data(config.max_patient_len, config.max_visit_len)
# add num_iter_per_epoch to config for trainer
config.train_size = train_loader.get_datasize()
config.valid_size = valid_loader.get_datasize()
config.test_size = test_loader.get_datasize()
config.num_iter_per_epoch = int(config.train_size / config.batch_size)
print("The sizes for train, valid and test are {}, {}, {}".format(
config.train_size, config.valid_size, config.test_size))
"""Run model"""
# create tensorflow session
# specify only using one GPU
tfconfig = tf.ConfigProto(device_count={'GPU': 1})
# allow the dynamic increase of GPU memory
tfconfig.gpu_options.allow_growth = True
# limit the maximum of GPU usage as 0.5
#tfconfig.gpu_options.per_process_gpu_memory_fraction = 0.5
with tf.Session(config=tfconfig) as sess:
# create an instance of the model you want
model = Model(config)
# create tensorboard logger
logger = Logger(sess, config)
# create trainer and pass all the previous components to it
trainer = PredTrainer(sess, model, train_loader, valid_loader,
test_loader, config, logger)
# load model if exists
model.load(sess)
# here you train your model
trainer.train()
def main():
# === Load arguments
args = load_dual_arguments()
dump_args_to_yaml(args, args.final_model_save_dir)
cls_args = load_args_from_yaml(args.cls_model_save_dir)
nmt_args = load_args_from_yaml(os.path.join(args.nmt_model_save_dir,
'0-1'))
nmt_args.learning_rate = args.learning_rate # a smaller learning rate for RL
min_seq_len = min(int(max(re.findall("\d", cls_args.filter_sizes))),
args.min_seq_len)
# === Load global vocab
word2id, word2id_size = load_vocab_dict(args.global_vocab_file)
global_vocab, global_vocab_size = load_vocab(args.global_vocab_file)
print("Global_vocab_size: %s" % global_vocab_size)
global_vocab_rev = tf.contrib.lookup.index_to_string_table_from_file(
args.global_vocab_file,
vocab_size=global_vocab_size - constants.NUM_OOV_BUCKETS,
default_value=constants.UNKNOWN_TOKEN)
src_vocab = tgt_vocab = global_vocab
src_vocab_size = tgt_vocab_size = global_vocab_size
src_vocab_rev = tgt_vocab_rev = global_vocab_rev
# === Create session
tf_config = tf.ConfigProto()
tf_config.gpu_options.allow_growth = True
tf_config.gpu_options.per_process_gpu_memory_fraction = 0.3
sess = tf.Session(config=tf_config)
# === Initial and build model
cls = cls_create_model(sess,
cls_args,
global_vocab_size,
mode=constants.EVAL,
load_pretrained_model=True)
nmts_train = []
nmts_random_infer = []
nmts_greedy_infer = []
train_data_next = []
dev_data_next = []
test_data_next = []
train_iterators = []
test_iterators = []
paired_train_iterators = []
paired_train_data_next = []
final_model_save_paths = []
# === Define nmt model
for A, B in [(0, 1), (1, 0)]:
with tf.device("/cpu:0"
): # Input pipeline should always be placed on the CPU.
src_train_iterator = load_dataset(args.train_data[A],
src_vocab,
mode=constants.TRAIN,
batch_size=args.batch_size,
min_seq_len=min_seq_len)
src_dev_iterator = load_dataset(args.dev_data[A],
src_vocab,
mode=constants.EVAL,
batch_size=500)
src_test_iterator = load_dataset(args.test_data[A],
src_vocab,
mode=constants.EVAL,
batch_size=500)
# Use (X', Y) to produce pseudo parallel data
paired_src_train_iterator = load_paired_dataset(
args.tsf_train_data[B],
args.train_data[B],
src_vocab,
tgt_vocab,
batch_size=args.batch_size,
min_seq_len=min_seq_len)
src_train_next_op = src_train_iterator.get_next(
) # To avoid frequent calls of `Iterator.get_next()`
src_dev_next_op = src_dev_iterator.get_next()
src_test_next_op = src_test_iterator.get_next()
src_paired_train_next_op = paired_src_train_iterator.get_next()
train_data_next.append(src_train_next_op)
dev_data_next.append(src_dev_next_op)
test_data_next.append(src_test_next_op)
paired_train_data_next.append(src_paired_train_next_op)
train_iterators.append(src_train_iterator)
test_iterators.append(src_test_iterator)
paired_train_iterators.append(paired_src_train_iterator)
direction = "%s-%s" % (A, B)
nmt_args.sampling_probability = 0.5
# == Define train model
nmt_train = nmt_create_model(sess,
nmt_args,
src_vocab_size,
tgt_vocab_size,
src_vocab_rev,
tgt_vocab_rev,
mode=constants.TRAIN,
direction=direction,
load_pretrained_model=True)
# == Define inference model
decode_type_before = nmt_args.decode_type
nmt_args.decode_type = constants.RANDOM
nmt_random_infer = nmt_create_model(sess,
nmt_args,
src_vocab_size,
tgt_vocab_size,
src_vocab_rev,
tgt_vocab_rev,
mode=constants.INFER,
direction=direction,
reuse=True)
nmt_args.decode_type = constants.GREEDY
nmt_greedy_infer = nmt_create_model(sess,
nmt_args,
src_vocab_size,
tgt_vocab_size,
src_vocab_rev,
tgt_vocab_rev,
mode=constants.INFER,
direction=direction,
reuse=True)
nmt_args.decode_type = decode_type_before # restore to previous setting
nmts_train.append(nmt_train)
nmts_random_infer.append(nmt_random_infer)
nmts_greedy_infer.append(nmt_greedy_infer)
# == Prepare for model saver
print("Prepare for model saver")
final_model_save_path = "%s/%s-%s/" % (args.final_model_save_dir, A, B)
if not os.path.exists(final_model_save_path):
os.makedirs(final_model_save_path)
print("Model save path:", final_model_save_path)
final_model_save_paths.append(final_model_save_path)
# === Start train
n_batch = -1
global_step = -1
A = 1
B = 0
G_scores = []
for i in range(args.n_epoch):
print("Epoch:%s" % i)
sess.run([train_iterators[A].initializer])
sess.run([train_iterators[B].initializer])
sess.run([paired_train_iterators[A].initializer])
sess.run([paired_train_iterators[B].initializer])
while True:
n_batch += 1
global_step += 1
if n_batch % args.eval_step == 0:
print(
'===== Start (N_batch: %s, Steps: %s): Evaluate on test datasets ===== '
% (n_batch, global_step))
_, dst_f_A = inference(nmts_greedy_infer[A],
sess=sess,
args=nmt_args,
A=A,
B=B,
src_test_iterator=test_iterators[A],
src_test_next=test_data_next[A],
src_vocab_rev=src_vocab_rev,
result_dir=args.final_tsf_result_dir,
step=global_step)
_, dst_f_B = inference(nmts_greedy_infer[B],
sess=sess,
args=nmt_args,
A=B,
B=A,
src_test_iterator=test_iterators[B],
src_test_next=test_data_next[B],
src_vocab_rev=src_vocab_rev,
result_dir=args.final_tsf_result_dir,
step=global_step)
t0 = time.time()
# calculate accuracy score
senti_acc = cls_evaluate_file(sess,
cls_args,
word2id,
cls, [dst_f_A, dst_f_B],
index_list=[B, A])
# calculate bleu score
bleu_score_A = bleu_evaluator.score(args.reference[A], dst_f_A)
bleu_score_B = bleu_evaluator.score(args.reference[B], dst_f_B)
bleu_score = (bleu_score_A + bleu_score_B) / 2
G_score = np.sqrt(senti_acc * bleu_score)
H_score = 2 / (1 / senti_acc + 1 / bleu_score)
G_scores.append(G_score)
print(
"%s-%s_Test(Batch:%d)\tSenti:%.3f\tBLEU(4ref):%.3f(A:%.3f+B:%.3f)"
"\tG-score:%.3f\tH-score:%.3f\tCost time:%.2f" %
(A, B, n_batch, senti_acc, bleu_score, bleu_score_A,
bleu_score_B, G_score, H_score, time.time() - t0))
print(
'===== End (N_batch: %s, Steps: %s): Evaluate on test datasets ====== '
% (n_batch, global_step))
if n_batch % args.save_per_step == 0:
print("=== Save model at dir:", final_model_save_paths[A],
final_model_save_paths[B])
nmts_train[A].saver.save(sess,
final_model_save_paths[A],
global_step=global_step)
nmts_train[B].saver.save(sess,
final_model_save_paths[B],
global_step=global_step)
if n_batch % args.change_per_step == 0:
A, B = B, A
print(
"============= Change to train model {}-{} at {} steps =============="
.format(A, B, global_step))
try:
t0 = time.time()
src = sess.run(train_data_next[A]) # get real data!!
batch_size = np.shape(src["ids"])[0]
decode_width = nmt_args.decode_width
tile_src_ids = np.repeat(src["ids"], decode_width,
axis=0) # [batch_size*sample_size],
tile_src_length = np.repeat(src['length'],
decode_width,
axis=0)
tile_src_ids_in = np.repeat(src["ids_in"],
decode_width,
axis=0)
tile_src_ids_out = np.repeat(src["ids_out"],
decode_width,
axis=0)
tile_src_ids_in_out = np.repeat(src["ids_in_out"],
decode_width,
axis=0)
random_predictions = sess.run(
nmts_random_infer[A].predictions,
feed_dict={
nmts_random_infer[A].input_ids: src['ids'],
nmts_random_infer[A].input_length: src['length']
})
assert np.shape(
random_predictions["ids"])[1] == nmt_args.decode_width
mid_ids_log_prob = np.reshape(random_predictions["log_probs"],
-1)
mid_ids, mid_ids_in, mid_ids_out, mid_ids_in_out, mid_ids_length = \
process_mid_ids(random_predictions["ids"], random_predictions["length"],
min_seq_len, global_vocab_size)
greedy_predictions = sess.run(
nmts_greedy_infer[A].predictions,
feed_dict={
nmts_greedy_infer[A].input_ids: src['ids'],
nmts_greedy_infer[A].input_length: src['length']
})
assert np.shape(greedy_predictions["ids"])[1] == 1
mid_ids_bs, mid_ids_in_bs, mid_ids_out_bs, mid_ids_in_out_bs, mid_ids_length_bs = \
process_mid_ids(greedy_predictions["ids"], greedy_predictions["length"],
min_seq_len, global_vocab_size)
# Get style reward from classifier
cls_probs = sess.run(cls.probs,
feed_dict={
cls.x: mid_ids,
cls.dropout: 1
})
y_hat = [p > 0.5 for p in cls_probs] # 1 or 0
cls_acu = [p == B for p in y_hat
] # accuracy: count the number of style B
style_reward = np.array(cls_acu, dtype=np.float32)
# Get content reward from backward reconstruction
feed_dict = {
nmts_train[B].input_ids: mid_ids,
nmts_train[B].input_length: mid_ids_length,
nmts_train[B].target_ids_in: tile_src_ids_in,
nmts_train[B].target_ids_out: tile_src_ids_out,
nmts_train[B].target_length: tile_src_length
}
nmtB_loss = sess.run(
nmts_train[B].loss_per_sequence,
feed_dict=feed_dict) # nmtB_loss = -log(prob)
nmtB_reward = nmtB_loss * (
-1) # reward = log(prob) ==> bigger is better
# Get baseline reward from backward reconstruction
feed_dict = {
nmts_train[B].input_ids: mid_ids_bs,
nmts_train[B].input_length: mid_ids_length_bs,
nmts_train[B].target_ids_in: src["ids_in"],
nmts_train[B].target_ids_out: src["ids_out"],
nmts_train[B].target_length: src["length"]
}
nmtB_loss_bs = sess.run(nmts_train[B].loss_per_sequence,
feed_dict=feed_dict)
nmtB_reward_bs = nmtB_loss_bs * (-1) # nmt baseline reward
def norm(x):
x = np.array(x)
x = (x - x.mean()) / (x.std() + safe_divide_constant)
# x = x - x.min() # to make sure > 0
return x
def sigmoid(x,
x_trans=0.0,
x_scale=1.0,
max_y=1,
do_norm=False):
value = max_y / (1 + np.exp(-(x - x_trans) * x_scale))
if do_norm:
value = norm(value)
return value
def norm_nmt_reward(x, baseline=None, scale=False):
x = np.reshape(x, (batch_size, -1)) # x is in [-16, 0]
dim1 = np.shape(x)[1]
if baseline is not None:
x_baseline = baseline # [batch_size]
else:
x_baseline = np.mean(x, axis=1) # [batch_size]
x_baseline = np.repeat(x_baseline,
dim1) # [batch_size*dim1]
x_baseline = np.reshape(x_baseline, (batch_size, dim1))
x_norm = x - x_baseline
if scale:
# x_norm = sigmoid(x_norm, x_scale=0.5) # x_norm: [-12, 12] => [0, 1]
x_norm = sigmoid(
x_norm
) # Sharper normalization, x_norm: [-6, 6] => [0, 1]
return x_norm.reshape(-1)
if args.use_baseline:
content_reward = norm_nmt_reward(nmtB_reward,
baseline=nmtB_reward_bs,
scale=True)
else:
content_reward = norm_nmt_reward(nmtB_reward, scale=True)
# Calculate reward
style_reward += safe_divide_constant
content_reward += safe_divide_constant
reward = (1 + 0.25) * style_reward * content_reward / (
style_reward + 0.25 * content_reward)
if args.normalize_reward:
reward = norm(reward)
# == Update nmtA via policy gradient training
feed_dict = {
nmts_train[A].input_ids: tile_src_ids,
nmts_train[A].input_length: tile_src_length,
nmts_train[A].target_ids_in: mid_ids_in,
nmts_train[A].target_ids_out: mid_ids_out,
nmts_train[A].target_length: mid_ids_length,
nmts_train[A].reward: reward
}
ops = [
nmts_train[A].lr_loss, nmts_train[A].loss,
nmts_train[A].loss_per_sequence, nmts_train[A].retrain_op
]
nmtA_loss_final, nmtA_loss_, loss_per_sequence_, _ = sess.run(
ops, feed_dict=feed_dict)
# == Update nmtA with pseudo data
if args.MLE_anneal:
gap = min(
args.anneal_max_gap,
int(args.anneal_initial_gap *
np.power(args.anneal_rate,
global_step / args.anneal_steps)))
else:
gap = args.anneal_initial_gap
if n_batch % gap == 0:
# Update nmtA using original pseudo data (used as pre-training)
# This is not a ideal way since the quality of the pseudo-parallel data is not acceptable for
# the later iterations of training.
# We highly recommend you adopt back translation to generate the pseudo-parallel data on-the-fly
if "pseudo" in args.teacher_forcing:
data = sess.run(
paired_train_data_next[A]) # get real data!!
feed_dict = {
nmts_train[A].input_ids: data["ids"],
nmts_train[A].input_length: data["length"],
nmts_train[A].target_ids_in: data["trans_ids_in"],
nmts_train[A].target_ids_out:
data["trans_ids_out"],
nmts_train[A].target_length: data["trans_length"],
}
nmtA_pse_loss_, _ = sess.run(
[nmts_train[A].loss, nmts_train[A].train_op],
feed_dict=feed_dict)
# Update nmtB using pseudo data generated via back_translation (on-the-fly)
if "back_trans" in args.teacher_forcing:
feed_dict = {
nmts_train[B].input_ids: mid_ids_bs,
nmts_train[B].input_length: mid_ids_length_bs,
nmts_train[B].target_ids_in: src["ids_in"],
nmts_train[B].target_ids_out: src["ids_out"],
nmts_train[B].target_length: src["length"],
}
nmtB_loss_, _ = sess.run(
[nmts_train[B].loss, nmts_train[B].train_op],
feed_dict=feed_dict)
except tf.errors.OutOfRangeError as e: # next epoch
print("===== DualTrain: Total N batch:{}\tCost time:{} =====".
format(n_batch,
time.time() - t0))
n_batch = -1
break
def main():
args = load_cycle_arguments()
dump_args_to_yaml(args, args.final_model_save_dir)
print(args)
reg_args = load_args_from_yaml(args.reg_model_save_dir)
s2ss_args = load_args_from_yaml(args.s2ss_model_save_dir)
# s2ss_args.seq2seq_model_save_dir = args.seq2seq_model_save_dir
s2ss_args.RL_learning_rate = args.RL_learning_rate # a smaller learning_rate for RL
s2ss_args.MLE_learning_rate = args.MLE_learning_rate # a smaller learning_rate for MLE
s2ss_args.batch_size = args.batch_size # a bigger batch_size for RL
min_seq_len = args.min_seq_len
max_seq_len = args.max_seq_len
# === Load global vocab
vocab, vocab_size = load_vocab(args.vocab_file)
print("Vocabulary size: %s" % vocab_size)
vocab_rev = tf.contrib.lookup.index_to_string_table_from_file(
args.vocab_file, # target vocabulary file(each lines has a word)
vocab_size=vocab_size - constants.NUM_OOV_BUCKETS,
default_value=constants.UNKNOWN_TOKEN)
bleu_evaluator = BLEUEvaluator()
# === Create session
tf_config = tf.ConfigProto()
tf_config.gpu_options.allow_growth = True
tf_config.gpu_options.per_process_gpu_memory_fraction = 0.4
sess = tf.Session(
config=tf_config
) # limit gpu memory; don't pre-allocate memory; allocate as-needed
# === Load dataset
with tf.device(
"/cpu:0"): # Input pipeline should always be place on the CPU.
train_data_iterator = load_dataset(args.train_data,
vocab,
mode=constants.TRAIN,
batch_size=args.batch_size,
min_seq_len=min_seq_len,
max_seq_len=max_seq_len)
dev_data_iterator = load_dataset(args.dev_data,
vocab,
mode=constants.EVAL,
batch_size=100,
min_seq_len=min_seq_len,
max_seq_len=max_seq_len)
test_data_iterator = load_dataset(args.test_data,
vocab,
mode=constants.TEST,
batch_size=100,
min_seq_len=min_seq_len,
max_seq_len=max_seq_len)
paired_train_data_iterator = load_paired_dataset(
args.pseudo_data,
vocab,
batch_size=args.batch_size,
min_seq_len=min_seq_len,
max_seq_len=max_seq_len)
train_data_next = train_data_iterator.get_next(
) # to avoid high number of `Iterator.get_next()` calls
dev_data_next = dev_data_iterator.get_next()
test_data_next = test_data_iterator.get_next()
paired_train_data_next = paired_train_data_iterator.get_next()
# === Initialize and build Seq2SentiSeq model
load_model = False if args.no_pretrain else True
s2ss_train = s2ss_create_model(sess,
s2ss_args,
constants.TRAIN,
vocab_size,
load_pretrained_model=load_model)
decode_type_before = s2ss_args.decode_type
s2ss_args.decode_type = constants.GREEDY
s2ss_greedy_infer = s2ss_create_model(sess,
s2ss_args,
constants.INFER,
vocab_size,
reuse=True)
s2ss_args.decode_type = constants.RANDOM
s2ss_random_infer = s2ss_create_model(sess,
s2ss_args,
constants.INFER,
vocab_size,
reuse=True)
s2ss_args.decode_type = decode_type_before
# === Load pre-trained sentiment regression model
eval_reg = reg_create_model(sess,
reg_args,
vocab_size,
mode=constants.EVAL,
load_pretrained_model=True)
print("Prepare for model saver")
final_model_save_path = args.final_model_save_dir
# === Start train
n_batch = -1
global_step = -1
for i in range(args.n_epoch):
print("Epoch:%s" % i)
sess.run([train_data_iterator.initializer])
sess.run([paired_train_data_iterator.initializer])
senti_reward_all = { # reward to measure the sentiment transformation of generated sequence
"upper":
[], # reward of ground truth (existed sequence in train dataset)
"lower": [], # reward of baseline: random generated sequence
"real": [], # reward of real generated sequence
}
cont_reward_all = { # reward to measure the content preservation of generated sequence
"upper":
[], # reward of ground truth (existed sequence in train dataset)
"lower": [], # reward of baseline: random generated sequence
"real": [], # reward of real generated sequence
}
reward_all = []
reward_expect_all = [] # reward expectation: r*p(y_k|x)
while True:
n_batch += 1
global_step += 1
if n_batch % args.eval_step == 0:
print(
'\n================ N_batch / Global_step (%s / %s): Evaluate on test datasets ================\n'
% (n_batch, global_step))
dst_fs = inference(
s2ss_greedy_infer,
sess=sess,
args=s2ss_args,
decoder_s=constants.SENT_LIST,
src_test_iterator=test_data_iterator,
src_test_next=test_data_next,
vocab_rev=vocab_rev,
result_dir=args.final_tsf_result_dir,
step=global_step if args.save_each_step else global_step)
t0 = time.time()
bleu_scores = bleu_evaluator.score(args.reference,
dst_fs[1],
all_bleu=True)
print(
"Test(Batch:%d)\tBLEU-1:%.3f\tBLEU-2:%.3f\tBLEU:%.3f\tCost time:%.2f"
% (n_batch, bleu_scores[1], bleu_scores[2], bleu_scores[0],
time.time() - t0))
# improve the diversity of generated sentences
dst_fs = inference(
s2ss_random_infer,
sess=sess,
args=s2ss_args,
decoder_s=constants.SENT_LIST,
src_test_iterator=test_data_iterator,
src_test_next=test_data_next,
vocab_rev=vocab_rev,
result_dir=args.final_tsf_result_dir + '-sample',
step=global_step if args.save_each_step else global_step)
t0 = time.time()
bleu_scores = bleu_evaluator.score(args.reference,
dst_fs[1],
all_bleu=True)
print(
"Test(Batch:%d)\tBLEU-1:%.3f\tBLEU-2:%.3f\tBLEU:%.3f\tCost time:%.2f ===> Sampled results"
% (n_batch, bleu_scores[1], bleu_scores[2], bleu_scores[0],
time.time() - t0))
if n_batch % args.save_per_step == 0:
print("Save model at dir:", final_model_save_path)
s2ss_train.saver.save(sess,
final_model_save_path,
global_step=n_batch)
try:
t0 = time.time()
src = sess.run(train_data_next) # get real data!!
batch_size = np.shape(src["ids"])[0]
decode_width = s2ss_args.decode_width
t0 = time.time()
tile_src_ids = np.repeat(src["ids"], decode_width,
axis=0) # [batch_size*beam_size],
tile_src_length = np.repeat(src['length'],
decode_width,
axis=0)
tile_src_ids_in = np.repeat(src["ids_in"],
decode_width,
axis=0)
tile_src_ids_out = np.repeat(src["ids_out"],
decode_width,
axis=0)
tile_src_ids_in_out = np.repeat(src["ids_in_out"],
decode_width,
axis=0)
tile_src_decoder_s = np.repeat(src["senti"],
decode_width,
axis=0)
tile_tgt_decoder_s = get_tareget_sentiment(size=batch_size)
tgt_decoder_s = get_tareget_sentiment(size=batch_size,
random=True)
t0 = time.time()
# random
random_predictions, log_probs = sess.run(
[
s2ss_random_infer.predictions,
s2ss_random_infer.log_probs
],
feed_dict={
s2ss_random_infer.encoder_input: tile_src_ids,
s2ss_random_infer.encoder_input_len: tile_src_length,
s2ss_random_infer.decoder_s: tile_tgt_decoder_s
})
mid_ids_log_prob = log_probs
mid_ids, mid_ids_in, mid_ids_out, mid_ids_in_out, mid_ids_length = \
process_mid_ids(random_predictions, min_seq_len, max_seq_len, vocab_size)
assert tile_src_length[0] == tile_src_length[decode_width - 1]
# baseline
greedy_predictions = sess.run(
s2ss_greedy_infer.predictions,
feed_dict={
s2ss_greedy_infer.encoder_input: src['ids'],
s2ss_greedy_infer.encoder_input_len: src['length'],
s2ss_greedy_infer.decoder_s: tgt_decoder_s
})
mid_ids_bs, mid_ids_in_bs, mid_ids_out_bs, mid_ids_in_out_bs, mid_ids_length_bs = \
process_mid_ids(greedy_predictions, min_seq_len, max_seq_len, vocab_size)
t0 = time.time()
# == get reward from sentiment scorer/regressor
def get_senti_reward(pred, gold):
if args.scale_sentiment:
gold = gold * 0.2 - 0.1 # todo: move this function to one file
reward_ = 1 / (np.fabs(pred - gold) + 1.0)
return reward_
# real sentiment reward
pred_senti_score = sess.run(eval_reg.predict_score,
feed_dict={
eval_reg.x:
mid_ids,
eval_reg.sequence_length:
mid_ids_length
})
senti_reward = get_senti_reward(pred_senti_score,
tile_tgt_decoder_s)
# upper bound of sentiment reward
upper_pred_senti_score = sess.run(eval_reg.predict_score,
feed_dict={
eval_reg.x:
src["ids"],
eval_reg.sequence_length:
src["length"]
})
upper_senti_reward = get_senti_reward(upper_pred_senti_score,
src["senti"])
# lower bound of sentiment reward
lower_pred_senti_score = sess.run(
eval_reg.predict_score,
feed_dict={
eval_reg.x:
np.random.choice(vocab_size, np.shape(tile_src_ids)),
eval_reg.sequence_length:
tile_src_length
})
lower_senti_reward = get_senti_reward(lower_pred_senti_score,
tile_src_decoder_s)
# == get reward from backward reconstruction
feed_dict = {
s2ss_train.encoder_input: mid_ids,
s2ss_train.encoder_input_len: mid_ids_length,
s2ss_train.decoder_input: tile_src_ids_in,
s2ss_train.decoder_target: tile_src_ids_out,
s2ss_train.decoder_target_len: tile_src_length + 1,
s2ss_train.decoder_s: tile_src_decoder_s,
}
loss = sess.run(s2ss_train.loss_per_sequence,
feed_dict=feed_dict)
cont_reward = loss * (-1) # bigger is better
t0 = time.time()
# get baseline content reward
feed_dict = {
s2ss_train.encoder_input: mid_ids_bs,
s2ss_train.encoder_input_len: mid_ids_length_bs,
s2ss_train.decoder_input: src["ids_in"],
s2ss_train.decoder_target: src["ids_out"],
s2ss_train.decoder_target_len: src["length"] + 1,
s2ss_train.decoder_s: src["senti"],
}
loss_bs = sess.run(s2ss_train.loss_per_sequence,
feed_dict=feed_dict)
cont_reward_bs = loss_bs * (-1) # baseline content reward
# get lower bound of content reward
feed_dict = {
s2ss_train.encoder_input:
np.random.choice(vocab_size, np.shape(mid_ids)),
s2ss_train.encoder_input_len:
mid_ids_length,
s2ss_train.decoder_input:
np.random.choice(vocab_size, np.shape(tile_src_ids_in)),
s2ss_train.decoder_target:
np.random.choice(vocab_size, np.shape(tile_src_ids_out)),
s2ss_train.decoder_target_len:
tile_src_length + 1,
s2ss_train.decoder_s:
tile_src_decoder_s,
}
lower_loss = sess.run(s2ss_train.loss_per_sequence,
feed_dict=feed_dict)
lower_cont_reward = lower_loss * (-1) # bigger is better
def norm(x):
x = np.array(x)
x = (x - x.mean()) / (x.std() + 1e-6) # safe divide
# x = x - x.min() # to make x > 0
return x
def sigmoid(x,
x_trans=0.0,
x_scale=1.0,
max_y=1,
do_norm=False):
value = max_y / (1 + np.exp(-(x - x_trans) * x_scale))
if do_norm:
value = norm(value)
return value
def norm_s2ss_reward(x,
baseline=None,
scale=False,
norm=False):
x = np.reshape(x, (batch_size, -1)) # x in [-16, 0]
dim1 = np.shape(x)[1]
if baseline is not None:
x_baseline = baseline # [batch_size]
else:
x_baseline = np.mean(x, axis=1) # [batch_size]
x_baseline = np.repeat(x_baseline,
dim1) # [batch_size*dim1]
x_baseline = np.reshape(x_baseline, (batch_size, dim1))
x_norm = x - x_baseline
if scale:
x_norm = sigmoid(x_norm)
if norm:
x_norm = 2 * x_norm - 1 # new x_norm in [-1, 1]
return x_norm.reshape(-1)
if args.use_baseline:
if global_step < 1: # only print at first 10 steps
print('%%% use_baseline')
cont_reward = norm_s2ss_reward(cont_reward,
baseline=cont_reward_bs,
scale=True)
lower_cont_reward = norm_s2ss_reward(
lower_cont_reward, baseline=cont_reward_bs, scale=True)
elif args.scale_cont_reward:
if global_step < 1: # only print at first 1 steps
print('%%% scale_cont_reward')
cont_reward = sigmoid(
cont_reward, x_trans=-3) # [-6, -2] => [0.1, 0.78]
lower_cont_reward = sigmoid(lower_cont_reward, x_trans=-3)
if args.scale_senti_reward:
if global_step < 1: # only print at first 1 steps
print('%%% scale_senti_reward')
senti_reward = sigmoid(
senti_reward, x_trans=-0.8,
x_scale=15) # [0.6, 1.0] => [0.04, 0.95]
lower_senti_reward = sigmoid(lower_senti_reward,
x_trans=-0.8,
x_scale=15)
upper_senti_reward = sigmoid(upper_senti_reward,
x_trans=-0.8,
x_scale=15)
cont_reward_all["lower"].extend(lower_cont_reward)
cont_reward_all["real"].extend(cont_reward)
senti_reward_all["upper"].extend(upper_senti_reward)
senti_reward_all["lower"].extend(lower_senti_reward)
senti_reward_all["real"].extend(senti_reward)
senti_reward += safe_divide_constant
cont_reward += safe_divide_constant
if args.increase_beta:
beta = min(1, 0.1 * global_step / args.increase_step)
else:
beta = 1
reward_merge_type = 'H(sentiment, content), beta=%.2f' % beta # enlarge the influence of senti_reward
reward = (1 + beta * beta) * senti_reward * cont_reward / (
beta * beta * senti_reward + cont_reward)
reward_all.extend(reward)
reward_expect_all.extend(reward * np.exp(mid_ids_log_prob))
# policy gradient training
if not args.no_RL:
feed_dict = {
s2ss_train.encoder_input: tile_src_ids,
s2ss_train.encoder_input_len: tile_src_length,
s2ss_train.decoder_input: mid_ids_in,
s2ss_train.decoder_target: mid_ids_out,
s2ss_train.decoder_target_len: mid_ids_length + 1,
s2ss_train.decoder_s: tile_tgt_decoder_s,
s2ss_train.reward: reward
}
sess.run([s2ss_train.rl_loss, s2ss_train.retrain_op],
feed_dict=feed_dict)
# Teacher forcing data types:
# 1. back translation data (greedy decode)
# 2. back translation data (random decode)
# 3. back translation noise data
# 4. pseudo data
# 5. same data (x->x)
# 6. same_noise (x'->x)
if "back_trans" in args.teacher_forcing:
if args.MLE_decay:
if args.MLE_decay_type == "linear":
gap = min(10, 2 + global_step /
args.MLE_decay_steps) # 10 after 1 epoch
else:
gap = min(
5,
int(1 / np.power(
args.MLE_decay_rate,
global_step / args.MLE_decay_steps)))
else:
gap = 1
if n_batch % gap == 0:
if global_step < 1:
print(
'$$$Update B use back-translated data (Update gap:%s)'
% gap)
# Update Seq2SentiSeq with previous model generated data # senti-, bleu+
feed_dict = {
s2ss_train.encoder_input: mid_ids_bs,
s2ss_train.encoder_input_len: mid_ids_length_bs,
s2ss_train.decoder_input: src["ids_in"],
s2ss_train.decoder_target: src["ids_out"],
s2ss_train.decoder_target_len: src["length"] + 1,
s2ss_train.decoder_s: src["senti"],
}
sess.run([s2ss_train.loss, s2ss_train.train_op],
feed_dict=feed_dict)
if "back_trans_random" in args.teacher_forcing:
if args.MLE_decay:
if args.MLE_decay_type == "linear":
gap = min(10, 2 + global_step /
args.MLE_decay_steps) # 10 after 1 epoch
else:
gap = min(
5,
int(1 / np.power(
args.MLE_decay_rate,
global_step / args.MLE_decay_steps)))
else:
gap = 1
if n_batch % gap == 0:
if global_step < 1:
print(
'$$$Update B use back_trans_random data (Update gap:%s)'
% gap)
# Update Seq2SentiSeq with previous model generated data with noise
feed_dict = {
s2ss_train.encoder_input: mid_ids,
s2ss_train.encoder_input_len: mid_ids_length,
s2ss_train.decoder_input: tile_src_ids_in,
s2ss_train.decoder_target: tile_src_ids_out,
s2ss_train.decoder_target_len: tile_src_length + 1,
s2ss_train.decoder_s: tile_src_decoder_s,
}
sess.run([s2ss_train.loss, s2ss_train.train_op],
feed_dict=feed_dict)
if "back_trans_noise" in args.teacher_forcing:
if args.MLE_decay:
if args.MLE_decay_type == "linear":
gap = min(10, 2 + global_step /
args.MLE_decay_steps) # 10 after 1 epoch
else:
gap = min(
5,
int(1 / np.power(
args.MLE_decay_rate,
global_step / args.MLE_decay_steps)))
else:
gap = 1
if n_batch % gap == 0:
if global_step < 1:
print(
'$$$Update B use back_trans_noise data (Update gap:%s)'
% gap)
# Update Seq2SentiSeq with previous model generated data with noise
noise_ids, noise_ids_length = add_noise(
mid_ids_bs, mid_ids_length_bs)
feed_dict = {
s2ss_train.encoder_input: noise_ids,
s2ss_train.encoder_input_len: noise_ids_length,
s2ss_train.decoder_input: src["ids_in"],
s2ss_train.decoder_target: src["ids_out"],
s2ss_train.decoder_target_len: src["length"] + 1,
s2ss_train.decoder_s: src["senti"],
}
sess.run([s2ss_train.loss, s2ss_train.train_op],
feed_dict=feed_dict)
if "pseudo_data" in args.teacher_forcing: # balance
if args.MLE_decay:
if args.MLE_decay_type == "linear":
gap = min(10, 3 + global_step /
args.MLE_decay_steps) # 10 after 1 epoch
else:
gap = min(
100,
int(3 / np.power(
args.MLE_decay_rate,
global_step / args.MLE_decay_steps)))
else:
gap = 3
if n_batch % gap == 0:
if global_step < 1:
print('$$$Update use pseudo data (Update gap:%s)' %
gap)
data = sess.run(
paired_train_data_next) # get real data!!
feed_dict = {
s2ss_train.encoder_input: data["source_ids"],
s2ss_train.encoder_input_len:
data["source_length"],
s2ss_train.decoder_input: data["target_ids_in"],
s2ss_train.decoder_target: data["target_ids_out"],
s2ss_train.decoder_target_len:
data["target_length"] + 1,
s2ss_train.decoder_s: data["target_senti"]
}
sess.run([s2ss_train.loss, s2ss_train.train_op],
feed_dict=feed_dict)
if "same" in args.teacher_forcing:
if args.same_decay:
if args.same_decay_type == "linear":
gap = min(
8, 2 + global_step /
args.same_decay_steps) # 10 after 1 epoch
else:
gap = min(
10,
int(2 / np.power(
args.same_decay_rate,
global_step / args.same_decay_rate)))
else:
gap = 2
if n_batch % gap == 0:
print('$$$Update use same data (Update gap:%s)' % gap)
# Update Seq2SentiSeq with target output # senti-, bleu+
feed_dict = {
s2ss_train.encoder_input: src["ids"],
s2ss_train.encoder_input_len: src["length"],
s2ss_train.decoder_input: src["ids_in"],
s2ss_train.decoder_target: src["ids_out"],
s2ss_train.decoder_target_len: src["length"] + 1,
s2ss_train.decoder_s: src["senti"]
}
sess.run([s2ss_train.loss, s2ss_train.train_op],
feed_dict=feed_dict)
if "same_noise" in args.teacher_forcing:
if args.same_decay:
if args.same_decay_type == "linear":
gap = min(
8, 2 + global_step /
args.same_decay_steps) # 10 after 1 epoch
else:
gap = min(
10,
int(2 / np.power(
args.same_decay_rate,
global_step / args.same_decay_rate)))
else:
gap = 2
if n_batch % gap == 0:
print('$$$Update use same_noise data (Update gap:%s)' %
gap)
noise_ids, noise_ids_length = add_noise(
src["ids"], src["length"])
feed_dict = {
s2ss_train.encoder_input: noise_ids,
s2ss_train.encoder_input_len: noise_ids_length,
s2ss_train.decoder_input: src["ids_in"],
s2ss_train.decoder_target: src["ids_out"],
s2ss_train.decoder_target_len: src["length"] + 1,
s2ss_train.decoder_s: src["senti"]
}
sess.run([s2ss_train.loss, s2ss_train.train_op],
feed_dict=feed_dict)
except tf.errors.OutOfRangeError: # next epoch
print("Train---Total N batch:{}\tCost time:{}".format(
n_batch,
time.time() - t0))
n_batch = -1
break
