import matplotlib.
pyplot as plt
import numpy as np
import pandas as pd
import tensorflow as tf
from [Link] import accuracy_score, precision_score, recall_score
from sklearn.model_selection import train_test_split
from [Link] import layers, losses
from [Link] import fashion_mnist
from [Link] import Model
#El conjunto de datos que utilizará se basa en uno de
[Link] .
# Download the dataset
import pandas as pd
dataframe = pd.read_csv('[Link]
data/[Link]', header=None)
raw_data = [Link]
[Link]()
# 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 = [Link](job ="localhost", replica = 0, device_type = "CPU")
train_data = [Link](train_data, tf.float32)
test_data = [Link](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.
[Link]()
[Link]([Link](140), normal_train_data[0])
[Link]("A Normal ECG")
#[Link]()
#Trazar un ECG anómalo
[Link]()
[Link]([Link](140), anomalous_train_data[0])
[Link]("An Anomalous ECG")
#[Link]()
#Construye el modelo
class AnomalyDetector(Model):
def __init__(self):
super(AnomalyDetector, self).__init__()
[Link] = [Link]([
[Link](32, activation="relu"),
[Link](16, activation="relu"),
[Link](8, activation="relu")])
[Link] = [Link]([
[Link](16, activation="relu"),
[Link](32, activation="relu"),
[Link](140, activation="sigmoid")])
def call(self, x):
encoded = [Link](x)
decoded = [Link](encoded)
return decoded
autoencoder = AnomalyDetector()
[Link](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 = [Link](normal_train_data, normal_train_data,
epochs=20,
batch_size=512,
validation_data=(test_data, test_data),
shuffle=True)
[Link]([Link]["loss"], label="Training Loss")
[Link]([Link]["val_loss"], label="Validation Loss")
[Link]()
#[Link]()
encoded_data = [Link](normal_test_data).numpy()
decoded_data = [Link](encoded_data).numpy()
[Link](normal_test_data[0], 'b')
[Link](decoded_data[0], 'r')
plt.fill_between([Link](140), decoded_data[0], normal_test_data[0],
color='lightcoral')
[Link](labels=["Input", "Reconstruction", "Error"])
#[Link]()
#Cree una trama similar, esta vez para un ejemplo de prueba anómalo.
encoded_data = [Link](anomalous_test_data).numpy()
decoded_data = [Link](encoded_data).numpy()
[Link](anomalous_test_data[0], 'b')
[Link](decoded_data[0], 'r')
plt.fill_between([Link](140), decoded_data[0], anomalous_test_data[0],
color='lightcoral')
[Link](labels=["Input", "Reconstruction", "Error"])
#[Link]()
#Trazar el error de reconstrucción en ECG normales del conjunto de entrenamiento
reconstructions = [Link](normal_train_data)
train_loss = [Link](reconstructions, normal_train_data)
[Link](train_loss[None,:], bins=50)
[Link]("Train loss")
[Link]("No of examples")
#[Link]()
#Elija un valor de umbral que sea una desviación estándar por encima de la media.
threshold = [Link](train_loss) + [Link](train_loss)
print("Threshold: ", threshold)
reconstructions = [Link](anomalous_test_data)
test_loss = [Link](reconstructions, anomalous_test_data)
[Link](test_loss[None, :], bins=50)
[Link]("Test loss")
[Link]("No of examples")
#[Link]()
#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 = [Link](reconstructions, data)
return [Link](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([Link](preds), [Link](test_labels))
