序列模型（Sequence Model）

基于文本内容及其前后信息进行预测

基于目标不同时刻状态进行预测


基于数据历史信息进行预测
序列模型：输入或者输出中包含有序列数据的模型
突出数据的前后序列关系
两大特点：

1. 输入（输出）元素之间是具有顺序关系。不同的顺序，得到的结果应该是不同的，比如“不吃饭”和“吃饭不”这两个短语意思是不同的
2. 输入输出不定长。比如文章生成、聊天机器人

循环神经网络(RNN)

前部序列的信息经处理后，作为输入信息传递到后部序列
任务：
自动寻找语句中的人名：

词汇数值化：建立一个词汇-数值一一对应的字典，然后把输入词汇转化数值矩阵



字典生成的另外一种方式

不同类型的RNN模型

RNN常见结构


多输入对多输出、维度相同RNN结构
应用：特定信息识别

应用：情感识别
举例：I feel happy watching the movie
判断：positive

应用：序列数据生成器
举例：文章生成、音乐生成

应用：语言翻译

普通RNN结构缺陷

• 前部序列信息在传递到后部的同时，信息权重下降，导致重要信息丢失
• 求解过程中梯度消失

需要提高前部特定信息的决策权重

长短期记忆网络（LSTM）

• 忘记门：选择性丢弃a与x中不重要的信息
• 更新门：确定给记忆细胞添加哪些信息
• 输出门：筛选需要输出的信息

• 在网络结构很深（很多层）的情况下，也能保留重要信息
• 解决了普通RNN求解过程中的梯度消失问题

双向循环神经网络（BRNN）

做判断时，把后部序列信息也考虑
深层循环神经网络（DRNN）
解决更复杂的序列任务，可以把单层RNN叠起来或者在输出前和普通mlp结构结合使用

实战准备

实战一：RNN实现股价预测

提取序列数据：

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])
    x=np.array(x)
	x=x.reshape(x.shape[0],x.shape[1],1)
	return x,y

建立普通RNN模型：

from keras.models import Sequential
from keras.layers import Dense,SimpleRNN
model = Sequential()
#增加一个RNN层
model.add(SimpleRNN(units=5,input_shape=(X.shape[1],X.shape[2]),activation='relu'))
#增加输出层
model.add(Dense(units=1,activation='linear'))
model.compile(optimizer='adam',loss='mean_squared_error')

实战二：LSTM自动生成文本

文本加载：

rew_data = open('flare').read()
# 移除换行字符'\n'
data = rew_data.replace('\n','').replace('\r','')

字符字典建立：

#字符去重
letters = list(set(data))
#建立数字到字符的索引字典
int_to_char = {a:b for a,b in enumerate(letters)}
#建立字符到数字的索引字典
char_to_int = {b:a for a,b in enumerate(letters)}

实战（一）：RNN实现股价预测

任务：基于zgpa_train.csv数据，建立RNN模型，预测股价：

• 完成数据预处理，将序列数据转化为可用于RNN输入的数据
• 对新数据zgpa_test.csv进行预测，可视化结果
• 存储预测结果，并观察局部预测结果

模型结构：单层RNN，输出有5个神经元；每次使用前8个数据预测第9个数据
加载数据

import pandas as pd
import numpy as np
data = pd.read_csv('zgpa_train.csv')
data.head()

赋值

price = data.loc[:,'close']
price.head()

归一化处理

price_norm = price/max(price)
print(price_norm)

可视化

from matplotlib import pyplot as plt
fig1 = plt.figure(figsize=(8,5))
plt.plot(price)
plt.title('close price')
plt.xlabel('time')
plt.ylabel('price')
plt.show()

X y赋值

def extract_data(data,time_step):
    X = []
    y = []
    #0,1,2,3...9:10个样本；time_step=8;0,1...7;1,2...8;2,3...9三组（两组样本）
    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

time_step = 8

X,y = extract_data(price_norm,time_step)
print(X[0,:,:])
print(y)

print(X.shape,len(y))

建立模型

