Tensorflow1.9循环神经网络

Tensorflow1.9循环神经网络

一、循环神经网络理论基础

1.简介

• 一些简单的词序混乱就可以使整个句子不通顺，类似的问题有:时间序列数据——时间定义了事件的发生
  基因组序列数据——每个序列都有不同的含义
• 传统神经网络很难解决这类问题，若要使用这类数据得到有用的输出，就需要一个这样的网络:能够访问一些关于数据的先前知识（prior knowledge)，以便完全理解这些数据，在这种应用
  场景的驱动下，循环神经网络(RNN)应运而生

2.应用

• 循环神经网络的优点在于其应用的多样性，RNNs可用于将输入映射到不同类型、长度的输出，并根据实际应用进行泛化，
  例
• 情感分析(Sentiment Classification)：把一条推文分为正负两种情绪，输入是任意长度的推文，输出是固定的长度和类型
• 图像标注(Image Captioning)：假设要得到一张图片的文本描述，输入是单一的图像，输出是一系列单词
  
• 语言翻译(Language Translation)：假设将英文翻译为法语，每种语言都有自己的语义，对同一句话有不同的长度，因此，这里的输入和输出是不同长度的

3.循环神经网络基本结构

• 输入输出可以不定长
• 可以编码时序的信息
  

二、双向循环神经网络

1.双向循环神经网络产生背景

• 对于语言模型来说，有时需要关注词语与上下文的关系，比如下面这句话:
• 我的手机坏了，我打算_一部新手机
  上例中如果只看横线前面的词『手机坏了』，那么『修』『换』『大哭一场』都有可能，若也看到了横线后面的词『一部新手机』，那么横线上的词填『换』的概率就大得多了
• 在上一小节中的基本循环神经网络无法对此进行建模，因此我们需要双向循环神经网络

2.双向循环神经网络结构

3.双向多层神经网络结构

三、训练

1.梯度爆炸和消逝问题

• 前面介绍的几种RNNs并不能很好的处理较长的序列，一个主要的原因是RNN在训练中很容易发生梯度爆炸和梯度消失，这导致训练时梯度不能在较长序列中一直传递下去，从而使RNN无法捕捉到长距离的影响
• 处理梯度爆炸可以采用梯度截断的方法，即手动设置梯度的上限处理梯度消失有如下办法:
  1.合理的初始化权重值，使每个神经元尽可能不取极大或极小值，以躲开梯度消失的区域
  2.使用ReLU代替Sigmoid和Tanh作为激活函数
  3.使用其他结构的RNNs，比如长短时记忆网络（LSTM）和Gated Recurrent Unit(GRU)

四、改进

1.LSTM

2.GRU

• LSTM引入了很多内容，导致参数变多，使得训练难度加大，因此常使用效果和LSTM相当但参数更少的GRU来构建大训练量的模型
  

五、案例

1.案例1

# -*- coding: utf-8 -*-
# In[]
import keras
from keras.preprocessing.sequence import pad_sequences
from keras.models import Sequential
from keras.layers import Dense,Dropout,Embedding,LSTM,SpatialDropout1D,SimpleRNN,GRU
from keras.layers import Bidirectional
from keras.callbacks import ModelCheckpoint
import os
from sklearn.metrics import roc_auc_score
import matplotlib.pyplot as plt
import pandas as pd
import numpy as np
import re
from keras.preprocessing.text import Tokenizer
from sklearn.model_selection import train_test_split

# In[]
tweets = pd.read_csv("airline_sentiment.csv")
# In[]
print(tweets.shape)
# In[]

data=tweets[['text','airline_sentiment']]
data=data[data.airline_sentiment != 'neutral']
data['text']=data['text'].apply(lambda x:x.lower())
data['text']=data['text'].apply((lambda x:re.sub('[^a-zA-z0-9\s]','',x)))

print(data[data['airline_sentiment']=='positive'].size)
print(data[data['airline_sentiment']=='negative'].size) 
# In[]
#数量化
max_fatures=2000 #取词频最高2000词
tokenizer=Tokenizer(num_words=max_fatures,split=' ')
tokenizer.fit_on_texts(data['text'].values)
X=tokenizer.texts_to_sequences(data['text'].values)
X=pad_sequences(X)
# In[]
print(X.shape)
print(X[0,:])
# In[]
#build RNN model loss: 0.2992 - acc: 0.8746 - val_loss: 0.4400 - val_acc: 0.8340
embed_dim=128
rnn_out=196

model =Sequential()
model.add(Embedding(max_fatures,embed_dim,input_length=X.shape[1]))
model.add(Dropout(0.5))
model.add(SimpleRNN(rnn_out,dropout=0.2,recurrent_dropout=0.2))
model.add(Dense(2,activation='softmax'))

model.compile(loss='categorical_crossentropy',optimizer="adam",metrics=['accuracy'])
model.summary()

# In[]
#build LSTM model  acc: 0.9603 - val_loss: 0.2053 - val_acc: 0.9160
embed_dim=128
rnn_out=196

model =Sequential()
model.add(Embedding(max_fatures,embed_dim,input_length=X.shape[1]))
model.add(Dropout(0.5))
model.add(LSTM(rnn_out,dropout=0.2,recurrent_dropout=0.2))
model.add(Dense(2,activation='softmax'))

model.compile(loss='categorical_crossentropy',optimizer="adam",metrics=['accuracy'])
model.summary()
# In[]
# In[]
#build GRU model loss: 0.0994 - acc: 0.9629 - val_loss: 0.2210 - val_acc: 0.9260
embed_dim=128
rnn_out=196

