一、循环神经网络简介

  循环神经网络的主要用途是处理和预测序列数据。循环神经网络刻画了一个序列当前的输出与之前信息的关系。从网络结构上,循环神经网络会记忆之前的信息,并利用之前的信息影响后面节点的输出。

下图展示了一个典型的循环神经网络。

循环神经网络的一个重要的概念就是时刻。上图中循环神经网络的主体结构A的输入除了来自输入层的Xt,还有一个自身当前时刻的状态St。

在每一个时刻,A会读取t时刻的输入Xt,并且得到一个输出Ht。同时还会得到一个当前时刻的状态St,传递给下一时刻t+1。

因此,循环神经网络理论上可看作同一神经结构被无限重复的过程。(无限重复目前还是不可行的)

将循环神经网络按照时间序列展开,如下图所示

 

 xt是t时刻的输入

St是t时刻的“记忆”,St = f(WSt-1 + Uxt),f是tanh等激活函数

Ot 是t时刻的输出

下图给出一个最简单的循环体或者叫记忆体的结构图

 

下图展示了一个循环神经网络的前向传播算法的具体计算过程。

在得到前向传播计算结果之后,可以和其他网络类似的定义损失函数。神经网络的唯一区别在于它每一个时刻都有一个输出,所以循环神经网络的总损失为前面所有时刻的损失函数的总和。

我们利用代码来实现这个简单的前向传播过程。

import numpy as np 
 
X = [1,2] 
state = [0.0,0.0] 
#定义不同输入部分的权重 
w_cell_state = np.asarray([[0.1,0.2],[0.3,0.4]]) 
w_cell_input = np.asarray([0.5,0.6]) 
b_cell = np.asarray([0.1,-0.1]) 
#定义输出层的权重 
w_output = np.asarray([[0.1],[0.2]]) 
b_output = 0.1 
#按照时间顺序执行循环神经网络的前向传播过程 
for i in range(len(X)): 
    before_activetion = np.dot(state,w_cell_state) + X[i] * w_cell_input + b_cell 
    state = np.tanh(before_activetion) 
    #计算当前时刻的最终输出 
    final_output = np.dot(state,w_output) + b_output 
    #输出每一时刻的信息 
    print("before_activation",before_activetion) 
    print("state",state) 
    print("final_output",final_output)

 

二、长短时记忆网络(LSTM)结构

循环神经网络工作的关键点就是使用历史的信息来帮助当前的决策。循环神经网络能很好的利用传统的神经网络不能建模的信息,但同时,也带来了更大的挑战——长期依赖的问题。

  在有些问题中,模型仅仅需要短期内的信息来执行当前的任务。但同时也会有一些上下文场景更加复杂的情况。当间隔不断增大时,简单的循环神经网络可能会丧失学习到如此远的信息的能力。或者在复杂的语言场景中,有用的信息的间隔有大有小,长短不一,循环神经网络的性能也会受限。

  为了解决这类问题,设计了LSTM。与单一tanh循环结构不同,LSTM拥有三个门:“输入门”、“输出门”、“遗忘门”。 

 

  LSTM靠这些“门”的结构信息有选择的影响循环神经网络中每个时刻的状态。所谓的“门”就是一个sigmod网络和一个按位做乘法的操作。当sigmod输出为1时,全部信息通过;为0时,信息无法通过。为了使循环神经网络更有效的保持长期记忆。“遗忘门“和”输入门”就至关重要。“遗忘门”就是让神经网络忘记之前没有用的信息。从当前的输入补充新的“记忆”是“输入门”作用。

使用LSTM结构的循环神经网络的前向传播时一个比较复杂的计算过程。在TensorFlow中可以被很简单的实现。例如下面的伪代码:

import tensorflow as tf 
 
#定义一个LSTM结构。TF通过一句简单的命令就可以定义一个LSTM循环体 
#LSTM中使用的变量也会自动声明 
 
