收藏！14 种异常检测方法总结("必藏干货！14种异常检测技术全解析")

原创

ithorizon 4周前 (10-19) 阅读数 18 #后端开发

必藏干货！14种异常检测技术全解析

一、引言

异常检测是数据挖掘和机器学习领域的一个重要研究方向，它旨在识别数据集中的异常或不寻常的模式。本文将为您介绍14种常见的异常检测方法，帮助您更好地领会和应用这些技术。

二、基于统计的方法

基于统计的方法关键利用数据的统计特性进行异常检测。

1. Z-Score

Z-Score是一种基于标准差的异常检测方法。它计算每个数据点与数据集平均值的标准差差值。


def z_score(data):
    mean = np.mean(data)
    std = np.std(data)
    z_scores = [(x - mean) / std for x in data]
    return z_scores

2. IQR（四分位数间距）

IQR是基于四分位数间距的异常检测方法。它将数据分为四等分，计算中间两个四分位数之间的距离。


def iqr(data):
    q1, q3 = np.percentile(data, [25, 75])
    iqr = q3 - q1
    lower_bound = q1 - 1.5 * iqr
    upper_bound = q3 + 1.5 * iqr
    return lower_bound, upper_bound

三、基于邻域的方法

基于邻域的方法关键利用数据点之间的相似性进行异常检测。

1. k-最近邻（k-NN）

k-最近邻算法通过计算数据点之间的距离来检测异常。如果一个数据点的最近邻中异常数据点的比例较高，则该数据点也许为异常。


from sklearn.neighbors import NearestNeighbors
def knn(data, k, threshold):
    knn = NearestNeighbors(n_neighbors=k)
    knn.fit(data)
    distances, indices = knn.kneighbors(data)
    abnormal_scores = [np.mean(distances[i, 1:]) for i in range(len(data))]
    return [score > threshold for score in abnormal_scores]

2. 局部异常因子（LOF）

LOF算法通过计算数据点的局部密度进行异常检测。如果一个数据点的局部密度明显低于其邻域数据点的局部密度，则该数据点也许为异常。


from sklearn.neighbors import LocalOutlierFactor
def lof(data, n_neighbors):
    lof = LocalOutlierFactor(n_neighbors=n_neighbors)
    return lof.fit_predict(data)

四、基于聚类的方法

基于聚类的方法通过将数据点聚类，然后检测聚类中的异常数据点。

1. K-Means

K-Means算法通过将数据点聚类为K个簇，然后计算每个数据点与其最近簇中心的距离。距离较远的点也许为异常。


from sklearn.cluster import KMeans
def kmeans(data, k, threshold):
    kmeans = KMeans(n_clusters=k)
    kmeans.fit(data)
    distances = np.min(kmeans.transform(data), axis=1)
    return distances > threshold

2. DBSCAN

DBSCAN算法通过检测数据点之间的密度连接性来聚类数据。它不需要指定簇的数量，能够识别出任意形状的簇。


from sklearn.cluster import DBSCAN
def dbscan(data, eps, min_samples):
    dbscan = DBSCAN(eps=eps, min_samples=min_samples)
    return dbscan.fit_predict(data)

五、基于模型的方法

基于模型的方法通过生成数据生成模型，然后检测不符合模型的数据点。

1. 高斯混合模型（GMM）

GMM算法通过拟合多个高斯分布来描述数据。如果一个数据点在所有高斯分布中的概率都很低，则该数据点也许为异常。


from sklearn.mixture import GaussianMixture
def gmm(data, n_components, threshold):
    gmm = GaussianMixture(n_components=n_components)
    gmm.fit(data)
    probabilities = gmm.predict_proba(data)
    return np.min(probabilities, axis=1) < threshold

2. Isolation Forest

Isolation Forest算法通过随机选择特征和分割值，将数据点隔离在树结构中。隔离路径较短的点也许为异常。


from sklearn.ensemble import IsolationForest
def isolation_forest(data, contamination):
    forest = IsolationForest(contamination=contamination)
    return forest.fit_predict(data)

六、基于深度学习的方法

基于深度学习的方法通过神经网络模型来检测异常。

1. 自编码器（Autoencoder）

自编码器通过学习重构输入数据的描述来检测异常。如果重构误差较大，则输入数据也许为异常。


import torch
import torch.nn as nn
import torch.optim as optim
class Autoencoder(nn.Module):
    def __init__(self, input_size):
        super(Autoencoder, self).__init__()
        self.encoder = nn.Sequential(
            nn.Linear(input_size, 64),
            nn.ReLU(True),
            nn.Linear(64, 32),
            nn.ReLU(True)
        )
        self.decoder = nn.Sequential(
            nn.Linear(32, 64),
            nn.ReLU(True),
            nn.Linear(64, input_size),
            nn.Sigmoid()
        )
    def forward(self, x):
        x = self.encoder(x)
        x = self.decoder(x)
        return x
def autoencoder(data, epochs, learning_rate, threshold):
    model = Autoencoder(data.shape[1])
    criterion = nn.MSELoss()
    optimizer = optim.Adam(model.parameters(), lr=learning_rate)
    for epoch in range(epochs):
        optimizer.zero_grad()
        outputs = model(data)
        loss = criterion(outputs, data)
        loss.backward()
        optimizer.step()
   重建误差 = torch.mean((data - model(data))**2, dim=1).numpy()
    return 重建误差 > threshold

2. GAN（生成对抗网络）

GAN通过训练生成器和判别器来生成与真实数据相似的数据。如果一个数据点被判别器判为真实数据的概率较低，则该数据点也许为异常。


import torch
import torch.nn as nn
import torch.optim as optim
class Generator(nn.Module):
    def __init__(self, input_size):
        super(Generator, self).__init__()
        self.model = nn.Sequential(
            nn.Linear(input_size, 128),
            nn.ReLU(True),
            nn.Linear(128, 256),
            nn.ReLU(True),
            nn.Linear(256, input_size),
            nn.Tanh()
        )
    def forward(self, x):
        return self.model(x)
class Discriminator(nn.Module):
    def __init__(self, input_size):
        super(Discriminator, self).__init__()
        self.model = nn.Sequential(
            nn.Linear(input_size, 256),
            nn.LeakyReLU(0.2, inplace=True),
            nn.Linear(256, 128),
            nn.LeakyReLU(0.2, inplace=True),
            nn.Linear(128, 1),
            nn.Sigmoid()
        )
    def forward(self, x):
        return self.model(x)
def gan(data, epochs, learning_rate, threshold):
    generator = Generator(data.shape[1])
    discriminator = Discriminator(data.shape[1])
    optimizer_G = optim.Adam(generator.parameters(), lr=learning_rate)
    optimizer_D = optim.Adam(discriminator.parameters(), lr=learning_rate)
    for epoch in range(epochs):
        for i, x in enumerate(data):
            z = torch.randn(1, data.shape[1])
            fake_x = generator(z)
            optimizer_D.zero_grad()
            real_loss = torch.mean((discriminator(x) - 1)**2)
            fake_loss = torch.mean(discriminator(fake_x)**2)
            d_loss = real_loss + fake_loss
            d_loss.backward()
            optimizer_D.step()
            optimizer_G.zero_grad()
            g_loss = torch.mean((discriminator(fake_x) - 1)**2)
            g_loss.backward()
            optimizer_G.step()
    fake_data = generator(torch.randn(len(data), data.shape[1]))
    fake_scores = discriminator(fake_data).numpy()
    return fake_scores < threshold