#set up the model
from keras.models import Sequential
from keras.layers import Dense, SimpleRNN
model = Sequential()
#add RNN layer
model.add(SimpleRNN(units=5, input_shape=(time_step,1),activation='relu'))
#add output layer
model.add(Dense(units=1,activation='linear'))
#configure the model
model.compile(optimizer='adam',loss='mean_squared_error')
model.summary()

训练

model.fit(X,y,batch_size=30,epochs=200)

根据训练数据进行预测

y_train_predict = model.predict(X)*max(price)
y_train = [i*max(price) for i in y]

可视化

fig2 = plt.figure(figsize=(8,5))
plt.plot(y_train,label='real price')
plt.plot(y_train_predict,label='predict price')
plt.title('close price')
plt.xlabel('time')
plt.ylabel('price')
plt.legend()
plt.show()

对测试数据进行预测
加载数据 归一化 提取数据

data_test = pd.read_csv('zgpa_test.csv')
price_test = data_test.loc[:,'close']
price_test_norm = price_test/max(price)
X_test_norm, y_test_norm = extract_data(price_test_norm,time_step)
print(X_test_norm.shape,len(y_test_norm))

预测

y_test_predict = model.predict(X_test_norm)*max(price)
y_test = [i*max(price) for i in y_test_norm]

可视化

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

预测数据存储

result_y_test = np.array(y_test).reshape(-1,1)
result_y_test_predict = y_test_predict
print(result_y_test.shape,result_y_test_predict.shape)
result = np.concatenate((result_y_test,result_y_test_predict),axis=1)
print(result.shape)
result = pd.DataFrame(result,columns=['real_price_test','predict_price_test'])
result.to_csv('zgpa_predict_test1.csv')

实战（二）：LSTM自动生成文本

任务：基于flare文本数据，建立LSTM模型，预测序列文字：

• 完成数据预处理，将文字序列数据转化为可用于LSTM输入的数据
• 查看文字数据预处理后的数据结构，并进行数据分离操作
• 针对字符串输入（“ flare is a teacher in ai industry. He obtained his phd in Australia.”），预测其对应的后续字符

模型结构：单层LSTM，输出有20个神经元；每次使用前20个字符预测第21个字符
加载数据 预处理

data = open('flare').read()
#移除换行符
data = data.replace('\n','').replace('\r','')

字符去重处理

letters = list(set(data))
print(letters)
num_letters = len(letters)
print(num_letters)

建立字典

#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)

time_step = 20

批量字符数据预处理

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

提取数据

X, y = data_preprocessing(data,time_step,num_letters,char_to_int)

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=10)
print(X_train.shape,len(y_train))

格式转换

y_train_category = to_categorical(y_train,num_letters)
print(y_train_category)

建立模型

from keras.models import Sequential
from keras.layers import Dense,LSTM

model = Sequential()
model.add(LSTM(units=20,input_shape=(X_train.shape[1],X_train.shape[2]),activation='relu'))
model.add(Dense(units=num_letters,activation='softmax'))
model.compile(optimizer='adam',loss='categorical_crossentropy',metrics=['accuracy'])
model.summary()

训练模型

model.fit(X_train,y_train_category,batch_size=1000,epochs=10)

预测

y_train_predict = model.predict_classes(X_train)
print(y_train_predict)

查看文本

y_train_predict_char = [int_to_char[i] for i in y_train_predict]
print(y_train_predict_char)

评估

from sklearn.metrics import accuracy_score
accuracy_train = accuracy_score(y_train,y_train_predict)
print(accuracy_train)

y_test_predict = model.predict_classes(X_test)
accuracy_test = accuracy_score(y_test,y_test_predict)

print(accuracy_test)
print(y_test_predict)
print(y_test)

针对字符串输入（“ flare is a teacher in ai industry. He obtained his phd in Australia.”），预测其对应的后续字符

new_letters = 'flare is a teacher in ai industry. He obtained his phd in Australia.'
X_new, y_new = data_preprocessing(new_letters,time_step,num_letters,char_to_int)
y_new_predict = model.predict_classes(X_new)
print(y_new_predict)

y_new_predict_char = [int_to_char[i] for i in y_new_predict]
print(y_new_predict_char)

for i in range(0,X_new.shape[0]-20):
    print(new_letters[i:i+20],'--predict next letter is---',y_new_predict_char[i])