代码：

https://download.csdn.net/download/richgene/10413943

训练数据：

https://download.csdn.net/download/richgene/10466872

RNN不像传统的神经网络-它们的输出输出是固定的，而RNN允许我们输入输出向量序列。RNN是为了对序列数据进行建模而产生的。

样本序列性：样本间存在顺序关系，每个样本和它之前的样本存在关联。比如说，在文本中，一个词和它前面的词是有关联的；在气象数据中，一天的气温和前几天的气温是有关联的。

例如本帖要使用RNN生成古诗，你给它输入一堆古诗词，它会学着生成和前面相关联的字词。如果你给它输入一堆姓名，它会学着生成姓名；给它输入一堆古典乐/歌词，它会学着生成古典乐/歌词，甚至可以给它输入源代码。

关于RNN：

  • http://karpathy.github.io/2015/05/21/rnn-effectiveness/

本帖代码移植自char-rnn，它是基于Torch的洋文模型，稍加修改即可应用于中文。char-rnn使用文本文件做为输入、训练RNN模型，然后使用它生成和训练数据类似的文本。

使用的数据集：全唐诗(43030首)：https://download.csdn.net/download/richgene/10466872

训练：

[python] view plaincopy

  1. importcollections
  2. importnumpy as np
  3. importtensorflow as tf
  4. #-------------------------------数据预处理---------------------------#
  5. poetry_file ='poetry.txt'
  6. # 诗集
  7. poetrys = []
  8. with open(poetry_file, "r", encoding='utf-8',) as f:
  9. forlineinf:
  10. try:
  11. title, content = line.strip().split(':')
  12. content = content.replace(' ','')
  13. if'_'incontentor'('incontentor'（'incontentor'《'incontentor'['incontent:
  14. continue
  15. iflen(content) <5orlen(content) >79:
  16. continue
  17. content = '['+ content +']'
  18. poetrys.append(content)
  19. exceptException as e:
  20. pass
  21. # 按诗的字数排序
  22. poetrys = sorted(poetrys,key=lambdaline: len(line))
  23. print('唐诗总数: ', len(poetrys))
  24. # 统计每个字出现次数
  25. all_words = []
  26. forpoetryinpoetrys:
  27. all_words += [word forwordinpoetry]
  28. counter = collections.Counter(all_words)
  29. count_pairs = sorted(counter.items(), key=lambdax: -x[1])
  30. words, _ = zip(*count_pairs)
  31. # 取前多少个常用字
  32. words = words[:len(words)] + (' ',)
  33. # 每个字映射为一个数字ID
  34. word_num_map = dict(zip(words, range(len(words))))
  35. # 把诗转换为向量形式，参考TensorFlow练习1
  36. to_num = lambdaword: word_num_map.get(word, len(words))
  37. poetrys_vector = [ list(map(to_num, poetry)) forpoetryinpoetrys]
  38. #[[314, 3199, 367, 1556, 26, 179, 680, 0, 3199, 41, 506, 40, 151, 4, 98, 1],
  39. #[339, 3, 133, 31, 302, 653, 512, 0, 37, 148, 294, 25, 54, 833, 3, 1, 965, 1315, 377, 1700, 562, 21, 37, 0, 2, 1253, 21, 36, 264, 877, 809, 1]
  40. #....]
  41. # 每次取64首诗进行训练
  42. batch_size = 64
  43. n_chunk = len(poetrys_vector) // batch_size
  44. x_batches = []
  45. y_batches = []
  46. foriinrange(n_chunk):
  47. start_index = i * batch_size
  48. end_index = start_index + batch_size
  49. batches = poetrys_vector[start_index:end_index]
  50. length = max(map(len,batches))
  51. xdata = np.full((batch_size,length), word_num_map[' '], np.int32)
  52. forrowinrange(batch_size):
  53. xdata[row,:len(batches[row])] = batches[row]
  54. ydata = np.copy(xdata)
  55. ydata[:,:-1] = xdata[:,1:]
  56. """
  57. xdata             ydata
  58. [6,2,4,6,9]       [2,4,6,9,9]
  59. [1,4,2,8,5]       [4,2,8,5,5]
  60. """
  61. x_batches.append(xdata)
  62. y_batches.append(ydata)
  63. #---------------------------------------RNN--------------------------------------#
  64. input_data = tf.placeholder(tf.int32, [batch_size, None])
  65. output_targets = tf.placeholder(tf.int32, [batch_size, None])
  66. # 定义RNN
  67. defneural_network(model='lstm', rnn_size=128, num_layers=2):
  68. ifmodel =='rnn':
  69. cell_fun = tf.nn.rnn_cell.BasicRNNCell
  70. elifmodel =='gru':
  71. cell_fun = tf.nn.rnn_cell.GRUCell
  72. elifmodel =='lstm':
  73. cell_fun = tf.nn.rnn_cell.BasicLSTMCell
  74. cell = cell_fun(rnn_size, state_is_tuple=True)
  75. cell = tf.nn.rnn_cell.MultiRNNCell([cell] * num_layers, state_is_tuple=True)
  76. initial_state = cell.zero_state(batch_size, tf.float32)
  77. with tf.variable_scope('rnnlm'):
  78. softmax_w = tf.get_variable("softmax_w", [rnn_size, len(words)+1])
  79. softmax_b = tf.get_variable("softmax_b", [len(words)+1])
  80. with tf.device("/cpu:0"):
  81. embedding = tf.get_variable("embedding", [len(words)+1, rnn_size])
  82. inputs = tf.nn.embedding_lookup(embedding, input_data)
  83. outputs, last_state = tf.nn.dynamic_rnn(cell, inputs, initial_state=initial_state, scope='rnnlm')
  84. output = tf.reshape(outputs,[-1, rnn_size])
  85. logits = tf.matmul(output, softmax_w) + softmax_b
  86. probs = tf.nn.softmax(logits)
  87. returnlogits, last_state, probs, cell, initial_state
  88. #训练
  89. deftrain_neural_network():
  90. logits, last_state, _, _, _ = neural_network()
  91. targets = tf.reshape(output_targets, [-1])
  92. loss = tf.nn.seq2seq.sequence_loss_by_example([logits], [targets], [tf.ones_like(targets, dtype=tf.float32)], len(words))
  93. cost = tf.reduce_mean(loss)
  94. learning_rate = tf.Variable(0.0, trainable=False)
  95. tvars = tf.trainable_variables()
  96. grads, _ = tf.clip_by_global_norm(tf.gradients(cost, tvars), 5)
  97. optimizer = tf.train.AdamOptimizer(learning_rate)
  98. train_op = optimizer.apply_gradients(zip(grads, tvars))
  99. with tf.Session() as sess:
  100. sess.run(tf.initialize_all_variables())
  101. saver = tf.train.Saver(tf.all_variables())
  102. forepochinrange(50):
  103. sess.run(tf.assign(learning_rate, 0.002* (0.97** epoch)))
  104. n = 0
  105. forbatcheinrange(n_chunk):
  106. train_loss, _ , _ = sess.run([cost, last_state, train_op], feed_dict={input_data: x_batches[n], output_targets: y_batches[n]})
  107. n += 1
  108. print(epoch, batche, train_loss)
  109. ifepoch %7==0:
  110. saver.save(sess, 'poetry.module', global_step=epoch)
  111. train_neural_network()

