LSTM入门预测单词

LSTM和普通的RNN相比，主要的改进是多了三个门控制器：输入门，输出门，遗忘门。他们仨结构相同，主要由sigmoid函数和点积操作构成，sigmoid取值范围[0,1].
LSTM 模型在原有的短期记忆单元Ht的基础上，增加了一个记忆单元Ct来保持长期记忆。

LSTM 与GRU：https://blog.youkuaiyun.com/qq_29831163/article/details/89929573
参考链接：https://blog.youkuaiyun.com/ma416539432/article/details/53509607

#将这时候dataX是一个一个用字母组成的序列， 但是还要转换一下格式，才能用到keras上。
/#reshape X to be [samples, time steps, features]
#reshape(x,y):x行y列
X = numpy.reshape(dataX, (len(dataX), seq_length, 1))

/# normalize整数值归一化到0～1的区间上
X = X / float(len(alphabet))

y = np_utils.to_categorical(dataY)
/# create and fit the model
model = Sequential()

#s输出维度32，input_dim：输入维度，当使用该层为模型首层时，应指定该值（或等价的指定input_shape)
#shape数组大小shape[1]第一维的长度
model.add(LSTM(32, input_shape=(X.shape[1], X.shape[2])))

#unit:空间维度
model.add(Dense(y.shape[1], activation=‘softmax’))

model.compile(loss=‘categorical_crossentropy’, optimizer=‘adam’, metrics=[‘accuracy’])
#x训练数组，y目标（标签）数组，np_epoch迭代轮次，一个轮次是在整个 x 和 y 上的一轮迭代
#verbose:日志显示模式，0-安静模式，1-进度条，2-每轮一次
model.fit(X, y, nb_epoch=500, batch_size=1, verbose=2)
/# x=None, #训练数据
/# y=None, #训练数据label标签
/# batch_size=None, #每经过多少个sample更新一次权重，defult 32
/# epochs=1, #训练的轮数epochs
/# verbose=1, #0为不在标准输出流输出日志信息，1为输出进度条记录，2为每个epoch输出一行记录

# fix random seed for reproducibility

import numpy
from keras.models import Sequential
from keras.layers import Dense
from keras.layers import LSTM
from keras.utils import np_utils
numpy.random.seed(7)

# define the raw dataset
alphabet = "ABCDEFGHIJKLMNOPQRSTUVWXYZ"

# 字母和数字的转换
char_to_int = dict((c, i) for i, c in enumerate(alphabet))
int_to_char = dict((i, c) for i, c in enumerate(alphabet))
# prepare the dataset of input to output pairs encoded as integers

seq_length = 1
dataX = []
dataY = []
for i in range(0, len(alphabet) - seq_length, 1):
    seq_in = alphabet[i:i + seq_length]
    seq_out = alphabet[i + seq_length]
    dataX.append([char_to_int[char] for char in seq_in])
    dataY.append(char_to_int[seq_out])
    print (seq_in,'->', seq_out)
#将这时候dataX是一个一个用字母组成的序列， 但是还要转换一下格式，才能用到keras上。
# reshape X to be [samples, time steps, features]
#reshape(x,y):x行y列
X = numpy.reshape(dataX, (len(dataX), seq_length, 1))
# normalize整数值归一化到0～1的区间上
X = X / float(len(alphabet))
y = np_utils.to_categorical(dataY)
# create and fit the model
model = Sequential()
#s输出维度32，input_dim：输入维度，当使用该层为模型首层时，应指定该值（或等价的指定input_shape)
#shape数组大小shape[1]第一维的长度
model.add(LSTM(32, input_shape=(X.shape[1], X.shape[2])))
#unit:空间维度
model.add(Dense(y.shape[1], activation='softmax'))
model.compile(loss='categorical_crossentropy', optimizer='adam', metrics=['accuracy'])
#x训练数组，y目标（标签）数组，np_epoch迭代轮次，一个轮次是在整个 x 和 y 上的一轮迭代
#verbose:日志显示模式，0-安静模式，1-进度条，2-每轮一次
model.fit(X, y, nb_epoch=500, batch_size=1, verbose=2)
# x=None, #训练数据
# y=None, #训练数据label标签
# batch_size=None, #每经过多少个sample更新一次权重，defult 32
# epochs=1, #训练的轮数epochs
# verbose=1, #0为不在标准输出流输出日志信息，1为输出进度条记录，2为每个epoch输出一行记录

to_categorical的功能
简单来说，to_categorical就是将类别向量转换为二进制（只有0和1）的矩阵类型表示。其表现为将原有的类别向量转换为独热编码的形式。先上代码看一下效果：

LSTM正确打开方式：
在keras中，利用lstm的关键是以时间序列的方法来提供上下文，而不是像其他网络结构一样，通过windowed features的方式。

timesteps这个参数，我们设置了3

，而不是前面的1。

也就是说我们把ABC 看成独立的三个特征 A B

C组成的时间序列，而不是把ABC看成一个总的特征。

# Naive LSTM to learn three-char time steps to one-char mapping
import numpy
from keras.models import Sequential
from keras.layers import Dense
from keras.layers import LSTM
from keras.utils import np_utils
# fix random seed for reproducibility
numpy.random.seed(7)
# define the raw dataset
alphabet = "ABCDEFGHIJKLMNOPQRSTUVWXYZ"
# create mapping of characters to integers (0-25) and the reverse
char_to_int = dict((c, i) for i, c in enumerate(alphabet))
int_to_char = dict((i, c) for i, c in enumerate(alphabet))
# prepare the dataset of input to output pairs encoded as integers
seq_length = 3
dataX = []
dataY = []
for i in range(0, len(alphabet) - seq_length, 1):
    seq_in = alphabet[i:i + seq_length]
    seq_out = alphabet[i + seq_length]
    dataX.append([char_to_int[char] for char in seq_in])
    dataY.append(char_to_int[seq_out])
    print (seq_in, '->', seq_out)
# reshape X to be [samples, time steps, features]
X = numpy.reshape(dataX, (len(dataX), seq_length, 1))
# normalize
X = X / float(len(alphabet))
# one hot encode the output variable
y = np_utils.to_categorical(dataY)
# create and fit the model
model = Sequential()
model.add(LSTM(32, input_shape=(X.shape[1], X.shape[2])))
model.add(Dense(y.shape[1], activation='softmax'))
model.compile(loss='categorical_crossentropy', optimizer='adam', metrics=['accuracy'])
model.fit(X, y, nb_epoch=500, batch_size=1, verbose=2)
# summarize performance of the model
scores = model.evaluate(X, y, verbose=0)
print("Model Accuracy: %.2f%%" % (scores[1]*100))
# demonstrate some model predictions
for pattern in dataX:
    x = numpy.reshape(pattern, (1, len(pattern), 1))
    x = x / float(len(alphabet))
    prediction = model.predict(x, verbose=0)
    index = numpy.argmax(prediction)
    result = int_to_char[index]
    seq_in = [int_to_char[value] for value in pattern]
    print (seq_in, "->", result)