LSTM唐诗生成
1课程简介
使用深度网络模型
写首歌
写个剧本等
原理类似
模块
递归神经网络，升级LSTM带记忆和遗忘的神经网络
最后使用LSTM作为核心模块
核心框架使用TensorFlow，不用担心GPU，只需要部分文本数据即可（使用部分唐诗数据，使其会做唐诗即可），使用CPU就能跑
1-2递归神经网络RNN
输入的数据100个，即每个数据都独立，后输入的数据对前面的数据无影响
而语言如“我出生在中国，会说汉语”，前后语句相互关联的，如
：我出生在中国，所以我说…
后面的说什么是需要预测的，正常预测只会考虑前面一个字说，“说”传进来后，“说”经过一系列权重参数得到预测“说什么”
说后面会有各种各样语言，但为什么接汉语的可能性最大，因为前面说了，出生在中国，所以说，希望打造这样的神经网络，可以将说之前的信息也利用上，数据之间不再独立，是有关系的
在中间层有个递归操作，在每次预测完一个结果后，不完全把结果输出，而是中间保留一些信息特征，保留一些信息，下次再输入时，保留的信息可以传给下一次使用
最左侧是数据结构，实际运算过程如右侧
X0与U组合得到中间储存信息
中间信息储存目的交给下一个输入
下一个输入与U组合，与前面的记忆内容还要组合，相当于两个输入，得到新的结果
如上可以将输入作为字演示
第一个输入的有价值的信息也会放在第2个输入
想预测说什么，想得到Ht，我，出生，在…说组合，在前面信息找到更重要的信息在中国，所以说汉语的几率大大提升，RNN递归神经网络中，会将前一层的信息利用，把信息组合得到新的结果
1-3RNN网络细节
xt表示第t,t=1,2,3…步(step)的输入（输入称每一步，，第一个输入Ot-1不一定是我们想要的最终结果，看大家是否想要一个中间结果，有些时候我们只追求最后的结果Ot+1.。）
st为隐藏层的第t步的状态，它是网络的记忆单元。
st=f(Uxt+Wst−1)，其中f一般是非线性的激活函数（每次组合都要加入非线性激活函数，使得表达是非线性的）
ot是第t步的输出，如下个单词的向量表示softmax(Vst)（对词的向量概率，可以知道当前词下一句可能说什么了）
通常预测的就是一句话，要将一句话分词，话分词后将每个分词结果输入
RNN最适合干的就是自然语言处理，之前的卷积神经网络CNN在计算机视觉中不强调先后关系，认为相互独立的，但在自然语言处理中，上下文是特别重要的，AI要符合人类逻辑，必须
递归神经网络反向传播，也会进行更新，每一步都会对前面的进行更新
RNN特别在中间有记忆单元
I am Chines, I Love China
RNN有什么缺点，假设一共传入200个词，在第200个词预测下面说的话，需要得到前面的词的记忆信息，但前面的非常远的此也记下来了，一方面前面离得比较远的信息价值不是很高，还传进来，前面的100词和后面的关系不大，也传递到神经网络中了，也会有影响。
在RNN中会将每个词都传进来，如果说做数据预处理时，传进来效果并不一定很好，因为记忆信息越近价值越大，
如love词预测后面，它与前面的Chinese近，与I比较远，所以Chinese价值大。
RNN输入的越多，记忆的也越多，会导致网络太冗余，信息太多也无用，前面反向传播，信息会一点一点往后传，若太大，200个每个往回传，199个回传，不仅计算量大，还会出现梯度消失，非常严重（一旦某个梯度约等于0，再前传都约等于0了就没法进行更新了）
递归神经网络问题
计算会梯度消失
计算量太大
下面讲递归神经网络改变，使其有选择的去忘记一些信息，或者其利用好当前的一部分信息，要将递归神经网络升级
1-4LSTM网络架构
RNN递归神经网络有问题，
将其升级成LSTM网络
LSTM是长短记忆网络，可长可短，可以选择的
LSTM整个网络结构可能比较复杂
拆分看
C：控制参数
决定什么样的信息会被保留什么样的会被遗忘
在LSTM中控制参数（之前RNN问题是不会忘记，全部记下来，但在LSTM中，使用控制参数，一个数据来之后，不会所有的数据都记住，可能选择一些有价值的保留，无价值的舍弃）
控制参数C也是通过训练得到的，用来确定什么信息保留，什么信息舍弃
门是一种让信息选择式通过的方法sigmoid 神经网络层和一乘法操作
sigmoid 可以将数据压缩到0-1
门单元让网络自己选择
Sigmoid 层输出 0 到 1 之间的数值，描述每个部分有多少量可以通过。0 代表“不许任何量通过”，1 就指“允许任意量通过”！
在LSTM网络中有很多的这种神经元，很多操作都是与这种门单元挂钩的
上面的是遗忘门单元
Ct是要永远维护的，每个阶段要保留和舍弃的不同，故每个阶段Ct都要更新，判断当前的遗忘信息
保留门单元
LSTM中核心控制参数怎样更新，其绝定什么信息保留，什么信息需要遗忘
会决定，即便输入的信息可能长，里的的近的有价值会保留的多一些，离得稍远一些的，会保留的没有那么多了
整个LSTM网络架构
RNN递归网络架构没变，LSTM只是如何利用中间信息，之前是一条直线，而这是C控制参数控制中间信息
实际用途LSTM更广泛，RNN有问题，LSTM巧妙的解决了问题
下面要使用的都是LSTM网络即RNN的升级版
2-1处理Minist数据集
递归或者循环神经网络
RNN与之前的CNN的不同
之前卷积每次batch，如batch1、2、3
Batch1来调整一下权重W\B就没事了，batch2再来
Batch1和2是没有关系的，一个batch来了只做相应的WB的更新
而在RNN中batch1、2、3就有一定的关系
在RNN中输入是什么样子
一般是序列化的输入
如将其分为4部分
batch1 Batch2 Batch3 Batch4
batch1与batch2间有潜在关系，batch2是在batch1基础发生的，batch3和batch4也是如此
他们间有相互影响的关系
希望我们RNN能将序列化的关系或者时间相关性的东西表达出来，这就是RNN网络一个主要想表达的概念
输入序列化的数据，而minist数据集是28*28的，好像数据是一个整体，需要将其变为序列化的形式，首先对数据进行预处理
28行28列，将28行拿出，每行作为一个序列
一共28号的序列，将一行一行的输入，每行神经网络基于当前进行预测，最终决策现在的手写字体到底是什么东西
如上图所示，将3手写字体28*28分为28行，每行作为一个序列
输入到上方的RNN网络
LSTM计算单元，会将前面信息和现在信息进行组合，组合成更有用的信息，会有两个输出
一个是当前结果（结果特征，输出向量最上方的O），还有一个中间结果向量，输入到下一个LSTM计算单元
在最后即最右侧，有个28号的输出O，第28号输出相当于总结了前面27个的输出，最终想要的是第28个输出，最后的样本的输出值O，就是样本的得分值，最后一个样本得到当前数字值，前面27个样本的特征给最后的关系，此处使用RNN完成分类任务
上方batchsize=5
实际中是batchsize可以更大一些，要先将数据预处理，通过中间隐层，数据切分成一个个序列，是的序列通过RNN的LSTM计算单元
然后进行预测
下面就是有代码进行minist数据集的预测
2-2RNN网络模型及训练
按照上一节的结构进行初始化
W,B
现在minst数据集分成28个序列
中间省略了，具体可以看视频
RNN确实可以预测minst手写数字
是有TensorFlow将带有LSTM计算单元的RNN搭建好后，选择一个优化器，就可以进行训练了
3-1任务概述与环境配置
接下来就是比较有意思的事情了
唐诗宋词
这些诗人写出来，非常有感觉
让计算机学习一下，然后写出来
就是学习这些话前后之间的关系，如第一句话说完了，第二句话怎么说
第一个词说完了，下一个词说什么比较恰当
这时用AI完成这样的古诗
这里大概有4万首诗，使用LSTM网络先去学习唐诗什么词后面怎么接，接下来就是预测，
这样就能作诗了
代码如何去写
环境配置
选择IDE环境（本人pycharm）
最好debug，在debug中可以看到数据怎么处理，怎么组合，debug懂了后再进行修改
下面就是代码实现
参数配置，就是使用命令行的时候可以打那些参数
import argparse
先将命令行解析库导入进来
3-2参数配置
要想写这些配置参数
https://www.cnblogs.com/yksgzlyh/p/10221960.html
配置参数必看
这种情况在调试程序时，如果只是在Pycharm环境中简单执行“Run”菜单下的“Run”命令，会出现以下错误，提示需要输入参数。
需要在mian.py
参数填写正确后，点“OK”，再执行“Run”菜单下的“Run”命令，就会得到正确运行结果。
这里是通过命令行的运行参数进行判断，然后进行是写诗还是写歌的创作的
3-3数据预处理模块
from models.model import rnn_model
import tensorflow as tf
import numpy as np
from dataset.poems import process_poems,generate_batch #将dataset下的模块中的函数process_poems，generate_batch导入
tf.app.flags.DEFINE_integer('batch_size',64,'batch size = ?')
tf.app.flags.DEFINE_float('learning_rate',0.01,'learning_rate') #学习率0.01比较好
tf.app.flags.DEFINE_string('check_pointss_dir','./model/','check_pointss_dir') #模型训练时需要保存的位置
tf.app.flags.DEFINE_string('file_path','./data/.txt','file_path') #此处的路径需要设置准确如tang_poems.py所示，否则会报错
tf.app.flags.DEFINE_integer('epoch',50,'train epoch') #有4万个唐诗，学习多少遍，这里是50遍
#诗的开头和结尾，希望诗有个终止，当网络预测到E就结束，不要一直预测下去
start_token = 'G'
end_token = 'E'
def run_training():
poems_vector,word_to_int,vocabularies = process_poems(FLAGS.file_path) #输入数据源，在上方的路径中有设置
batch_inputs,batch_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=input_data,output_data = output_targets,vocab_size = len(vocabularies)
,run_size = 128,num_layers = 2,batch_size = 64,learning_rate = 0.01)
def main(is_train):
if is_train: #如果是训练开始，就训练
print ('training')
run_training()
else:
print ('test') #如果是测试就输入一个开始的词语
begin_word = input('word')
if __name__ == '__main__':
tf.app.run()
import collections
import os
import sys
import numpy as np
start_token = 'G'
end_token = 'E'
#预处理诗歌（主要参照dataset/data/poems.txt进行设置）
def process_poems(file_name):
# 诗集
poems = []
with open(file_name, "r", encoding='utf-8', ) as f:
for line in f.readlines():
try:
title, content = line.strip().split(':') #使用：分割得到诗的名字和内容
content = content.replace(' ', '')
#如果有乱码就去掉
if '_' in content or '(' in content or '（' in content or '《' in content or '[' in content or \
start_token in content or end_token in content:
continue
if len(content) < 5 or len(content) > 79: #内容若太小或者太大都不希望
continue
content = start_token + content + end_token #此处对内容处理，结果为“E”+CONETNT+"G"，使其有开始结尾
poems.append(content)
except ValueError as e:
pass
# 按诗的字数排序（按照长度进行排序）
poems = sorted(poems, key=lambda l: len(line))
# 统计每个字出现次数
all_words = []
for poem in poems: #每首诗
all_words += [word for word in poem] #每首字
# 这里根据包含了每个字对应的频率（对一些生僻字，出现频率少的进行过滤）
counter = collections.Counter(all_words)
count_pairs = sorted(counter.items(), key=lambda x: -x[1]) #得到一个词出现的个数是多少
words, _ = zip(*count_pairs)
# 取前多少个常用字
words = words[:len(words)] + (' ',)
# 每个字映射为一个数字ID（计算机是不认识字的，这里将字简单的映射为数字了，有个Wordtovector效果应该是更好，这里每个词对应数字1,2,3，要简单些）
#若想复杂，一行诗，可以将其当成段落，有Wordtovector可以将一个词一个词转换成向量，也可以将段落组合成向量，有个库jnsim，
#把一个词真正做到和上下文相关，还是用Wordtovector，字和字之间用lstm去做，但诗和诗之间它本质也是类似，押韵等都是这样风格的
word_int_map = dict(zip(words, range(len(words))))
poems_vector = [list(map(lambda word: word_int_map.get(word, len(words)), poem)) for poem in poems] #映射，全部的诗变成了对应的数字
return poems_vector, word_int_map, words
3-4batch数据制作
之前的预处理模块process写完了
接下来是batch了
使用batch拿数据
每首诗长度不同，神经网络输入的时候，整个神经网络结构是确定下来的，如第一层输入必须是固定的
必须保证输入的是恒定的，不能第一次输入100，第二次90.所以取训练集中数字最大的作为输入，剩下的数字小的就进行填充
#将数据做出来（参数2：映射转换）
def generate_batch(batch_size, poems_vec, word_to_int):
# 每次取64首诗进行训练
n_chunk = len(poems_vec) // batch_size
x_batches = []
y_batches = []
for i in range(n_chunk):
start_index = i * batch_size
end_index = start_index + batch_size
batches = poems_vec[start_index:end_index] #
# 找到这个batch的所有poem中最长的poem的长度
length = max(map(len, batches))
# 填充一个这么大小的空batch，空的地方放空格对应的index标号
x_data = np.full((batch_size, length), word_to_int[' '], np.int32)
for row in range(batch_size):
# 每一行就是一首诗，在原本的长度上把诗还原上去
x_data[row, :len(batches[row])] = batches[row]
y_data = np.copy(x_data)
# y的话就是x向左边也就是前面移动一个（y是x词的预测的下一个词的可能性，如x：我今天打球。对应y：今天打球去。y是x的左移）
y_data[:, :-1] = x_data[:, 1:]
"""
x_data y_data
[6,2,4,6,9] [2,4,6,9,9]
[1,4,2,8,5] [4,2,8,5,5]
"""
x_batches.append(x_data)
y_batches.append(y_data)
return x_batches, y_batches
3-5RNN模型定义
数据做好后，接下来就是写RNN网络模型模型了
先把input
# -*- coding: utf-8 -*-
# file: model.py
# author: JinTian
# time: 07/03/2017 3:07 PM
# Copyright 2017 JinTian. All Rights Reserved.
#
# Licensed under the Apache License, Version 2.0 (the "License");
# you may not use this file except in compliance with the License.
# You may obtain a copy of the License at
#
# http://www.apache.org/licenses/LICENSE-2.0
#
# Unless required by applicable law or agreed to in writing, software
# distributed under the License is distributed on an "AS IS" BASIS,
# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
# See the License for the specific language governing permissions and
# limitations under the License.
# ------------------------------------------------------------------------
import tensorflow as tf
import numpy as np
def rnn_model(model, input_data, output_data, vocab_size, rnn_size=128, num_layers=2, batch_size=64,
learning_rate=0.01):
"""
construct rnn seq2seq model.
:param model: model class
:param input_data: input data placeholder
:param output_data: output data placeholder
:param vocab_size:
:param rnn_size:
:param num_layers:
:param batch_size:
:param learning_rate:
:return:
"""
end_points = {}
#整个LSTM中有基本单元cell_fun
if model == 'rnn':
cell_fun = tf.contrib.rnn.BasicRNNCell
elif model == 'gru':
cell_fun = tf.contrib.rnn.GRUCell
elif model == 'lstm':
cell_fun = tf.contrib.rnn.BasicLSTMCell
#门单元中有h值和c值，即输出值和控制值，state_is_tuple把他们当成元组进行返回
cell = cell_fun(rnn_size, state_is_tuple=True)
#整个单元由多个基本单元组成（下方整个LSTM单元做好了）
cell = tf.contrib.rnn.MultiRNNCell([cell] * num_layers, state_is_tuple=True)
if output_data is not None:
initial_state = cell.zero_state(batch_size, tf.float32) #此时初始化状态完成
else:
initial_state = cell.zero_state(1, tf.float32)
with tf.device("/cpu:0"):
#vocab_size + 1加终止符，
embedding = tf.get_variable('embedding', initializer=tf.random_uniform(
[vocab_size + 1, rnn_size], -1.0, 1.0))
#当前输入是所有词的一部分，lookup寻找哪个词
inputs = tf.nn.embedding_lookup(embedding, input_data)
# [batch_size, ?, rnn_size] = [64, ?, 128]
#LSTM网络输出值，dynamic_rnn的方式比较好执行rnn
outputs, last_state = tf.nn.dynamic_rnn(cell, inputs, initial_state=initial_state)
output = tf.reshape(outputs, [-1, rnn_size]) #进行向量变换
#vocab_size词汇表个数
weights = tf.Variable(tf.truncated_normal([rnn_size, vocab_size + 1]))
bias = tf.Variable(tf.zeros(shape=[vocab_size + 1]))
logits = tf.nn.bias_add(tf.matmul(output, weights), bias=bias)
# [?, vocab_size+1]
if output_data is not None:
# output_data must be one-hot encode
labels = tf.one_hot(tf.reshape(output_data, [-1]), depth=vocab_size + 1)
# should be [?, vocab_size+1]
loss = tf.nn.softmax_cross_entropy_with_logits(labels=labels, logits=logits)
# loss shape should be [?, vocab_size+1]
total_loss = tf.reduce_mean(loss)
train_op = tf.train.AdamOptimizer(learning_rate).minimize(total_loss)
end_points['initial_state'] = initial_state
end_points['output'] = output
end_points['train_op'] = train_op
end_points['total_loss'] = total_loss
end_points['loss'] = loss
end_points['last_state'] = last_state
else:
prediction = tf.nn.softmax(logits)
end_points['initial_state'] = initial_state
end_points['last_state'] = last_state
end_points['prediction'] = prediction
return end_points
3-8测试唐诗生成效果
总共迭代了51个epoch，其中将部分epoch保存了下来
其实，不一定是最后一个epoch表达效果好
要的风格不同，内容不同，之前的模型可能表达效果要好一些
笔记本CPU大概训练了1天1夜
运行main.py
当预测过程中可能出现空格，这个问题还是比较头疼的
及时停止，重新生成
8596
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