使用训练好的模型生成古诗：

[python] view plaincopy

  1. importcollections
  2. importnumpy as np
  3. importtensorflow as tf
  4. #-------------------------------数据预处理---------------------------#
  5. poetry_file ='poetry.txt'
  6. # 诗集
  7. poetrys = []
  8. with open(poetry_file, "r", encoding='utf-8',) as f:
  9. forlineinf:
  10. try:
  11. title, content = line.strip().split(':')
  12. content = content.replace(' ','')
  13. if'_'incontentor'('incontentor'（'incontentor'《'incontentor'['incontent:
  14. continue
  15. iflen(content) <5orlen(content) >79:
  16. continue
  17. content = '['+ content +']'
  18. poetrys.append(content)
  19. exceptException as e:
  20. pass
  21. # 按诗的字数排序
  22. poetrys = sorted(poetrys,key=lambdaline: len(line))
  23. print('唐诗总数: ', len(poetrys))
  24. # 统计每个字出现次数
  25. all_words = []
  26. forpoetryinpoetrys:
  27. all_words += [word forwordinpoetry]
  28. counter = collections.Counter(all_words)
  29. count_pairs = sorted(counter.items(), key=lambdax: -x[1])
  30. words, _ = zip(*count_pairs)
  31. # 取前多少个常用字
  32. words = words[:len(words)] + (' ',)
  33. # 每个字映射为一个数字ID
  34. word_num_map = dict(zip(words, range(len(words))))
  35. # 把诗转换为向量形式，参考TensorFlow练习1
  36. to_num = lambdaword: word_num_map.get(word, len(words))
  37. poetrys_vector = [ list(map(to_num, poetry)) forpoetryinpoetrys]
  38. #[[314, 3199, 367, 1556, 26, 179, 680, 0, 3199, 41, 506, 40, 151, 4, 98, 1],
  39. #[339, 3, 133, 31, 302, 653, 512, 0, 37, 148, 294, 25, 54, 833, 3, 1, 965, 1315, 377, 1700, 562, 21, 37, 0, 2, 1253, 21, 36, 264, 877, 809, 1]
  40. #....]
  41. batch_size = 1
  42. n_chunk = len(poetrys_vector) // batch_size
  43. x_batches = []
  44. y_batches = []
  45. foriinrange(n_chunk):
  46. start_index = i * batch_size
  47. end_index = start_index + batch_size
  48. batches = poetrys_vector[start_index:end_index]
  49. length = max(map(len,batches))
  50. xdata = np.full((batch_size,length), word_num_map[' '], np.int32)
  51. forrowinrange(batch_size):
  52. xdata[row,:len(batches[row])] = batches[row]
  53. ydata = np.copy(xdata)
  54. ydata[:,:-1] = xdata[:,1:]
  55. """
  56. xdata             ydata
  57. [6,2,4,6,9]       [2,4,6,9,9]
  58. [1,4,2,8,5]       [4,2,8,5,5]
  59. """
  60. x_batches.append(xdata)
  61. y_batches.append(ydata)
  62. #---------------------------------------RNN--------------------------------------#
  63. input_data = tf.placeholder(tf.int32, [batch_size, None])
  64. output_targets = tf.placeholder(tf.int32, [batch_size, None])
  65. # 定义RNN
  66. defneural_network(model='lstm', rnn_size=128, num_layers=2):
  67. ifmodel =='rnn':
  68. cell_fun = tf.nn.rnn_cell.BasicRNNCell
  69. elifmodel =='gru':
  70. cell_fun = tf.nn.rnn_cell.GRUCell
  71. elifmodel =='lstm':
  72. cell_fun = tf.nn.rnn_cell.BasicLSTMCell
  73. cell = cell_fun(rnn_size, state_is_tuple=True)
  74. cell = tf.nn.rnn_cell.MultiRNNCell([cell] * num_layers, state_is_tuple=True)
  75. initial_state = cell.zero_state(batch_size, tf.float32)
  76. with tf.variable_scope('rnnlm'):
  77. softmax_w = tf.get_variable("softmax_w", [rnn_size, len(words)+1])
  78. softmax_b = tf.get_variable("softmax_b", [len(words)+1])
  79. with tf.device("/cpu:0"):
  80. embedding = tf.get_variable("embedding", [len(words)+1, rnn_size])
  81. inputs = tf.nn.embedding_lookup(embedding, input_data)
  82. outputs, last_state = tf.nn.dynamic_rnn(cell, inputs, initial_state=initial_state, scope='rnnlm')
  83. output = tf.reshape(outputs,[-1, rnn_size])
  84. logits = tf.matmul(output, softmax_w) + softmax_b
  85. probs = tf.nn.softmax(logits)
  86. returnlogits, last_state, probs, cell, initial_state
  87. #-------------------------------生成古诗---------------------------------#
  88. # 使用训练完成的模型
  89. defgen_poetry():
  90. defto_word(weights):
  91. t = np.cumsum(weights)
  92. s = np.sum(weights)
  93. sample = int(np.searchsorted(t, np.random.rand(1)*s))
  94. returnwords[sample]
  95. _, last_state, probs, cell, initial_state = neural_network()
  96. with tf.Session() as sess:
  97. sess.run(tf.initialize_all_variables())
  98. saver = tf.train.Saver(tf.all_variables())
  99. saver.restore(sess, 'poetry.module-49')
  100. state_ = sess.run(cell.zero_state(1, tf.float32))
  101. x = np.array([list(map(word_num_map.get, '['))])
  102. [probs_, state_] = sess.run([probs, last_state], feed_dict={input_data: x, initial_state: state_})
  103. word = to_word(probs_)
  104. #word = words[np.argmax(probs_)]
  105. poem = ''
  106. whileword !=']':
  107. poem += word
  108. x = np.zeros((1,1))
  109. x[0,0] = word_num_map[word]
  110. [probs_, state_] = sess.run([probs, last_state], feed_dict={input_data: x, initial_state: state_})
  111. word = to_word(probs_)
  112. #word = words[np.argmax(probs_)]
  113. returnpoem
  114. print(gen_poetry())

