从锅炉工到AI专家(10)

RNN循环神经网络(Recurrent Neural Network)

如同word2vec中提到的,很多数据的原型,前后之间是存在关联性的。关联性的打破必然造成关键指征的丢失,从而在后续的训练和预测流程中降低准确率。 除了提过的自然语言处理(NLP)领域,自动驾驶前一时间点的雷达扫描数据跟后一时间点的扫描数据、音乐旋律的时间性、股票前一天跟后一天的数据,都属于这类的典型案例。 因此在传统的神经网络中,每一个节点,如果把上一次的运算结果记录下来,在下一次数据处理的时候,跟上一次的运算结果结合在一起混合运算,就可以体现出上一次的数据对本次的影响。

如上图所示,图中每一个节点就相当于神经网络中的一个节点,t-1 、 t 、 t+1是指该节点在时间序列中的动作,你可以理解为第n批次的数据。 所以上面图中的3个节点,在实现中实际是同1个节点。 指的是,在n-1批次数据到来的时候,节点进行计算,完成输出,同时保留了一个state。 在下一批次数据到来的时候,state值跟新到来的数据一起进行运算,再次完成输出,再次保留一个state参与下一批次的运算,如此循环。这也是循环神经网络名称的由来。

RNN算法存在一个问题,那就是同一节点在某一时间点所保存的状态,随着时间的增长,它所能造成的影响就越小,逐渐衰减至无。这对于一些长距离上下文相关的应用,仍然是不满足要求的。 这就又发展出了LSTM算法。

LSTM长短期记忆网络(Long Short-Term Memory)

如图所示:LSTM区别于RNN的地方,主要就在于它在算法中加入了一个判断信息有用与否的“处理器”,这个处理器作用的结构被称为cell。 一个cell当中被放置了三个“门电路”,分别叫做输入门、遗忘门和输出门。一个信息进入LSTM的网络当中,可以根据规则来判断是否有用。只有符合算法认证的信息才会留下,不符的信息则通过遗忘门被遗忘。

  • 遗忘门决定让哪些信息继续通过这个cell。
  • 输入门决定让多少新的信息加入到 cell状态中来。
  • 输出门决定我们要输出什么样的值。

通过这样简单的节点结构改善,就有效的解决了长时序依赖数据在神经网络中的表现。

LSTM随后还出现了不少变种,进一步加强了功能或者提高了效率。比如当前比较有名的GRU(Gated Recurrent Unit )是2014年提出的。GRU在不降低处理效果的同时,减少了一个门结构。只有重置门(reset gate)和更新门(update gate)两个门,并且把细胞状态和隐藏状态进行了合并。这使得算法的实现更容易,结构更清晰,运算效率也有所提高。 目前的应用中,较多的使用是LSTM或者GRU。RNN网络其实已经很少直接用到了。

实现一个RNN网络

官方的RNN网络教程是实现了一个NLP的应用,技术上很切合RNN的典型特征。不过从程序逻辑上太复杂了,而且计算结果也很不直观。 为了能尽快的抓住RNN网络的本质,本例仍然延续以前用过的MNIST程序,把其中的识别模型替换为RNN-LSTM网络,相信可以更快的让大家上手RNN-LSTM。 本例中的源码来自aymericdamien的github仓库,为了更接近我们原来的示例代码,适当做了修改。在此对原作者表示感谢。 官方的课程建议在读完这里的内容之后再去学习,并且也很值得深入的研究。 源码:

#!/usr/bin/env python
# -*- coding=UTF-8 -*-

""" Recurrent Neural Network.

A Recurrent Neural Network (LSTM) implementation example using TensorFlow library.
This example is using the MNIST database of handwritten digits (http://yann.lecun.com/exdb/mnist/)

Links:
    [Long Short Term Memory](http://deeplearning.cs.cmu.edu/pdfs/Hochreiter97_lstm.pdf)
    [MNIST Dataset](http://yann.lecun.com/exdb/mnist/).

Author: Aymeric Damien
Project: https://github.com/aymericdamien/TensorFlow-Examples/
"""

from __future__ import print_function

import tensorflow as tf
from tensorflow.contrib import rnn

# Import MNIST data
from tensorflow.examples.tutorials.mnist import input_data
#这里指向以前下载的数据,节省下载时间
#使用时请将后面的路径修改为自己数据所在路径
mnist = input_data.read_data_sets("../mnist/data", one_hot=True)