model =Sequential()
model.add(Embedding(max_fatures,embed_dim,input_length=X.shape[1]))
model.add(Dropout(0.5))
model.add(GRU(rnn_out,dropout=0.2,recurrent_dropout=0.2))
model.add(Dense(2,activation='softmax'))

model.compile(loss='categorical_crossentropy',optimizer="adam",metrics=['accuracy'])
model.summary()

# In[]
#build BiLSTM model  loss: 0.1016 - acc: 0.9606 - val_loss: 0.1990 - val_acc: 0.9280
embed_dim=128
rnn_out=196

model =Sequential()
model.add(Embedding(max_fatures,embed_dim,input_length=X.shape[1]))
model.add(Dropout(0.5))
model.add(Bidirectional(LSTM(rnn_out,dropout=0.2,recurrent_dropout=0.2)))
model.add(Dense(2,activation='softmax'))

model.compile(loss='categorical_crossentropy',optimizer="adam",metrics=['accuracy'])
model.summary()
# In[]
#build muti-LSTM model 
embed_dim=128
rnn_out=196

model =Sequential()
model.add(Embedding(max_fatures,embed_dim,input_length=X.shape[1]))
model.add(Dropout(0.5))
model.add(LSTM(rnn_out,dropout=0.2,recurrent_dropout=0.2))
model.add(Dropout(0.5))
model.add(LSTM(rnn_out,dropout=0.2,recurrent_dropout=0.2))
model.add(Dense(2,activation='softmax'))

model.compile(loss='categorical_crossentropy',optimizer="adam",metrics=['accuracy'])
model.summary()
# In[]
#training data prepare
Y=pd.get_dummies(data["airline_sentiment"]).values
X_train,X_test,Y_train,Y_test=train_test_split(X,Y,test_size=0.33,random_state=42)
print(X_train.shape,Y_train.shape)
print(X_test.shape,Y_test.shape)

# In[]
X_val = X_train[:500]
Y_val = Y_train[:500]
partial_X_train = X_train[500:]
partial_Y_train = Y_train[500:]
# In[]
# train network
batch_size=512
history=model.fit(partial_X_train,partial_Y_train,epochs=10,batch_size=batch_size,validation_data=(X_val,Y_val))
# In[]
import matplotlib.pyplot as plt
loss = history.history["loss"]
val_loss = history.history["val_loss"]
epoches=range(1,len(loss)+1)
plt.plot(epoches,loss,'bo',label="Training Loss")
plt.plot(epoches,val_loss,'b',label='Validation loss')
plt.title("training and Validation Loss")
plt.xlabel("Epochs")
plt.ylabel("Loss")
plt.legend()
plt.show()

# In[]
#validation
pos_cnt,neg_cnt,pos_correct,neg_correct=0,0,0,0
for x in range(len(X_test)):
    result=model.predict(X_test[x].reshape(1,X_test.shape[1]),batch_size=1,verbose=2)[0]
    
    if np.argmax(result)==np.argmax(Y_test[x]):
        if np.argmax(Y_test[x])==0:
            neg_correct+=1
        else:
            pos_correct+=1
            
    if np.argmax(Y_test[x])==0:
        neg_cnt+=1
    else:
        pos_cnt+=1
        
print('pos acc',pos_correct / np.float32(pos_cnt) * 100,"%")
print('neg acc',neg_correct / np.float32(neg_cnt) * 100,"%")       
            

2.案例2

# 加载数据
import pandas as pd
data = pd.read_csv('000001.csv')
data['date'] = pd.to_datetime(data['date'])
data = data.sort_values(by='date')

# Min-Max标准化
import numpy as np
data1 = data.iloc[:, 1:]
data1 = (data1 - np.min(data1, axis=0))/(np.max(data1, axis=0) - np.min(data1, axis=0))

#定义输入和输出，给定某日，输入为该日前5天的8个特征，输出为该日收盘价
window_size = 5
X = []
Y = []
for i in range(window_size, len(data1)):
    X.append(np.array(data1.iloc[i-window_size:i]))
    Y.append(np.array(data1['close'][i]))
X = np.array(X)
Y = np.array(Y) 

# 载入必要库
from tensorflow.keras.models import Sequential
from tensorflow.keras.layers import Dropout, GRU

#定义训练集和测试集
X_train = X[:-20]
y_train = Y[:-20]
y_train = y_train.reshape(-1, 1)
X_test = X[-20:]
y_test = Y[-20:]
y_test = y_test.reshape(-1, 1)

#构建模型
model = Sequential()

#input dropout为0.2，循环dropout为0.1
model.add(GRU(units = 1, 
              dropout=0.2, 
              recurrent_dropout=0.1, 
              input_shape=[X.shape[1], X.shape[2]]
             ))

# 模型编译，损失函数使用均方误差损失，优化函数使用“adam”
model.compile(loss='mean_squared_error', optimizer='adam')

# 创建会话
with tf.Session() as sess:
    history = model.fit(x=X_train, y=y_train, ## 指定训练数据 
                    batch_size=2,         ## batch大小为2
                    epochs=10,            ## 迭代10轮 
                    validation_split=.1)  ## 分割10%的训练集作为验证集

    # 使用模型在测试集上做出预测
    y_pred = model.predict(X_test)

    # 计算模型在测试集上的损失
    test_loss = model.evaluate(X_test, y_test)
    print("testing loss:", test_loss)# -*- coding: utf-8 -*-