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:///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(32, [FLAGS.batch_size,None])
    output_targets = tf.placeholder(32, [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[' '], 32)
        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:///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

当预测过程中可能出现空格，这个问题还是比较头疼的

及时停止，重新生成