深度学习之循环神经网络

一、序列模型之循环神经网络RNN

1.1定义与特点

• 输入或者输出中包含有序列数据的模型叫做序列模型（序列中包含信息）
• 输入（输出）元素之间是具有顺序关系。不同顺序，得到的结果应该是不同的，比如“不睡觉”和“睡觉不”这两个短句的意思是不同的
• 输入输出不定长，比如聊天机器人，聊天之间的对话长度都是不定的

1.2场景应用

• 机器翻译
• 语音识别
• 行为预测
• 股价预测

1.3循环神经网络（RNN

）

• 一类以序列（Sequence）数据为输入，在序列的演进方向进行递归（recursion）的神经网络
  
  

二、RNN处理字符串

2.1转化字典

• 词汇数值化：建立一个词汇-数值的字典，然后把输入词汇转化为数值数据
  

2.2RNN处理字符串：one-hot向量格式

• 不同字符之间不存在定理关系，因此需要通过One-hot向量格式的数据来表达字符信息
  
  
  

2.3RNN处理字符串：转化字典的另外一种方式

• 对每个字母建立字典
  

三、多样的RNN结构：LSTM、BRNN、DRNN

3.1多对一

• 输入：X1,X2,X3,…Xi
• 输出：y
• 应用：情感识别
• 举例 I am angry about this thing.[y=negative]

3.2一对多

• 输入：x
• 输出：y1,y2,y3,…,yi
• 应用：序列数据生成器（图像字母、约了生成、文章生成）

3.3多对多

• 输入：X1,X2,X3,…Xi
• 输出：y1,y2,y3,…yi
• 应用：机器翻译
• 举例：Do you want to sing with me【y=你想和我一起唱歌吗？】

3.4RNN结构中的信息丢失问题

• 前部序列信息在传递到后部的同时，信息权重下降，导致重要信息丢失
• 反向传播算法进行模型求解时，梯度消失
  

3.5长短期记忆网络（LSTM）

• 相比于普通RNN单元通过Ai传递前部序列信息，距离越远信息丢失越多，LSTM增加了记忆细胞Ci,可以传递前部远处重要信息
• Ai实现了序列信息传递，记忆细胞Ci则保证了重要信息不易丢失，提高预测准确性
• 即使网络很深（很多层），前部的重要信息也能在后续预测中保留
• 减少了普通RNN在求解过程中的梯度消失问题
  
• 忘记门：选择性丢弃Ai-1与Xi中不重要的信息
• 更新门：确定给记忆细胞添加哪些信息
• 输出门：筛选需要输出的信息
  

3.6双向循环神经网络（BRNN）

• 根据前后双项进行预测（后部序列信息也用于前部信息的预测）
  

3.7深层循环神经网络（DRNN）

• 对于更难提取的复杂信息，可以把单层RNN叠起来或和mlp结构结合使用
  

四、任务

4.1RNN预测股价

• 基于数据，建立RNN模型，使用收盘价格预测贵州茅台次日价
• 完成基本的数据加载，可视化工作
• 数据预处理：将数据转化为符合RNN模型输入要求的数据
• 建立RNN模型并训练模型，计算训练集、测试集模型预测r2分数
• 可视化预测表现（模型结构：单层RNN,5个神经元，每次使用前10个数据预测第11个数据）
• 将测试数据预测结果保存到本地csv文件

# -*- coding: utf-8 -*-

# In[]
import numpy as np
import pandas as pd
import matplotlib.pyplot as plt

data_train=pd.read_csv('task1_data_train.csv')

price_close=data_train.loc[:,'close']

# In[]
#数据可视化
plt1 =plt.figure(figsize=(8,5))
plt.plot(price_close)
plt.title('gzmt price close')
plt.xlabel('time serice')
plt.ylabel('price')
plt.show()

# In[]
#归一化
price_n=price_close/max(price_close)
print(price_n)

# In[]
#Input_shape(samples,time_steps.features)

#samples:样本数量（可不填写）
#time_steps:序列长度，及用多少个连续样本预测一个输出
#每个样本的特征数features
# In[]
#提取出符合要求的序列数据
def extract_data(data,time_step):
    X=[]
    y=[]
    #0,1,2,3,...,10:11个样本;time_step=10;0,1...9;1,2,...,10两组（两组样本）
    for i in range(len(data)-time_step):
        X.append([a for a in data[i:i+time_step]])
        y.append(data[i+time_step])
    X=np.array(X)
    X=X.reshape(X.shape[0],X.shape[1],1)
    return X,y