'''
To classify images using a recurrent neural network, we consider every image
row as a sequence of pixels. Because MNIST image shape is 28*28px, we will then
handle 28 sequences of 28 steps for every sample.
'''

# Training Parameters
#训练梯度
learning_rate = 0.001
#训练总步骤
training_steps = 10000
#每批次量
batch_size = 128
#每200步显示一次训练进度
display_step = 200

# Network Parameters
#下面两个值实际就是28x28的图片,但是分成每组进入RNN的数据28个,
#然后一共28个批次(时序)的数据,利用这种方式,找出单方向相邻两个点之间的规律
#这种方式当时不如CNN的效果,但我们这里是为了展示RNN的应用
num_input = 28 # MNIST data input (img shape: 28*28)
timesteps = 28 # timesteps
#LSTM网络的参数,隐藏层数量
num_hidden = 128 # hidden layer num of features
#最终分为10类,0-9十个字付
num_classes = 10 # MNIST total classes (0-9 digits)

# tf Graph input
#训练数据输入,跟MNIST相同
X = tf.placeholder("float", [None, timesteps, num_input])
Y = tf.placeholder("float", [None, num_classes])

# Define weights
#权重和偏移量
weights = tf.Variable(tf.random_normal([num_hidden, num_classes]))
biases = tf.Variable(tf.random_normal([num_classes]))


def RNN(x, weights, biases):

    # Prepare data shape to match `rnn` function requirements
    # Current data input shape: (batch_size, timesteps, n_input)
    # Required shape: 'timesteps' tensors list of shape (batch_size, n_input)

    # Unstack to get a list of 'timesteps' tensors of shape (batch_size, n_input)
    #进入的数据是X[128(批量),784(28x28)]这样的数据
    #下面函数转换成x[128,28]的数组,数组长度是28
    #相当于一个[28,128,28]的张量
    x = tf.unstack(x, timesteps, 1)

    # Define a lstm cell with tensorflow
    #定义一个lstm Cell,其中有128个单元,这个数值可以修改调优
    lstm_cell = rnn.BasicLSTMCell(num_hidden, forget_bias=1.0)

    # Get lstm cell output
    #使用单元计算x,最后获得输出及状态
    outputs, states = rnn.static_rnn(lstm_cell, x, dtype=tf.float32)

    # Linear activation, using rnn inner loop last output
    #仍然是我们熟悉的算法,这里相当于该节点的激活函数(就是原来rule的位置)
    return tf.matmul(outputs[-1], weights) + biases

#使用RNN网络定义一个算法模型
logits = RNN(X, weights, biases)
#预测算法
prediction = tf.nn.softmax(logits)

# Define loss and optimizer
#代价函数、优化器及训练器,跟原来基本是类似的
loss_op = tf.reduce_mean(tf.nn.softmax_cross_entropy_with_logits(
    logits=logits, labels=Y))
optimizer = tf.train.GradientDescentOptimizer(learning_rate=learning_rate)
train_op = optimizer.minimize(loss_op)

# Evaluate model (with test logits, for dropout to be disabled)
#使用上面定义的预测算法进行预测,跟样本标签相同即为预测正确
correct_pred = tf.equal(tf.argmax(prediction, 1), tf.argmax(Y, 1))
#最后换算成正确率
accuracy = tf.reduce_mean(tf.cast(correct_pred, tf.float32))

# Initialize the variables (i.e. assign their default value)
init = tf.global_variables_initializer()

