Upload 37 files

.gitattributes

@@ -32,3 +32,8 @@ saved_model/**/* filter=lfs diff=lfs merge=lfs -text
 *.zip filter=lfs diff=lfs merge=lfs -text
 *.zst filter=lfs diff=lfs merge=lfs -text
 *tfevents* filter=lfs diff=lfs merge=lfs -text
+models/antonior92/model_6.hdf5 filter=lfs diff=lfs merge=lfs -text
+models/antonior92/model.hdf5 filter=lfs diff=lfs merge=lfs -text
+models/Chapman/best.ptl filter=lfs diff=lfs merge=lfs -text
+models/CPSC-2018/best.ptl filter=lfs diff=lfs merge=lfs -text
+models/CPSC-2018/bestInt.ptl filter=lfs diff=lfs merge=lfs -text

configVars.py

@@ -0,0 +1,3 @@
+pathCasos = "./datasets/"
+pathModel = "./models/"
+pathThresholds = './thresholds/'

data.py

@@ -0,0 +1,45 @@
+
+import os, sys
+from libs import *
+
+class ECGDataset(torch.utils.data.Dataset):
+    def __init__(self, 
+        df_path, data_path, 
+        config, 
+        augment = False, 
+    ):
+        self.df_path, self.data_path,  = df_path, data_path, 
+        self.df = pandas.read_csv(self.df_path)
+
+        self.config = config
+        self.augment = augment
+
+    def __len__(self, 
+    ):
+        return len(self.df)
+
+    def __getitem__(self, 
+        index, 
+    ):
+        row = self.df.iloc[index]
+
+        # save np.load
+        np_load_old = np.load
+
+        # modify the default parameters of np.load
+        np.load = lambda *a,**k: np_load_old(*a, allow_pickle=True, **k)
+
+        # call load_data with allow_pickle implicitly set to true
+        ecg = np.load("{}/{}.npy".format(self.data_path, row["id"]))[self.config["ecg_leads"], :]
+
+        # restore np.load for future normal usage
+        np.load = np_load_old
+
+        ecg = pad_sequences(ecg, self.config["ecg_length"], "float64", 
+            "post", "post", 
+        )
+        if self.augment:
+            ecg = self.drop_lead(ecg)
+        ecg = torch.tensor(ecg).float()
+
+        return ecg

datasets/pred.csv

@@ -0,0 +1,2 @@
+id
+pred

datasets/pred.npy

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:f4ab872234216a14c7a700dfe7c871f9429eeb43a08eba464770d4dc9ce5cf2f
+size 508928

interface.py

@@ -0,0 +1,20 @@
+from libs import *
+from predicts import procesar_archivo
+import gradio as gr
+
+with gr.Blocks() as interface:
+    gr.Image(value='./ComplutenseTFGBanner.png',show_label=False)
+    with gr.Column():
+        format = gr.inputs.Dropdown(["XMLsierra","CSV"],default="XMLsierra",label= "Formato del archivo")   
+    with gr.Row():
+        number = gr.inputs.Slider(label="Valor",default=200,minimum=1,maximum=999)
+        unit = gr.inputs.Dropdown(["V","miliV","microV","nanoV"], label="Unidad",default="miliV")
+    with gr.Column():
+        frec = gr.inputs.Number(label= "Frecuencia (Hz)",default=500)
+        file = gr.inputs.File(label="Selecciona un archivo.")
+        button = gr.Button(value='Analizar')
+        out = gr.DataFrame(label="Diagnostico automático.",type="pandas",headers = ['Red','Predicción'])
+        img = gr.outputs.Image(label="Imagen",type='filepath')
+    button.click(fn=procesar_archivo,inputs=[format,number,unit,frec,file] ,outputs=[out,img])
+    
+interface.launch(share = True)

libs.py