# In[]
#函数功能确认
# test_data=[i for i in range(1,10)]
# test_step=5
# X,y=extract_data(test_data,test_step)
# print(test_data)
# print(X,y)

# In[]
#股票价格数据处理
time_step=10
X,y=extract_data(price_n, time_step)
X=np.array(X)
y=np.array(y)
print(X[0:2,:,:])
print(y)
print(X.shape,len(y))

# In[]
from keras.models import Sequential
from keras.layers import Dense,SimpleRNN
model=Sequential()

model.add(SimpleRNN(units=5,input_shape=(10,1),activation='relu'))

model.add(Dense(units=1,activation='linear'))


model.summary()

# In[]
#模型配置
model.compile(optimizer='adam',loss='mean_squared_error')

# In[]
#模型训练
model.fit(X,y,batch_size=30,epochs=200)



# In[]
#结果预测
y_train_predict=model.predict(X)
y_train_predict=y_train_predict*max(price_close)
print(y_train_predict)

y=y*max(price_close)


# In[]
#结构可视化
plt1 =plt.figure(figsize=(8,5))
plt.plot(y,label='real price')
plt.plot(y_train_predict,label='predict price')
plt.title('gzmt price close')
plt.xlabel('time serice')
plt.ylabel('price')
plt.legend()
plt.show()



# In[]
#模型评估
from sklearn.metrics import r2_score

r2_train=r2_score(y,y_train_predict)
print(r2_train)
# In[]
#测试集
data_test=pd.read_csv('task1_data_test.csv')
price_test=data_test.loc[:,'close']


# In[]
#归一化(使用前面数据的最大值来完成归一化)
price_test_n=price_test/max(price_close)

# In[]
#测试数据的数据提取
X_test,y_test=extract_data(price_test_n, time_step)
print(X_test.shape,len(y_test))

# In[]
#测试数据的预测
y_test_predict=model.predict(X_test)

y_test_predict=y_test_predict*max(price_close)

y_test=np.array(y_test)
y_test=y_test*max(price_close)
# In[]

plt1 =plt.figure(figsize=(8,5))
plt.plot(y_test,label='real price')
plt.plot(y_test_predict,label='predict price')
plt.title('gzmt price close')
plt.xlabel('time serice')
plt.ylabel('price')
plt.legend()
plt.show()


# In[]
r2_train=r2_score(y_test,y_test_predict)
print(r2_train)



# In[]
#数据存储
y_test_r=np.array(y_test).reshape(-1,1)
print(y_test_r.shape)
print(y_test_predict.shape)
final_result=np.concatenate((y_test_r,y_test_predict),axis=1)

final_result_df=pd.DataFrame(final_result,columns=["real price","predict price"])

final_result_df.to_csv('predict.csv')
# In[]

4.2LSTM文本生成

• 基于数据，建立LSTM模型，生成文本
• 加载本地文本数据，生成字典
• 数据预处理：将数据转化为符合LSTM模型输入要求的数据，确认数据结构
• 建立LSTM模型，进行模型训练，计算模型在训练、测试数据集的准确率
• 预测”artificial intelligence(AI)，sometimes called machine intelligence,is intelligence demostrated by machines“的后续字母
• 模型结构：单层LSTM,30神经元
• 每次使用前30个字母(或符号)预测第31个字母

# -*- coding: utf-8 -*-
# In[]


# In[]
#文本数据加载
data=open('LSTM_data').read()
#移除换行符
data=data.replace('\n','').replace('\r','')
print(data)
# In[]
#字符去重处理
letters=list(set(data))
print(letters)
features=len(letters)
print(features)


# In[]
#建立字典
# int to char
int_to_char={a:b for a,b in enumerate(letters)}
print(int_to_char)

#char to int
char_to_int={b:a for a,b in enumerate(letters)}
print(char_to_int)


# In[]
time_step=30

import numpy as np
from keras.utils import to_categorical
#滑动窗口提取数据
def extract_data(data, slide):    
    x = []
    y = []    
    for i in range(len(data) - slide):
        x.append([a for a in data[i:i+slide]])
        y.append(data[i+slide])        
    return x,y