lstm = tf.nn.rnn_cell.BasicLSTMCell(lstm_hidden_size) 
#将LSTM中的状态初始化问哦全0数组。 
#BasicLSTMCell类提供了zero_state函数来生成全0 的初始状态 
state = lstm.zero_state(batch_size,tf.float32) 
current_input = "hello" 
#定义损失函数 
loss = 0.0 
#虽然rnn理论上可以处理任意长度的序列,但是在训练时为了避免梯度消散的问题,会规定一个最大的循环长度num_temps 
for i in range(num_temps): 
    #在第一个时刻声明LSTM结构中使用的变量,在之后的时刻都需要服用之前的定义好的变量。 
    if i > 0: 
        tf.get_variable_scope().reuse_variables() 
    #每一步处理时间序列中的一个时刻 
    lstm_output,state = lstm(current_input,state) 
    #将当前时刻LSTM结构的输出传入一个全连接层得到最后的输出 
    final_output = full_connected(lstm_output) 
    #计算当前时刻的输出的损失 
    loss += calc_loss(final_output,expected_output) 
 
#利用BP后向传播算法训练模型

三、循环神经网络的变种

1、双向循环神经网络和深层循环神经网络

在经典的循环神经网络中,状态的传输时从前向后单向的。然而,在有些问题中,当前时刻的输出不仅和之前的状态有关,也和之后的转台有关。只是后就需要使用双向循环神经网络来解决此类问题。双向循环神经网络时由连个神经网络上下叠加在一起组成的。输出有这两个神经网络的转台共同决定的。下图展示了一个双向循环神经网络。

深层循环神经网络是循环神经网络的另外一种变体。为了增强模型的表达能力,可以将每一时刻上的循环体重复多次。深层循环神经网络在每一时刻上将循环体结构重复了多次。 每一层循环体中的参数是一致的,不同层的循环体参数可以不一致。TF提供了MultiRNNCell类来实现深层循环神经网络的前向传播过程。

 

import tensorflow as tf 
 
#定义一个基本的LSTM结构作为循环体的基础结构,深层循环神经网络也可以支持其他的循环提结构 
lstm = tf.nn.rnn_cell.BasicLSTMCell(lstm_size) 
 
#通过MultiRNNCell类来实现深层循环神经网络中每一时刻的前向传播过程。其中。number_of_layers 表示了有多少层,也就是图 
#中从xi到hi需要经过多少个LSTM结构。 
stacked_lstm = tf.nn.rnn_cell.MultiRNNCell([lstm]*number_of_layers) 
#和经典神经网络一样,可以通过zero_state函数获得初始状态。 
state = stacked_lstm.zero_state(batch_size,tf.float32) 
#计算每一时刻的前向传播过程 
for i in range(num_steps): 
    if i > 0: 
        tf.get_variable_scope().reuse_variables() 
    stacked_lstm_output  ,state = stacked_lstm(current_input,state) 
    final_output =  fully_connected(stacked_lstm_output) 
    loss += calc_loss(final_output,expected_output) 
    

2、循环神经网络的dropout

  dropout可以样循环神经网络更加的健壮。dropout一般只在不同层循环体之间使用。也就是说从t-1时刻传递到时刻t,RNN不会进行状态的dropout,而在同一时刻t,不同层循环体之间会使用dropout。

在TF中,使用tf.nn.rnn_cell.DropoutWrapper类可以很容易实现dropout功能。

#定义LSTM结构 
lstm  = tf.nn.rnn_cell.BasicLSTMCell(lstm_size) 
#通过DropoutWrapper来实现dropout功能。input_keep_drop参数用来控制输入的dropout的概率,output_keep_drop参数用来控制输出的dropout的概率, 
dropout_lstm = tf.nn.rnn_cell.DropoutWrapper(lstm,input_keep_prob=0.5,output_keep_prob=0.5) 
#在使用了dropout的基础上定义深层RNN 
stacked_lstm = tf.nn.rnn_cell.MultiRNNCell([dropout_lstm]* 5)

 

四、循环神经网络的样例应用

