Pytorch深度学习实战(1)—— 使用LSTM 自动编码器进行时间序列异常检测

 大家好,我是Sonhhxg_柒,希望你看完之后,能对你有所帮助,不足请指正!共同学习交流

个人主页-Sonhhxg_柒的博客_CSDN博客 

欢迎各位→点赞 + 收藏⭐️ + 留言​

系列专栏 - 机器学习【ML】 自然语言处理【NLP】  深度学习【DL】

 foreword

✔说明⇢本人讲解主要包括Python、机器学习(ML)、深度学习(DL)、自然语言处理(NLP)等内容。

如果你对这个系列感兴趣的话,可以关注订阅哟

文章目录

数据

探索性数据分析

LSTM 自动编码器

重建损失

ECG 数据中的异常检测

数据预处理

训练

保存模型

选择阈值

评估

正常听力节拍

异常情况

概括


TL;DR 使用真实世界的心电图 (ECG) 数据来检测患者心跳中的异常情况。我们将构建一个 LSTM 自动编码器,在一组正常的心跳上对其进行训练,并将看不见的示例分类为正常或异常

在本教程中,您将学习如何使用 LSTM 自动编码器检测时间序列数据中的异常。您将使用来自单个心脏病患者的真实心电图数据来检测异常心跳。

  • 在浏览器中运行完整的笔记本 (Google Colab)
  • 阅读使用 Pytorch 完成工作这本书

在本教程结束时,您将学习如何:

  • 准备数据集以从时间序列数据中进行异常检测
  • 使用 PyTorch 构建 LSTM 自动编码器
  • 训练和评估您的模型
  • 选择异常检测的阈值
  • 将看不见的示例分类为正常或异常

数据

该数据集包含 5,000 个时间序列示例(通过 ECG 获得),具有 140 个时间步长。每个序列对应于单个充血性心力衰竭患者的单个心跳。

心电图(ECG 或 EKG)是一种通过测量心脏的电活动来检查心脏功能的测试。每次心跳时,都会有一个电脉冲(或电波)穿过您的心脏。这种波会导致肌肉挤压并从心脏泵出血液。资源

我们有 5 种类型的心跳(类):

  • 正常 (N)
  • R-on-T 室性早搏 (R-on-T PVC)
  • 室性早搏 (PVC)
  • 室上性早搏或异位搏动(SP 或 EB)
  • 未分类节拍 (UB)。

假设一个健康的心脏和每分钟 70 到 75 次的典型心率,每个心动周期或心跳大约需要 0.8 秒才能完成一个周期。频率:每分钟 60-100 次(人类) 持续时间:0.6-1 秒(人类)来源

该数据集在我的 Google Drive 上可用。我们去取得它:

# BASH
!gdown --id 16MIleqoIr1vYxlGk4GKnGmrsCPuWkkpT
!unzip -qq ECG5000.zip
device = torch.device("cuda" if torch.cuda.is_available() else "cpu")

数据有多种格式。我们将arff文件加载到 Pandas 数据帧中:

with open('ECG5000_TRAIN.arff') as f:
    train = a2p.load(f)
with open('ECG5000_TEST.arff') as f:
    test = a2p.load(f)

我们将把训练和测试数据合并到一个数据框中。这将为我们提供更多数据来训练我们的自动编码器。我们还将对其进行洗牌:

df = train.append(test)
df = df.sample(frac=1.0)
df.shape

(5000, 141)

 我们有 5,000 个示例。每行代表一个心跳记录。让我们命名可能的类:

CLASS_NORMAL = 1
class_names = ['Normal','R on T','PVC','SP','UB']

 接下来,我们将最后一列重命名为target,以便更容易引用它:

new_columns = list(df.columns)
new_columns[-1] = 'target'
df.columns = new_columns

探索性数据分析

让我们检查一下每个心跳类有多少个示例:

df.target.value_counts()

 Output:

1    2919
2    1767
4     194
3      96
5      24
Name: target, dtype: int64

让我们绘制结果: Pytorch深度学习实战(1)—— 使用LSTM 自动编码器进行时间序列异常检测_第1张图片

 

     到目前为止,普通班的例子最多。这很棒,因为我们将使用它来训练我们的模型。