#字符到数字的批量转化
def char_to_int_Data(x,y, char_to_int):    
    x_to_int = []
    y_to_int = []
    for i in range(len(x)):
        x_to_int.append([char_to_int[char] for char in x[i]])
        y_to_int.append([char_to_int[char] for char in y[i]])    
    return x_to_int, y_to_int
#实现输入字符文章的批量处理，输入整个字符、滑动窗口大小、转化字典
def data_preprocessing(data, slide, num_letters, char_to_int):    
    char_Data = extract_data(data, slide)
    int_Data = char_to_int_Data(char_Data[0], char_Data[1], char_to_int)
    Input = int_Data[0]
    Output = list(np.array(int_Data[1]).flatten())
    Input_RESHAPED = np.array(Input).reshape(len(Input), slide)
    new = np.random.randint(0,10,size=[Input_RESHAPED.shape[0],Input_RESHAPED.shape[1],num_letters])
    for i in range(Input_RESHAPED.shape[0]):
        for j in range(Input_RESHAPED.shape[1]):
            new[i,j,:] = to_categorical(Input_RESHAPED[i,j],num_classes=num_letters)
    return new, Output

# In[]
#完成字符串预处理
X,y=data_preprocessing(data,time_step,features,char_to_int)

#data:待处理的字符串
#time_step:序列的长度
#features:样本的特征数
#char_to_int:字符转数字的字典
#X:转化为one-hot格式的数组
#y:转化为字符对应数值的列表

# In[]
#确认维度

print(X.shape)
print(len(y))

#数据分离
from sklearn.model_selection import train_test_split
X_train,X_test,y_train,y_test=train_test_split(X,y,test_size=0.1,random_state=0)
print(X.shape,X_train.shape,X_test.shape)
# In[]
#输出结果格式转化
y_train_c=to_categorical(y_train,features)
print(y_train_c)
print(y_train_c.shape)


# In[]
#建立LSTM模型
from keras.models import Sequential
from keras.layers import Dense,LSTM

model=Sequential()
model.add(LSTM(units=30,input_shape=(X_train.shape[1],X_train.shape[2]),activation='relu'))
model.add(Dense(units=features,activation='softmax'))
model.summary()


# In[]
#参数配置与训练
model.compile(optimizer='adam',loss='categorical_crossentropy',metrics=['accuracy'])
model.fit(X_train,y_train_c,batch_size=1000,epochs=50)


# In[]
model.fit(X_train,y_train_c,batch_size=1000,epochs=50)
# In[]
#新字符的预测
y_train_predict=model.predict_classes(X_train)
print(y_train_predict)



# In[]
#新字符串预测
new_letters='Artficial intelligence(AI),sometimes called machine intelligence,is intelligence demonstrated by machines'
X_new,y_new=data_preprocessing(new_letters,time_step,features,char_to_int)
y_new_predict=model.predict_classes(X_new)
# print(y_new_predict)


# In[]
#结果转化为字符
y_train_predict_char=[int_to_char[i] for i in y_train_predict]
# print(y_train_predict_char)


# In[]
#准确率
from sklearn.metrics import accuracy_score
accuracy_train=accuracy_score(y_train,y_train_predict)

#In[]
#测试数据的预测
y_test_predict=model.predict_classes(X_test)
y_test_predict_char=[int_to_char[i] for i in y_train_predict]
# print(y_test_predict_char)


# In[]
#准确率

accuracy_test=accuracy_score(y_test,y_test_predict)
print(accuracy_test)
# In[]
#新字符串的预测
new_letters='Artificial intelligence (AI), sometimes called machine intelligence, is intelligence demonstrated by machines'
X_new,y_new=data_preprocessing(new_letters,time_step,features,char_to_int)
print(X_new.shape,len(y_new))

# In[]
y_new_predict=model.predict_classes(X_new)
print(y_new_predict)


# In[]
y_new_predict_char=[int_to_char[i] for i in y_new_predict]
print(y_new_predict_char)
# In[]
for i in range(0,X_new.shape[0]-30):
    print(new_letters[i:i+30],'--predict new letters is >>>',y_new_predict_char[i])