# Start training
with tf.Session() as sess:

    # Run the initializer
    sess.run(init)

    for step in range(1, training_steps+1):
        batch_x, batch_y = mnist.train.next_batch(batch_size)
        # Reshape data to get 28 seq of 28 elements
        #首先把数据从[128,784]转换成[128,28,28]的形状,这跟以前线性回归是不同的
        batch_x = batch_x.reshape((batch_size, timesteps, num_input))
        # Run optimization op (backprop)
        #逐批次训练
        sess.run(train_op, feed_dict={X: batch_x, Y: batch_y})
        if step % display_step == 0 or step == 1:
            # Calculate batch loss and accuracy
            #每200个批次显示一下进度,当前的代价值机正确率
            loss, acc = sess.run([loss_op, accuracy], feed_dict={X: batch_x,
                                                                 Y: batch_y})
            print("Step " + str(step) + ", Minibatch Loss= " + \
                  "{:.4f}".format(loss) + ", Training Accuracy= " + \
                  "{:.3f}".format(acc))

    print("Optimization Finished!")

    # Calculate accuracy for 128 mnist test images
    #训练完成,使用测试组数据进行预测
    test_len = 128
    test_data = mnist.test.images[:test_len].reshape((-1, timesteps, num_input))
    test_label = mnist.test.labels[:test_len]
    print("Testing Accuracy:", \
        sess.run(accuracy, feed_dict={X: test_data, Y: test_label}))

跟原来的MNIST代码对比,本源码有以下几个修改:

  • 常量在前面集中定义,这是编程习惯上的调整,跟TensorFlow及RNN-LSTM无关
  • 核心算法替换成了RNN,在RNN函数中实现,其中主要做了3个动作:
    • 首先把数据切成28个数据一个批次。原来从训练集中读取的数据是[128批次,784数据]的张量。 随后在主循环中改成了:[128,28,28]的张量喂入RNN。注释中有说明,这是利用RNN的特征,试图寻找每张图片在单一方向上相邻两个点之间是否存在规律。 RNN中第一个动作就是按照时序分成28个批次。变成了[28,128,28]的样式。
    • 随后定义了一个基本的LSTM Cell,包含128个单元,这里可以理解为神经网络中的隐藏层。
    • 最后使用我们熟悉的线性回归作用到每一个输出单元中去,在这里,这个线性回归也相当于神经网络中每个节点的激活函数。
  • 交叉熵的计算又换了一种算法:softmax_cross_entropy_with_logits,同我们前面用过的sparse_softmax_cross_entropy功能是接近的,基本可以互相代换。
  • 随后的训练和预测,基本同原来的算法是相同。

运算结果:

Step 9000, Minibatch Loss= 0.4518, Training Accuracy= 0.859
Step 9200, Minibatch Loss= 0.4717, Training Accuracy= 0.852
Step 9400, Minibatch Loss= 0.5074, Training Accuracy= 0.859
Step 9600, Minibatch Loss= 0.4006, Training Accuracy= 0.883
Step 9800, Minibatch Loss= 0.3571, Training Accuracy= 0.875
Step 10000, Minibatch Loss= 0.3069, Training Accuracy= 0.906
Optimization Finished!
Testing Accuracy: 0.8828125

训练的结果并不是很高,因为对于图像识别,RNN并不是很好的算法,这里只是演示一个基本的RNN-LSTM模型。

自动写诗