@@ -0,0 +1,31 @@
+import os, sys
+import warnings; warnings.filterwarnings("ignore")
+
+
+import pandas, numpy as np
+import pandas as pd
+import gradio as gr
+#import argparse
+#import random
+#import neurokit2 as nk
+import torch
+import torch.nn as nn, torch.optim as optim
+import torch.nn.functional as F
+import torch.nn.utils.prune as prune
+#import captum.attr as attr
+#import matplotlib.pyplot as pyplot
+#from sklearn.metrics import f1_score
+from tensorflow.keras.models import load_model
+from tensorflow.keras.optimizers import Adam
+from tensorflow.keras.preprocessing.sequence import pad_sequences
+import h5py
+import scipy.signal as sgn
+from sierraecg import read_file
+import ecg_plot
+
+
+#!pip install pandas 
+#!pip install torch 
+#!pip install gradio
+#!pip install tesorflow 
+#!pip install sierraecg 

models/CPSC-2018/best.ptl

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:41ce4ff6c2b17ec41b03f22eb8c303b14f965b0db2462cba57abf5de5cedca1a
+size 21740080

models/CPSC-2018/bestInt.ptl

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:41ce4ff6c2b17ec41b03f22eb8c303b14f965b0db2462cba57abf5de5cedca1a
+size 21740080

models/Chapman/best.ptl

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:0b5b27cf250cad4b1c872722ffdb75896b6efbb0c22f57abd6283d8a33bb8172
+size 21729840

models/antonior92/model.hdf5

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:93232c0dcecf2ac62cfa17758b86beb6bbf1fff36a4fb228f383b03af181a661
+size 25826560

models/antonior92/model_6.hdf5

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:93232c0dcecf2ac62cfa17758b86beb6bbf1fff36a4fb228f383b03af181a661
+size 25826560

nets/backbones.py

@@ -0,0 +1,57 @@
+
+import os, sys
+from libs import *
+from .layers import *
+from .modules import *
+from .bblocks import *
+
+class LightSEResNet18(nn.Module):
+    def __init__(self, 
+        base_channels = 64, 
+    ):
+        super(LightSEResNet18, self).__init__()
+        self.bblock = LightSEResBlock
+        self.stem = nn.Sequential(
+            nn.Conv1d(
+                1, base_channels, 
+                kernel_size = 15, padding = 7, stride = 2, 
+            ), 
+            nn.BatchNorm1d(base_channels), 
+            nn.ReLU(), 
+            nn.MaxPool1d(
+                kernel_size = 3, padding = 1, stride = 2, 
+            ), 
+        )
+        self.stage_0 = nn.Sequential(
+            self.bblock(base_channels), 
+            self.bblock(base_channels), 
+        )
+
+        self.stage_1 = nn.Sequential(
+            self.bblock(base_channels*1, downsample = True), 
+            self.bblock(base_channels*2), 
+        )
+        self.stage_2 = nn.Sequential(
+            self.bblock(base_channels*2, downsample = True), 
+            self.bblock(base_channels*4), 
+        )
+        self.stage_3 = nn.Sequential(
+            self.bblock(base_channels*4, downsample = True), 
+            self.bblock(base_channels*8), 
+        )
+
+        self.pool = nn.AdaptiveAvgPool1d(1)
+
+    def forward(self, 
+        input, 
+    ):
+        output = self.stem(input)
+        output = self.stage_0(output)
+
+        output = self.stage_1(output)
+        output = self.stage_2(output)
+        output = self.stage_3(output)
+
+        output = self.pool(output)
+
+        return output

nets/bblocks.py

