【机器学习实战入门】基于机器学习智能文本摘要 深度学习 注意力机制源码 自然语言处理
文本摘要项目教程
1. 项目概述
今天你将学习如何使用深度学习创建一个文本摘要项目。让我们开始吧！！
2. 什么是文本摘要？
文本摘要是指从大量信息中生成摘要的过程，同时保持信息的实际上下文。摘要应通顺且简洁。
谷歌使用特色片段来展示文章的摘要或用户查询的答案。这些片段基本上是从网页中提取的。
3. 文本摘要的类型
3.1 提取式摘要
在提取式摘要过程中，我们专注于输入句子中的关键信息，并提取这些特定的句子来生成摘要。不会生成新的句子，摘要中的句子与原始输入句子组完全相同。
示例：
源文本： DataFlair 是一个面向全球学生的在线、沉浸式、讲师引导、自定进度的技术学校。DataFlair 提供终身支持、测验以提升学生知识，以及各种实项目参与。DataFlair 的机器学习项目是学生解决实际问题的最佳途径。
摘要： DataFlair 是一个面向全球学生的在线技术学校。DataFlair 提供终身支持、测验和实项目。DataFlair 的机器学习项目是学生学习解决实际问题的最佳途径。
3.2 抽象式摘要
抽象式摘要与提取式摘要相反，它不是直接提取句子，而是关注原始句子组中的关键信息，并生成新的句子来作为摘要。新生成的句子可能不在原始句子中出现。
示例：
源文本： DataFlair 是一个面向全球学生的在线、沉浸式、讲师引导、自定进度的技术学校。DataFlair 提供终身支持、测验以提升学生知识，以及各种实项目参与。DataFlair 的机器学习项目是学生解决实际问题的最佳途径。
摘要： DataFlair 是一个在线技术学校，学生可以参加各种测验和项目，包括机器学习项目，来解决实际问题。
4. 什么是序列到序列（Seq2Seq）建模？
Seq2Seq 模型是一种将一系列句子作为输入并输出另一系列句子的模型。这在神经机器翻译中可以看到，输入句子是一种语言，输出句子是该语言的翻译版本。编码器和解码器是序列到序列建模中使用的两个主要技术。让我们了解一下它们的工作原理。
4.1 编码器模型
编码器模型用于编码或转换输入句子，并在每一步生成反馈。这个反馈可以是内部状态（即隐藏状态或细胞状态，如果我们使用 LSTM 层）。编码器模型捕捉输入句子中的关键信息，同时保持整个句子的上下文。
在神经机器翻译中，输入语言将被传递到编码器模型，该模型将捕捉上下文信息而不改变输入序列的含义。编码器模型的输出然后传递到解码器模型以生成输出序列。
4.2 解码器模型
解码器模型用于逐词解码或预测目标句子。解码器的输入数据是目标句子，预测下一个词，然后将这个词作为输入传递到下一层以进行下一个词的预测。‘’（目标句子的开始）和 ‘’（目标句子的结束）是帮助模型了解初始变量以预测下一个词和结束变量以确定句子结束的两个词。在训练模型时，我们首先提供词 ‘’，模型然后预测下一个词，即解码器的目标数据。这个词然后作为输入数据传递到下一个时间步以进行下一个词的预测。
例如，如果我们的句子是 ‘I Love Python’，我们将在句子的开头添加 ‘’，在句子的结尾添加 ‘’，因此我们的句子将变为 ‘ I Love Python ’。现在让我们看看它是如何工作的。
| 时间步 | 输入数据 | 目标数据 |
|---|---|---|
| 1 | I | |
| 2 | I | Love |
| 3 | I Love | Python |
| 4 | I Love Python |
正如你所见，我们的输入数据从 ‘’ 开始，目标数据在每个时间步的帮助下预测下一个词。我们的输入数据不包含最后一个词，因为最后一个时间步的目标数据是 ‘’，这告诉我们在到达句子结尾时停止迭代。同样，我们的目标数据比输入数据提前一个时间步，因为第一个词 ‘’ 是由输入数据提供的。
5. 什么是注意力机制？
让我们通过一个例子来理解注意力机制。以下是输入文本（评论）和目标文本（摘要）。
输入文本： 现在我已经学习了机器学习，我想参与一些项目。有人能推荐最好的机器学习项目来源吗？
目标文本： DataFlair 是最好的机器学习项目来源。
如你所见，我们将输入文本传递到模型中。而不是关注整个单词，这非常难以记忆，我们只会关注特定的单词来进行预测。在我们的例子中，我们只会关注 ‘source’、‘machine learning’ 和 ‘projects’ 这些词来预测目标文本。
注意力机制有两种类型：
a) 全局注意力
b) 局部注意力
5.1 全局注意力
在全局注意力中，编码器模型在每个时间步的所有隐藏状态都用于生成上下文向量。
5.2 局部注意力
在局部注意力中，编码器模型的某些隐藏状态用于生成上下文向量。
6. 项目简介
在这个项目中，我们将使用多对多序列模型和抽象式文本摘要技术来创建模型，这些模型可以预测评论的摘要。模型将在数据集文件 ‘Reviews.csv’ 的前 100,000 行上进行训练和测试。使用注意力机制，我们将在保持句子上下文的同时关注特定的关键词。
7. 项目前置条件
本项目要求你具备 Python、深度学习和自然语言处理（NLP）的良好知识。你可以使用以下命令安装本项目所需的所有模块：
pip install numpy, pandas, pickle, nltk, tensorflow, sklearn, bs4
本项目使用的 Python 和相应模块的版本如下：
- Python: 3.8.5
- TensorFlow: 2.3.1 注意：TensorFlow 版本应为 2.2 或更高版本，以使用 Keras，否则直接安装 Keras。
- sklearn: 0.24.2
- bs4: 4.6.3
- pickle: 4.0
- numpy: 1.19.5
- pandas: 1.1.5
- nltk: 3.2.5
8. 文本摘要数据集
你可以从 Amazon Fine Food Reviews 下载本项目的数据集文件。
链接: 基于机器学习智能文本摘要 深度学习 注意力机制源码 自然语言处理 源代码与数据集
9. 项目结构
- Reviews.csv: 这是我们的数据集文件，包含亚马逊食品评论和摘要。
- text_summarizer.py: 在这个文件中，我们将创建并训练我们的模型，以输入和目标数据预测摘要。
- s2s/: 这个目录包含训练模型的优化器、指标和权重。
- contractions.pkl: 这个文件包含一个词典，键为缩写词，值为扩展或原始词。
步骤进行文本摘要：
- 导入库
首先我们将创建一个名为 ‘text_summarizer.py’ 的文件，并导入在先决条件部分共用的所有库。
代码：
# DataFlair 项目
# 导入所有所需的库
import numpy as np
import pandas as pd
import pickle
from statistics import mode
import nltk
from nltk import word_tokenize
from nltk.stem import LancasterStemmer
nltk.download('wordnet')
nltk.download('stopwords')
nltk.download('punkt')
from nltk.corpus import stopwords
from tensorflow.keras.models import Model
from tensorflow.keras import models
from tensorflow.keras import backend as K
from tensorflow.keras.preprocessing.sequence import pad_sequences
from tensorflow.keras.preprocessing.text import Tokenizer
from tensorflow.keras.utils import plot_model
from tensorflow.keras.layers import Input, LSTM, Embedding, Dense, Concatenate, Attention
from sklearn.model_selection import train_test_split
from bs4 import BeautifulSoup
- 解析数据集文件
我们将进入数据集文件即 ‘Reviews.csv’ 并提取所有的输入和目标文本。为此，我们将使用数据集的前100,000行进行训练和测试部分。这可以根据需求进行更改。我们的输入将是‘Text’列，也就是评论列，而目标将是‘Summary’列。我们还将从数据框中删除重复记录和NA值。
数据集文件：
数据集文件
代码：
# 为文本摘要读取数据集文件
df=pd.read_csv("Reviews.csv",nrows=100000)
# 从记录中删除重复和NA值
df.drop_duplicates(subset=['Text'],inplace=True)
df.dropna(axis=0,inplace=True)
input_data = df.loc[:,'Text']
target_data = df.loc[:,'Summary']
target.replace('', np.nan, inplace=True)
- 预处理
现实世界中的文本是不完整的，它们不能直接发送到模型上，这将导致某些错误。因此，我们需要清理所有文本并将其转换为适合预测任务的格式。首先，我们将初始化所有的变量和方法。
代码：
input_texts=[]
target_texts=[]
input_words=[]
target_words=[]
contractions=pickle.load(open("contractions.pkl","rb"))['contractions']
# 初始化停用词和LancasterStemmer
stop_words=set(stopwords.words('english'))
stemm=LancasterStemmer()
我们的一些文本是以HTML格式存储并包含HTML标签，因此我们将使用‘BeautifulSoup库’解析此文本并删除所有HTML标签。之后，我们将文本分词为词。同时检查以下条件：
- 包含整数
- 少于3个字符或
- 它们是停用词
如果上述条件中的任何一个匹配，我们将从输入或目标词列表中移除该特定词。
代码：
def clean(texts, src):
# 删除HTML标签
texts = BeautifulSoup(texts, "lxml").text
# 将文本分词为词
words=word_tokenize(texts.lower())
# 过滤包含 \
# 整数或其长度小于或等于3的词
words= list(filter(lambda w: (w.isalpha() and len(w)>=3), words))
我们的输入或目标文本中还包含缩写词，这些词是通过使用撇号或删除字母将两个词组合而成的，例如 ‘haven’t’ 是 ‘have not’ 的缩写。我们将使用 ‘contractions.pkl’ 文件中的字典来扩展这类词，其中词的缩写形式为键，完整的词形式为值。同时，我们将所有输入词词干化为其根词。
词干化：词干化是指将词还原为其根词的过程。
例如，如果文本中包含一个拼写错误的词 “chocollate”（拼写错误的 “chocolate”）。如果我们不进行词干化，模型会将它们视为两个不同的词。词干化器会将这个错误词词干化为其根词，即 “chocol”。因此，“chocol” 是 “chocolate” 和 “chocollate” 的根词。
代码：
# 使用缩写词文件扩展缩写词
words= [contractions[w] if w in contractions else w for w in words ]
# 将词词干化为其根词并过滤停用词
if src=="inputs":
words= [stemm.stem(w) for w in words if w not in stop_words]
else:
words= [w for w in words if w not in stop_words]
return words
我们将在目标文本的开始处添加 ‘sos’，并在其结束处添加 ‘eos’，以告诉模型这些是句子的开始和结束。
代码：
# 传递输入记录和目标记录
for in_txt, tr_txt in zip(input_data, target_data):
in_words= clean(in_txt, "inputs")
input_texts+= [' '.join(in_words)]
input_words+= in_words
# 在文本的开始处添加 'sos'，在文本的结束处添加 'eos'
tr_words= clean("sos "+tr_txt+" eos", "target")
target_texts+= [' '.join(tr_words)]
target_words+= tr_words
现在我们清理了句子后，将过滤重复词，并按顺序排列它们。我们还将存储输入和目标词的总数。
代码：
# 只从输入和目标词列表中存储唯一词
input_words = sorted(list(set(input_words)))
target_words = sorted(list(set(target_words)))
num_in_words = len(input_words) # 输入词的总数
num_tr_words = len(target_words) # 目标词的总数
# 获取最常出现的输入和目标文本的长度
max_in_len = mode([len(i) for i in input_texts])
max_tr_len = mode([len(i) for i in target_texts])
print("输入词的数量 : ", num_in_words)
print("目标词的数量 : ", num_tr_words)
print("最大输入长度 : ", max_in_len)
print("最大目标长度 : ", max_tr_len)
- 分割记录
将数据集记录分割成训练集和测试集。我们将按照80:20的比例进行分割，其中80%的记录用于训练集，20%用于测试集。
代码：
# 将输入和目标文本按80:20的比例分割或测试集大小为20%
x_train, x_test, y_train, y_test=train_test_split(input_texts, target_texts, test_size=0.2, random_state=0)
- 文本向量化
我们将使用向量化技术将词转换为整数序列。
例如：
L = [ ‘what doing’, ‘how are you’, ’good ’]
将列表 ‘L’ 中的所有元素进行分词，并创建一个字典，其中键为分词，值为计数编号。因此，在数据适合后，我们得到的是一个字典
D = { ‘what’ : 1 , ‘doing’ :2 , ‘how’ : 3 , ‘are’ : 4 , ‘you’ :5 , ‘good’ : 6 }
因此我们的数据已经适合，现在使用我们的分词器将下面的列表 ‘J’ 转换为整数序列。
J = [ ‘what are you doing’, ‘you are good’ ]
转换后的（向量化）J : [ [ 1 , 4 , 5 , 2 ] , [ 5 , 4 , 6 ] ]
代码：
# 使用所有词训练分词器
in_tokenizer = Tokenizer()
in_tokenizer.fit_on_texts(x_train)
tr_tokenizer = Tokenizer()
tr_tokenizer.fit_on_texts(y_train)
# 将文本转换为整数序列
# 其中整数将是该词的索引
x_train= in_tokenizer.texts_to_sequences(x_train)
y_train= tr_tokenizer.texts_to_sequences(y_train)
转换为整数序列后，我们还将使所有输入和目标文本具有相同的长度，以适用于我们的模型。因此，我们将取输入句子的最高频率长度，并将其存储在 ‘max_in_length’ 变量中，对目标数据也进行相同的操作。如果文本长度小于指定的最大输入长度，我们将在文本中填充0的数组。
我们的编码器输入数据将是填充后的 ‘x_train’，解码器输入数据将是填充后的 ‘y_train’，但不包含最后一个词‘eos’。解码器目标数据将与解码器输入数据相同，但它将比输入数据提前一个时间步，因为它不包含目标句子的第一个词‘sos’。
代码：
# 如果长度小于最大长度，则填充0的数组
en_in_data= pad_sequences(x_train, maxlen=max_in_len, padding='post')
dec_data= pad_sequences(y_train, maxlen=max_tr_len, padding='post')
# 解码器输入数据不包括最后一个词
# 即解码器输入数据中的 ‘eos’
dec_in_data = dec_data[:,:-1]
# 解码器目标数据将比输入数据提前一个时间步
# 因为它不包括目标句子的开始词 ‘sos’
dec_tr_data = dec_data.reshape(len(dec_data),max_tr_len,1)[:,1:]
- 构建模型
我们使用堆叠LSTM，其中包含3层LSTM。这将使我们的预测更加准确。根据您的需求，也可以有更多层。下面我们将了解编码器模型和解码器模型。
编码器：我们将使用‘Input’对象初始化编码器输入张量。批量的预期形状为74（最大输入长度）维。然后我们将创建一个‘嵌入层’，其中将输入词的总数作为第一个参数，500为形状，即潜藏（隐藏）维度。
代码：
K.clear_session()
latent_dim = 500
# 创建总编码器词的数量的输入对象
en_inputs = Input(shape=(max_in_len,))
en_embedding = Embedding(num_in_words+1, latent_dim)(en_inputs)
LSTM：现在我们将创建3个堆叠的LSTM层，其中第一个LSTM层将有编码器的输入，然后创建一个连续的LSTM层序列。
LSTM层将捕获输入序列中存在的所有上下文信息。我们将返回隐藏状态的输出，并在每个LSTM层执行后返回状态，即隐藏状态和单元状态。
代码：
# 创建3个堆叠的LSTM层，用于通过深度学习进行文本摘要，LSTM的形状为隐藏维度
# LSTM 1
en_lstm1= LSTM(latent_dim, return_state=True, return_sequences=True)
en_outputs1, state_h1, state_c1= en_lstm1(en_embedding)
# LSTM2
en_lstm2= LSTM(latent_dim, return_state=True, return_sequences=True)
en_outputs2, state_h2, state_c2= en_lstm2(en_outputs1)
# LSTM3
en_lstm3= LSTM(latent_dim,return_sequences=True,return_state=True)
en_outputs3 , state_h3 , state_c3= en_lstm3(en_outputs2)
# 编码器状态
en_states= [state_h3, state_c3]
解码器：就像编码器一样，我们将初始化解码器输入张量，然后将其传递给LSTM。在这里，解码器也将拥有初始状态，我们将传递从编码器LSTM层获得的隐藏状态和单元状态值。
代码：
# 解码器.
dec_inputs = Input(shape=(None,))
dec_emb_layer = Embedding(num_tr_words+1, latent_dim)
dec_embedding = dec_emb_layer(dec_inputs)
# 使用编码器的输出状态初始化解码器的LSTM层
dec_lstm = LSTM(latent_dim, return_sequences=True, return_state=True)
dec_outputs, *_ = dec_lstm(dec_embedding, initial_state=en_states)
注意力机制层：我们将把编码器和解码器的输出传递给注意力机制层，然后我们将注意力机制层的输出与解码器的输出进行连接。
代码：
# 注意力机制层
attention = Attention()
attn_out = attention([dec_outputs, en_outputs3])
# 将注意力输出与解码器输出进行连接
merge=Concatenate(axis=-1, name='concat_layer1')([dec_outputs, attn_out])
现在我们将创建我们的模型的输出层，即密集层。它将拥有目标词总数的形状，并且具有Softmax激活函数。
代码：
# 密集层 (输出层)
dec_dense = Dense(num_tr_words+1, activation='softmax')
dec_outputs = dec_dense(merge)
5) 训练模型
最后，我们将使用编码器和解码器层的输入和输出数据初始化 Model 类。我们还可以绘制模型层并获取模型的摘要。
# 用于文本摘要的模型类和模型摘要
model = Model([en_inputs, dec_inputs], dec_outputs)
model.summary()
plot_model(model, to_file='model_plot.png', show_shapes=True, show_layer_names=True)
模型摘要和图表:
Model: “model”
___________________________________________________________________________________
Layer (type) Output Shape Param # Connected to
===================================================================================
input_5 (InputLayer) [(None, 74)] 0
___________________________________________________________________________________
embedding (Embedding) (None, 74, 500) 16066000 input_5[0][0]
___________________________________________________________________________________
lstm (LSTM) [(None, 74, 500), (N 2002000 embedding[0][0]
___________________________________________________________________________________
input_6 (InputLayer) [(None, None)] 0
___________________________________________________________________________________
lstm_1 (LSTM) [(None, 74, 500), (N 2002000 lstm[0][0]
___________________________________________________________________________________
embedding_1 (Embedding) (None, None, 500) 7079000 input_6[0][0]
___________________________________________________________________________________
lstm_2 (LSTM) [(None, 74, 500), (N 2002000 lstm_1[0][0]
___________________________________________________________________________________
lstm_3 (LSTM) [(None, None, 500), 2002000 embedding_1[0][0]
lstm_2[0][1]
lstm_2[0][2]
___________________________________________________________________________________
attention (Attention) (None, None, 500) 0 lstm_3[0][0]
lstm_2[0][0]
___________________________________________________________________________________
concat_layer1 (Concatenate) (None, None, 1000) 0 lstm_3[0][0]
attention[0][0]
___________________________________________________________________________________
dense (Dense) (None, None, 14158) 14172158 concat_layer1[0][0]
===================================================================================
Total params: 45,325,158
Trainable params: 45,325,158
Non-trainable params: 0
训练模型
我们将使用‘512’的批量大小，‘10’的轮次来传递数据并训练我们的模型。我们将在‘RMSprop’优化器中训练我们的模型。您可以增加或减少轮次，但要注意验证损失。
model.compile(
optimizer="rmsprop", loss="sparse_categorical_crossentropy", metrics=["accuracy"] )
model.fit(
[en_in_data, dec_in_data],
dec_tr_data,
batch_size=512,
epochs=10,
validation_split=0.1,
)
# 保存模型
model.save("s2s")
训练完模型后，我们将得到一个目录‘s2s/’，其中包含‘saved_model.pb’文件，包括模型的优化器、损失和指标。权重保存在 variables/ 目录中。
6) 推理模型
我们将使用保存的模型为编码器和解码器模型创建推理架构。推理模型用于测试目标序列未知的新句子。
编码器推理:
推理编码器模型的输入将是第 0 层，即我们创建的 Input 对象（您可以从上面的摘要和模型图中查看）。输出将是最后一个 LSTM 的输出，即第 6 层。
# 编码器推理
latent_dim=500
#/content/gdrive/MyDrive/Text Summarizer/
# 加载模型
model = models.load_model("s2s")
# 从最后一个 LSTM 层构建编码器模型
en_outputs,state_h_enc,state_c_enc = model.layers[6].output
en_states=[state_h_enc,state_c_enc]
# 添加输入和状态层
en_model = Model(model.input[0],[en_outputs]+en_states)
解码器推理:
与编码器推理模型相同，我们将从保存的模型中获取输入、嵌入和 LSTM 层。使用隐层（隐藏）维度的形状初始化解码器隐藏输入和其他两个状态层。
# 解码器推理
# 创建解码器隐层和细胞状态的输入对象
# 隐层维度的层形状
dec_state_input_h = Input(shape=(latent_dim,))
dec_state_input_c = Input(shape=(latent_dim,))
dec_hidden_state_input = Input(shape=(max_in_len,latent_dim))
# 从模型中获取嵌入和输入层
dec_inputs = model.input[1]
dec_emb_layer = model.layers[5]
dec_lstm = model.layers[7]
dec_embedding= dec_emb_layer(dec_inputs)
# 添加输入并使用编码器 LSTM 状态初始化 LSTM 层
dec_outputs2, state_h2, state_c2 = dec_lstm(dec_embedding, initial_state=[dec_state_input_h,dec_state_input_c])
注意力推理:
在我们的情况下，第 8 层是注意力层。我们将获取它，并将推理解码器输出与我们之前初始化的隐状态输入一起传递。然后我们将解码器输出与注意力层输出连接起来。
# 注意力层
attention = model.layers[8]
attn_out2 = attention([dec_outputs2,dec_hidden_state_input])
merge2 = Concatenate(axis=-1)([dec_outputs2, attn_out2])
对于密集层（输出层），它是我们的保存模型的第 10 层。使用上述数据初始化 Inference Model 类。
# 密集层
dec_dense = model.layers[10]
dec_outputs2 = dec_dense(merge2)
# 最终定义 Model 类
dec_model = Model(
[dec_inputs] + [dec_hidden_state_input,dec_state_input_h,dec_state_input_c],
[dec_outputs2] + [state_h2, state_c2])
将输入序列编码为状态向量。创建一个目标序列的空数组，并为每对生成一个开始词，即在我们的情况下为‘sos’。使用这个状态值以及输入序列来预测输出索引。使用反向目标词索引从输出索引中获取词，并将其添加到解码序列中。
# 创建一个字典，键为索引，值为词
reverse_target_word_index = tr_tokenizer.index_word
reverse_source_word_index = in_tokenizer.index_word
target_word_index = tr_tokenizer.word_index
reverse_target_word_index[0]=' '
def decode_sequence(input_seq):
# 通过输入序列获取编码器输出和状态
en_out, en_h, en_c= en_model.predict(input_seq)
# 目标序列以开始词为 'sos'
target_seq = np.zeros((1, 1))
target_seq[0, 0] = target_word_index['sos']
# 如果迭代到达文本末尾，则停止迭代
stop_condition = False
# 将每个预测的词追加到解码句子中
decoded_sentence = ""
while not stop_condition:
# 获取预测输出、隐层和细胞状态
output_words, dec_h, dec_c= dec_model.predict([target_seq] + [en_out,en_h, en_c])
# 获取索引，并从字典中获取该索引对应的词
word_index = np.argmax(output_words[0, -1, :])
text_word = reverse_target_word_index[word_index]
decoded_sentence += text_word +" "
将我们词的索引分配给目标序列，因此在下一次迭代中，我们的目标序列将包含前一个词的向量。直到我们的词等于最后一个词即‘eos’在我们的情况下或目标文本的最大长度为止。
# 停止条件：达到最大长度
# 或找到停止词或最后的词
if text_word == "eos" or len(decoded_sentence) > max_tr_len:
stop_condition = True
# 更新目标序列到当前词索引
target_seq = np.zeros((1, 1))
target_seq[0, 0] = word_index
en_h, en_c = dec_h, dec_c
# 返回解码的句子
return decoded_sentence
最后，我们完成了所有步骤，现在可以为输入的评论预测摘要。
inp_review = input("Enter : ")
print("Review :", inp_review)
inp_review = clean(inp_review, "inputs")
inp_review = ' '.join(inp_review)
inp_x = in_tokenizer.texts_to_sequences([inp_review])
inp_x = pad_sequences(inp_x, maxlen=max_in_len, padding='post')
summary = decode_sequence(inp_x.reshape(1, max_in_len))
if 'eos' in summary:
summary = summary.replace('eos', '')
print("\nPredicted summary:", summary); print("\n")
文本摘要模型输出
文本摘要模型的输出
摘要
在这个项目中，我们开发了一个文本摘要模型，该模型使用 LSTM 模型和注意力机制从提供的评论中生成摘要。我们获得了 87.82% 的准确率，这是很好的结果，因为我们只使用了 100,000 条记录作为训练和测试集。
参考资料
| 参考资料 | 链接 |
|---|---|
| TensorFlow 官方文档 | https://www.tensorflow.org/guide/keras/functional |
| Keras 官方文档 | https://keras.io/guides/functional_api/ |
| LSTM 模型详解 | https://colah.github.io/posts/2015-08-Understanding-LSTMs/ |
| 注意力机制介绍 | https://lilianweng.github.io/posts/2018-06-24-attention/ |
| 文本摘要综述 | https://zhuanlan.zhihu.com/p/34372794 |
| 文本摘要方法综述 | https://arxiv.org/abs/1902.09255 |
| PyTorch 官方文档 | https://pytorch.org/tutorials/beginner/nlp/sequence_models_tutorial.html |
| 机器学习教程 | https://machinelearningmastery.com/ |
| NLP 教程 | https://www.nltk.org/book/ |
| NLP 实战 | https://github.com/bentrevett/pytorch-seq2seq |
| 文本摘要研究论文 | https://www.aclweb.org/anthology/W18-4328/ |
| 深度学习教程 | https://deeplearningbook.com/ |
| PyTorch 文本摘要代码示例 | https://pytorch.org/hub/pytorch_fairseq_bart/ |
| TensorFlow 文本摘要代码示例 | https://github.com/tensorflow/text/tree/master/tensorflow_text/examples/tutorials/text_summarization |
| 文本摘要的数据集 | https://huggingface.co/datasets/cnn_dailymail |
数据集介绍：
关于数据集
背景介绍
该数据集由来自亚马逊的精品食品评论组成，涵盖了超过10年的数据，包含截至2012年10月的所有约500,000条评论。这些评论不仅包含了产品和用户信息、评分，还有纯文本形式的评论内容。值得注意的是，此数据集还收录了亚马逊所有其他类别的商品评论。
内容
- Reviews.csv：从名为
Reviews的SQLite表中提取。 - database.sqlite：包含一个名为
Reviews的表，即上述CSV文件的数据源。
数据详情
- 时间范围：1999年10月至2012年10月
- 总评论数：568,454条
- 用户总数：256,059位
- 涉及产品数：74,258种
- 审评次数超过50次的用户数：260位
此外，数据集中还包括了一个词云图（wordcloud），它可以帮助我们直观地理解哪些词汇在评论中最常出现，从而反映出消费者对于产品的关注点或偏好。
【推荐】国内首个AI IDE，深度理解中文开发场景，立即下载体验Trae
【推荐】编程新体验，更懂你的AI，立即体验豆包MarsCode编程助手
【推荐】抖音旗下AI助手豆包，你的智能百科全书，全免费不限次数
【推荐】轻量又高性能的 SSH 工具 IShell：AI 加持，快人一步
· 分享4款.NET开源、免费、实用的商城系统
· 全程不用写代码，我用AI程序员写了一个飞机大战
· MongoDB 8.0这个新功能碉堡了，比商业数据库还牛
· 白话解读 Dapr 1.15：你的「微服务管家」又秀新绝活了
· 上周热点回顾（2.24-3.2）