Table des matières
2. Détection d'anomalies basée sur l'encodeur automatique
Troisièmement, la mise en œuvre de la détection d'anomalies Tensorflow
3.2, construire un modèle d'auto-codage
1. Détection d'anomalies
Les anomalies sont définies comme des événements qui s'écartent de la norme, se produisent rarement et ne suivent pas le reste du «modèle». Voici des exemples d'exceptions:
- La bourse a chuté en raison des événements mondiaux
- Articles défectueux sur l'usine / la bande transporteuse
- Échantillons contaminés dans le laboratoire
En supposant que nos données obéissent à une distribution normale, les données anormales sont généralement situées des deux côtés de la courbe de distribution normale. Comme indiqué ci-dessous.
Comme nous l'avons vu, ces événements se produiront, mais la probabilité d'occurrence est extrêmement faible. Du point de vue de l'apprentissage automatique, cela rend difficile la détection des anomalies - par définition, nous avons de nombreux exemples d'événements «standard» et très peu d'exemples d'événements «anormaux». Par conséquent, notre ensemble de données présente un écart important. Lorsque l'anomalie que nous voulons détecter ne se produit que 1%, 0,1% ou 0,0001% du temps, comment l'algorithme d'apprentissage automatique qui fonctionne le mieux dans l'ensemble de données équilibré devrait-il fonctionner? À ce stade, nous devons utiliser la détection des anomalies pour traiter spécifiquement ce type de problème.
En raison de l'énorme déséquilibre dans les étiquettes de notre ensemble de données, des données anormales se produisent rarement par définition, et nous avons une grande quantité de données normales. Afin de détecter des données anormales, des algorithmes d'apprentissage automatique traditionnels dérivent, tels que des forêts isolées, des SVM à une classe, des enveloppes elliptiques et des algorithmes de facteurs d'anomalie locaux. Je ne vais pas les présenter un par un ici. Les étudiants intéressés peuvent aller à la recherche et étudier. Le sujet principal ici est comment utiliser l'apprentissage en profondeur pour résoudre ce problème.
2. Détection d'anomalies basée sur l'encodeur automatique
Autoencoder est un réseau de neurones non supervisé, il peut:
- Acceptez un ensemble de données d'entrée;
- Encodez les données;
- Décodez les entités codées pour reconstruire les données d'entrée.
Habituellement, un auto-encodeur se compose principalement de deux parties: l'encodeur et le décodeur. L'encodeur accepte les données d'entrée et les convertit en une représentation d'entité. Ensuite, le décodeur tente de reconstruire les caractéristiques compressées pour obtenir les données d'entrée. Lorsque nous entraînons l'auto-encodeur de bout en bout, le réseau peut apprendre un filtre puissant qui peut même débruiter les données d'entrée.
Du point de vue de la détection d'anomalies, l'auto-encodeur est spécial en ce qu'il peut reconstruire la perte.L'erreur quadratique moyenne (MSE) entre l'entrée et les données reconstruites est généralement mesurée lorsque l'auto-encodeur est entraîné. Si la perte est moindre, l'image reconstruite ressemble plus aux données d'origine.
Supposons que nous entraînions un auto-encodeur sur l'ensemble de données MNIST, puis fournissions un numéro à l'auto-encodeur et le reconstruisions. Nous espérons pouvoir le reconstruire pour qu'il soit similaire aux données d'entrée, puis nous constaterons que l'EQM entre ces deux images est relativement faible.
Si, à ce moment, nous fournissons une image non numérique, comme un éléphant, la MSE de ces deux images est très élevée à ce moment. C'est parce que l'auto-encodeur n'a jamais vu d'éléphant auparavant et, plus important encore, n'a jamais été formé pour reconstruire un éléphant, donc notre MSE est très élevée.
À ce stade, si la MSE reconstruite est élevée, alors nous pouvons avoir une valeur aberrante.
Troisièmement, la mise en œuvre de la détection d'anomalies Tensorflow
3.1, chargement des données
Ici, nous utilisons l'ensemble de données mnist, l'étiquette est 1 en tant que données normales, l'étiquette est 1% du nombre de données et l'étiquette est 3 en tant que données anormales, et produisons des données anormales. détails comme suit:
- Charger l'ensemble de données
# 加载MNIST数据集
print("[INFO] loading MNIST dataset...")
((trainX,trainY),(testX,testY))=tf.keras.datasets.mnist.load_data()- Générer des données anormales
def build_unsupervised_dataset(data,labels,validLabel=1,
anomalyLabel=3, contam=0.01, seed=42):
'''制作数据集'''
# 抓取提供的类标签的所有 * 真正 * 索引特定的标签，
# 然后获取图像的索引个标签将成为我们的“异常”
validIdxs=np.where(labels==validLabel)[0]
anomalyLabelIdx=np.where(labels==anomalyLabel)[0]
#随机打乱数据
random.shuffle(validIdxs)
random.shuffle(anomalyLabelIdx)
#计算并设置异常数据的个数
i=int(len(validIdxs)*contam)
anomalyLabelIdx=anomalyLabelIdx[:i]
#提取正常数据和异常数据
validImages=data[validIdxs]
anomalyImages=data[anomalyLabelIdx]
#打包数据并进行数据打乱
images=np.vstack([validImages,anomalyImages])
return images
# 建立少量的无监督图像数据集,污染（即异常）添加到其中
print("[INFO] creating unsupervised dataset...")
images = build_unsupervised_dataset(trainX, trainY, validLabel=1,
anomalyLabel=3, contam=0.01)3.2, construire un modèle d'auto-codage
Voici le code directement:
class ConvAutoencoder:
@staticmethod
def build(width,height,depth=None,filters=(32,64),latentDim=16):
'''
构建自动编码器模型
:param width: 图像的宽度
:param height: 图像的高度
:param depth: 图像的深度
:param filters: 卷积核的尺寸
:param latentDim: 全连接的维数
:return:
'''
#定义解码器
inputs=tf.keras.layers.Input(shape=(height,width,depth))
x=inputs
for filter in filters:
x=tf.keras.layers.Conv2D(filter,kernel_size=(3,3),strides=2,padding='same')(x)
x=tf.keras.layers.LeakyReLU(alpha=0.2)(x)
x=tf.keras.layers.BatchNormalization(axis=-1)(x)
volumeSize=tf.keras.backend.int_shape(x)
x=tf.keras.layers.Flatten()(x)
latent=tf.keras.layers.Dense(latentDim)(x)
encoder=tf.keras.Model(inputs=inputs,outputs=latent,name='encoder')
#定义编码器
latentinputs=tf.keras.layers.Input(shape=(latentDim,))
x=tf.keras.layers.Dense(np.prod(volumeSize[1:]))(latentinputs)
x=tf.keras.layers.Reshape((volumeSize[1],volumeSize[2],volumeSize[3]))(x)
for filter in filters[::-1]:
x=tf.keras.layers.Conv2DTranspose(filter,kernel_size=(3,3),strides=2,padding='same')(x)
x=tf.keras.layers.LeakyReLU(alpha=0.2)(x)
x=tf.keras.layers.BatchNormalization(axis=-1)(x)
x=tf.keras.layers.Conv2DTranspose(depth,(3,3),padding='same')(x)
outputs=tf.keras.layers.Activation('sigmoid')(x)
decoder=tf.keras.Model(latentinputs,outputs,name='decoder')
autoencoder=tf.keras.Model(inputs,decoder(encoder(inputs)),name='autoencoder')
return (encoder,decoder,autoencoder)
autoencoder.summary()La structure de la trame du réseau est la suivante:
3.3, formation modèle
epochs=20
lr=1e-3
batch_size=32
#搭建模型
print("[INFO] building autoencoder...")
(encoder, decoder, autoencoder) = ConvAutoencoder.build(28, 28,1)
#搭建优化器
opt=tf.keras.optimizers.Adam(lr=lr,decay=lr/epochs)
autoencoder.compile(loss='mse',optimizer=opt,metrics=['acc'])
#训练
H=autoencoder.fit(trainX,trainX,validation_data=(testX,testX),epochs=epochs,batch_size=batch_size)
Le processus de formation est le suivant:
3.4. Prédiction du modèle
Il utilise principalement l'image reconstruite à auto-codage et l'image d'origine pour calculer l'EQM, puis effectue le jugement correspondant en fonction du seuil. La réalisation principale est la suivante:
# 加载模型
print("[INFO] loading autoencoder and image data...")
autoencoder = tf.keras.models.load_model("autoencoder.h5")
images = pickle.loads(open("mages.pickle", "rb").read())
#预测图片
images=images.reshape(-1,28,28,1)
images=images.astype('float32')
images/=255
decoded = autoencoder.predict(images)
errors = []
for (image, recon) in zip(images, decoded):
# 计算预测和真实图片之间的均方差1
mse = np.mean((image - recon) ** 2)
errors.append(mse)
# compute the q-th quantile of the errors which serves as our
# threshold to identify anomalies -- any data point that our model
# reconstructed with > threshold error will be marked as an outlier
thresh = np.quantile(errors, 0.999)
idxs = np.where(np.array(errors) >= thresh)[0]
print("[INFO] mse threshold: {}".format(thresh))
print("[INFO] {} outliers found".format(len(idxs)))Les résultats des tests sont les suivants:
Lien de code détaillé: https://github.com/kingqiuol/learning_tensorflow/tree/master/cv/Anomaly_detection
Lien de référence:
https://www.pyimagesearch.com/2020/03/02/anomaly-detection-with-keras-tensorflow-and-deep-learning/
Classification manuscrite des chiffres de l'ensemble de données MNIST basée sur Keras + CNN