让我们看一下每个类的平均时间序列(在顶部和底部用一个标准偏差平滑):

Pytorch深度学习实战(1)—— 使用LSTM 自动编码器进行时间序列异常检测_第2张图片

正常类与所有其他类具有明显不同的模式,这是非常好的。也许我们的模型将能够检测到异常?

LSTM 自动编码器

自动编码器的工作是获取一些输入数据,将其传递给模型,并获得输入的重构。重建应该尽可能匹配输入。诀窍是使用少量参数,以便您的模型学习数据的压缩表示。

从某种意义上说,自动编码器试图只学习数据最重要的特征(压缩版本)。在这里,我们将了解如何将时间序列数据提供给自动编码器。我们将使用几个 LSTM 层(因此是 LSTM 自动编码器)来捕获数据的时间依赖性。

要将序列分类为正常或异常,我们将选择一个阈值,超过该阈值时心跳被视为异常。

重建损失

在训练自动编码器时,目标是尽可能地重构输入。这是通过最小化损失函数来完成的(就像在监督学习中一样)。这个函数被称为重建损失。交叉熵损失和均方误差是常见的例子。

ECG 数据中的异常检测

我们将使用正常的心跳作为模型的训练数据并记录重建损失。但首先,我们需要准备数据:

数据预处理

让我们获取所有正常的心跳并删除目标(类)列:

normal_df = df[df.target == str(CLASS_NORMAL)].drop(labels='target', axis=1)
normal_df.shape

(2919, 140)

 我们将合并所有其他类并将它们标记为异常:

anomaly_df = df[df.target != str(CLASS_NORMAL)].drop(labels='target', axis=1)
anomaly_df.shape

 (2081, 140)

我们将正常示例拆分为训练集、验证集和测试集:

train_df, val_df = train_test_split(
    normal_df,
    test_size=0.15,
    random_state=RANDOM_SEED
)
val_df, test_df = train_test_split(
    val_df,
    test_size=0.33,
    random_state=RANDOM_SEED
)

我们需要将我们的示例转换为张量,以便我们可以使用它们来训练我们的自动编码器。让我们为此编写一个辅助函数:

def create_dataset(df):
    sequences = df.astype(np.float32).to_numpy().tolist()
    dataset = [torch.tensor(s).unsqueeze(1).float() for s in sequences]
    n_seq, seq_len, n_features = torch.stack(dataset).shape
    return dataset, seq_len, n_features

每个时间序列都将转换为形状序列长度x特征数(在我们的例子中为 140x1)的 2D 张量。

让我们创建一些数据集:

train_dataset, seq_len, n_features = create_dataset(train_df)
val_dataset, _, _ = create_dataset(val_df)
test_normal_dataset, _, _ = create_dataset(test_df)
test_anomaly_dataset, _, _ = create_dataset(anomaly_df)

 LSTM 自动编码器Pytorch深度学习实战(1)—— 使用LSTM 自动编码器进行时间序列异常检测_第3张图片

                                                                        自动编码器 

示例自动编码器架构图像源

通用的自动编码器架构由两个组件组成。一个压缩输入的编码器和一个尝试重建它的解码器。

我们将使用来自这个GitHub存储库的 LSTM 自动编码器,并进行一些小的调整。我们模型的工作是重建时间序列数据。让我们从编码器开始:

class Encoder(nn.Module):
    def __init__(self, seq_len, n_features, embedding_dim=64):
        super(Encoder, self).__init__()
        self.seq_len, self.n_features = seq_len, n_features
        self.embedding_dim, self.hidden_dim = embedding_dim, 2 * embedding_dim
        self.rnn1 = nn.LSTM(
            input_size=n_features,
            hidden_size=self.hidden_dim,
            num_layers=1,
            batch_first=True
        )
        self.rnn2 = nn.LSTM(
            input_size=self.hidden_dim,
            hidden_size=embedding_dim,
            num_layers=1,
            batch_first=True
        )
    def forward(self, x):
        x = x.reshape((1, self.seq_len, self.n_features))
        x, (_, _) = self.rnn1(x)
        x, (hidden_n, _) = self.rnn2(x)
        return hidden_n.reshape((self.n_features, self.embedding_dim))