1、自然语言建模

  简单的说,语言模型的目的就是为了计算一个句子的出现概率。在这里把句子看成单词的序列S = (w1,w2,w3....wm),其中m为句子的长度,它的概率可以表示为

P(S) = p(w1,w2,w3.....wm) = p(w1)p(w2|w1)p(w3|w1,w2)p(wm| w1,w2...wm)

等式右边的每一项都是语言模型中的一个参数。为了估计这些参数的取值,常用的方法有n-gram、决策树、最大熵模型、条件随机场、神经网络模型。

  语言模型效果的好坏的常用的评价指标是复杂度(perplexity)。简单来说,perplexity刻画的就是通过某一语言模型估计一句话出现的概率。值越小越好。复杂度的计算公式:

下面就利用语言模型来处理PTB数据集。

为了让PTB数据集使用更方便,TF提供了两个函数来预处理PTB数据集。ptb_raw_data用来读取原始数据,并将原始数据的单词转化为单词ID,形成一个非常长的序列。ptb_iterator将序列按照某固定的长度来截断,并将数据组成batch。

 

使用循环神经网络实现语言模型

# -*- coding:utf-8 -*- 
 
import numpy as np 
import tensorflow as tf 
from tensorflow.models.rnn.ptb import reader 
from tensorflow.contrib.legacy_seq2seq import sequence_loss_by_example 
DATA_PATH = "path/to/ptb/data" 
HIDDEN_SIZE = 200 #隐藏层的规模 
NUM_LAYERS = 2 #DRNN中LSTM结构的层数 
VOCAB_SIZE = 10000 #词典规模,加上语句结束符和稀有单词结束符总共10000 
LEARNING_RATE = 1.0 
TRAIN_BATCH_SIZE = 20  #训练数据BATCH大小 
TRAIN_NUM_STEPS = 35    #训练数据截断长度 
#在测试的时候不需要使用截断 
EVAL_BATCH_SIZE = EVAL_NUM_STEP = 1 
NUM_EPOCH = 2 #使用训练数据的轮数 
KEEP_DROP =0.5 #节点不被dropout的概率 
MAX_GRAD_NORM =5 #用于控制梯度膨胀的参数 
 
 
#定义一个PTBMODEL类来描述模型,方便维护循环神经网络中的状态 
class PTBMODEL: 
    def __init__(self,batch_size,num_steps,is_training = True): 
        self.batch_size = batch_size 
        self.num_steps = num_steps 
        #定义输入层,维度为batch_size* num_steps 
        self.input_data = tf.placeholder(tf.int32,shape=[batch_size,num_steps]) 
        #定义预期输出。它的维度和ptb_iterrattor输出的正确答案维度是一样的。 
        self.targets = tf.placeholder(tf.int32,[batch_size,num_steps]) 
        #定义使用LSTM结构为循环体结构且使用dropout的深层循环神经网络 
        lstm_cell = tf.nn.rnn_cell.BasicLSTMCell(HIDDEN_SIZE) 
        if is_training: 
            lstm_cell = tf.nn.rnn_cell.DropoutWrapper(lstm_cell,output_keep_prob=KEEP_DROP) 
        cell = tf.nn.rnn_cell.MultiRNNCell(lstm_cell) 
        #初始化初始状态 
        self.initial_state = cell.zero_state(batch_size,tf.float32) 
        #将单词ID转换为单词向量,总共有VOCAB_SIZE个单词,每个单词向量的维度为HIDDEN_SIZE,所以embedding参数的维度为 
        #VOCAB_SIZE*HIDDEN_SIZE 
        embedding = tf.get_variable("embedding",[VOCAB_SIZE,HIDDEN_SIZE]) 
        #将原本batch_size * num_steps个单词ID转化为单词向量,转化后的输入层维度为batch_size * num_steps * HIDDEN_SIZE 
        inputs = tf.nn.embedding_lookup(embedding,self.input_data) 
        #只在训练时使用dropout 
        if is_training: 
            inputs  = tf.nn.dropout(inputs,KEEP_DROP) 
        #定义输出列表,在这里现将不同时刻LSTM结构的输出收集起来,再通过一个全连接层得到最终输出 
        output = [] 
        #state 存储不同batch中LSTM的状态,并且初始化为0. 
        state = self.initial_state 
        with tf.variable_scope("RNN"): 
            for time_step  in range(num_steps): 
                if time_step > 0 : 
                    tf.get_variable_scope().reuse_variables() 
                cell_output,state = cell(inputs[:,time_step,:],state) 
                #将当前输出加入输出队列 
                output.append(cell_output) 
        #把输出队列展开成[batch,hidden_size*num_steps]的形状,然后再reshape成【batch*num_steps,hidden_size】的形状。 
        output = tf.reshape(tf.concat(output,1),[-1,HIDDEN_SIZE]) 
        #将从LSTM中得到的输出再经过一个全连接层得到最后的预测结果,最终的预测结果在每一时刻上都是一个长度为VOCAB_SIZE的数组 
        #经过SoftMax层之后表示下一个位置是不同单词的概率。 
        weight = tf.get_variable("weight",[HIDDEN_SIZE,VOCAB_SIZE]) 
        baias  =  tf.get_variable("bias",[VOCAB_SIZE]) 
        logits = tf.matmul(output,weight) + baias 
        #定义交叉熵损失函数 
        loss  = sequence_loss_by_example([logits],[tf.reshape(self.targets,[-1])], 
                                                                   [tf.ones([batch_size*num_steps],dtype=tf.float32)] 
                                                                   ) 
        #计算得到每个batch的平均损失 
        self.cost = tf.reduce_sum(loss)/batch_size 
        self.final_state = state 
        #只在训练模型是定义反向传播操作 
        if not is_training: 
            return 
 
        trainable_variables = tf.trainable_variables() 
        #通过clip_by_global_norm函数控制梯度的大小,避免梯度膨胀的问题 
        grads,_ = tf.clip_by_global_norm(tf.gradients(self.cost,trainable_variables),MAX_GRAD_NORM) 
        #定义优化方法 
        optimizer = tf.train.GradientDescentOptimizer(LEARNING_RATE) 
        #定义训练步骤 
        self.train_op = optimizer.apply_gradients(zip(grads,trainable_variables)) 
 