上面的例子让大家对于RNN/LSTM做了入门。实际上RNN/LSTM并不适合用于图像识别,一个典型的LSTM应用案例应当是NLP。我们下面再举一个这方面的案例。 本节是一个利用唐诗数据库,训练一个RNN/LSTM网络,随后利用训练好的网络自动写诗的案例。 源码来自互联网,作者:斗大的熊猫,在此表示感谢。 为了适应python2.x+TensorFlow1.4.1的运行环境,另外也为了大家读起来方便把训练部分跟生成部分集成到了一起,因此源码有所修改。也建议大家去原作者的博客去读一读相关的文章,会很有收获,在引文中也有直接的链接。 源码讲解:

  • 首先是唐诗的数据库,可以在此链接下载到:全唐诗(43030首)
  • readPoetry()函数中,读取了全部的唐诗,分离并抛弃掉标题部分,因为这部分往往不符合诗词的一般格式,参与诗词的训练没有意义。 随后对诗词进行基本的归一化,诸如剔除空格、根据字数分类。原诗中包含说明、介绍、引用等不署于诗词的部分,因为这部分数据完全不规范不能自动处理,所以这样的诗词干脆剔除掉不参与训练。 最后得到的样本集,每首诗保持了中间的逗号和句号,用于体现逗号、句号跟之前的字的规律。此外认为在开头和结尾增加了"["和"]"字符。用于体现每首诗第一个字和最后一个字跟相邻字之间的规律。
  • 接着把诗文向量化,就是上一篇word2vec的工作。但这个源码估计为了降低工作量,没有进行分词,程序假定每个字就是一个词,多字词的关系会被丢失,但这在后面“自动写诗”的环节会比较容易处理,否则可能造成每句诗中因为词语的存在而字数不同。另外一点就是没有把同义词在向量空间中拉近相关的距离,这里也是为了简化操作。也可以说还存在改进的空间。
  • genTrainData()以64首诗为一个批次,生成了训练数据集x_batches/y_batches,因为总体算诗词的数据集比较小。这里没有动态逐批次生成,而是一次生成到两个数组中去。在训练结束生成古诗的时候,这部分实际是没有用的,但训练跟生成集成在同一个程序中,就忽略这点工作了。需要注意的是,生成古诗的时候,批次会设定为1,因为是通过一个汉字预测下一个汉字。
  • neural_network()函数中定义了RNN/LSTM网络,实际上这个主函数考虑了使用RNN / LSTM / GRU三种网络的构建选择,可以任意选择其一。在这里使用了python函数可以跟变量一样赋值并调用的特性,读源码的时候可以注意一下。 与上一个例子还有一点不同,就是这里使用了两层的RNN网络,回忆一下多层神经网络,理解这个概念应当不难。这项工作是由tf.nn.rnn_cell.MultiRNNCell函数完成的。 tf.get_variable()函数也是定义TensorFlow变量,我们之前一直使用tf.Variable(),两者功能类似,前者更适合在作用域的管理下共享变量。 接着要介绍的是个重点:tf.nn.dynamic_rnn,我们前面说过,因为是时序输入的计算模式,所以输入数据可以是不等长的,这是RNN网络的特征之一。我们之前所有的案例,每个训练批次的数据必须是定长,上一个RNN案例中也使用了rnn.static_rnn,这表示使用定长的数据集。 后面的激活函数再次是我们熟悉的softmax,这次等于是把上面数字化之后的唐诗中的汉字做成一个库,分类到其中之一,即为推测出的下一个字。 总结一下模型部分:唐诗数字化的时候,完整的保留了每首诗开头文字、结尾文字、每句的结尾文字之间的关系。所建立的RNN模型,实际上会以上一个文字,预测下一个文字,甚至标点符号都是预测而得到的。
  • 随后的训练部分train_neural_network()没有太多新概念,要注意的是每次调用模型的训练,会保留其last_state,并在下个批次训练的时候,迭代进去。这是我们前面讲RNN模型的时候说过的。而这种模式,是在之前的各种模型中没有出现过的。
  • gen_poetry()自动生成诗句是一个很完整的预测,初始的值会是一个字符"[",表示一个诗的开始,我们样本中,每首诗的开始都是人为增加的“[”字符。RNN模型肯定不会对这么高频的规律搞错。这种模式生成的古诗虽然远远比不上人的作品,但可读性还是比较好的。
  • 藏头诗部分gen_poetry_with_head(),这部分生成的会比较牵强。原因是,人为指定的藏头诗第一个字,不可能刚好吻合唐诗数据库中每句第一个字的规律,因此直接预测出来,很可能没有完成一句话,就已经是句号或者逗号。 程序只能根据预置的句长(这里指定七言),跳过逗号、句号以及结束符号“]”,跳过之后再次重新生成,其实已经不符合一句话中的规律,但为了达到藏头诗的效果,也只能如此。
  • 训练模型使用的批次是64。生成时候所使用的预测模型批次是1,因为使用一个汉字去预测后一个。这个在main()中会自动调整。

其余的部分相信凭借注释和以前的经验应当能看懂了:

#!/usr/bin/env python
# -*- coding=UTF-8 -*-

# source from: 
#  http://blog.topspeedsnail.com/archives/10542
# poetry.txt from:
#  https://pan.baidu.com/s/1o7QlUhO
# revised: andrew
#  https://formoon.github.io
#  add python 2.x support and tf 1.4.1 support
#------------------------------------------------------------------#

import collections
import numpy as np
import tensorflow as tf
import argparse
import codecs
import os,time
import sys
reload(sys)
sys.setdefaultencoding('utf-8')

#-------------------------------数据预处理---------------------------#

poetry_file ='poetry.txt'