生成的“诗词”（至少格式对上了）：

1
2
3
4
5
6
7
8
9
10
11
12
13

新犬随风起，一璃迹阵悲。
浅昏罢庄哉，清插去园空。
双叶坐成鉴，王妓水正苑。
鸟声不成影，胙滩朱瓮声。
无斑红芜踏，那期日正闲。
吾燕登无士，无处得赵名。
并灭图微蒿，淮头水十荔。
晴花尚乘望，官宽留可求。
最忆青州守，英仍临阳峰。
生人隔天道，在国思山田。
登临闭石土，阵下一欢娱。
林暝今又少，孙频唯在愁。

生成藏头诗：

[python] view plaincopy

  1. defgen_poetry_with_head(head):
  2. defto_word(weights):
  3. t = np.cumsum(weights)
  4. s = np.sum(weights)
  5. sample = int(np.searchsorted(t, np.random.rand(1)*s))
  6. returnwords[sample]
  7. _, last_state, probs, cell, initial_state = neural_network()
  8. with tf.Session() as sess:
  9. sess.run(tf.initialize_all_variables())
  10. saver = tf.train.Saver(tf.all_variables())
  11. saver.restore(sess, 'poetry.module-49')
  12. state_ = sess.run(cell.zero_state(1, tf.float32))
  13. poem = ''
  14. i = 0
  15. forwordinhead:
  16. whileword !='，'andword !='。':
  17. poem += word
  18. x = np.array([list(map(word_num_map.get, word))])
  19. [probs_, state_] = sess.run([probs, last_state], feed_dict={input_data: x, initial_state: state_})
  20. word = to_word(probs_)
  21. time.sleep(1)
  22. ifi %2==0:
  23. poem += '，'
  24. else:
  25. poem += '。'
  26. i += 1
  27. returnpoem
  28. print(gen_poetry_with_head('一二三四'))