#使用给定的模型model在数据data上运行train_op并返回全部数据上的perplexity值 
 
def run_epoch(session,model,data,train_op,output_log): 
    #计算perplexity的辅助变量 
    total_costs = 0.0 
    iters = 0 
    state = session.run(model.initial_state) 
    #使用当前数据训练或者测试模型 
    for step ,(x,y) in  enumerate(reader.ptb_iterator( data,model.batch_size,model.num_steps)): 
        cost,state,_ = session.run([model.cost,model.final_output,model.train_op],{ 
            model.input_data:x,model.targets:y, 
            model.initial_state:state 
        }) 
        total_costs += cost 
        iters += model.num_steps 
        #只有在训练时输出日志 
        if output_log and step % 100 == 0: 
            print("After %s steps ,perplexity is %.3f"%(step,np.exp(total_costs/iters))) 
 
    #返回给定模型在给定数据上的perplexity 
    return np.exp(total_costs/iters) 
 
 
def main(_): 
    #获取原始数据 
    train_data,valid_data,test_data = reader.ptb_raw_data(DATA_PATH) 
    #定义初始化函数 
    initializer = tf.random_uniform_initializer(-0.05,0.05) 
    #定义训练用的循环神经网络模型 
    with tf.variable_scope("language_model",reuse=True,initializer=initializer): 
        train_model = PTBMODEL(TRAIN_BATCH_SIZE,TRAIN_NUM_STEPS,is_training=True) 
    #定义评估用的循环神经网络模型 
    with tf.variable_scope("language_model",reuse=True,initializer=initializer): 
        eval_model = PTBMODEL(EVAL_BATCH_SIZE,EVAL_NUM_STEP,is_training=False) 
    with tf.Session() as sess: 
        tf.global_variables_initializer().run() 
        #使用训练数据训练模型 
        for i in range(NUM_EPOCH): 
            print("In iteration:%s"%(i+1)) 
            #在所有训练数据上训练RNN 
            run_epoch(sess,train_model,train_data,train_model.train_op,True) 
            #使用验证集评测模型效果 
            valid_perplexity = run_epoch(sess,eval_model,valid_data,tf.no_op(),False) 
            print("Epoch %s ,Validation perplexity :%.3f"%(i+1,valid_perplexity)) 
        # 最后使用测试集验证模型效果 
        test_perplexity = run_epoch(sess,eval_model,valid_data,tf.no_op(),False) 
        print("TEST perplexity :%.3f"%(test_perplexity)) 
 
