def train(self, n_epochs=6):
print("Training RNN-based generator ...")
with tf.Session(config=tf.ConfigProto(
log_device_placement=True)) as session:
self._initialize_session(session)
try:
for epoch in range(n_epochs):
batch_no = 0
for keywords, contexts, sentences \
in batch_train_data(_BATCH_SIZE):
sys.stdout.write("[Seq2Seq Training] epoch = %d, " \
"line %d to %d ..." %
(epoch, batch_no * _BATCH_SIZE,
(batch_no + 1) * _BATCH_SIZE))
sys.stdout.flush()
self._train_a_batch(session, epoch, keywords, contexts,
sentences)
batch_no += 1
# if 0 == batch_no % 32:
# with open('save/check_epoch', 'a+') as file:
# file.write('{}-{}\n'.format(epoch, batch_no))
# self.saver.save(session, _model_path)
with open('save/check_epoch', 'a+') as file:
file.write('{}\n'.format(epoch))
self.saver.save(session, _model_path)
print("Training is done.")
except KeyboardInterrupt:
print("Training is interrupted.")
def train(self, epoch, mode, phase, data_mode=-1, data_phase=-1, seq=-1):
if data_mode == -1:
data_mode = mode
data_phase = phase
# keyword_id, keyword_length, context_id, context_length, label_id
with tf.Session() as sess:
sess.run(tf.global_variables_initializer())
model_path_l = model_load_path[mode]
model_path_s = model_save_path[mode]
saver = tf.train.Saver(max_to_keep=5, sharded=False)
try:
saver.restore(sess, tf.train.latest_checkpoint(model_path_s))
except:
print('mode not found')
model_load_path[mode] = model_path_s
for i in range(epoch):
# time.sleep(10)
print(f'begin epoch {i}')
for keywords, ground_truth, contexts, sentences in batch_train_data(
BATCH_SIZE, data_mode, data_phase):
keyword_id, keyword_length = self.get_id_length(keywords)
ground_truth_id, _ = self.get_id_length(ground_truth)
context_id, context_length = self.get_id_length(contexts)
label_id, _ = self.get_id_length(sentences)
_, loss = sess.run(
(self.train_op, self.loss),
feed_dict={
self.keyword_id: keyword_id,
self.keyword_length: keyword_length,
self.decoder_input_id: ground_truth_id,
self.context_id: context_id,
self.label_id: label_id,
self.context_length: context_length,
})
if (i + 1) % 5 == 0:
time.sleep(30)
with open(result_save_path[mode] + '/loss.txt', 'a') as f:
f.write(f'{i}\t{loss}\n')
print(loss)
saver.save(sess,
model_save_path[mode] + f'/{seq}_{i}',
global_step=i + 1)
poem = self.generate(['春', '秋', '冬', '夏'], i,
result_save_path[mode],
model_save_path[mode], f'{seq}_{i}')
print(poem)
with open(result_save_path[mode] + '/poem.txt', 'a') as f:
f.write(poem + '\n')
def train(self, n_epochs):
print("Training RNN-based generator ...")
try:
for epoch in range(n_epochs):
batch_no = 0
for keywords, contexts, sentences in batch_train_data(
_BATCH_SIZE):
sys.stdout.write(
"[Seq2Seq Training] epoch = %d, line %d to %d ..." %
(epoch, batch_no * _BATCH_SIZE,
(batch_no + 1) * _BATCH_SIZE))
sys.stdout.flush()
self._train_a_batch(keywords, contexts, sentences)
batch_no += 1
if 0 == batch_no % 32:
self.manager.save()
self.manager.save()
print("Training is done.")
except KeyboardInterrupt:
print("Training is interrupted.")
def train(n_epochs=6):
funcutils = FuncUtils()
generator = Generator()
tf.summary.scalar('accuracy', generator.loss) # 生成准确率标量图
tf.summary.scalar('lr', generator.lr) # 生成准确率标量图
merge_summary = tf.summary.merge_all()
batch_no = 0
saver = tf.train.Saver()
tf_config = tf.ConfigProto()
tf_config.gpu_options.allow_growth = True
loss_best = 1000
with tf.Session(config=tf_config) as sess:
train_writer = tf.summary.FileWriter(
_logwriter_dir, sess.graph) #定义一个写入summary的目标文件，dir为写入文件地址
generator.initialize_session(sess, saver)
for epoch_iter in range(n_epochs):
# print('epoch_iter\t{}'.format(epoch_iter))
for keywords, contexts, sentences in batch_train_data(_BATCH_SIZE):
# print('-4-'*5)
if batch_no % 32 == 0:
# print('len(poems_set)==>',len(poems_set))
print_onehot, logits, lr, loss, summary_value = _train_a_batch(
funcutils, generator, sess, epoch_iter, keywords,
contexts, sentences, merge_summary)
train_writer.add_summary(summary_value, batch_no)
print('epoch\t{}\tloss\t{}lr\t{}'.format(
epoch_iter, loss, lr))
# print('print_onehot==>',print_onehot)
# print('logits==>',logits)
if loss < loss_best:
saver.save(sess, _model_path)
loss_best = loss
batch_no += 1
def train(self, n_epochs=6):
print("Training RNN-based generator ...")
with tf.Session() as session:
self._initialize_session(session)
try:
for epoch in range(n_epochs):
batch_no = 0
for keywords, contexts, sentences \
in batch_train_data(_BATCH_SIZE):
sys.stdout.write("[Seq2Seq Training] epoch = %d, " \
"line %d to %d ..." %
(epoch, batch_no * _BATCH_SIZE,
(batch_no + 1) * _BATCH_SIZE))
sys.stdout.flush()
self._train_a_batch(session, epoch, keywords, contexts,
sentences)
batch_no += 1
if 0 == batch_no % 32:
self.saver.save(session, _model_path)
self.saver.save(session, _model_path)
print("Training is done.")
except KeyboardInterrupt:
print("Training is interrupted.")
import argparse
from train import train
from infer import generate_control
from char2vec import Char2Vec
from char_dict import CharDict
from poems import Poems
from data_utils import batch_train_data
from rank_words import RankedWords
if __name__=='__main__':
arguementparser=argparse.ArgumentParser(description='chinese poem generation')
arguementparser.add_argument('-t',action='store_true',dest='train',default=False)
arguementparser.add_argument('-p',action='store_true',dest='pretrain',default=False)
arguementparser.add_argument('-i',action='store_true',dest='infer',default=False)
# arguementparser.add_argument('-p', dest = 'planner', default = False,action = 'store_true',
# help = 'train planning model')
args=arguementparser.parse_args()
# print('args==>',args)
if args.train:
print('进入训练阶段')
train(n_epochs=1000)
elif args.pretrain:
print('进入预训练阶段')
CharDict()
RankedWords()
Char2Vec()
Poems()
batch_train_data(32)
elif args.infer:
print('进入测试阶段')
generate_control()
