Scribd
Upload
5 views3 pages

Anomaly Detection

The document outlines a process for training an anomaly detection model using an autoencoder on ECG data. It includes data preprocessing, model construction, training, and evaluation steps, as well as visualizations of normal and anomalous ECG signals. The model's performance is assessed using accuracy, precision, and recall metrics based on reconstruction errors.

Uploaded by

juanfe86
Copyright
© © All Rights Reserved
We take content rights seriously. If you suspect this is your content, claim it here.
Available Formats
Download as TXT, PDF, TXT or read online on Scribd
5 views3 pages

Anomaly Detection

The document outlines a process for training an anomaly detection model using an autoencoder on ECG data. It includes data preprocessing, model construction, training, and evaluation steps, as well as visualizations of normal and anomalous ECG signals. The model's performance is assessed using accuracy, precision, and recall metrics based on reconstruction errors.

Uploaded by

juanfe86
Copyright
© © All Rights Reserved
We take content rights seriously. If you suspect this is your content, claim it here.
Available Formats
Download as TXT, PDF, TXT or read online on Scribd
You are on page 1/ 3

import matplotlib.

pyplot as plt
import numpy as np
import pandas as pd
import tensorflow as tf

from sklearn.metrics import accuracy_score, precision_score, recall_score


from sklearn.model_selection import train_test_split
from tensorflow.keras import layers, losses
from tensorflow.keras.datasets import fashion_mnist
from tensorflow.keras.models import Model

#El conjunto de datos que utilizará se basa en uno de


timeseriesclassification.com .

# Download the dataset


import pandas as pd

dataframe = pd.read_csv('http://storage.googleapis.com/download.tensorflow.org/
data/ecg.csv', header=None)
raw_data = dataframe.values
dataframe.head()

# The last elememt contains the labels


labels = raw_data[:, -1]

# The other data points are the electrocadriogram data


data = raw_data[:, 0:-1]

train_data, test_data, train_labels, test_labels = train_test_split(


data, labels, test_size=0.2, random_state=21
)

#Normalice los datos a [0,1]


min_val = tf.reduce_min(train_data)
max_val = tf.reduce_max(train_data)

train_data = (train_data - min_val) / (max_val - min_val)


test_data = (test_data - min_val) / (max_val - min_val)

device_spec = tf.DeviceSpec(job ="localhost", replica = 0, device_type = "CPU")

train_data = tf.cast(train_data, tf.float32)


test_data = tf.cast(test_data, tf.float32)

#Entrenará el codificador automático usando solo los ritmos normales, que están
etiquetados en este
#conjunto de datos como 1 . Separar los ritmos normales de los ritmos anormales.
train_labels = train_labels.astype(bool)
test_labels = test_labels.astype(bool)

normal_train_data = train_data[train_labels]
normal_test_data = test_data[test_labels]

anomalous_train_data = train_data[~train_labels]
anomalous_test_data = test_data[~test_labels]

#Trazar un ECG normal.


plt.grid()
plt.plot(np.arange(140), normal_train_data[0])
plt.title("A Normal ECG")
#plt.show()

#Trazar un ECG anómalo


plt.grid()
plt.plot(np.arange(140), anomalous_train_data[0])
plt.title("An Anomalous ECG")
#plt.show()

#Construye el modelo
class AnomalyDetector(Model):
def __init__(self):
super(AnomalyDetector, self).__init__()
self.encoder = tf.keras.Sequential([
layers.Dense(32, activation="relu"),
layers.Dense(16, activation="relu"),
layers.Dense(8, activation="relu")])

self.decoder = tf.keras.Sequential([
layers.Dense(16, activation="relu"),
layers.Dense(32, activation="relu"),
layers.Dense(140, activation="sigmoid")])

def call(self, x):


encoded = self.encoder(x)
decoded = self.decoder(encoded)
return decoded

autoencoder = AnomalyDetector()

autoencoder.compile(optimizer='adam', loss='mae')

#Tenga en cuenta que el codificador automático se entrena utilizando solo los ECG
normales, pero se evalúa
# utilizando el conjunto de prueba completo.

history = autoencoder.fit(normal_train_data, normal_train_data,


epochs=20,
batch_size=512,
validation_data=(test_data, test_data),
shuffle=True)

plt.plot(history.history["loss"], label="Training Loss")


plt.plot(history.history["val_loss"], label="Validation Loss")
plt.legend()
#plt.show()

encoded_data = autoencoder.encoder(normal_test_data).numpy()
decoded_data = autoencoder.decoder(encoded_data).numpy()

plt.plot(normal_test_data[0], 'b')
plt.plot(decoded_data[0], 'r')
plt.fill_between(np.arange(140), decoded_data[0], normal_test_data[0],
color='lightcoral')
plt.legend(labels=["Input", "Reconstruction", "Error"])
#plt.show()

#Cree una trama similar, esta vez para un ejemplo de prueba anómalo.
encoded_data = autoencoder.encoder(anomalous_test_data).numpy()
decoded_data = autoencoder.decoder(encoded_data).numpy()

plt.plot(anomalous_test_data[0], 'b')
plt.plot(decoded_data[0], 'r')
plt.fill_between(np.arange(140), decoded_data[0], anomalous_test_data[0],
color='lightcoral')
plt.legend(labels=["Input", "Reconstruction", "Error"])
#plt.show()

#Trazar el error de reconstrucción en ECG normales del conjunto de entrenamiento


reconstructions = autoencoder.predict(normal_train_data)
train_loss = tf.keras.losses.mae(reconstructions, normal_train_data)

plt.hist(train_loss[None,:], bins=50)
plt.xlabel("Train loss")
plt.ylabel("No of examples")
#plt.show()

#Elija un valor de umbral que sea una desviación estándar por encima de la media.
threshold = np.mean(train_loss) + np.std(train_loss)
print("Threshold: ", threshold)

reconstructions = autoencoder.predict(anomalous_test_data)
test_loss = tf.keras.losses.mae(reconstructions, anomalous_test_data)

plt.hist(test_loss[None, :], bins=50)


plt.xlabel("Test loss")
plt.ylabel("No of examples")
#plt.show()

#Clasifique un ECG como una anomalía si el error de reconstrucción es mayor que el


umbral.

def predict(model, data, threshold):


reconstructions = model(data)
loss = tf.keras.losses.mae(reconstructions, data)
return tf.math.less(loss, threshold)

def print_stats(predictions, labels):


print("Accuracy = {}".format(accuracy_score(labels, predictions)))
print("Precision = {}".format(precision_score(labels, predictions)))
print("Recall = {}".format(recall_score(labels, predictions)))

preds = predict(autoencoder, test_data, threshold)

print_stats(np.array(preds), np.array(test_labels))

You might also like