if __name__ == '__main__': 
    tf.app.run()

 四、时间序列预测

   怎么用循环神经网络来预测正弦函数,可利用TF的高级封装--TFLearn.

  1、使用TFLearn自定义模型

  

from sklearn  import cross_validation 
from sklearn import datasets 
from sklearn import metrics 
import tensorflow as tf 
from tensorflow.contrib.learn import models,Estimator,SKCompat 
from tensorflow.contrib import layers,framework 
import numpy as np 
#导入TFLearn 
 
#自定义模型,对于给定的输入数据以及其对应的正确答案,返回在这些输入上的预测值、损失值以及训练步骤 
def my_model(feature,target): 
    #将预测的模型转换为one-hot编码的形式,因为共有三个类别,所以向量长度为3.经过转化后,三个个类别(1,0,0),(0,1,0),(0,0,1) 
    target = tf.one_hot(target,3,1,0) 
    #定义模型以及其在给定数据上的损失函数。TFLearn通过logistic_regression封装了一个单层全链接神经网络 
    logits,loss = models.logistic_regression(feature,target) 
    #创建模型的优化器,并得到优化步骤 
    train_op = layers.optimize_loss(loss,   #损失函数 
                                    framework.get_global_step(), #获取训练步数并在训练时更新 
                                    optimizer="Adagrad",  #定义优化器 
                                    learning_rate=0.1 #定义学习率 
                                    ) 
    #返回在给定数据上的预测结果、损失值以及优化步骤 
    return tf.argmax(logits,1) ,loss,train_op 
 
#加载iris数据集,并划分为训练集合和测试集合 
iris  = datasets.load_iris() 
x_train,x_test,y_train,y_test = cross_validation.train_test_split(iris.data,iris.target,test_size=0.2,random_state=0) 
#对自定义的模型进行封装 
classifier =Estimator(model_fn=my_model) 
classifier = SKCompat(classifier) 
#使用封装好的模型和训练数据执行100轮的迭代 
classifier.fit(x_train,y_train,steps=100) 
#使用训练好的模型进行预测 
y_predicted = classifier.predict(x_test) 
 
 
 
#计算模型的准确度 
score  = metrics.accuracy_score(y_test,y_predicted) 
print("Accuracy: %.2f %%"%(score * 100))

2、预测正选函数

  因为标准的RNN预测的是离散值,所以程序需要将连续的sin函数曲线离散化。

  每个SAMPLE_ITERVAL对sin函数进行一次采样,采样得到的序列就是sin函数离散化之后的结果

 

import numpy as np 
import tensorflow as tf 
import matplotlib as mpl 
from matplotlib import pyplot as plt 
from tensorflow.contrib.learn.python.learn.estimators.estimator import SKCompat 
 
# TensorFlow的高层封装TFLearn 
learn = tf.contrib.learn 
 
# 神经网络参数 
HIDDEN_SIZE = 30  # LSTM隐藏节点个数 
NUM_LAYERS = 2  # LSTM层数 
TIMESTEPS = 10  # 循环神经网络截断长度 
BATCH_SIZE = 32  # batch大小 
 