@@ -0,0 +1,55 @@
+
+import os, sys
+from libs import *
+from .layers import *
+from .modules import *
+
+class LightSEResBlock(nn.Module):
+    def __init__(self, 
+        in_channels, 
+        downsample = False, 
+    ):
+        super(LightSEResBlock, self).__init__()
+        if downsample:
+            self.out_channels = in_channels*2
+            self.conv_1 = DSConv1d(
+                in_channels, self.out_channels, 
+                kernel_size = 7, padding = 3, stride = 2, 
+            )
+            self.identity = nn.Sequential(
+                DSConv1d(
+                    in_channels, self.out_channels, 
+                    kernel_size = 1, padding = 0, stride = 2, 
+                ), 
+                nn.BatchNorm1d(self.out_channels), 
+            )
+        else:
+            self.out_channels = in_channels
+            self.conv_1 = DSConv1d(
+                in_channels, self.out_channels, 
+                kernel_size = 7, padding = 3, stride = 1, 
+            )
+            self.identity = nn.Identity()
+        self.conv_2 = DSConv1d(
+            self.out_channels, self.out_channels, 
+            kernel_size = 7, padding = 3, stride = 1, 
+        )
+
+        self.convs = nn.Sequential(
+            self.conv_1, 
+            nn.BatchNorm1d(self.out_channels), 
+            nn.ReLU(), 
+            nn.Dropout(0.3), 
+            self.conv_2, 
+            nn.BatchNorm1d(self.out_channels), 
+            LightSEModule(self.out_channels), 
+        )
+        self.act_fn = nn.ReLU()
+
+    def forward(self, 
+        input, 
+    ):
+        output = self.convs(input) + self.identity(input)
+        output = self.act_fn(output)
+
+        return output

nets/layers.py

@@ -0,0 +1,29 @@
+
+import os, sys
+from libs import *
+
+class DSConv1d(nn.Module):
+    def __init__(self, 
+        in_channels, out_channels, 
+        kernel_size, padding = 0, stride = 1, 
+    ):
+        super(DSConv1d, self).__init__()
+        self.dw_conv = nn.Conv1d(
+            in_channels, in_channels, 
+            kernel_size = kernel_size, padding = padding, stride = stride, 
+            groups = in_channels, 
+            bias = False, 
+        )
+        self.pw_conv = nn.Conv1d(
+            in_channels, out_channels, 
+            kernel_size = 1, 
+            bias = False, 
+        )
+
+    def forward(self, 
+        input, 
+    ):
+        output = self.dw_conv(input)
+        output = self.pw_conv(output)
+
+        return output

nets/modules.py

@@ -0,0 +1,33 @@
+
+import os, sys
+from libs import *
+from .layers import *
+
+class LightSEModule(nn.Module):
+    def __init__(self, 
+        in_channels, 
+        reduction = 16, 
+    ):
+        super(LightSEModule, self).__init__()
+        self.pool = nn.AdaptiveAvgPool1d(1)
+
+        self.s_conv = DSConv1d(
+            in_channels, in_channels//reduction, 
+            kernel_size = 1, 
+        )
+        self.act_fn = nn.ReLU()
+        self.e_conv = DSConv1d(
+            in_channels//reduction, in_channels, 
+            kernel_size = 1, 
+        )
+
+    def forward(self, 
+        input, 
+    ):
+        attention_scores = self.pool(input)
+
+        attention_scores = self.s_conv(attention_scores)
+        attention_scores = self.act_fn(attention_scores)
+        attention_scores = self.e_conv(attention_scores)
+
+        return input*torch.sigmoid(attention_scores)

nets/nets.py

@@ -0,0 +1,73 @@
+
+import os, sys
+from libs import *
+from .layers import *
+from .modules import *
+from .bblocks import *
+from .backbones import *
+
+class LightX3ECG(nn.Module):
+    def __init__(self, 
+        base_channels = 64, 
+        num_classes = 1, 
+    ):
+        super(LightX3ECG, self).__init__()
+        self.backbone_0 = LightSEResNet18(base_channels)
+        self.backbone_1 = LightSEResNet18(base_channels)
+        self.backbone_2 = LightSEResNet18(base_channels)
+        self.lw_attention = nn.Sequential(
+            nn.Linear(
+                base_channels*24, base_channels*8, 
+            ), 
+            nn.BatchNorm1d(base_channels*8), 
+            nn.ReLU(), 
+            nn.Dropout(0.3), 
+            nn.Linear(
+                base_channels*8, 3, 
+            ), 
+        )
+
+        self.classifier = nn.Sequential(
+            nn.Dropout(0.2), 
+            nn.Linear(
+                base_channels*8, num_classes, 
+            ), 
+        )
+
+    def forward(self, 
+        input, 
+        return_attention_scores = False, 
+    ):
+        features_0 = self.backbone_0(input[:, 0, :].unsqueeze(1)).squeeze(2)
+        features_1 = self.backbone_1(input[:, 1, :].unsqueeze(1)).squeeze(2)
+        features_2 = self.backbone_2(input[:, 2, :].unsqueeze(1)).squeeze(2)
+        attention_scores = torch.sigmoid(
+            self.lw_attention(
+                torch.cat(
+                [
+                    features_0, 
+                    features_1, 
+                    features_2, 
+                ], 
+                dim = 1, 
+                )
+            )
+        )
+        merged_features = torch.sum(
+            torch.stack(
+            [
+                features_0, 
+                features_1, 
+                features_2, 
+            ], 
+            dim = 1, 
+            )*attention_scores.unsqueeze(-1), 
+            dim = 1, 
+        )
+
+        output = self.classifier(merged_features)
+
+        if not return_attention_scores:
+            return output
+        else:
+            return output, attention_scores