# 诗集
poetrys = []
def readPoetry():
    global poetrys
    #with open(poetry_file, "r", encoding='utf-8',) as f:
    with codecs.open(poetry_file, "r","utf-8") as f:
        for line in f:
            try:
                content = line.strip().split(':')[1]
                #title, content = line.strip().split(':')
                content = content.replace(' ','')
                if '_' in content or '(' in content or '(' in content or '《' in content or '[' in content:
                    continue
                if len(content) < 5 or len(content) > 79:
                    continue
                content = '[' + content + ']'
                poetrys.append(content)
            except Exception as e:
                pass
    # 按诗的字数排序
    poetrys = sorted(poetrys,key=lambda line: len(line))

#for item in poetrys:
#    print(item)

# 统计每个字出现次数
readPoetry()
all_words = []
for poetry in poetrys:
    all_words += [word for word in poetry]
#    print poetry
#    for word in poetry:
#        print(word)
#        all_words += word
counter = collections.Counter(all_words)
count_pairs = sorted(counter.items(), key=lambda x: -x[1])
words, _ = zip(*count_pairs)
#print words

# 取前多少个常用字
words = words[:len(words)] + (' ',)
# 每个字映射为一个数字ID
word_num_map = dict(zip(words, range(len(words))))
#print(word_num_map)
# 把诗转换为向量形式,参考word2vec
to_num = lambda word: word_num_map.get(word, len(words))
poetrys_vector = [ list(map(to_num, poetry)) for poetry in poetrys]
#[[314, 3199, 367, 1556, 26, 179, 680, 0, 3199, 41, 506, 40, 151, 4, 98, 1],
#[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]
#....]

# 每次取64首诗进行训练
batch_size = 64
n_chunk = len(poetrys_vector) // batch_size
x_batches = []
y_batches = []
def genTrainData(b):
    global batch_size,n_chunk,x_batches,y_batches,poetrys_vector
    batch_size=b
    for i in range(n_chunk):
        start_index = i * batch_size
        end_index = start_index + batch_size

        batches = poetrys_vector[start_index:end_index]
        length = max(map(len,batches))
        xdata = np.full((batch_size,length), word_num_map[' '], np.int32)
        for row in range(batch_size):
            xdata[row,:len(batches[row])] = batches[row]
        ydata = np.copy(xdata)
        ydata[:,:-1] = xdata[:,1:]
        """
        xdata ydata
        [6,2,4,6,9] [2,4,6,9,9]
        [1,4,2,8,5] [4,2,8,5,5]
        """
        x_batches.append(xdata)
        y_batches.append(ydata)


#---------------------------------------RNN--------------------------------------#

# 定义RNN
def neural_network(input_data, model='lstm', rnn_size=128, num_layers=2):
    if model == 'rnn':
        cell_fun = tf.nn.rnn_cell.BasicRNNCell
    elif model == 'gru':
        cell_fun = tf.nn.rnn_cell.GRUCell
    elif model == 'lstm':
        cell_fun = tf.nn.rnn_cell.BasicLSTMCell

    cell = cell_fun(rnn_size, state_is_tuple=True)
    cell = tf.nn.rnn_cell.MultiRNNCell([cell] * num_layers, state_is_tuple=True)

    initial_state = cell.zero_state(batch_size, tf.float32)

    with tf.variable_scope('rnnlm'):
        softmax_w = tf.get_variable("softmax_w", [rnn_size, len(words)+1])
        softmax_b = tf.get_variable("softmax_b", [len(words)+1])
        with tf.device("/cpu:0"):
            embedding = tf.get_variable("embedding", [len(words)+1, rnn_size])
            inputs = tf.nn.embedding_lookup(embedding, input_data)

    outputs, last_state = tf.nn.dynamic_rnn(cell, inputs, initial_state=initial_state, scope='rnnlm')
    output = tf.reshape(outputs,[-1, rnn_size])

    logits = tf.matmul(output, softmax_w) + softmax_b
    probs = tf.nn.softmax(logits)
    return logits, last_state, probs, cell, initial_state