编码器使用两个 LSTM 层来压缩时间序列数据输入。

接下来,我们将使用解码器对压缩表示进行解码

class Decoder(nn.Module):
    def __init__(self, seq_len, input_dim=64, n_features=1):
        super(Decoder, self).__init__()
        self.seq_len, self.input_dim = seq_len, input_dim
        self.hidden_dim, self.n_features = 2 * input_dim, n_features
        self.rnn1 = nn.LSTM(
            input_size=input_dim,
            hidden_size=input_dim,
            num_layers=1,
            batch_first=True
        )
        self.rnn2 = nn.LSTM(
            input_size=input_dim,
            hidden_size=self.hidden_dim,
            num_layers=1,
            batch_first=True
        )
        self.output_layer = nn.Linear(self.hidden_dim, n_features)
    def forward(self, x):
        x = x.repeat(self.seq_len, self.n_features)
        x = x.reshape((self.n_features, self.seq_len, self.input_dim))
        x, (hidden_n, cell_n) = self.rnn1(x)
        x, (hidden_n, cell_n) = self.rnn2(x)
        x = x.reshape((self.seq_len, self.hidden_dim))
        return self.output_layer(x)

我们的解码器包含两个 LSTM 层和一个提供最终重建的输出层。

是时候将所有内容包装到一个易于使用的模块中了:

class RecurrentAutoencoder(nn.Module):
    def __init__(self, seq_len, n_features, embedding_dim=64):
        super(RecurrentAutoencoder, self).__init__()
        self.encoder = Encoder(seq_len, n_features, embedding_dim).to(device)
        self.decoder = Decoder(seq_len, embedding_dim, n_features).to(device)
    def forward(self, x):
        x = self.encoder(x)
        x = self.decoder(x)
        return x

我们的自动编码器通过编码器和解码器传递输入。让我们创建它的一个实例:

model = RecurrentAutoencoder(seq_len, n_features, 128)
model = model.to(device)

训练

让我们为我们的训练过程编写一个辅助函数:

def train_model(model, train_dataset, val_dataset, n_epochs):
    optimizer = torch.optim.Adam(model.parameters(), lr=1e-3)
    criterion = nn.L1Loss(reduction='sum').to(device)
    history = dict(train=[], val=[])
    best_model_wts = copy.deepcopy(model.state_dict())
    best_loss = 10000.0
    for epoch in range(1, n_epochs + 1):
        model = model.train()
        train_losses = []
        for seq_true in train_dataset:
            optimizer.zero_grad()
            seq_true = seq_true.to(device)
            seq_pred = model(seq_true)
            loss = criterion(seq_pred, seq_true)
            loss.backward()
            optimizer.step()
            train_losses.append(loss.item())
        val_losses = []
        model = model.eval()
        with torch.no_grad():
            for seq_true in val_dataset:
                seq_true = seq_true.to(device)
                seq_pred = model(seq_true)
                loss = criterion(seq_pred, seq_true)
                val_losses.append(loss.item())
        train_loss = np.mean(train_losses)
        val_loss = np.mean(val_losses)
        history['train'].append(train_loss)
        history['val'].append(val_loss)
        if val_loss < best_loss:
            best_loss = val_loss
            best_model_wts = copy.deepcopy(model.state_dict())
        print(f'Epoch {epoch}: train loss {train_loss} val loss {val_loss}')
    model.load_state_dict(best_model_wts)
    return model.eval(), history

 在每个时期,训练过程都会为我们的模型提供所有训练示例,并评估验证集的性能。请注意,我们使用的批量大小为 1(我们的模型一次只能看到 1 个序列)。我们还记录了过程中的训练和验证集损失。

请注意,我们正在最小化L1Loss,它测量 MAE(平均绝对误差)。为什么?重建似乎比 MSE(均方误差)更好。

我们将获得具有最小验证错误的模型版本。让我们做一些训练:

model, history = train_model(
    model,
    train_dataset,
    val_dataset,
    n_epochs=150
)
Pytorch深度学习实战(1)—— 使用LSTM 自动编码器进行时间序列异常检测_第4张图片

 我们的模型收敛得很好。似乎我们可能需要一个更大的验证集来平滑结果,但现在就可以了。