predicts.py

@@ -0,0 +1,118 @@
+from libs import *
+import configVars
+from tools import tools
+from data import ECGDataset
+
+def procesar_archivo(format,number,unit,frec,file):
+    try:
+        prepare_data(format,number,unit,frec,file)
+        antonior92 = predict_antonior92()
+        CPSC = predict_CPSC_2018()
+        Chapman = predict_Chapman()
+        result = pd.DataFrame(data = [['Antonior92',antonior92],['CPSC-2018',CPSC],['Chapman',Chapman]],columns=['Red','Predicción'])
+        tools.ecgPlot("./datasets/pred.npy",500)
+        return result, "ecg.png"
+    except:
+        return pd.DataFrame(data = ["Se ha producido un error inesperado.","Compruebe que los datos de entrada sean correctos"],columns = ["ERROR."]), "error.jpg"
+
+
+def predict_CPSC_2018():
+    config = {
+    "ecg_leads":[
+        0, 1, 
+        6, 
+    ], 
+    "ecg_length":5000, 
+    "is_multilabel":True, 
+    }
+
+    train_loaders = {
+        "pred":torch.utils.data.DataLoader(
+            ECGDataset(
+                df_path = f"{configVars.pathCasos}pred.csv", data_path = f"{configVars.pathCasos}",
+                config = config, 
+                augment = False, 
+            ), 
+            timeout=0
+        )
+    }
+    save_ckp_dir = f"{configVars.pathModel}CPSC-2018"
+
+    pred = tools.LightX3ECG(
+                train_loaders, 
+                config,
+                save_ckp_dir, 
+                )
+    return pred if len(pred) != 0 else ['El archivo introducido no satisface ninguno de los criterios de clasificación']
+
+def predict_Chapman():
+    config = {
+    "ecg_leads":[
+        0, 1, 
+        6, 
+    ], 
+    "ecg_length":5000, 
+    "is_multilabel":False, 
+    }
+
+    train_loaders = {
+        "pred":torch.utils.data.DataLoader(
+            ECGDataset(
+                df_path = f"{configVars.pathCasos}pred.csv", data_path = f"{configVars.pathCasos}",
+                config = config, 
+                augment = False, 
+            ), 
+            timeout=0
+        )
+    }
+    save_ckp_dir = f"{configVars.pathModel}Chapman"
+
+    pred = tools.LightX3ECG(
+                train_loaders, 
+                config,
+                save_ckp_dir, 
+                )
+    return pred
+
+def predict_antonior92():
+    f = h5py.File(f"{configVars.pathCasos}pred.hdf5", 'r')
+    model = load_model(f"{configVars.pathModel}/antonior92/model.hdf5", compile=False)
+    model.compile(loss='binary_crossentropy', optimizer=Adam())
+    pred = model.predict(f['tracings'],  verbose=0)
+    optimal_thresholds = pd.read_csv(f"{configVars.pathThresholds}antonior92/optimal_thresholds_best.csv")
+    result = optimal_thresholds[optimal_thresholds["Threshold"]<=pred[0]]
+    result = result['Pred'].values.tolist()
+    f.close()
+    
+    return result if len(result) != 0 else ['Normal']
+
+def prepare_data(format,number,unit,frec,file):
+    units = {
+        'V':0.001,
+        'miliV':1,
+        'microV':1000,
+        'nanoV':1000000
+    }
+    if(format == 'XMLsierra'):
+        f = read_file(file.name)
+        df = pd.DataFrame()
+        for lead in f.leads:
+            df[lead.label]=lead.samples
+        data = df
+    elif(format == 'CSV'):
+        data = pd.read_csv(file.name,header = None)
+        
+    data = data[:-200]
+    data = data.T
+    leads = len(data)
+    frec = frec if frec>0 else 1
+    scale = 1/(number*units[unit])
+    ecg_preprocessed = tools.preprocess_ecg(data, frec, leads,
+                                            scale=scale,######### modificar para que segun la unidad introducida se pueda convertir los datos
+                                            use_all_leads=True,
+                                            remove_baseline=True)
+    tools.generateH5(ecg_preprocessed,
+             "pred.hdf5",new_freq=400,new_len=4096,
+             scale=2,sample_rate = frec)
+
+    np.save(f"{configVars.pathCasos}pred.npy",ecg_preprocessed )