# 数据参数 
TRAINING_STEPS = 3000  # 训练轮数 
TRAINING_EXAMPLES = 10000  # 训练数据个数 
TESTING_EXAMPLES = 1000  # 测试数据个数 
SAMPLE_GAP = 0.01  # 采样间隔 
 
 
def generate_data(seq): 
    # 序列的第i项和后面的TIMESTEPS-1项合在一起作为输入,第i+TIMESTEPS项作为输出 
    X = [] 
    y = [] 
    for i in range(len(seq) - TIMESTEPS - 1): 
        X.append([seq[i:i + TIMESTEPS]]) 
        y.append([seq[i + TIMESTEPS]]) 
    return np.array(X, dtype=np.float32), np.array(y, dtype=np.float32) 
 
 
# LSTM结构单元 
def LstmCell(): 
    lstm_cell = tf.contrib.rnn.BasicLSTMCell(HIDDEN_SIZE) 
    return lstm_cell 
 
 
def lstm_model(X, y): 
    # 使用多层LSTM,不能用lstm_cell*NUM_LAYERS的方法,会导致LSTM的tensor名字都一样 
    cell = tf.contrib.rnn.MultiRNNCell([LstmCell() for _ in range(NUM_LAYERS)]) 
 
    # 将多层LSTM结构连接成RNN网络并计算前向传播结果 
    output, _ = tf.nn.dynamic_rnn(cell, X, dtype=tf.float32) 
    output = tf.reshape(output, [-1, HIDDEN_SIZE]) 
 
    # 通过无激活函数的全联接层计算线性回归,并将数据压缩成一维数组的结构 
    predictions = tf.contrib.layers.fully_connected(output, 1, None) 
 
    # 将predictions和labels调整为统一的shape 
    y = tf.reshape(y, [-1]) 
    predictions = tf.reshape(predictions, [-1]) 
 
    # 计算损失值 
    loss = tf.losses.mean_squared_error(predictions, y) 
 
    # 创建模型优化器并得到优化步骤 
    train_op = tf.contrib.layers.optimize_loss( 
        loss, 
        tf.train.get_global_step(), 
        optimizer='Adagrad', 
        learning_rate=0.1) 
 
    return predictions, loss, train_op 
 
 
# 用sin生成训练和测试数据集 
test_start = TRAINING_EXAMPLES * SAMPLE_GAP 
test_end = (TRAINING_EXAMPLES + TESTING_EXAMPLES) * SAMPLE_GAP 
train_X, train_y = generate_data( 
    np.sin(np.linspace(0, test_start, TRAINING_EXAMPLES, dtype=np.float32))) 
test_X, test_y = generate_data( 
    np.sin( 
        np.linspace(test_start, test_end, TESTING_EXAMPLES, dtype=np.float32))) 
 
# 建立深层循环网络模型 
regressor = SKCompat(learn.Estimator(model_fn=lstm_model, model_dir='model/')) 
 
# 调用fit函数训练模型 
regressor.fit(train_X, train_y, batch_size=BATCH_SIZE, steps=TRAINING_STEPS) 
 
# 使用训练好的模型对测试集进行预测 
predicted = [[pred] for pred in regressor.predict(test_X)] 
 
# 计算rmse作为评价指标 
rmse = np.sqrt(((predicted - test_y)**2).mean(axis=0)) 
print('Mean Square Error is: %f' % (rmse[0])) 
 
# 对预测曲线绘图,并存储到sin.jpg 
fit = plt.figure() 
plot_predicted = plt.plot(predicted,label = "predicted") 
plot_test = plt.plot(test_y,label = "real_sin") 
plt.legend([plot_predicted, plot_test], ['predicted', 'real_sin']) 
 
plt.savefig("sin.png")

 

发布评论

分享到:

IT虾米网

微信公众号号:IT虾米 (左侧二维码扫一扫)欢迎添加!

机器学习算法之降维详解
你是第一个吃螃蟹的人
发表评论

◎欢迎参与讨论,请在这里发表您的看法、交流您的观点。