上面使用的TensroFlow版本为0.11，0.12版本貌似不能直接运行，简单修改如下代码：

读取模型的方法：

[python] view plaincopy

  1. module_file = tf.train.latest_checkpoint('.')
  2. #print(module_file)
  3. saver.restore(sess, module_file)

tf.initialize_all_variables()  deprecated，使用tf.global_variables_initializer()替代。

zf：tf7: RNN—古诗词相关推荐

  1. MachineLN博客目录

    MachineLN博客目录 https://blog.csdn.net/u014365862/article/details/78422372 本文为博主原创文章,未经博主允许不得转载.有问题可以加微 ...

  2. 基于Skip-Thought的Sentence2Vec神经网络实现

    一.前言 1.Skip-Thought-Vector论文 2.本文假设读者已了解Skip-Gram-Vector和RNN相关基础,以下文章可做参考: (1)RNN古诗词生成 (2)Skip-Gram- ...

  3. TensorFlow练习7: 基于RNN生成古诗词

    RNN不像传统的神经网络-它们的输出输出是固定的,而RNN允许我们输入输出向量序列.RNN是为了对序列数据进行建模而产生的. 样本序列性:样本间存在顺序关系,每个样本和它之前的样本存在关联.比如说,在 ...

  4. 基于RNN的中文古诗词生成神经网络实现

    一.前言 1.图解RNN 2.Tensorflow中RNN实现的正确打开方式 二.实战 1.训练数据处理 (1)文字转为向量 def _get_poetry(self):with open(self. ...

  5. 基于RNN实现古诗词生成模型

    我们知道,RNN(循环神经网络)模型是基于当前的状态和当前的输入来对下一时刻做出预判.而LSTM(长短时记忆网络)模型则可以记忆距离当前位置较远的上下文信息. 在此,我们根据上述预判模型来进行 古诗词 ...

  6. java rnn生成古诗_Tensorflow 基于RNN生成古诗词 自己的实践

    在网上看到一篇利用Tensorflow+RNN模型生成古诗词的练习,觉得挺有意思的便自己来试了下,算是熟悉下Tensorflow+NLP的基本操作流程 首先pip 安装NLTK 在你的Tensorfl ...

  7. 机器学习笔记4 古诗词自动生成 RNN with Keras

    这是一个RNN的典型应用,也是RNN最能解决的一个应用场景. 我们这里以中国古诗为例,我们将要构造一个RNN 模型,并用它来自动生成古诗. 准备工作: 我们拿到的是一个txt文件,里面包含了一些古诗. ...

  8. TensorFlow2学习：RNN生成古诗词

    本文转自 AI科技大本营 TensorFlow2学习:RNN生成古诗词 文章不见了可以参考这位博主的文章 公众号的文章写得挺好的,这里简单介绍下思路及值得学习的地方 模型简介 模型不算多么复杂高大上, ...

  9. python输出古诗词_TensorFlow：基于RNN生成古诗词

    时间:2017-07-26 发布人:SHX 浏览次数:3806 评论:0 实例来源于网络,但是以前的代码都是基于TensorFlow1.0以前的版本写的,实际运行时会报错,对于小白来说是一头雾水.这里 ...

  10. 记忆网络RNN、LSTM与GRU

    RNN 结构 训练 应用 RNN Variants LSTM 结构 梯度消失及梯度爆炸 GRU 结构 一般的神经网络输入和输出的维度大小都是固定的,针对序列类型(尤其是变长的序列)的输入或输出数据束手 ...

最新文章

  1. PHP中的SESSION
  2. java例程练习（批量修改文件后缀名）
  3. java实现第三方网页获取微信用户授权后的微信用户基本信息
  4. springboot启动时An attempt was made to call a method that does not exist
  5. 设计模式：桥接模式（Bridge Pattern）
  6. iOS 11 下 UICollectionView 出现滚动条被 HeaderView 遮挡的问题
  7. python【第三篇】迭代器、生成器、闭包
  8. ethtool工具设置网口配置
  9. 【结课报告】游戏中的知识产权
  10. 黑苹果 hackintosh 声卡驱动
  11. 手机端链接拼多多的商品主图和视频抓取方法
  12. itextpdf生成列表基本用法
  13. WorldFirst澳元收款账户上线，人民币提现当天到账！
  14. Appium H5自动化测试
  15. python大数相乘
  16. k线图基础知识图解——单根K线的含义
  17. NodeJs模块化（KPD）
  18. 圆柱模板行业B2B站点打造MIP推送+熊掌号推送+历史普通推送插件
  19. 山楂整形修剪的技术方法
  20. html2canvas生成PDF并下载的解决方案

热门文章

  1. 无法初始化windows sockets
  2. 你真的了解开源镜像站吗？
  3. PT px pc 的区别
  4. word文件怎么压缩？详细的操作步骤
  5. 摄像头 RTSP 以及远程管理
  6. 315|大数据杀熟，如何才不被坑？
  7. gitlab安装注册记录——gitlab（一）
  8. Laravel文档阅读笔记-How to use @auth and @guest directives in Laravel
  9. 提升幸福感的100件小事
  10. JS图片压缩+图片上传前检测类型、大小、尺寸