thresholds/CPSC-2018/optimal_thresholds_best.csv

@@ -0,0 +1,10 @@
+Pred,Threshold
+Normal,0.6
+AF,0.8
+I-AVB,0.5
+LBBB,0.15
+RBBB,0.5
+PAC,0.4
+PVC,0.5
+STD,0.55
+STE,0.2

thresholds/antonior92/optimal_thresholds_best.csv

@@ -0,0 +1,7 @@
+Pred,Threshold
+I-AVB,0.124
+RBBB,0.07
+LBBB,0.05
+SB,0.278
+AF,0.390
+ST,0.174

tools/tools.py

@@ -0,0 +1,124 @@
+from libs import *
+import configVars
+import ecg_plot
+def remove_baseline_filter(sample_rate):
+    fc = 0.8  # [Hz], cutoff frequency
+    fst = 0.2  # [Hz], rejection band
+    rp = 0.5  # [dB], ripple in passband
+    rs = 40  # [dB], attenuation in rejection band
+    wn = fc / (sample_rate / 2)
+    wst = fst / (sample_rate / 2)
+
+    filterorder, aux = sgn.ellipord(wn, wst, rp, rs)
+    sos = sgn.iirfilter(filterorder, wn, rp, rs, btype='high', ftype='ellip', output='sos')
+
+    return sos
+
+reduced_leads = ['DI', 'DII', 'V1', 'V2', 'V3', 'V4', 'V5', 'V6']
+all_leads = ['DI', 'DII', 'DIII', 'AVR', 'AVL', 'AVF', 'V1', 'V2', 'V3', 'V4', 'V5', 'V6']
+
+def preprocess_ecg(ecg, sample_rate, leads, scale=1,
+                   use_all_leads=True, remove_baseline=False):
+    # Remove baseline
+    if remove_baseline:
+        sos = remove_baseline_filter(sample_rate)
+        ecg_nobaseline = sgn.sosfiltfilt(sos, ecg, padtype='constant', axis=-1)
+    else:
+        ecg_nobaseline = ecg
+
+    # Rescale
+    ecg_rescaled = scale * ecg_nobaseline
+    
+     # Resample
+    if sample_rate != 500:
+        ecg_resampled = sgn.resample_poly(ecg_rescaled, up=500, down=sample_rate, axis=-1)
+    else:
+        ecg_resampled = ecg_rescaled
+    length = len(ecg_resampled[0])
+    
+    # Add leads if needed
+    target_leads = all_leads if use_all_leads else reduced_leads
+    n_leads_target = len(target_leads)
+    l2p = dict(zip(target_leads, range(n_leads_target)))
+    ecg_targetleads = np.zeros([n_leads_target, length])
+    ecg_targetleads = ecg_rescaled
+    if n_leads_target >= leads and use_all_leads:
+        ecg_targetleads[l2p['DIII'], :] = ecg_targetleads[l2p['DII'], :] - ecg_targetleads[l2p['DI'], :]
+        ecg_targetleads[l2p['AVR'], :] = -(ecg_targetleads[l2p['DI'], :] + ecg_targetleads[l2p['DII'], :]) / 2
+        ecg_targetleads[l2p['AVL'], :] = (ecg_targetleads[l2p['DI'], :] - ecg_targetleads[l2p['DIII'], :]) / 2
+        ecg_targetleads[l2p['AVF'], :] = (ecg_targetleads[l2p['DII'], :] + ecg_targetleads[l2p['DIII'], :]) / 2
+
+    return ecg_targetleads
+
+
+def generateH5(input_file,out_file,new_freq=None,new_len=None,scale=1,sample_rate=None):
+    n = len(input_file)  # Get length
+    try:
+      h5f = h5py.File(f"{configVars.pathCasos}{out_file}", 'r+')
+      h5f.clear()
+    except:
+      h5f = h5py.File(f"{configVars.pathCasos}{out_file}", 'w')
+
+    # Resample
+    if new_freq is not None:
+        ecg_resampled = sgn.resample_poly(input_file, up=new_freq, down=sample_rate, axis=-1)
+    else:
+        ecg_resampled = input_file
+        new_freq = sample_rate
+    n_leads, length = ecg_resampled.shape
+    
+    # Rescale
+    ecg_rescaled = scale * ecg_resampled
+    
+    # Reshape
+    if new_len is None or new_len == length:
+        ecg_reshaped = ecg_rescaled
+    elif new_len > length:
+        ecg_reshaped = np.zeros([n_leads, new_len])
+        pad = (new_len - length) // 2
+        ecg_reshaped[..., pad:length+pad] = ecg_rescaled
+    else:
+        extra = (length - new_len) // 2
+        ecg_reshaped = ecg_rescaled[:, extra:new_len + extra]
+    
+    n_leads, n_samples = ecg_reshaped.shape
+    x = h5f.create_dataset('tracings', (1, n_samples, n_leads), dtype='f8')
+    x[0, :, :] = ecg_reshaped.T
+    h5f.close()
+    
+def LightX3ECG(
+    train_loaders, 
+    config,
+    save_ckp_dir, 
+):
+    model = torch.load(f"{save_ckp_dir}/best.ptl", map_location='cpu')
+    #model = torch.load(f"{save_ckp_dir}/best.ptl", map_location = "cuda")
+    model.to(torch.device('cpu'))
+    with torch.no_grad():
+        model.eval()
+        running_preds = []
+    
+        for ecgs in train_loaders["pred"]:  
+            ecgs = ecgs.cpu()
+            logits = model(ecgs)
+            preds = list(torch.max(logits, 1)[1].detach().cpu().numpy()) if not config["is_multilabel"] else list(torch.sigmoid(logits).detach().cpu().numpy())
+            running_preds.extend(preds)
+    
+    if config["is_multilabel"]:
+        running_preds =  np.array(running_preds)
+        optimal_thresholds = pd.read_csv(f"{configVars.pathThresholds}CPSC-2018/optimal_thresholds_best.csv")
+        preds = optimal_thresholds[optimal_thresholds["Threshold"]<=running_preds[0]]
+        preds = preds['Pred'].values.tolist()
+    else:   
+        enfermedades = ['AFIB','GSVT','SB','SR']
+        running_preds =  np.array(running_preds)
+        #running_preds=np.reshape(running_preds, (len(running_preds),-1))
+        preds = enfermedades[running_preds[0]]
+    return preds
+
+def ecgPlot(source,sample):
+    data = np.load(source)
+    #print(data)
+    xml_leads = ['DI', 'DII', 'DIII', 'AVR', 'AVL', 'AVF', 'V1', 'V2', 'V3', 'V4', 'V5', 'V6']
+    ecg_plot.plot_12(data, sample_rate= sample,lead_index=xml_leads, title="Muestra")
+    ecg_plot.save_as_png("ecg")