def test():
batch_size = 1
print('## loading model from %s...' % model_dir)
input_data = tf.placeholder(tf.int32, [batch_size, 7])
end_points = rnn_model(model='lstm', input_data=input_data, output_data=None, vocab_size=33+16,
rnn_size=128, output_num=7,input_num=7,num_layers=7, batch_size=batch_size, learning_rate=0.01)
saver = tf.train.Saver(tf.global_variables())
init_op = tf.group(tf.global_variables_initializer(), tf.local_variables_initializer())
with tf.Session() as sess:
sess.run(init_op)
checkpoint = tf.train.latest_checkpoint(model_dir)
saver.restore(sess, checkpoint)
ssqdata = get_datas_from_database()
predict = sess.run(end_points['prediction'], feed_dict={input_data: [ssqdata[2223]]})
predict_result, aa = get_correct(predict)
print("概率最大的一组: {}".format(predict_result))
for c in range(2, 11):
j = -1
for i in aa:
j += 1
predict[j][i] -= 1
predict_result, aa = get_correct(predict)
print("概率第{}大的一组: {}".format(c, predict_result))
def gen_poem():
batch_size = 1
print('## loading model from %s' % model_dir)
input_data = tf.placeholder(tf.int32, [batch_size, None])
end_points = rnn_model(model='lstm',
input_data=input_data,
output_data=None,
vocab_size=33 + 16,
rnn_size=128,
output_num=7,
num_layers=7,
batch_size=1,
learning_rate=0.01)
saver = tf.train.Saver(tf.global_variables())
init_op = tf.group(tf.global_variables_initializer(),
tf.local_variables_initializer())
with tf.Session() as sess:
sess.run(init_op)
checkpoint = tf.train.latest_checkpoint(model_dir)
saver.restore(sess, checkpoint)
ssqdata = get_exl_data()
# x = np.array([list(map(word_int_map.get, start_token))])
x = [ssqdata[len(ssqdata) - 1]]
print("input: %s" % (x + np.asarray([1, 1, 1, 1, 1, 1, -32])))
[predict, last_state
] = sess.run([end_points['prediction'], end_points['last_state']],
feed_dict={input_data: x})
poem_ = np.argmax(np.array(predict), axis=1)
results = poem_ + np.asarray([1, 1, 1, 1, 1, 1, -32])
print("output:" % results)
return poem_
def run_training():
if not os.path.exists(FLAGS.model_dir):
os.makedirs(FLAGS.model_dir)
poems_vector, word_to_int, vocabularies = process_poems(FLAGS.file_path)
batches_inputs, batches_outputs = generate_batch(FLAGS.batch_size,
poems_vector, word_to_int)
input_data = tf.placeholder(tf.int32, [FLAGS.batch_size, None])
output_targets = tf.placeholder(tf.int32, [FLAGS.batch_size, None])
end_points = rnn_model(model='lstm',
input_data=input_data,
output_data=output_targets,
vocab_size=len(vocabularies),
rnn_size=128,
num_layers=2,
batch_size=64,
learning_rate=FLAGS.learning_rate)
saver = tf.train.Saver(tf.global_variables())
init_op = tf.group(tf.global_variables_initializer(),
tf.local_variables_initializer())
with tf.Session() as sess:
# sess = tf_debug.LocalCLIDebugWrapperSession(sess=sess)
# sess.add_tensor_filter("has_inf_or_nan", tf_debug.has_inf_or_nan)
sess.run(init_op)
start_epoch = 0
checkpoint = tf.train.latest_checkpoint(FLAGS.model_dir)
if checkpoint:
saver.restore(sess, checkpoint)
print("## restore from the checkpoint {0}".format(checkpoint))
start_epoch += int(checkpoint.split('-')[-1])
print('## start training...')
try:
for epoch in range(start_epoch, FLAGS.epochs):
n = 0
n_chunk = len(poems_vector) // FLAGS.batch_size
#for batch in range(n_chunk):
# loss, _, _ = sess.run([
# end_points['total_loss'],
# end_points['last_state'],
# end_points['train_op']
# ], feed_dict={input_data: batches_inputs[n], output_targets: batches_outputs[n]})
# n += 1
# print('Epoch: %d, batch: %d, training loss: %.6f' % (epoch, batch, loss))
if epoch % 6 == 0:
saver.save(sess,
os.path.join(FLAGS.model_dir,
FLAGS.model_prefix),
global_step=epoch)
except KeyboardInterrupt:
print('## Interrupt manually, try saving checkpoint for now...')
saver.save(sess,
os.path.join(FLAGS.model_dir, FLAGS.model_prefix),
global_step=epoch)
print(
'## Last epoch were saved, next time will start from epoch {}.'
.format(epoch))
def run_training():
if not os.path.exists(FLAGS.model_dir):
os.makedirs(FLAGS.model_dir)
ssqdata = get_datas_from_database()
trainnum = 2206
batches_inputs = ssqdata[0:trainnum - 1]
batches_outputs = ssqdata[1:trainnum]
FLAGS.batch_size = trainnum - 1
del ssqdata
input_data = tf.placeholder(tf.int32, [FLAGS.batch_size, 7])
output_targets = tf.placeholder(tf.int32, [FLAGS.batch_size, 7])
end_points = rnn_model(model='lstm',
input_data=input_data,
output_data=output_targets,
vocab_size=33 + 16,
output_num=7,
input_num=7,
rnn_size=128,
num_layers=7,
batch_size=FLAGS.batch_size,
learning_rate=FLAGS.learning_rate)
saver = tf.train.Saver(tf.global_variables())
init_op = tf.group(tf.global_variables_initializer(),
tf.local_variables_initializer())
with tf.Session() as sess:
sess.run(init_op)
start_epoch = 0
checkpoint = tf.train.latest_checkpoint(FLAGS.model_dir)
if checkpoint:
saver.restore(sess, checkpoint)
print("## restore from the checkpoint {0}".format(checkpoint))
start_epoch += int(checkpoint.split('-')[-1])
print('## start training...')
for epoch in range(start_epoch, FLAGS.epochs):
loss, _, _ = sess.run([
end_points['total_loss'], end_points['last_state'],
end_points['train_op']
],
feed_dict={
input_data: batches_inputs,
output_targets: batches_outputs
})
print('Epoch: %d, training loss: %.6f' % (epoch, loss))
if epoch % 10 == 0:
saver.save(sess,
os.path.join(FLAGS.model_dir, FLAGS.model_prefix),
global_step=epoch)
def gen_poem(begin_word):
batch_size = 1
print('## loading corpus from %s' % model_dir)
poems_vector, word_int_map, vocabularies = process_poems(corpus_file)
input_data = tf.placeholder(tf.int32, [batch_size, None])
end_points = rnn_model(model='lstm',
input_data=input_data,
output_data=None,
vocab_size=len(vocabularies),
rnn_size=128,
num_layers=2,
batch_size=64,
learning_rate=lr)
saver = tf.train.Saver(tf.global_variables())
init_op = tf.group(tf.global_variables_initializer(),
tf.local_variables_initializer())
with tf.Session() as sess:
sess.run(init_op)
checkpoint = tf.train.latest_checkpoint(model_dir)
saver.restore(sess, checkpoint)
x = np.array([list(map(word_int_map.get, start_token))])
[predict, last_state
] = sess.run([end_points['prediction'], end_points['last_state']],
feed_dict={input_data: x})
if begin_word:
word = begin_word
else:
word = to_word(predict, vocabularies)
poem_ = ''
i = 0
while word != end_token:
poem_ += word
i += 1
if i >= 24:
break
x = np.zeros((1, 1))
x[0, 0] = word_int_map[word]
[predict, last_state
] = sess.run([end_points['prediction'], end_points['last_state']],
feed_dict={
input_data: x,
end_points['initial_state']: last_state
})
word = to_word(predict, vocabularies)
return poem_
def gen_poem():
batch_size = 1
print('## loading model from %s' % model_dir)
input_data = tf.compat.v1.placeholder(tf.float32, [1, 10, 7 + 8, 1])
logits = inference(input_data, 1, reuse=False, output_num=128)
# print(tf.shape(input_data))
output_targets = tf.compat.v1.placeholder(tf.int32, [1, None])
end_points = rnn_model(model='lstm',
input_data=logits,
output_data=output_targets,
vocab_size=33 + 16,
output_num=7,
rnn_size=128,
num_layers=7,
batch_size=1,
learning_rate=0.001)
# input_data = tf.placeholder(tf.int32, [batch_size, None])
#
# end_points = rnn_model(model='lstm', input_data=input_data, output_data=None, vocab_size=33,
# rnn_size=128, num_layers=7, batch_size=0, learning_rate=0.01)
saver = tf.compat.v1.train.Saver(tf.compat.v1.global_variables())
init_op = tf.group(tf.compat.v1.global_variables_initializer(),
tf.compat.v1.local_variables_initializer())
with tf.compat.v1.Session() as sess:
sess.run(init_op)
checkpoint = tf.train.latest_checkpoint('./model4all_v4/')
saver.restore(sess, checkpoint)
# saver.restore(sess, "E:/workplace/tensorflow_poems-master/model4all/poems-208368")
# ssqdata = get_exl_data(random_order=True,use_resnet=True)
# ssqdata = get_exl_data_v3(random_order=True, use_resnet=True)
ssqdata = get_exl_data_by_period(random_order=False,
use_resnet=True,
times=10)
x = [ssqdata[len(ssqdata) - 1]]
print("input: %s" %
(x + np.asarray([[[[0], [0], [0], [0], [0], [0], [-33], [0], [0],
[0], [0], [0], [0], [0], [0]]]])))
[predict, last_state
] = sess.run([end_points['prediction'], end_points['last_state']],
feed_dict={input_data: x})
poem_ = np.argmax(np.array(predict), axis=1)
sorted_result = np.argsort(np.array(predict), axis=1)
results = poem_ + np.asarray([0, 0, 0, 0, 0, 0, -33])
print(sorted_result)
print("output: %s" % results)
return poem_
def gen_poem():
batch_size = 1
print('## loading model from %s' % model_dir)
input_data = tf.placeholder(tf.float32, [1, 1, 7, 1])
logits = inference(input_data, 10, reuse=False, output_num=128)
# print(tf.shape(input_data))
output_targets = tf.placeholder(tf.int32, [1, None])
end_points = rnn_model(model='lstm',
input_data=logits,
output_data=output_targets,
vocab_size=33 + 16,
output_num=7,
rnn_size=128,
num_layers=7,
batch_size=1,
learning_rate=0.01)
# input_data = tf.placeholder(tf.int32, [batch_size, None])
#
# end_points = rnn_model(model='lstm', input_data=input_data, output_data=None, vocab_size=33,
# rnn_size=128, num_layers=7, batch_size=1, learning_rate=0.01)
saver = tf.train.Saver(tf.global_variables())
init_op = tf.group(tf.global_variables_initializer(),
tf.local_variables_initializer())
with tf.Session() as sess:
sess.run(init_op)
# checkpoint = tf.train.latest_checkpoint('./model4all/')
# saver.restore(sess, checkpoint)
saver.restore(sess,
"F:/tensorflow_poems-master/model4all/poems-401713")
ssqdata = get_exl_data(random_order=True, use_resnet=True)
# x = np.array([list(map(word_int_map.get, start_token))])
x = [ssqdata[len(ssqdata) - 1]]
print("input: %s" %
(x + np.asarray([[[[1], [1], [1], [1], [1], [1], [-32]]]])))
[predict, last_state
] = sess.run([end_points['prediction'], end_points['last_state']],
feed_dict={input_data: x})
poem_ = np.argmax(np.array(predict), axis=1)
sorted_result = np.argsort(np.array(predict), axis=1)
results = poem_ + np.asarray([1, 1, 1, 1, 1, 1, -32])
print(sorted_result)
print("output: %s" % results)
poem_ = np.argmin(np.array(predict), axis=1)
results = poem_ + np.asarray([1, 1, 1, 1, 1, 1, -32])
print("min output:%s" % results)
return poem_
def run_training():
if not os.path.exists(FLAGS.model_dir):
os.makedirs(FLAGS.model_dir)
poems_vector, word_to_int, vocabularies = process_poems(FLAGS.file_path)
batches_inputs, batches_outputs = generate_batch(FLAGS.batch_size, poems_vector, word_to_int)
input_data = tf.placeholder(tf.int32, [FLAGS.batch_size, None])
output_targets = tf.placeholder(tf.int32, [FLAGS.batch_size, None])
end_points = rnn_model(model='lstm', input_data=input_data, output_data=output_targets, vocab_size=len(
vocabularies), rnn_size=128, num_layers=2, batch_size=64, learning_rate=FLAGS.learning_rate)
saver = tf.train.Saver(tf.global_variables())
init_op = tf.group(tf.global_variables_initializer(), tf.local_variables_initializer())
with tf.Session() as sess:
# sess = tf_debug.LocalCLIDebugWrapperSession(sess=sess)
# sess.add_tensor_filter("has_inf_or_nan", tf_debug.has_inf_or_nan)
sess.run(init_op)
start_epoch = 0
checkpoint = tf.train.latest_checkpoint(FLAGS.model_dir)
if checkpoint:
saver.restore(sess, checkpoint)
print("## restore from the checkpoint {0}".format(checkpoint))
start_epoch += int(checkpoint.split('-')[-1])
print('## start training...')
try:
for epoch in range(start_epoch, FLAGS.epochs):
n = 0
n_chunk = len(poems_vector) // FLAGS.batch_size
for batch in range(n_chunk):
loss, _, _ = sess.run([
end_points['total_loss'],
end_points['last_state'],
end_points['train_op']
], feed_dict={input_data: batches_inputs[n], output_targets: batches_outputs[n]})
n += 1
print('Epoch: %d, batch: %d, training loss: %.6f' % (epoch, batch, loss))
if epoch % 6 == 0:
saver.save(sess, os.path.join(FLAGS.model_dir, FLAGS.model_prefix), global_step=epoch)
except KeyboardInterrupt:
print('## Interrupt manually, try saving checkpoint for now...')
saver.save(sess, os.path.join(FLAGS.model_dir, FLAGS.model_prefix), global_step=epoch)
print('## Last epoch were saved, next time will start from epoch {}.'.format(epoch))
def gen_poem(begin_word):
batch_size = 1
print('## loading corpus from %s' % model_dir)
poems_vector, word_int_map, vocabularies = process_poems(corpus_fileh)
input_data = tf.placeholder(tf.int32, [batch_size, None])
end_points = rnn_model(model='lstm', input_data=input_data, output_data=None, vocab_size=len(
vocabularies), rnn_size=128, num_layers=2, batch_size=64, learning_rate=FLAGS.learning_rate)
saver = tf.train.Saver(tf.global_variables())
init_op = tf.group(tf.global_variables_initializer(), tf.local_variables_initializer())
with tf.Session() as sess:
sess.run(init_op)
checkpoint = tf.train.latest_checkpoint(model_dir)
saver.restore(sess, checkpoint)
x = np.array([list(map(word_int_map.get, start_token))])
[predict, last_state] = sess.run([end_points['prediction'], end_points['last_state']],
feed_dict={input_data: x})
if begin_word:
word = begin_word
else:
word = to_word(predict, vocabularies)
poem_ = ''
i = 0
while word != end_token:
poem_ += word
i += 1
if i >= 24:
break
x = np.zeros((1, 1))
x[0, 0] = word_int_map[word]
[predict, last_state] = sess.run([end_points['prediction'], end_points['last_state']],
feed_dict={input_data: x, end_points['initial_state']: last_state})
word = to_word(predict, vocabularies)
return poem_
def __init__(self, s_word):
self.begin_word = s_word
self.start_token = 'B'
self.end_token = 'E'
self.model_dir = './model/'
self.corpus_file = './data/poems.txt'
self.lr = 0.0002
self.RATE = 0.008
self.max_len = 78
self.poems_vector, self.word_int_map, self.vocabs = process_poems(
self.corpus_file)
self.input_data = tf.placeholder(tf.int32, [1, None])
self.end_points = rnn_model(model='lstm',
input_data=self.input_data,
output_data=None,
vocab_size=len(self.vocabs),
rnn_size=128,
num_layers=2,
batch_size=64,
learning_rate=self.lr)
self._parse_input()
def test():
batch_size = 1
print('## loading model from %s...' % model_dir)
input_data = tf.placeholder(tf.int32, [batch_size, 7])
end_points = rnn_model(model='lstm',
input_data=input_data,
output_data=None,
vocab_size=33 + 16,
rnn_size=128,
output_num=7,
input_num=7,
num_layers=7,
batch_size=batch_size,
learning_rate=0.01)
saver = tf.train.Saver(tf.global_variables())
init_op = tf.group(tf.global_variables_initializer(),
tf.local_variables_initializer())
with tf.Session() as sess:
sess.run(init_op)
checkpoint = tf.train.latest_checkpoint(model_dir)
saver.restore(sess, checkpoint)
ssqdata = get_datas_from_database()
accuracy = 0
for i in range(2206, 2224):
predict = sess.run(end_points['prediction'],
feed_dict={input_data: [ssqdata[i]]})
correct_result = np.asarray(ssqdata[i + 1]) + np.asarray(
[1, 1, 1, 1, 1, 1, 1])
predict_result = get_correct(predict)
matches = match(correct_result, predict_result)
print("组{}正确率: {}".format(i, reduce(sum, matches) / 8))
accuracy += reduce(sum, matches) / 8
accuracy /= 18
print("模型准确率: {}".format(accuracy))
def predict():
batch_size = 1
print('## loading model from %s...' % model_dir)
input_data = tf.placeholder(tf.int32, [batch_size, None])
end_points = rnn_model(model='lstm',
input_data=input_data,
output_data=None,
vocab_size=33 + 16,
rnn_size=128,
output_num=7,
input_num=7,
num_layers=7,
batch_size=1,
learning_rate=0.01)
saver = tf.train.Saver(tf.global_variables())
init_op = tf.group(tf.global_variables_initializer(),
tf.local_variables_initializer())
with tf.Session() as sess:
sess.run(init_op)
checkpoint = tf.train.latest_checkpoint(model_dir)
saver.restore(sess, checkpoint)
ssqdata = get_datas_from_database()
x = ssqdata[len(ssqdata) - 1]
print("input: %s" % (x + np.asarray([1, 1, 1, 1, 1, 1, 1])))
[predict, last_state
] = sess.run([end_points['prediction'], end_points['last_state']],
feed_dict={input_data: [x]})
results = get_correct(predict)
print("output:%s" % results)
print("预测下一组双色球结果：红 {} {} {} {} {} {}, 蓝 {}".format(
results[0], results[1], results[2], results[3], results[4],
results[5], results[6]))
def run_training():
# dir to save model
if os.path.exists(FLAGS.model_dir):
os.mkdir(FLAGS.model_dir)
poems_vector, word_to_int, vocabularies = process_poems(FLAGS.file_path)
batches_input, batches_outputs = generate_batch(FLAGS.batch_size,
poems_vector, word_to_int)
# print(word_to_int)
# print(batches_input[0][0])
# print(batches_outputs[0][1])
# print(batches_outputs)
# time.sleep(10000)
input_data = tf.placeholder(tf.int32, [FLAGS.batch_size, None])
output_targets = tf.placeholder(tf.int32, [FLAGS.batch_size, None])
end_points = rnn_model(model="lstm",
input_data=input_data,
output_data=output_targets,
vocab_size=len(vocabularies),
rnn_size=128,
num_layers=2,
batch_size=64,
learning_rate=FLAGS.learning_rate)
saver = tf.train.Saver(tf.global_variables())
init_op = tf.group(tf.global_variables_initializer(),
tf.local_variables_initializer())
with tf.Session() as sess:
# 初始化所有的变量
sess.run(init_op)
start_epoch = 0
checkpoint = tf.train.latest_checkpoint(FLAGS.model_dir)
if checkpoint:
saver.restore(sess, checkpoint)
print("### restore from the checkpoint {0}".format(checkpoint))
start_epoch += int(checkpoint.split('-')[-1])
print(' ## start training... ')
try:
for epoch in range(start_epoch, FLAGS.epochs):
n = 0
n_chunk = len(poems_vector) // FLAGS.batch_size
for batch in range(n_chunk):
loss, _, _ = sess.run(
[
end_points['total_loss'], end_points['last_state'],
end_points['train_op']
],
feed_dict={
input_data: batches_input[n],
output_targets: batches_outputs[n]
})
n += 1
print('Epoch: %d, batch: %d, training loss: %.6f' %
(epoch, batch, loss))
if epoch % 6:
saver.save(sess,
os.path.join(FLAGS.model_dir,
FLAGS.model_prefix),
global_step=epoch)
except KeyboardInterrupt:
print('## Interrupt manually, try saving checkpoint for now...')
saver.save(sess,
os.path.join(FLAGS.model_dir, FLAGS.model_prefix),
global_step=epoch)
print(
'## Last epoch were saved, next time will start from epoch {}.'
.format(epoch))
def gen_poem(begin_word):
# 根据首个汉字作诗
# 作诗时, batch_size设为1
batch_size = 1
print('## loading corpus from %s' % model_dir)
# 读取诗集文件
# 依次得到数字ID表示的诗句、汉字-ID的映射map、所有的汉字的列表
poems_vector, word_int_map, vocabularies = process_poems(corpus_file)
# 声明输入的占位符
input_data = tf.placeholder(tf.int32, [batch_size, None])
# 通过rnn模型得到结果状态集
end_points = rnn_model(model='lstm', input_data=input_data, output_data=None, vocab_size=len(
vocabularies), rnn_size=128, num_layers=2, batch_size=64, learning_rate=lr)
# 初始化saver和session
saver = tf.train.Saver(tf.global_variables())
init_op = tf.group(tf.global_variables_initializer(), tf.local_variables_initializer())
with tf.Session() as sess:
sess.run(init_op)
# 加载上次的模型参数
checkpoint = tf.train.latest_checkpoint(model_dir)
# 注: 无模型参数时, 该步直接crash, 强制有训练好的模型参数
saver.restore(sess, checkpoint)
# 取出诗文前缀(G)对应的索引值所谓初始输入
x = np.array([list(map(word_int_map.get, start_token))])
# 得出预测值和rnn的当前状态
[predict, last_state] = sess.run([end_points['prediction'], end_points['last_state']],
feed_dict={input_data: x})
if begin_word:
# 用户输入值赋值给word
word = begin_word
else:
# 若未输入, 则取初始预测值的词向量
word = to_word(predict, vocabularies)
# 初始化作诗结果变量
poem_ = ''
i = 0
# 未到结束符时, 一直预测下一个词
while word != end_token:
# 没预测一个则追加到结果上
poem_ += word
i += 1
if i >= 24:
break
# 初始化输入为[[0]]
x = np.zeros((1, 1))
# 赋值为当前word对应的索引值
x[0, 0] = word_int_map[word]
# 根据当前词和当前的上下文状态(last_state)进行预测
# 返回的结果是预测值和最新的上下文状态
[predict, last_state] = sess.run([end_points['prediction'], end_points['last_state']],
feed_dict={input_data: x, end_points['initial_state']: last_state})
# 根据预测值得出词向量
word = to_word(predict, vocabularies)
return poem_
def run_training():
if not os.path.exists(model_dir):
os.makedirs(model_dir)
if not os.path.exists(log_dir):
os.makedirs(log_dir)
poems_vector, word_to_int, vocabularies = process_poems(corpus_path)
batches_inputs, batches_outputs = generate_batch(FLAGS.batch_size,
poems_vector, word_to_int)
print("## top ten vocabularies: %s" % str(vocabularies[:10]))
print("## tail ten vocabularies: %s" % str(vocabularies[-10:]))
print("## len(first vector)=%d, first vector[:50]: %s" %
(len(poems_vector[0]), poems_vector[0][:50]))
print("## len(last vector)=%d, second vector[:50]: %s" %
(len(poems_vector[-1]), poems_vector[-1][:50]))
input_data = tf.placeholder(tf.int32, [FLAGS.batch_size, None])
output_targets = tf.placeholder(tf.int32, [FLAGS.batch_size, None])
end_points = rnn_model(model='lstm',
input_data=input_data,
output_data=output_targets,
vocab_size=len(vocabularies),
rnn_size=128,
num_layers=2,
batch_size=FLAGS.batch_size,
learning_rate=FLAGS.learning_rate)
saver = tf.train.Saver(tf.global_variables())
init_op = tf.group(tf.global_variables_initializer(),
tf.local_variables_initializer())
summary_op = tf.summary.merge_all()
with tf.Session() as sess:
train_writer = tf.summary.FileWriter(os.path.join(log_dir, "train"),
sess.graph)
sess.run(init_op)
start_epoch = 0
checkpoint = tf.train.latest_checkpoint(model_dir)
if checkpoint:
saver.restore(sess, checkpoint)
print("## restore from the checkpoint {0}".format(checkpoint),
flush=True)
start_epoch += int(checkpoint.split('-')[-1]) + 1
print('## start training...', flush=True)
n_chunk = len(poems_vector) // FLAGS.batch_size
try:
for epoch in range(start_epoch, FLAGS.epochs):
n = 0
for batch in range(n_chunk):
step = epoch * n_chunk + batch
if step % FLAGS.print_every_steps == 0:
loss, _, _, train_summary = sess.run(
[
end_points['total_loss'],
end_points['last_state'],
end_points['train_op'], summary_op
],
feed_dict={
input_data: batches_inputs[n],
output_targets: batches_outputs[n]
})
train_writer.add_summary(train_summary,
global_step=step)
print(
'[%s] Step: %d, Epoch: %d, batch: %d, training loss: %.6f'
% (time.strftime('%Y-%m-%d %H:%M:%S'), step, epoch,
batch, loss),
flush=True)
else:
_, _ = sess.run(
[end_points['last_state'], end_points['train_op']],
feed_dict={
input_data: batches_inputs[n],
output_targets: batches_outputs[n]
})
n += 1
step += 1
if epoch % FLAGS.save_every_epoch == 0:
saver.save(sess, model_file, global_step=epoch)
print("[%s] Saving checkpoint for epoch %d" %
(time.strftime('%Y-%m-%d %H:%M:%S'), epoch),
flush=True)
except KeyboardInterrupt:
print('## Interrupt manually, try saving checkpoint for now...')
saver.save(sess, model_file, global_step=epoch)
print(
'## Last epoch were saved, next time will start from epoch {}.'
.format(epoch),
flush=True)
tf.app.flags.DEFINE_integer('epochs', 50, 'train how many epochs.')
FLAGS = tf.app.flags.FLAGS
def run_training():
if not os.path.exists(FLAGS.model_dir): //没有路径
os.makedirs(FLAGS.model_dir) //创造路径
poems_vector, word_to_int, vocabularies = process_poems(FLAGS.file_path) //前置处理，生成词向量
batches_inputs, batches_outputs = generate_batch(FLAGS.batch_size, poems_vector, word_to_int) //分成batch
input_data = tf.placeholder(tf.int32, [FLAGS.batch_size, None])
output_targets = tf.placeholder(tf.int32, [FLAGS.batch_size, None])
end_points = rnn_model(model='lstm', input_data=input_data, output_data=output_targets, vocab_size=len(
vocabularies), rnn_size=128, num_layers=2, batch_size=64, learning_rate=FLAGS.learning_rate) //建立RNN模型
saver = tf.train.Saver(tf.global_variables()) //
init_op = tf.group(tf.global_variables_initializer(), tf.local_variables_initializer())
with tf.Session() as sess:
# sess = tf_debug.LocalCLIDebugWrapperSession(sess=sess)
# sess.add_tensor_filter("has_inf_or_nan", tf_debug.has_inf_or_nan)
sess.run(init_op)
start_epoch = 0
checkpoint = tf.train.latest_checkpoint(FLAGS.model_dir)
if checkpoint:
saver.restore(sess, checkpoint)
print("## restore from the checkpoint {0}".format(checkpoint))
start_epoch += int(checkpoint.split('-')[-1])
print('## start training...')
def run(self):
batch_size = 1
begin_word = None
print('## loading corpus from %s' % model_dir)
poems_vector, word_int_map, vocabularies = process_poems(corpus_file)
input_data = tf.placeholder(tf.int32, [batch_size, None])
end_points = rnn_model(model='lstm',
input_data=input_data,
output_data=None,
vocab_size=len(vocabularies),
rnn_size=128,
num_layers=2,
batch_size=64,
learning_rate=lr)
saver = tf.train.Saver(tf.global_variables())
init_op = tf.group(tf.global_variables_initializer(),
tf.local_variables_initializer())
with tf.Session() as sess:
sess.run(init_op)
checkpoint = tf.train.latest_checkpoint(model_dir)
saver.restore(sess, checkpoint)
x = np.array([list(map(word_int_map.get, start_token))])
while True:
if 100 > len(poemList):
lock = False
try:
[predict,
last_state] = sess.run([
end_points['prediction'], end_points['last_state']
],
feed_dict={input_data: x})
word = begin_word or to_word(predict, vocabularies)
poem_ = ''
i = 0
poem_ = ''
while word != end_token:
poem_ += word
i += 1
if i > 40:
break
x = np.array([[word_int_map[word]]])
[predict, last_state] = sess.run(
[
end_points['prediction'],
end_points['last_state']
],
feed_dict={
input_data: x,
end_points['initial_state']: last_state
})
word = to_word(predict, vocabularies)
poem = pretty_print_poem(poem_)
if "" != poem and " 。" != poem:
lock = True
mutex.acquire()
poemList.append(poem)
finally:
if lock:
mutex.release()
else:
time.sleep(1)
def run_training():
# if not os.path.exists(FLAGS.model_dir):
# os.makedirs(FLAGS.model_dir)
#
# poems_vector, word_to_int, vocabularies = process_poems(FLAGS.file_path)
# batches_inputs, batches_outputs = generate_batch(FLAGS.batch_size, poems_vector, word_to_int)
# ssqdata=get_exl_data(random_order=False,use_resnet=True)
# # print(ssqdata[len(ssqdata)-1])
# batches_inputs=ssqdata[0:(len(ssqdata)-1)]
# ssqdata=get_exl_data(random_order=False,use_resnet=False)
ssqdata = get_dlt_data(random_order=False, use_resnet=True)
# print(ssqdata[len(ssqdata)-1])
batches_inputs = ssqdata[0:(len(ssqdata) - 1)]
ssqdata = get_dlt_data(random_order=False, use_resnet=False)
batches_outputs = ssqdata[1:(len(ssqdata))]
FLAGS.batch_size = len(batches_inputs)
# print(np.shape(batches_outputs))
# data=batches_outputs[1:7]
# print(len(data))
del ssqdata
input_data = tf.placeholder(tf.float32, [FLAGS.batch_size, 1, 7, 1])
logits = inference(input_data, 1, reuse=False, output_num=128)
# print(tf.shape(input_data))
output_targets = tf.placeholder(tf.int32, [FLAGS.batch_size, None])
end_points = rnn_model(model='lstm',
input_data=logits,
output_data=output_targets,
vocab_size=35 + 12,
output_num=7,
rnn_size=128,
num_layers=7,
batch_size=FLAGS.batch_size,
learning_rate=FLAGS.learning_rate)
# end_points = rnn_model(model='lstm', input_data=input_data, output_data=output_targets, vocab_size=len(
# vocabularies), rnn_size=128, num_layers=2, batch_size=64, learning_rate=FLAGS.learning_rate)
saver = tf.train.Saver(tf.global_variables())
init_op = tf.group(tf.global_variables_initializer(),
tf.local_variables_initializer())
with tf.Session() as sess:
# sess = tf_debug.LocalCLIDebugWrapperSession(sess=sess)
# sess.add_tensor_filter("has_inf_or_nan", tf_debug.has_inf_or_nan)
sess.run(init_op)
start_epoch = 0
# saver.restore(sess, "D:/tensorflow_poems-master/model4all/poems-207261")
checkpoint = tf.train.latest_checkpoint(FLAGS.model_dir)
if checkpoint:
saver.restore(sess, checkpoint)
print("## restore from the checkpoint {0}".format(checkpoint))
start_epoch += int(checkpoint.split('-')[-1])
print('## start training...')
try:
for epoch in range(start_epoch, FLAGS.epochs):
n = 0
# n_chunk = len(poems_vector) // FLAGS.batch_size
# n_chunk = len(batches_inputs) // FLAGS.batch_size
n_chunk = math.ceil(len(batches_inputs) / FLAGS.batch_size)
for batch in range(n_chunk):
left = (batch + 1) * FLAGS.batch_size - len(batches_inputs)
if left < 0:
inputdata = batches_inputs[(batch * FLAGS.batch_size):(
(batch + 1) * FLAGS.batch_size)]
outputdata = batches_outputs[(
batch * FLAGS.batch_size):((batch + 1) *
FLAGS.batch_size)]
else:
# temp=batches_inputs[batch*FLAGS.batch_size:len(batches_inputs) ]
# temp.extend(batches_inputs[0:left])
inputdata = batches_inputs[
len(batches_inputs) -
FLAGS.batch_size:len(batches_inputs)]
# temp=batches_outputs[batch*FLAGS.batch_size:len(batches_inputs) ]
# temp.extend(batches_outputs[0:left])
outputdata = batches_outputs[
len(batches_outputs) -
FLAGS.batch_size:len(batches_outputs)]
# print(len(inputdata))
loss, _, _ = sess.run([
end_points['total_loss'], end_points['last_state'],
end_points['train_op']
],
feed_dict={
input_data: inputdata,
output_targets: outputdata
})
# ], feed_dict={input_data: batches_inputs, output_targets: batches_outputs})
n += 1
if epoch % 1000 == 0:
print('Epoch: %d, batch: %d, training loss: %.6f' %
(epoch, batch, loss))
if epoch % 50000 == 0:
saver.save(sess,
os.path.join(FLAGS.model_dir,
FLAGS.model_prefix),
global_step=epoch)
except KeyboardInterrupt:
print('## Interrupt manually, try saving checkpoint for now...')
saver.save(sess,
os.path.join(FLAGS.model_dir, FLAGS.model_prefix),
global_step=epoch)
print(
'## Last epoch were saved, next time will start from epoch {}.'
.format(epoch))
saver.save(sess,
os.path.join(FLAGS.model_dir, FLAGS.model_prefix),
global_step=epoch)
def gen_poem():
batch_size = 1
poems_vector, word_int_map, vocabularies = process_poems(corpus_path)
input_data = tf.placeholder(tf.int32, [batch_size, None])
end_points = rnn_model(model='lstm',
input_data=input_data,
output_data=None,
vocab_size=len(vocabularies),
rnn_size=128,
num_layers=2,
batch_size=64,
learning_rate=lr)
saver = tf.train.Saver(tf.global_variables())
init_op = tf.group(tf.global_variables_initializer(),
tf.local_variables_initializer())
with tf.Session() as sess:
sess.run(init_op)
checkpoint = tf.train.latest_checkpoint(model_dir)
print('## loading corpus from %s' % checkpoint)
saver.restore(sess, checkpoint)
while True:
# start_token=vocabularies[np.random.randint(len(vocabularies))]
# x = np.array([list(map(word_int_map.get, start_token))])
# [predict, last_state] = sess.run([end_points['prediction'], end_points['last_state']],
# feed_dict={input_data: x})
begin_word = input('## please input the first character:')
if begin_word and begin_word in vocabularies:
word = begin_word
else:
word = vocabularies[np.random.randint(len(vocabularies))]
print(
'## begin word not in vocabularies, use random begin word:'
+ word)
poem_ = word
x = np.array([list(map(word_int_map.get, word))])
[predict, last_state
] = sess.run([end_points['prediction'], end_points['last_state']],
feed_dict={input_data: x})
# second word
word = to_word(predict, vocabularies)
i = 1
while i < FLAGS.gen_sequence_len:
poem_ += word
i += 1
x = np.zeros((1, 1))
x[0, 0] = word_int_map[word]
[predict, last_state] = sess.run(
[end_points['prediction'], end_points['last_state']],
feed_dict={
input_data: x,
end_points['initial_state']: last_state
})
word = to_word(predict, vocabularies)
print(poem_, flush=True)
