基于单层LSTM模型的文本序列预测：从预处理到字符预测的完整流程

数据集

我的数据集就是重复的两句话，重复了几百次。

引言

在自然语言处理（NLP）领域，序列预测是一个非常重要的任务，它涉及到根据已有的文本序列来预测接下来的内容。近年来，循环神经网络（RNN）及其变体，如长短时记忆网络（LSTM），因其能够有效处理序列数据中的长期依赖关系而广受青睐。本博客将详细介绍如何使用单层LSTM模型来完成一个文本序列预测的任务，从数据预处理到模型构建，再到结果预测。

1.目的

任务：基于语句文本数据，使用LSTM模型预测序列文字。  

1.完成数据预处理，将文字序列化数据转化为可用于LSTM输入的数据  

2.查看文字数据预处理后的数据结构，进行数据分离操作  

3.针对字符串输入（“ 星空下的海滩，海浪轻拍着岸边”），预测其对应的后续字符  

备注：模型结构：单层LSTM，输出有10个神经元；每次使用前10个字符预测第11个字符

2.模型训练

1.数据加载

# 加载数据
data = open("语句数据.txt").read()
#进行数据预处理
data = data.replace('\n', '').replace('\r', '')
print(data)

运行结果：这里我的是横向显示的没有截完整

2.数据预处理

#字符去重处理
letters = list(set(data))
print(letters)
# 字符串转数字
num_letters = len(letters)
print(num_letters)

运行结果

2.建立字典

#建立字典，将字符映射到数字
int_to_char = {a:b for a, b in enumerate(letters)}
print(int_to_char)
# 建立字典，将数字映射到字符
char_to_int = {b:a for a, b in enumerate(letters)}
print(char_to_int)

运行结果

3.批量处理字符

#字符批量预处理
import numpy as np
from tensorflow.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

4.准备数据并分割数据集

#定义使用字数个数
time_step = 10
#准备x,y数据
x,y = data_preprocessing(data, time_step, num_letters, char_to_int)
#分割数据集
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)

运行结果

5.构建模型

#构建模型
from keras.models import Sequential
from keras.layers import Dense,LSTM

model = Sequential()
model.add(LSTM(units=10, 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()

运行结果

6.训练模型

#训练模型
model.fit(x_train, y_train_category,batch_size=1000, epochs=10)

运行结果

3.模型评估

1.基于训练模型进行预测

#基于训练模型进行预测
y_train_predict = model.predict(x_train)
y_train_predict = np.argmax(y_train_predict,axis=1)
print(y_train_predict)
#将int转换为字母
y_train_predict_char = [int_to_char[i] for i in y_train_predict]
print(y_train_predict_char)

运行结果

2.准确度评估

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

运行结果

3.测试集评估

y_test_predict = model.predict(x_test)
y_test_predict = np.argmax(y_test_predict,axis=1)
accuracy_test = accuracy_score(y_test,y_test_predict)
print(accuracy_test)
print(y_test_predict)
print(y_test)

运行结果

4.模型测试

new_letters = '星空下的海滩，海浪轻拍着岸边'
x_new, y_new = data_preprocessing(new_letters, time_step, num_letters, char_to_int)
y_new_predict = model.predict(x_new)
y_new_predict = np.argmax(y_new_predict,axis=1)
print(y_new_predict)
y_new_predict_char = [int_to_char[i] for i in y_new_predict]
print(y_new_predict_char)

运行结果

5.总结

        通过本博客，我们详细介绍了如何使用单层LSTM模型来完成文本序列预测的任务。从数据预处理到模型构建，再到结果预测，每一步都至关重要。虽然单层LSTM模型在处理简单文本序列时表现良好，但对于更复杂的文本数据，可能需要更复杂的模型结构或更深的网络层次。