保存模型

让我们存储模型以备后用:

MODEL_PATH = 'model.pth'
torch.save(model, MODEL_PATH)

 如果要下载并加载预训练模型,请取消注释下一行:

# !gdown --id 1jEYx5wGsb7Ix8cZAw3l5p5pOwHs3_I9A
# model = torch.load('model.pth')
# model = model.to(device)

选择阈值

有了我们手头的模型,我们可以看看训练集上的重建误差。让我们首先编写一个辅助函数来从我们的模型中获取预测:

def predict(model, dataset):
    predictions, losses = [], []
    criterion = nn.L1Loss(reduction='sum').to(device)
    with torch.no_grad():
        model = model.eval()
        for seq_true in dataset:
            seq_true = seq_true.to(device)
            seq_pred = model(seq_true)
            loss = criterion(seq_pred, seq_true)
            predictions.append(seq_pred.cpu().numpy().flatten())
            losses.append(loss.item())
    return predictions, losses

我们的函数遍历数据集中的每个示例并记录预测和损失。让我们得到损失并看看它们:

_, losses = predict(model, train_dataset)
sns.distplot(losses, bins=50, kde=True);
Pytorch深度学习实战(1)—— 使用LSTM 自动编码器进行时间序列异常检测_第5张图片
THRESHOLD = 26

评估

使用阈值,我们可以将问题转化为简单的二元分类任务:

  • 如果示例的重建损失低于阈值,我们会将其归类为正常心跳
  • 或者,如果损失高于阈值,我们会将其归类为异常

正常听力节拍

让我们检查一下我们的模型在正常心跳上的表现如何。我们将使用测试集中的正常心跳(我们的模型没有看到这些):

predictions, pred_losses = predict(model, test_normal_dataset)
sns.distplot(pred_losses, bins=50, kde=True);

Pytorch深度学习实战(1)—— 使用LSTM 自动编码器进行时间序列异常检测_第6张图片
 我们将计算正确的预测:

correct = sum(l <= THRESHOLD for l in pred_losses)
print(f'Correct normal predictions: {correct}/{len(test_normal_dataset)}')

Correct normal predictions: 142/145 

异常情况

我们将对异常示例执行相同的操作,但它们的数量要高得多。我们将得到一个与正常心跳大小相同的子集:

anomaly_dataset = test_anomaly_dataset[:len(test_normal_dataset)]

 现在我们可以对异常子集的模型进行预测:

predictions, pred_losses = predict(model, anomaly_dataset)
sns.distplot(pred_losses, bins=50, kde=True);
Pytorch深度学习实战(1)—— 使用LSTM 自动编码器进行时间序列异常检测_第7张图片

 最后,我们可以统计超过阈值的示例数量(视为异常): 

correct = sum(l > THRESHOLD for l in pred_losses)
print(f'Correct anomaly predictions: {correct}/{len(anomaly_dataset)}')

 Correct anomaly predictions: 142/145 

我们取得了非常好的结果。在现实世界中,您可以根据要容忍的错误类型来调整阈值。在这种情况下,您可能希望误报(正常心跳被视为异常)多于误报(异常被视为正常)。

看例子

我们可以叠加真实的和重建的时间序列值,看看它们有多接近。我们将针对一些正常和异常情况执行此操作:

Pytorch深度学习实战(1)—— 使用LSTM 自动编码器进行时间序列异常检测_第8张图片 

概括

在本教程中,您学习了如何使用 PyTorch 创建 LSTM 自动编码器,并使用它来检测 ECG 数据中的心跳异常。

  • 在浏览器中运行完整的笔记本 (Google Colab)
  • 阅读使用 Pytorch 完成工作这本书

你学会了如何:

  • 准备数据集以从时间序列数据中进行异常检测
  • 使用 PyTorch 构建 LSTM 自动编码器
  • 训练和评估您的模型
  • 选择异常检测的阈值
  • 将看不见的示例分类为正常或异常

虽然我们的时间序列数据是单变量的(我们只有 1 个特征),但代码应该适用于多变量数据集(多个特征),几乎不需要修改。随意尝试!

你可能感兴趣的:(深度学习(DL),机器学习(ML),深度学习,pytorch,lstm)