#训练
def train_neural_network():
    global datafile
    input_data = tf.placeholder(tf.int32, [64, None])
    output_targets = tf.placeholder(tf.int32, [64, None])
    
    logits, last_state, _, _, _ = neural_network(input_data)
    targets = tf.reshape(output_targets, [-1])
    #loss = tf.nn.seq2seq.sequence_loss_by_example([logits], [targets], [tf.ones_like(targets, dtype=tf.float32)], len(words))
    loss = tf.contrib.legacy_seq2seq.sequence_loss_by_example([logits], [targets], [tf.ones_like(targets, dtype=tf.float32)], len(words))
    cost = tf.reduce_mean(loss)
    learning_rate = tf.Variable(0.0, trainable=False)
    tvars = tf.trainable_variables()
    grads, _ = tf.clip_by_global_norm(tf.gradients(cost, tvars), 5)
    optimizer = tf.train.AdamOptimizer(learning_rate)
    train_op = optimizer.apply_gradients(zip(grads, tvars))

    with tf.Session() as sess:
        sess.run(tf.global_variables_initializer())

        #saver = tf.train.Saver(tf.all_variables())
        saver = tf.train.Saver()

        for epoch in range(50):
            sess.run(tf.assign(learning_rate, 0.002 * (0.97 ** epoch)))
            n = 0
            for batche in range(n_chunk):
                train_loss, _ , _ = sess.run([cost, last_state, train_op], feed_dict={input_data: x_batches[n], output_targets: y_batches[n]})
                n += 1
                print(epoch, batche, train_loss)
            if epoch % 7 == 0:
                #保存的数据,文件名中有批次的标志
                saver.save(sess, datafile, global_step=epoch)

#-------------------------------生成古诗---------------------------------#
# 使用训练完成的模型
 
def gen_poetry():
    global datafile
    input_data = tf.placeholder(tf.int32, [1, None])
    output_targets = tf.placeholder(tf.int32, [1, None])

    def to_word(weights):
        t = np.cumsum(weights)
        s = np.sum(weights)
        sample = int(np.searchsorted(t, np.random.rand(1)*s))
        return words[sample]

    _, last_state, probs, cell, initial_state = neural_network(input_data)

    with tf.Session() as sess:
        sess.run(tf.global_variables_initializer())

        saver = tf.train.Saver()
        #读取最后一个批次的训练数据
        saver.restore(sess, datafile+"-49")

        state_ = sess.run(cell.zero_state(1, tf.float32))

        x = np.array([list(map(word_num_map.get, '['))])
        [probs_, state_] = sess.run([probs, last_state], feed_dict={input_data: x, initial_state: state_})
        word = to_word(probs_)
        #word = words[np.argmax(probs_)]
        poem = ''
        while word != ']':
            poem += word
            if word == ',' or word=='。':
                poem += '\n'
            x = np.zeros((1,1))
            x[0,0] = word_num_map[word]
            [probs_, state_] = sess.run([probs, last_state], feed_dict={input_data: x, initial_state: state_})
            word = to_word(probs_)
            #word = words[np.argmax(probs_)]
        return poem
 

#-------------------------------生成藏头诗---------------------------------#
def gen_poetry_with_head(head,phase):
    global datafile
    input_data = tf.placeholder(tf.int32, [1, None])
    output_targets = tf.placeholder(tf.int32, [1, None])

    def to_word(weights):
        t = np.cumsum(weights)
        s = np.sum(weights)
        sample = int(np.searchsorted(t, np.random.rand(1)*s))
        return words[sample]

    _, last_state, probs, cell, initial_state = neural_network(input_data)

    with tf.Session() as sess:
#        sess.run(tf.initialize_all_variables())
        sess.run(tf.global_variables_initializer())

        saver = tf.train.Saver()
        saver.restore(sess, datafile+"-49")

        state_ = sess.run(cell.zero_state(1, tf.float32))
        poem = ''
        i = 0
        p = 0
        head=unicode(head,"utf-8");
        for word in head:
            while True:
                if word != ',' and word != '。' and word != ']':
                    poem += word
                    p += 1
                    if p == phase:
                        p = 0
                        break
                else:
                    word='['
                x = np.array([list(map(word_num_map.get, word))])
                [probs_, state_] = sess.run([probs, last_state], feed_dict={input_data: x, initial_state: state_})
                word = to_word(probs_)
            if i % 2 == 0:
                poem += ',\n'
            else:
                poem += '。\n'
            i += 1
        return poem

FLAGS = None 
datafile='./data/module-49'
def datafile_exist():
    return os.path.exists(datafile+"-49.index")

def main(_):
#    if FLAGS.train or (not datafile_exist()):
    if FLAGS.train:
        genTrainData(64)
        print("poems: ",len(poetrys))
        train_neural_network()
        exit()
    if datafile_exist():
        genTrainData(1)
        if FLAGS.generate:
            print(gen_poetry())
        else:
            print(gen_poetry_with_head(FLAGS.head,7))

if __name__ == '__main__':
    parser = argparse.ArgumentParser()
    parser.add_argument('-a','--head', type=str, default='大寒将至',
                      help='poetry with appointed head char')
    parser.add_argument('-t','--train', action='store_true',default=False,
                      help='Force do train')
    parser.add_argument('-g','--generate', action='store_true',default=False,
                      help='Force do train')
    FLAGS, unparsed = parser.parse_known_args()
    tf.app.run(main=main, argv=[sys.argv[0]] + unparsed)

使用方法: -a参数是指定藏头诗开始的字; -g参数直接自动生成; -t强制开始训练。(注意训练的时间还是比较长的)

生成的效果请看:

> ./poetry.py -g
沉眉默去迎风雪,
江上才风著故人。
手把柯子不看泪,
笑逢太守也怜君。
秋风不定红钿啭,
茶雪欹眠愁断人。
语苦微成求不死,
醉看花发渐盈衣。

#藏头诗
> ./poetry.py -a "春节快乐"
春奔桃芳水路犹,
节似鸟飞酒绿出。
快龟缕日发春时,
乐见来还日只相。

至少有了个古诗的样子了。

(待续...)

引文及参考

TensorFlow练习3: RNN, Recurrent Neural Networks TensorFlow练习7: 基于RNN生成古诗词 如何用TensorFlow构建RNN?这里有一份极简的教程 (译)理解 LSTM 网络 (Understanding LSTM Networks by colah)

本文参与腾讯云自媒体分享计划,欢迎正在阅读的你也加入,一起分享。

发表于

我来说两句

0 条评论
登录 后参与评论

相关文章

来自专栏ATYUN订阅号

【机器学习】伪标签(Pseudo-Labelling)的介绍:一种半监督机器学习技术

我们在解决监督机器学习的问题上取得了巨大的进步。这也意味着我们需要大量的数据来构建我们的图像分类器。但是,这并不是人类思维的学习方式。一个人的大脑不需要上百万个...

7646
来自专栏ml

模式识别---图像二值化

要对图像进行识别,首先要做的将图像从多通道颜色分量变为单通道,也就是gray色调中来,常用的方法有目下三种, 第一种  求rgb颜色风量的平均值:       ...

36912
来自专栏机器之心

ACL 2018 | 神经语言模型如何利用上下文信息:长距离上下文的词序并不重要

1955
来自专栏大数据挖掘DT机器学习

R语言与机器学习(分类算法)决策树算法

决策树定义 首先,我们来谈谈什么是决策树。我们还是以鸢尾花为例子来说明这个问题。 ? 观察上图,我们判决鸢尾花的思考过程可以这么...

3914
来自专栏编程软文

前端慌不慌?用深度学习自动生成HTML代码

2636
来自专栏机器之心

听说你用JavaScript写代码?本文是你的机器学习指南

3676
来自专栏PaddlePaddle

转载|使用PaddleFluid和TensorFlow训练RNN语言模型

在图像领域,最流行的 building block 大多以卷积网络为主。上一篇我们介绍了转载|使用PaddleFluid和TensorFlow实现图像分类网络S...

1173
来自专栏ATYUN订阅号

【教程】OpenCV—Node.js教程系列:用Tensorflow和Caffe“做游戏”

? 今天我们来看看OpenCV的深度神经网络模块。如果你想要释放神经网络的awesomeness来识别和分类图像中的物体,但完全不知道深度学习如何工作,也不知...

4438
来自专栏Hadoop数据仓库

HAWQ + MADlib 玩转数据挖掘之(六)——主成分分析与主成分投影

一、主成分分析(Principal Component Analysis,PCA)简介         在数据挖掘中经常会遇到多个变量的问题,而且在多数情况下,...

1746
来自专栏超智能体

YJango:TensorFlow高层API Custom Estimator建立CNN+RNN的演示

该文是YJango:TensorFlow中层API Datasets+TFRecord的数据导入的后续。

9107

扫码关注云+社区