mimic3-benchmarks-irit.py

import csv
import os
import datasets
import numpy as np
from datetime import datetime
import pandas as pd
from datasets import IterableDataset
from scipy.stats import skew
import sys
import pickle
from sklearn.preprocessing import LabelEncoder

DATASET_SAVE_PATH = os.path.join(os.path.expanduser('~'),"mimic3_dataset")
os.makedirs(DATASET_SAVE_PATH,exist_ok=True)

np.set_printoptions(threshold=sys.maxsize)
np.set_printoptions(suppress=True)
###################################
# SOME UTILS                      #
###################################

def get_progression(current,total,length=20,filled_str="=",empty_str="-"):
    nb = round(length*current/total)
    return "["+(nb*filled_str)+((length-nb)*empty_str)+"]"

def is_empty_value(value,empty_value):
    """
        Returns if value is an empty value (for exemple np.nan if empty_value is np.nan)
        value must not be a list
    """
    return (isinstance(value,float) and np.isnan(empty_value) and np.isnan(value)) or ((type(value) != list) and (value == empty_value))

def is_empty_list(l,empty_value):
    """
        Returns if list is filled only with empty values (for exemple empty_value==np.nan and empty_value==[np.nan,np.nan])
        value must be a list
    """
    if isinstance(l,float) or isinstance(l,str) or isinstance(l,int):
        return False
    for elem in l:
        if not is_empty_value(elem,empty_value):
            return False
    return True

def dtc(x):
    """
        string to datetime
    """
    return datetime.strptime(x, '%Y-%m-%d %H:%M:%S')

def bic(x):
    """
        string to int
    """
    try:
        return (-1 if x == "" else int(x))
    except:
        print("error",x)
        return -1
def bfc(x):
    """
        string to float
    """
    try:
        return (-1 if x == "" else float(x))
    except:
        print("error",x)
        return -1
    
def id_to_string(id):
    """
        id (string or float) to float
    """
    if (isinstance(id,float) and np.isnan(id)) or not id or id == "":
        return id
    try:
        return str(int(float(id)))
    except:
        return str(id)


################################################################################
################################################################################
##                                                                            ##
##                          DATASET TO NUMPY ARRAY                            ##
##                                                                            ##
################################################################################
################################################################################

###################################
# ABOUT DATA NORMALIZATION        #
###################################

def calculate_normalization(iterator):
    """
        calculates means and stds over every columns of every episode given by iterator\n
    """
    nb = 0
    sum_x = None
    sum_x_sq = None

    #feeding data
    for batch in iterator:
        x = np.array(batch[0])
        nb += x.shape[0]*x.shape[1]
        if sum_x is None:
            sum_x = np.sum(x, axis=(0,1))
            sum_x_sq = np.sum(x**2, axis=(0,1))
        else:
            sum_x += np.sum(x, axis=(0,1))
            sum_x_sq += np.sum(x**2, axis=(0,1))

    #Computing mean
    means = (1.0 / nb) * sum_x
    eps = 1e-7

    #Computing stds
    stds = np.sqrt((1.0/(nb - 1)) * (sum_x_sq - (2.0 * sum_x * means) + (nb * means**2)))
    stds[stds < eps] = eps

    return means,stds

def normalize(X, means, stds, columns=[]):
    """
        normalizes X with means and stds. Columns is the list of columns you want to normalize. if no columns given everything is normalized\n
    """
    ret = 1.0 * X
    if len(columns) > 0:
        for col in columns:
            ret[:,:,col] = (X[:,:,col] - means[col]) / stds[col]
    else:
        for col in range(X.shape[2]):
            ret[:,:,col] = (X[:,:,col] - means[col]) / stds[col]
    return ret

def try_load_normalizer(path, nb_columns):
    """
        Tries to load means and stds from saved file.\n
        If files (path) doesn't exist returns empty means and stds lists
        nb_columns is the number of columns in the dataset (not the number of columns you load)
    """
    means,stds = np.zeros(nb_columns),np.ones(nb_columns)

    if not os.path.isfile(path):
        return [],[]

    with open(path, newline='') as csvfile:
        spamreader = csv.DictReader(csvfile, delimiter=',')
        for row in spamreader:
            means[int(row["column"])] = float(row["mean"])
            stds[int(row["column"])] = float(row["std"])

    return means,stds



###################################
# THE DICTIONARIES / CONSTANTS    #
###################################


#The default values for some columns
normal_values = {
        "Capillary refill rate": 0.0,
        "Diastolic blood pressure": 59.0,
        "Fraction inspired oxygen": 0.21,
        "Glascow coma scale eye opening": "4 Spontaneously",
        "Glascow coma scale motor response": "6 Obeys Commands",
        "Glascow coma scale total": "15.0",
        "Glascow coma scale verbal response": "5 Oriented",
        "Glucose": 128.0,
        "Heart Rate": 86,
        "Height": 170.0,
        "Mean blood pressure": 77.0,
        "Oxygen saturation": 98.0,
        "Respiratory rate": 19,
        "Systolic blood pressure": 118.0,
        "Temperature": 36.6,
        "Weight": 81.0,
        "pH": 7.4
    }

#Dictionary to transform some string values in columns to integers or indexes
discretizer = {
    "Glascow coma scale eye opening": [
      (["None"],0),
      (["1 No Response"],1),
      (["2 To pain","To Pain"],2),
      (["3 To speech","To Speech"],3),
      (["4 Spontaneously","Spontaneously"],4),
      
    ],
    "Glascow coma scale motor response": [
      (["1 No Response","No response"],1),
      (["2 Abnorm extensn","Abnormal extension"],2),
      (["3 Abnorm flexion","Abnormal Flexion"],3),
      (["4 Flex-withdraws","Flex-withdraws"],4),
      (["5 Localizes Pain","Localizes Pain"],5),
      (["6 Obeys Commands","Obeys Commands"],6),
    ],
    "Glascow coma scale total": [
      (["3.0"],3),
      (["4.0"],4),
      (["5.0"],5),
      (["6.0"],6),
      (["7.0"],7),
      (["8.0"],8),
      (["9.0"],9),
      (["10.0"],10),
      (["11.0"],11),
      (["12.0"],12),
      (["13.0"],13),
      (["14.0"],14),
      (["15.0"],15),
    ],
    "Glascow coma scale verbal response": [
      (["1 No Response","No Response-ETT","1.0 ET/Trach","No Response"],1),
      (["2 Incomp sounds","Incomprehensible sounds"],2),
      (["3 Inapprop words","Inappropriate Words"],3),
      (["4 Confused","Confused"],4),
      (["5 Oriented","Oriented"],5),
      ]
    }

#The loaded files dictionaries
itemiddict = {}


######################################################################
#        NORMALIZATION TYPE "WINDOW" WITH AMOUNT/RATE PROBLEM        #
######################################################################

def normalize_onehot_episodes_window(row, code_column="", value_column=False, period_length=48.0, window_size=1e-1):
    """
        returns a dict which keys are the items of code_column, and values lists representing the sliding window over period_length of size window_size
        made for hot encodings
    """
    
    N_bins = int(period_length / window_size + 1.0 - 0.000001)

    returned_rates = {}

    for idx,starttime in enumerate(row["STARTTIME"]):

        if not pd.isnull(row["ENDTIME"][idx]) and row["ENDTIME"][idx] != None and row["ENDTIME"][idx] != "":
            endtime = row["ENDTIME"][idx]
            isRate = True
        else:
            endtime = starttime
            isRate = False
        code = row[code_column][idx]
        if code == "" or (isinstance(code,float) and np.isnan(code)) or pd.isnull(code):
            continue

        first_bin_id = int(starttime / window_size - 0.000001)
        last_bin_id = min(N_bins-1,int(endtime / window_size - 0.000001))

        val = 1
        if value_column:
            val = row["RATE"][idx]*60 if isRate else row["AMOUNT"][idx]*60
        
        #If code not in dict we add an array of size N_bins containing zeros
        if not code in returned_rates:
            returned_rates[code] = [0]*N_bins

        #We add the current value to the good timestamp in the rates array
        for bin_id in range(first_bin_id,last_bin_id+1):
            returned_rates[code][bin_id] += val
        
    return returned_rates


#######################################
# NORMALIZATION TYPE "WINDOW"         #
#######################################

def normalize_episodes_window(row, period_length=48.0, window_size=1e-1):
    """
        returns a window for the first period_length hours with window_size hours
        values in the dict "row" must not be lists
    """

    #Getting types in every columns
    types = {}
    for e in row["episode"]:
        if isinstance(row["episode"][e][0],float):
            types[e] = float
        else:
            types[e] = str


    episode = {}

    #Number of rows
    N_bins = int(period_length / window_size + 1.0 - 0.000001)

    #Building every column with empty values
    for e in row["episode"]:
        if e != "Hours":
            episode[e] = [np.nan]*N_bins

    #Filling with avaible data in the episode
    for idx,time in enumerate(row["episode"]["Hours"]):

        #Calculating row of the current data
        bin_id = int(time / window_size - 0.000001)

        #Filling for every column
        for col in episode:

            v = row["episode"][col][idx]

            #If data is not empty we add it
            if v != "" and not (isinstance(v,float) and np.isnan(v)) and not v == None:
                episode[col][bin_id] = v

    return episode

#######################################
# NORMALIZATION TYPE "STATISTICS"     #
#######################################

def normalize_episodes_statistics(row, column_scale=True,windows = [(0,1),(0,0.10),(0,0.25),(0,0.50),(0.90,1),(0.75,1),(0.50,1)],functions = [(min,"min"), (max,"max"), (np.mean,"mean"), (np.std,"std"), (skew,"skew"), (len,"len")]):
    """
        Doing statistics over episode (row["episode"]) and returning array of it
        windows is an array containing all the periods to do statistics on (tuples of percentages, ex: (0.5,0.6) means "between 50% and 60% of the episode")\n
        functions are the functions to apply to compute statistics\n
        column_scale=True means we calculate the percentages between first and last value for every column. False means we calculate the pourcentages between first and last hours in episode.
    """
    episode = row["episode"]
    
    returned_episode = {x:[] for _,x in functions}

    #First and last hour (we will keep it if column_scale=False)
    L = row["episode"]["Hours"][0]
    R = row["episode"]["Hours"][-1]
    length = R - L

    #For every column in episode
    for e in episode:

        #If column_scale we find first and last hour that has value (!= np.nan)
        if column_scale:
            Li = 0
            Ri = len(row["episode"]["Hours"])-1
            while Li < len(row["episode"]["Hours"])-1 and (np.isnan(row["episode"][e][Li]) or row["episode"][e][Li] == ""):
                Li += 1
            while Ri >= 0 and (np.isnan(row["episode"][e][Ri]) or row["episode"][e][Ri] == ""):
                Ri -= 1
            if Ri < 0 or Li >= len(row["episode"]["Hours"]):
                Li,Ri = 0,0
            L = row["episode"]["Hours"][Li]
            R = row["episode"]["Hours"][Ri]
            length = R - L

        #We ignore Hour column
        if e == "Hours":
            continue

        #For every statistics windows
        for window in windows:
            #We calculate first and last hour for current column
            start_index,end_index = window
            start_index,end_index = L + start_index*length,L + end_index*length
            onepiece = []
            #For every value in the column, if is on the window we add it to statistics
            for i,x in enumerate(row["episode"][e]):
                if not np.isnan(x) and end_index+1e-6 > row["episode"]["Hours"][i] > start_index-1e-6:
                    onepiece.append(x)
            #If there are no values to do statistics on, we return array of np.nan
            if len(onepiece) == 0:
                for function,fname in functions:
                    returned_episode[fname].append(np.nan)
            #else we compute every functions on the list
            else:
                for function,fname in functions:
                    returned_episode[fname].append(function(onepiece))
    return returned_episode


#######################################
# SINGLE VALUE TRANSFORMATION         #
#######################################


def convert_CODE_to_onehot(itemid, d_path, field):
    """
    returns a oneshot encoding for item of itemid
    the dict is found in (d_path)
    the fields the itemid are in the dict are in columns field
    """

    global itemiddict

    #If itemiddict doesn't contain the field we load id
    if not field in itemiddict:
        itemiddict[field] = pd.DataFrame()
        for e in d_path:
            itemiddict[field] = pd.concat([itemiddict[field],pd.read_csv(e,converters={field:lambda x:str(x)})],ignore_index=True)
        itemiddict[field] = itemiddict[field].sort_values(by=field,ignore_index=True).reset_index(drop=True)

    #We build the oneshot encoding of size of the field column
    length = len(itemiddict[field].index)
    one_hot = np.zeros((length))

    #Filling the onehot encoding
    if itemid != "" and itemid != 0:
        idx = itemiddict[field][field].searchsorted(str(itemid))
        if idx > 0:
            one_hot[idx-1] = 1

    
    return one_hot

def codes_to_onehot(episode):
    """
    returns the episode with every not float value as onehot encodings
    """
    episode = episode.copy()

    #For every column in the episode
    for e in episode:

        #If the column is in the local discretizer
        if e in discretizer:

            #Computing size of the onehot encoding
            size = 0
            for die in discretizer[e]:
                size += len(die[0])

            #for every value in the column
            for i in range(len(episode[e])):

                v = episode[e][i]

                #If the value we are transforming means something
                if (not isinstance(v,float) or not np.isnan(v)) and v != "" and v != 0:

                    #Transforming the value to onehot encoding
                    episode[e][i] = np.zeros(size,dtype=int)
                    index = 0

                    #Finding the index in the onehot encoding to put 1
                    for die in discretizer[e]:
                        for item in die[0]:
                            if str(v) == item:
                                episode[e][i][index] = 1
                            index += 1

                #If the value is empty returns a full 0 array
                else:
                    episode[e][i] = np.full(size,fill_value=np.nan)

        #Special column that may contain floats but must be converted to onehot encoding
        elif e == "Capillary refill rate":
            for i in range(len(episode[e])):
                v = episode[e][i]
                episode[e][i] = np.zeros(2,dtype=int)
                if v != "" and float(v) == 1:
                    episode[e][i][1] = 1
                elif v != "" and float(v) == 0:
                    episode[e][i][0] = 1
    
    return episode

def convert_CODE_to_int(itemid, d_path, field):
    """
    returns an int encoding for item of itemid
    the dict is found in (d_path)
    the fields the itemid are in the dict are in columns field
    """
    global itemiddict

    #If the field is not avaible in local, we load it from d_path
    if not field in itemiddict:
        itemiddict[field] = pd.DataFrame()
        for e in d_path:
            itemiddict[field] = pd.concat([itemiddict[field],pd.read_csv(e,converters={field:lambda x:str(x)})],ignore_index=True)
        itemiddict[field] = itemiddict[field].sort_values(by=field,ignore_index=True).reset_index(drop=True)
    
    #If the itemid is avaible we return the associated value we find
    if itemid != "" and itemid != 0:
        idx = itemiddict[field][field].searchsorted(str(itemid))
        if idx > 0:
            return idx-1
    return np.nan

def codes_to_int(episode):
    """
    returns the episode with every not float value as int encodings
    """

    episode = episode.copy()

    #For every column in episode
    for e in episode:

        #If the column is avaible in local discretizer
        if e in discretizer:

            #For every value in the column
            for i in range(len(episode[e])):

                v = episode[e][i]

                #If the current value is not None or NaN, we find the encoding
                if not isinstance(v,float) or not np.isnan(v):

                    #If the value is not empty or 0 we find in the encoder
                    if v != "" and v != 0:
                        value = np.nan
                        for die in discretizer[e]:
                            if str(v) in die[0]:
                                value = die[1]
                        episode[e][i] = value
                    
                    #Else we said it's not found
                    else:
                        episode[e][i] = np.nan
        
    return episode



#######################################
# FULL EPISODE TRANSFORM UTILS        #
#######################################

def convert_to_numpy_arrays(episode, empty_value=np.nan):
    """
    returns the episode as numpy array of shape (row_number,features_width(=features are the keys in episode, can contain arrays,list or values))
    """

    #Computing features length
    features_width = 0
    row_number = 0
    for e in episode["episode"]:
        x = episode["episode"][e][0]
        if isinstance(x,int) or isinstance(x,float) or x == "":
            features_width += 1
        else:
            features_width += len(x)
        row_number = len(episode["episode"][e])
    
    #Computing y_true length
    y_length = 0
    for e in episode:
        if e != "episode":
            y_length += 1

    #Computing y_true
    y_true = np.empty(y_length)
    index = 0
    for e in episode:
        if e != "episode":
            y_true[index] = episode[e]
            index+=1

    #Computing features
    features = np.empty((row_number,features_width))
    index = 0

    #For every column in episode
    for e in episode["episode"]:

        #For every row in the column
        for line,x in enumerate(episode["episode"][e]):

            #If the value is empty, we fill with empty_value
            if (isinstance(x,float) and np.isnan(x)) or x == "":
                features[line,index] = empty_value

            #Else we fill the array with the numeric value
            elif isinstance(x,int) or isinstance(x,float):
                features[line,index] = x

            #Else (is array or list)
            else:
                is_empty_array = True

                #We check if the array contains only np.nan (is empty)
                for elem in x:
                    if not is_empty_value(elem,np.nan):
                        is_empty_array = False
                        break

                #If the array is not empty, if we copy the value of it in the right place in the returned array
                if not is_empty_array:
                    features[line,index:index+len(x)] = x

                #Else we fill the part of the returned array with empty_value so user knows the data is missing here
                else:
                    features[line,index:index+len(x)] = np.full(len(x),empty_value)

        #checking the number of elements we added in the returned array
        column_exemple = episode["episode"][e][0]
        if isinstance(column_exemple,int) or isinstance(column_exemple,float) or x == "":
            index += 1
        else:
            index += len(x)

    return features,y_true

def filter_episode(row, episode_filter):
    """
    Row contains an episode and the y_trues.
    Filters row["episode"] to remove rows within it that satisfies the episode_filter
    """
    episode = {col:[] for col in row["episode"]}

    for i in range(len(row["episode"]["Hours"])):
        #Calculating a row (dico) (= row["episode"][:][i])
        dico = {header:row["episode"][header][i] for header in row["episode"]}

        #If episode_filter returns true we add the row
        if episode_filter(dico):
            for col in episode:
                episode[col].append(row["episode"][col][i])

    #Building returned episode
    returned = {}
    for col in row:
        if col != "episode":
            returned[col] = row[col]
    returned["episode"] = episode

    return returned

#######################################
# ABOUT IMPUTING VALUES               #
#######################################

def input_values(features, empty_value=np.nan, strategy="previous"):
    """
    Inputing values in the features (to replace empty_value values in features) with strategy
    strategy is in ["previous", "previous-next"]
    """
    features = features.copy()

    #Inputing previous value if exists, next else, empty_value if no next
    if strategy == "previous-next":
        for col in features:
            col_vals = features[col]

            for i in range(len(col_vals)):
                #If current value if the empty_value
                if is_empty_list(col_vals[i],np.nan) or is_empty_value(col_vals[i], empty_value):
                    prev_index = i-1

                    #We find the previous value
                    while prev_index >= 0 and (is_empty_list(col_vals[prev_index],np.nan) or is_empty_value(col_vals[prev_index], empty_value)):
                        prev_index -= 1
                    
                    #If found we input it
                    if prev_index >= 0:
                        features[col][i] = col_vals[prev_index]

                    #Else we check next value
                    else:
                        prev_index = i+1
                        while prev_index < len(col_vals) and (is_empty_list(col_vals[prev_index],np.nan) or is_empty_value(col_vals[prev_index], empty_value)):
                            prev_index += 1
                        
                        if prev_index >= i+1 and prev_index < len(col_vals):
                            features[col][i] = col_vals[prev_index]
                        elif col in normal_values:
                            features[col][i] = normal_values[col]
    elif strategy == "previous":
        for col in features:
            col_vals = features[col]

            for i in range(len(col_vals)):
                #If current value if the empty_value
                if is_empty_list(col_vals[i],np.nan) or is_empty_value(col_vals[i], empty_value):
                    prev_index = i-1

                    #We find the previous value
                    while prev_index >= 0 and (is_empty_list(col_vals[prev_index],np.nan) or is_empty_value(col_vals[prev_index], empty_value)):
                        prev_index -= 1
                    
                    #If found we input it
                    if prev_index >= 0:
                        features[col][i] = col_vals[prev_index]
                    #Else we input normal value if found
                    elif col in normal_values:
                        features[col][i] = normal_values[col]


    return features



def add_mask(episode):    
    """
    Adding special features to the episode for every column, which is an array of 1 for every not null value
    Can be used before DataImputer to know where data were imputed
    """
    keys = [key for key in episode.keys()]
    for e in keys:
        episode["mask_"+e] = []
        for el in episode[e]:
            if el == "" or (isinstance(el,float) and np.isnan(el)):
                episode["mask_"+e].append(0)
            else:
                episode["mask_"+e].append(1)
    return episode

#######################################
# DATASET TO READABLE DATA FOR ML     #
#######################################

def preprocess_to_learn(
    episode,
    code_to_onehot=True,
    episode_filter=None,
    mode="full",

    window_period_length=48.0,
    window_size=0.7,

    statistics_mode_column_scale=True,

    empty_value=np.nan,
    input_strategy=None,
    add_mask_columns=False,
):
    """
    Main function to transform dataset rows to numpy arrays\n
    episode is the episode to transform\n
    code_to_onehot is True if you want to transform non-float data to onehot, else it is converted to int\n
    episode_filter is a filter function you want to apply to episodes to remove rows\n
    mode is the mode of transformation. Avaible : statistics (for randomforest), window (for LSTM)\n\n
    window_period_length is the length of episode to do windows in (for window mode)\n
    window_size is the size of the window (for window mode)\n\n
    statistics_mode_column_scale is the column mode for statistics mode (see normalize_episodes_statistics)\n
    empty_value is the value to put where no data\n
    input_strategy can be "previous" or "previous-next" or "None" (see input_values)\n
    add_mask_columns adds mask features before imputing missing data (see add_mask) \n
    episode_length is the episode length for window mode\n
    """

    #Filtering rows from the episode
    if episode_filter == None:
        discr_episode = episode
    else:
        discr_episode = filter_episode(episode, episode_filter)

    #Discretization of data
    if mode == "statistics":
        discr_episode["episode"] = codes_to_int(discr_episode["episode"])
        discr_episode["episode"] = normalize_episodes_statistics(discr_episode,column_scale=statistics_mode_column_scale)

    elif mode == "window":
        discr_episode["episode"] = normalize_episodes_window(discr_episode, window_period_length, window_size)
    
    #Adding mask
    if add_mask_columns:
        discr_episode["episode"] = add_mask(discr_episode["episode"])

    #Trying to input some missing values
    discr_episode["episode"] = input_values(discr_episode["episode"],empty_value=empty_value,strategy=input_strategy)

    #Transforming text to integer (index of string in file) or onehot vector
    if mode != "statistics":
        if code_to_onehot:
            discr_episode["episode"] = codes_to_onehot(discr_episode["episode"])
        else:
            discr_episode["episode"] = codes_to_int(discr_episode["episode"])
    #Transforming to numpy array from dict
    returned = convert_to_numpy_arrays(discr_episode, empty_value=empty_value)
    return returned


#######################################
# ITERATOR FROM DATASET               #
#######################################

def my_generator(dataset,transform):
    iterator = iter(dataset)
    for x in iterator:
        yield transform(x)

def mapped_iterabledataset(dataset, function):
    return IterableDataset.from_generator(my_generator, gen_kwargs={"dataset": dataset,"transform":function})


################################################################################
################################################################################
##                                                                            ##
##                      DATASET CREATION AND DOWNLOADING                      ##
##                                                                            ##
################################################################################
################################################################################

def do_listfile(task,subfolder,mimic3_benchmark_data_folder,mimic3_benchmark_new_data_folder,stays,inputevents,procedurevents,diagnoses,insurances):


    file = subfolder+"_listfile.csv"

    print("working on",task+"/"+file)

    listfile = pd.read_csv(os.path.join(mimic3_benchmark_data_folder,file),sep=',')
    listfile = listfile.sort_values(by=["stay"]) if not "period_length" in listfile else listfile.sort_values(by=["stay","period_length"])

    subfolder = "train"
    if "test" in file:
        subfolder = "test"

    to_save = []
    if task == "mimic4-in-hospital-mortality":
        for idx,(_,x) in enumerate(listfile.iterrows()):
            print(get_progression(idx,len(listfile.index),length=20),str(round(100*idx/len(listfile.index),2))+"%",file,end="\r")

            current_dict = {}

            #Getting episode/subject ids
            fname = x["stay"].split("_")
            subject_id = fname[0]
            episode_number = int(fname[1][7:])

            #Getting current episode start date
            current_ep_desc = pd.read_csv(os.path.join(DATASET_SAVE_PATH,"root",subfolder,subject_id,"episode"+str(episode_number)+".csv"))
            icustay_id = current_ep_desc.at[current_ep_desc.index[0],"Icustay"]

            deathtime = stays.loc[stays["ICUSTAY_ID"] == icustay_id]
            dt = np.nan
            bd = np.nan
            #Doing basic data (age ethnicity and gender)
            for _,y in deathtime.iterrows():
                if isinstance(y["DEATHTIME"], str) and y["DEATHTIME"] != "":
                    dt = dtc(y["DEATHTIME"])
                bd = dtc(y["INTIME"])
                current_dict["age"] = y["AGE"]
                current_dict["ethnicity"] = y["ETHNICITY"]
                current_dict["gender"] = y["GENDER"]
                current_dict["insurance"] = insurances.loc[insurances["HADM_ID"] == y["HADM_ID"]]["INSURANCE"].iloc[0]
                

            #checking if is dead or not, and if data is valid
            valid = True
            if isinstance(dt, datetime):
                sec = (dt - bd).total_seconds() >= 54*3600
                if sec:
                    current_dict["label"] = 1
                else:
                    valid = False
            else:
                current_dict["label"] = 0
            
            if not valid:
                continue

            #Building diagnoses
            current_diags = diagnoses[diagnoses["ICUSTAY_ID"] == icustay_id]
            ICD9_list = []
            for _,icd_code in current_diags.iterrows():
                ICD9_list.append(icd_code["ICD9_CODE"])
            current_dict["Cond"] = {"fids":ICD9_list}



            def map_date(date):
                if isinstance(date,datetime):
                    return (date - bd).total_seconds()/3600.0
                else:
                    return date
                

            #Building procedurevents
            pde = procedurevents[procedurevents["ICUSTAY_ID"] == icustay_id].applymap(map_date,na_action="ignore")
            current_dict["Proc"] = normalize_onehot_episodes_window(pde.to_dict(orient='list'), value_column=False, code_column="ITEMID", period_length=48.0, window_size=1)

            #Building inputevents
            ie = inputevents[inputevents["ICUSTAY_ID"] == icustay_id].applymap(map_date,na_action="ignore")
            current_dict["Med"] = normalize_onehot_episodes_window(ie.to_dict(orient='list'), value_column=True, code_column="ITEMID", period_length=48.0, window_size=1)
            
            #Building chartevents
            current_ep_charts = pd.read_csv(os.path.join(DATASET_SAVE_PATH,"in-hospital-mortality",subfolder,x["stay"])).to_dict(orient='list')
            current_dict["Chart"] = normalize_episodes_window({"episode":current_ep_charts})
            
            #The output events are in the chartevents
            current_dict["Out"] = {}
            
            to_save.append(current_dict)
    else:
        for idx,(_,x) in enumerate(listfile.iterrows()):
            print(get_progression(idx,len(listfile.index),length=20),str(round(100*idx/len(listfile.index),2))+"%",file,end="\r")
            to_save.append(x)
    

    
    os.makedirs(mimic3_benchmark_new_data_folder,exist_ok=True)
    with open(os.path.join(mimic3_benchmark_new_data_folder,file[:-3]+"pkl"), "wb+") as fp:
        pickle.dump(to_save,fp,pickle.HIGHEST_PROTOCOL)


def generate_dics(diagnoses, inputevents, procedurevents, insurances, stays, mimic3_path):
    
    #Diagnoses dictionary
    if not os.path.isfile(os.path.join(DATASET_SAVE_PATH,"icd_dict.csv")):
        print("creating icd indexes")

        #Loading Diagnoses
        used_col = ["ICD9_CODE","SHORT_TITLE","LONG_TITLE"]
        dtype = {"ICD9_CODE":str,"SHORT_TITLE":str,"LONG_TITLE":str}
        dcsv = pd.read_csv(mimic3_path+"/D_ICD_DIAGNOSES.csv",sep=',',usecols=used_col,dtype=dtype)
        print("icd ressources loaded")
        dic = {}
        for _,row in diagnoses.iterrows():
            if not row["ICD9_CODE"] in dic:
                fif = dcsv.loc[dcsv["ICD9_CODE"] == row["ICD9_CODE"]]
                dic[row["ICD9_CODE"]] = {"SHORT_TITLE":fif["SHORT_TITLE"].values[0],"LONG_TITLE":fif["LONG_TITLE"].values[0]}
        with open(os.path.join(DATASET_SAVE_PATH,'icd_dict.csv'), 'w') as f:
            f.write("ICD9_CODE,SHORT_TITLE,LONG_TITLE\n")
            for key in dic.keys():
                f.write("%s,\"%s\",\"%s\"\n"%(key,dic[key]["SHORT_TITLE"],dic[key]["LONG_TITLE"]))

    #itemids dictionary
    if not os.path.isfile(os.path.join(DATASET_SAVE_PATH,"ie_itemid_dict.csv")):
        print("creating itemid indexes")

        #Loading itemids
        used_col = ["ITEMID","LABEL","ABBREVIATION"]
        dtype = {"ITEMID":int,"LABEL":str,"ABBREVIATION":str}
        itemidcsv = pd.read_csv(mimic3_path+"/D_ITEMS.csv",sep=',',usecols=used_col,dtype=dtype)

        print("itemid ressources loaded")
        dic = {}
        for _,row in inputevents.iterrows():
            if not row["ITEMID"] in dic:
                fif = itemidcsv.loc[itemidcsv["ITEMID"] == row["ITEMID"]]
                dic[row["ITEMID"]] = {"LABEL":fif["LABEL"].values[0],"ABBREVIATION":fif["ABBREVIATION"].values[0]}
        with open(os.path.join(DATASET_SAVE_PATH,'ie_itemid_dict.csv'), 'w') as f:
            f.write("ITEMID,LABEL,ABBREVIATION\n")
            for key in dic.keys():
                f.write("%s,\"%s\",\"%s\"\n"%(key,dic[key]["ABBREVIATION"],dic[key]["LABEL"]))

        dic = {}
        for _,row in procedurevents.iterrows():
            if not row["ITEMID"] in dic:
                fif = itemidcsv.loc[itemidcsv["ITEMID"] == row["ITEMID"]]
                dic[row["ITEMID"]] = {"LABEL":fif["LABEL"].values[0],"ABBREVIATION":fif["ABBREVIATION"].values[0]}
        with open(os.path.join(DATASET_SAVE_PATH,'pe_itemid_dict.csv'), 'w') as f:
            f.write("ITEMID,LABEL,ABBREVIATION\n")
            for key in dic.keys():
                f.write("%s,\"%s\",\"%s\"\n"%(key,dic[key]["ABBREVIATION"],dic[key]["LABEL"]))

    #insurances dictionary
    if not os.path.isfile(os.path.join(DATASET_SAVE_PATH,"insurances_dict.csv")):
        print("creating insurances indexes")
        dic = {}
        index = 0
        for _,row in insurances.iterrows():
            if not row["INSURANCE"] in dic:
                dic[row["INSURANCE"]] = index
                index += 1
        with open(os.path.join(DATASET_SAVE_PATH,'insurances_dict.csv'), 'w') as f:
            f.write("INSURANCE,INDEX\n")
            for key in dic.keys():
                f.write("\"%s\",%s\n"%(key,dic[key]))

    #gender dictionary
    if not os.path.isfile(os.path.join(DATASET_SAVE_PATH,"genders_dict.csv")):
        print("creating genders indexes")
        dic = {}
        index = 0
        for _,row in stays.iterrows():
            if not row["GENDER"] in dic:
                dic[row["GENDER"]] = index
                index += 1
        with open(os.path.join(DATASET_SAVE_PATH,'genders_dict.csv'), 'w') as f:
            f.write("GENDER,INDEX\n")
            for key in dic.keys():
                f.write("\"%s\",%s\n"%(key,dic[key]))


    #age dictionary
    if not os.path.isfile(os.path.join(DATASET_SAVE_PATH,"ages_dict.csv")):
        print("creating ages indexes")
        dic = {}
        index = 0
        for _,row in stays.iterrows():
            if not round(row["AGE"]) in dic:
                dic[round(row["AGE"])] = index
                index += 1
        with open(os.path.join(DATASET_SAVE_PATH,'ages_dict.csv'), 'w') as f:
            f.write("AGE,INDEX\n")
            for key in dic.keys():
                f.write("%s,%s\n"%(key,dic[key]))

    #ethny dictionary
    if not os.path.isfile(os.path.join(DATASET_SAVE_PATH,"ethnicities_dict.csv")):
        print("creating ethnicities indexes")
        dic = {}
        index = 0
        for _,row in stays.iterrows():
            if not row["ETHNICITY"] in dic:
                dic[row["ETHNICITY"]] = index
                index += 1
        with open(os.path.join(DATASET_SAVE_PATH,'ethnicities_dict.csv'), 'w') as f:
            f.write("ETHNICITY,INDEX\n")
            for key in dic.keys():
                f.write("\"%s\",%s\n"%(key,dic[key]))

def clean_units(df):
    df.loc[df["AMOUNTUOM"].isin(["grams","L"]),"AMOUNT"] = df.loc[df["AMOUNTUOM"].isin(["grams","L"]),"AMOUNT"].apply((lambda x:x*1000))
    df.loc[df["AMOUNTUOM"].isin(["ounces"]),"AMOUNT"] = df.loc[df["AMOUNTUOM"].isin(["ounces"]),"AMOUNT"].apply((lambda x:x*28.3495*1000))
    df.loc[df["AMOUNTUOM"].isin(["uL"]),"AMOUNT"] = df.loc[df["AMOUNTUOM"].isin(["uL"]),"AMOUNT"].apply((lambda x:x/1000))
    df.loc[df["AMOUNTUOM"].isin(["mlhr","Hours"]),"AMOUNT"] = df.loc[df["AMOUNTUOM"].isin(["mlhr","Hours"]),"AMOUNT"].apply((lambda x:x/60))

    df.loc[df["RATEUOM"].isin(["mLhour","unitshour","mcghour","mcgkghour","mgkghour","mLkghour","mEq.hour"]),"RATE"] = df.loc[df["RATEUOM"].isin(["mLhour","unitshour","mcghour","mcgkghour","mgkghour","mLkghour","mEq.hour"]),"RATE"].apply((lambda x:x/60))
    df.loc[df["RATEUOM"].isin(["gramshour"]),"RATE"] = df.loc[df["RATEUOM"].isin(["gramshour"]),"RATE"].apply((lambda x:x*1000/60))
    df.loc[df["RATEUOM"].isin(["gramsmin","gramskgmin"]),"RATE"] = df.loc[df["RATEUOM"].isin(["gramsmin","gramskgmin"]),"RATE"].apply((lambda x:x*1000))


def load_mimic3_files(mimic3_dir):
    #Loading inputevents
    used_col = ["SUBJECT_ID","ICUSTAY_ID","CHARTTIME","ITEMID","AMOUNT","AMOUNTUOM","RATE","RATEUOM"]
    dtype = {"AMOUNTUOM":str,"RATEUOM":str}
    converters={"SUBJECT_ID":bic,"ICUSTAY_ID":bic,"CHARTTIME":dtc,"ITEMID":bic,"AMOUNT":bfc,"RATE":bfc}
    inputevents = pd.read_csv(mimic3_dir+"/INPUTEVENTS_CV.csv",sep=',',usecols=used_col,dtype=dtype,converters=converters)
    inputevents.rename(columns={"CHARTTIME": "STARTTIME"}, inplace=True)
    print("inputevents 1/2 loaded")

    used_col = ["SUBJECT_ID","ICUSTAY_ID","STARTTIME","ENDTIME","ITEMID","AMOUNT","AMOUNTUOM","RATE","RATEUOM"]
    dtype = {"AMOUNTUOM":str,"RATEUOM":str}
    converters={"SUBJECT_ID":bic,"ICUSTAY_ID":bic,"STARTTIME":dtc,"ENDTIME":dtc,"ITEMID":bic,"AMOUNT":bfc,"RATE":bfc}
    inputevents_2 = pd.read_csv(mimic3_dir+"/INPUTEVENTS_MV.csv",sep=',',usecols=used_col,dtype=dtype,converters=converters)
    inputevents = pd.concat([inputevents,inputevents_2])
    inputevents.drop(inputevents[(inputevents["SUBJECT_ID"] == -1) | (inputevents["ICUSTAY_ID"] == -1)].index, inplace=True)
    clean_units(inputevents)
    print("inputevents 2/2 loaded")

    #Loading procedurevents
    used_col = ["SUBJECT_ID","ICUSTAY_ID","STARTTIME","ENDTIME","ITEMID"]
    converters={"SUBJECT_ID":bic,"ICUSTAY_ID":bic,"STARTTIME":dtc,"ENDTIME":dtc,"ITEMID":bic}
    procedurevents = pd.read_csv(mimic3_dir+"/PROCEDUREEVENTS_MV.csv",sep=',',usecols=used_col,converters=converters)
    procedurevents.drop(procedurevents[(procedurevents["SUBJECT_ID"] == -1) | (procedurevents["ICUSTAY_ID"] == -1)].index, inplace=True)
    print("procedurevents loaded")

    #Loading Diagnoses
    used_col = ["SUBJECT_ID","SEQ_NUM","ICD9_CODE","ICUSTAY_ID"]
    dtype = {"ICD9_CODE":str}
    converters={"SUBJECT_ID":bic,"SEQ_NUM":bic,"ICUSTAY_ID":bic}
    diagnoses = pd.read_csv(os.path.join(DATASET_SAVE_PATH,"root","all_diagnoses.csv"),sep=',',usecols=used_col,dtype=dtype,converters=converters)
    print("diagnoses loaded")

    #Loading stays
    used_col = ["SUBJECT_ID","HADM_ID","ICUSTAY_ID","INTIME","DEATHTIME","ETHNICITY","GENDER","AGE"]
    dtype = {"INTIME":str,"DEATHTIME":str,"ETHNICITY":str,"GENDER":str}
    converters={"SUBJECT_ID":bic,"HADM_ID":bic,"ICUSTAY_ID":bic,"AGE":bfc}
    stays = pd.read_csv(os.path.join(DATASET_SAVE_PATH,"root","all_stays.csv"),sep=',',usecols=used_col,dtype=dtype,converters=converters)
    print("stays loaded")

    #Loading insurances
    used_col = ["SUBJECT_ID","HADM_ID","INSURANCE"]
    dtype = {"INSURANCE":str}
    converters={"SUBJECT_ID":bic,"HADM_ID":bic}
    insurances = pd.read_csv(mimic3_dir+"/ADMISSIONS.csv",sep=',',usecols=used_col,dtype=dtype,converters=converters)
    print("insurances loaded")

    generate_dics(diagnoses, inputevents, procedurevents, insurances, stays, mimic3_dir)

    diagnoses.drop(diagnoses[(diagnoses["SUBJECT_ID"] == -1) | (diagnoses["ICUSTAY_ID"] == -1)].index, inplace=True)
    diagnoses.drop(diagnoses[(diagnoses["ICD9_CODE"] == 7981) | (diagnoses["ICD9_CODE"] == 7982) | (diagnoses["ICD9_CODE"] == 7989)].index, inplace=True)
    diagnoses["Hours"] = 0
    diagnoses = diagnoses.sort_values(by="SEQ_NUM")

    return stays,inputevents,procedurevents,diagnoses,insurances



def do_directory_cleaning(current_file):

    if "IC9_CODE" in current_file:
        current_file["ICD9_CODE"] = current_file["ICD9_CODE"].apply(id_to_string)

    #Cleaning
    current_file.loc[current_file["AMOUNT"] == -1, "AMOUNT"] = np.nan
    current_file.loc[current_file["RATE"] == -1, "RATE"] = np.nan
    current_file["ITEMID"] = current_file["ITEMID"].astype(pd.Int64Dtype())
    if "SEQ_NUM" in current_file:
        current_file["SEQ_NUM"] = current_file["SEQ_NUM"].astype(pd.Int64Dtype())
    clean_units(current_file)
    current_file = current_file.drop(["AMOUNTUOM","RATEUOM"], axis=1)
    return current_file


def load_mimic3_benchmark(mimic3_path):

    mimic3_path = os.path.join(os.getcwd(),mimic3_path)
    starting_dir = os.getcwd()
    os.chdir(DATASET_SAVE_PATH)

    print("Starting preprocessing of raw mimic3 data...")

    if not os.path.isdir("mimic3-benchmarks"):
        print("MIMIC3-BENCHMARK Data not found... Loading mimic3-benchmark github...")
        os.system('git clone https://github.com/YerevaNN/mimic3-benchmarks.git')

    if not os.path.isdir("mimic3-benchmarks"):
        print("Could not load the github... Exiting...")
        exit(1)
    os.chdir("mimic3-benchmarks")
    print("Preprocessing of data... This step may take hours.")

    print("Extracting subjects...")
    os.system("python -m mimic3benchmark.scripts.extract_subjects "+mimic3_path+" ../root/")

    print("Fixing issues...")
    os.system("python -m mimic3benchmark.scripts.validate_events ../root/")
    
    print("Extracting episodes...")
    os.system("python -m mimic3benchmark.scripts.extract_episodes_from_subjects ../root/")

    print("Spliting train and test...")
    os.system("python -m mimic3benchmark.scripts.split_train_and_test ../root/")
    
    print("Creating specific tasks")
    os.system("python -m mimic3benchmark.scripts.create_in_hospital_mortality ../root/ ../in-hospital-mortality/")
    os.system("python -m mimic3benchmark.scripts.create_decompensation ../root/ ../decompensation/")
    os.system("python -m mimic3benchmark.scripts.create_length_of_stay ../root/ ../length-of-stay/")
    os.system("python -m mimic3benchmark.scripts.create_phenotyping ../root/ ../phenotyping/")
    os.system("python -m mimic3benchmark.scripts.create_multitask ../root/ ../multitask/")

    print("Spliting validation...")
    os.system("python -m mimic3models.split_train_val ../in-hospital-mortality/")
    os.system("python -m mimic3models.split_train_val ../decompensation/")
    os.system("python -m mimic3models.split_train_val ../length-of-stay/")
    os.system("python -m mimic3models.split_train_val ../phenotyping/")
    os.system("python -m mimic3models.split_train_val ../multitask/")
    os.chdir(starting_dir)

def preprocess(task,mimic3_dir=None):
    origin_task = task
    if "mimic4-" in task:
        origin_task = task[7:]

    original_task_path = os.path.join(DATASET_SAVE_PATH,origin_task)
    print("need of",original_task_path,"to generate new task...")
    if not os.path.isdir(original_task_path):
        if mimic3_dir == None:
            mimic3_dir = input("Preprocessing has to be done, please enter mimic3's path : ")
            if not os.path.isdir(mimic3_dir):
                print("Could not load mimic3 files...")
                exit(1)
        load_mimic3_benchmark(mimic3_dir)

    loaded,inputevents,procedurevents,diagnoses = False,None,None,None

    mimic3_benchmark_data_folder,mimic3_benchmark_new_data_folder = None,None
    if "mimic4-" in task:
        print("the requested task is a mimic4-benchmark task...")
        #Data folder
        mimic3_benchmark_data_folder = os.path.join(DATASET_SAVE_PATH,task[7:])

        #New data folder
        mimic3_benchmark_new_data_folder = os.path.join(DATASET_SAVE_PATH,task)
    

        for subfolder in ["train","test","val"]:
            print("checking subfolder",subfolder)

            #Chargement des fichiers mimic3 pour modification
            if not os.path.isfile(os.path.join(DATASET_SAVE_PATH,task,subfolder+"_listfile.pkl")):
                if not loaded:
                    if mimic3_dir == None:
                        mimic3_dir = input("preprocessing has to be done, please enter mimic3's path : ")
                        if not os.path.isdir(mimic3_dir):
                            print("Could not load mimic3 files...")
                            exit(1)
                    print("this task does not exist yet... loading required files to create the task. this may take 20 minutes")
                    stays,inputevents,procedurevents,diagnoses,insurances = load_mimic3_files(mimic3_dir)
                    loaded = True
                print("creating the subfolder",subfolder,"| estimated time : 1h")
                do_listfile(task, subfolder, mimic3_benchmark_data_folder, mimic3_benchmark_new_data_folder, stays, inputevents, procedurevents, diagnoses, insurances)
        if not os.path.isfile("icd_dict.csv"):
            if mimic3_dir == None:
                mimic3_dir = input("preprocessing has to be done, please enter mimic3's path : ")
                if not os.path.isdir(mimic3_dir):
                    print("Could not load mimic3 files...")
                    exit(1)
            print("loading data and creating dicts...")
            load_mimic3_files(mimic3_dir)


################################################################################
################################################################################
##                                                                            ##
##                           HUGGING FACE DATASET                             ##
##                                                                            ##
################################################################################
################################################################################


class Mimic3DatasetConfig(datasets.BuilderConfig):
    def __init__(self, **kwargs):
        super().__init__(**kwargs)

class Mimic3Benchmark_Dataset(datasets.GeneratorBasedBuilder):
    def __init__(self, **kwargs):
        self.code_to_onehot=kwargs.pop("code_to_onehot",True)
        self.episode_filter=kwargs.pop("episode_filter",None)
        self.mode=kwargs.pop("mode","statistics")
        self.window_period_length=kwargs.pop("window_period_length",48.0)
        self.window_size=kwargs.pop("window_size",0.7)
        self.empty_value=kwargs.pop("empty_value",np.nan)
        self.input_strategy=kwargs.pop("input_strategy",None)
        self.add_mask_columns=kwargs.pop("add_mask_columns",False)
        self.statistics_mode_column_scale=kwargs.pop("statistics_mode_column_scale",True)
        self.mimic3_path=kwargs.pop("mimic3_path",None)

        self.mimic4_text_demos = kwargs.pop("mimic4_text_demos",True)
        self.mimic4_text_charts = kwargs.pop("mimic4_text_charts",True)
        self.mimic4_text_meds = kwargs.pop("mimic4_text_meds",True)
        self.mimic4_text_cond = kwargs.pop("mimic4_text_cond",True)
        self.mimic4_text_procs = kwargs.pop("mimic4_text_procs",True)

        self.full_meds_loaded = False
        self.full_proc_loaded = False
        self.full_cond_loaded = False

        self.full_gens_loaded = False
        self.full_ages_loaded = False
        self.full_eths_loaded = False
        self.full_ins_loaded = False

        super().__init__(**kwargs)

    VERSION = datasets.Version("1.0.0")

    BUILDER_CONFIGS = [
        Mimic3DatasetConfig(name="in-hospital-mortality", version=VERSION, description="This datasets covers the in-hospital-mortality benchmark of mimiciii-benchmark"),
        Mimic3DatasetConfig(name="decompensation", version=VERSION, description="This datasets covers the decompensation benchmark of mimiciii-benchmark"),
        Mimic3DatasetConfig(name="length-of-stay", version=VERSION, description="This datasets covers the length-of-stay benchmark of mimiciii-benchmark"),
        Mimic3DatasetConfig(name="multitask", version=VERSION, description="This datasets covers the multitask benchmark of mimiciii-benchmark"),
        Mimic3DatasetConfig(name="phenotyping", version=VERSION, description="This datasets covers the in phenotyping benchmark of mimiciii-benchmark"),
        Mimic3DatasetConfig(name="mimic4-in-hospital-mortality", version=VERSION, description="This datasets covers the mimic4-in-hospital-mortality benchmark of mimiciii-benchmark"),
    ]

    def _info(self):
        if self.config.name in ["in-hospital-mortality", "decompensation", "phenotyping", "mimic4-in-hospital-mortality", "length-of-stay"]:
            
            

            if self.config.name == "phenotyping":
                return datasets.DatasetInfo(
                    description="Dataset "+self.config.name,
                    features=datasets.Features(
                    {
                        "Acute and unspecified renal failure": datasets.Value("float"),
                        "Acute cerebrovascular disease": datasets.Value("float"),
                        "Acute myocardial infarction": datasets.Value("float"),
                        "Cardiac dysrhythmias": datasets.Value("float"),
                        "Chronic kidney disease": datasets.Value("float"),
                        "Chronic obstructive pulmonary disease and bronchiectasis": datasets.Value("float"),
                        "Complications of surgical procedures or medical care": datasets.Value("float"),
                        "Conduction disorders": datasets.Value("float"),
                        "Congestive heart failure; nonhypertensive": datasets.Value("float"),
                        "Coronary atherosclerosis and other heart disease": datasets.Value("float"),
                        "Diabetes mellitus with complications": datasets.Value("float"),
                        "Diabetes mellitus without complication": datasets.Value("float"),
                        "Disorders of lipid metabolism": datasets.Value("float"),
                        "Essential hypertension": datasets.Value("float"),
                        "Fluid and electrolyte disorders": datasets.Value("float"),
                        "Gastrointestinal hemorrhage": datasets.Value("float"),
                        "Hypertension with complications and secondary hypertension": datasets.Value("float"),
                        "Other liver diseases": datasets.Value("float"),
                        "Other lower respiratory disease": datasets.Value("float"),
                        "Other upper respiratory disease": datasets.Value("float"),
                        "Pleurisy; pneumothorax; pulmonary collapse": datasets.Value("float"),
                        "Pneumonia (except that caused by tuberculosis or sexually transmitted disease)": datasets.Value("float"),
                        "Respiratory failure; insufficiency; arrest (adult)": datasets.Value("float"),
                        "Septicemia (except in labor)": datasets.Value("float"),
                        "Shock": datasets.Value("float"),
                        "episode": datasets.Array2D(shape=(None,None), dtype=float)
                    }),
                    homepage="",
                    license="",
                    citation="",
                )
            elif self.config.name == "mimic4-in-hospital-mortality" and self.mode in ["mimic4-aggreg"]:
                return datasets.DatasetInfo(
                    description="Dataset "+self.config.name,
                    features = datasets.Features(
                        {
                            "label": datasets.ClassLabel(num_classes=2,names=["0", "1"]),
                            "features" : datasets.Sequence(datasets.Value("float32")),
                            "columns": datasets.Squence(datasets.value("string"))
                        }
                    ),
                    homepage="",
                    license="",
                    citation="",)
            elif self.config.name == "mimic4-in-hospital-mortality" and self.mode == "mimic4-naive-prompt":
                return datasets.DatasetInfo(
                    description="Dataset "+self.config.name,
                    features = datasets.Features(
                        {
                            "label": datasets.ClassLabel(num_classes=2,names=["0", "1"]),
                            "features" : datasets.Value(dtype='string', id=None),
                        }
                    ),
                    homepage="",
                    license="",
                    citation="",)
            elif self.config.name == "mimic4-in-hospital-mortality" and self.mode == "mimic4-tensor":
                return datasets.DatasetInfo(
                    description="Dataset "+self.config.name,
                    features = datasets.Features(
                        {
                            "label": datasets.ClassLabel(num_classes=2,names=["0", "1"]),
                            "DEMO": datasets.Sequence(datasets.Value("int64")),
                            "COND" : datasets.Sequence(datasets.Value("int64")),
                            "MEDS" : datasets.Array2D(shape=(None, None), dtype='int64') ,
                            "PROC" : datasets.Array2D(shape=(None, None), dtype='int64') ,
                            "CHART/LAB" : datasets.Array2D(shape=(None, None), dtype='int64')
                        }
                    ),
                    homepage="",
                    license="",
                    citation="",)
            return datasets.DatasetInfo(
                description="Dataset "+self.config.name,
                features=datasets.Features(
                {
                    "y_true": datasets.Value("float"),
                    "episode": datasets.Array2D(shape=(None,None), dtype=float)
                }),
                homepage="",
                license="",
                citation="",
            )

    def _split_generators(self, dl_manager):
        self.path = os.path.join(DATASET_SAVE_PATH,self.config.name)
        preprocess(self.config.name,self.mimic3_path)
        if "mimic4" in self.config.name:
            return [
                datasets.SplitGenerator(
                    name=datasets.Split.TRAIN,
                    gen_kwargs={
                        "filepath":os.path.join(self.path,"train_listfile.pkl"),
                        "split": "train",
                    },
                ),
                datasets.SplitGenerator(
                    name=datasets.Split.VALIDATION,
                    gen_kwargs={
                        "filepath":os.path.join(self.path,"val_listfile.pkl"),
                        "split": "validation",
                    },
                ),
                datasets.SplitGenerator(
                    name=datasets.Split.TEST,
                    gen_kwargs={
                        "filepath":os.path.join(self.path,"test_listfile.pkl"),
                        "split": "test"
                    },
                ),
            ]
        return [
            datasets.SplitGenerator(
                name=datasets.Split.TRAIN,
                gen_kwargs={
                    "filepath":os.path.join(self.path,"train_listfile.csv"),
                    "split": "train",
                },
            ),
            datasets.SplitGenerator(
                name=datasets.Split.VALIDATION,
                gen_kwargs={
                    "filepath":os.path.join(self.path,"val_listfile.csv"),
                    "split": "validation",
                },
            ),
            datasets.SplitGenerator(
                name=datasets.Split.TEST,
                gen_kwargs={
                    "filepath":os.path.join(self.path,"test_listfile.csv"),
                    "split": "test"
                },
            ),
        ]
    
    def _generate_exemples_CHARTONLY(self, filepath):
        key = 0
        with open(filepath, encoding="utf-8") as f:
            reader1 = csv.DictReader(f)
            for data in reader1:
                
                y_trues = {}

                for e in data:
                    if e != "period_length" and e != "stay":
                        y_trues[e] = data[e]

                if "period_length" in data:
                    period_length = float(data["period_length"])
                else:
                    period_length = self.window_period_length
                stay = data["stay"]

                if os.path.isfile(os.path.join(self.path,"test",stay)):
                    stay = os.path.join(self.path,"test",stay)
                else:
                    stay = os.path.join(self.path,"train",stay)
                
                # stay = self.path+"/train/30820_episode1_timeseries.csv"
                # period_length = 42.0
                episode = {
                    "Hours": [],
                    "Capillary refill rate": [],
                    "Diastolic blood pressure": [],
                    "Fraction inspired oxygen": [],
                    "Glascow coma scale eye opening": [],
                    "Glascow coma scale motor response": [],
                    "Glascow coma scale total": [],
                    "Glascow coma scale verbal response": [],
                    "Glucose": [],
                    "Heart Rate": [],
                    "Height": [],
                    "Mean blood pressure": [],
                    "Oxygen saturation": [],
                    "Respiratory rate": [],
                    "Systolic blood pressure": [],
                    "Temperature": [],
                    "Weight": [],
                    "pH": [],
                }
                with open(stay, encoding="utf-8") as f2:
                    reader2 = csv.DictReader(f2)
                    for data2 in reader2:
                        if self.config.name in ["length-of-stay","decompensation"] and float(data2["Hours"]) > period_length + 1e-6:
                            break
                        
                        episode["Hours"].append(float(data2["Hours"]) if data2["Hours"] else 0.0)
                        episode["Capillary refill rate"].append(float(data2["Capillary refill rate"]) if data2["Capillary refill rate"] else np.nan)
                        episode["Diastolic blood pressure"].append(float(data2["Diastolic blood pressure"]) if data2["Diastolic blood pressure"] else np.nan)
                        episode["Fraction inspired oxygen"].append(float(data2["Fraction inspired oxygen"]) if data2["Fraction inspired oxygen"] else np.nan)
                        episode["Glascow coma scale eye opening"].append(data2["Glascow coma scale eye opening"])
                        episode["Glascow coma scale motor response"].append(data2["Glascow coma scale motor response"])
                        episode["Glascow coma scale total"].append(float(data2["Glascow coma scale total"]) if data2["Glascow coma scale total"] else np.nan)
                        episode["Glascow coma scale verbal response"].append(data2["Glascow coma scale verbal response"])
                        episode["Glucose"].append(float(data2["Glucose"]) if data2["Glucose"] else np.nan)
                        episode["Heart Rate"].append(float(data2["Heart Rate"]) if data2["Heart Rate"] else np.nan)
                        episode["Height"].append(float(data2["Height"]) if data2["Height"] else np.nan)
                        episode["Mean blood pressure"].append(float(data2["Mean blood pressure"]) if data2["Mean blood pressure"] else np.nan)
                        episode["Oxygen saturation"].append(float(data2["Oxygen saturation"]) if data2["Oxygen saturation"] else np.nan)
                        episode["Respiratory rate"].append(float(data2["Respiratory rate"]) if data2["Respiratory rate"] else np.nan)
                        episode["Systolic blood pressure"].append(float(data2["Systolic blood pressure"]) if data2["Systolic blood pressure"] else np.nan)
                        episode["Temperature"].append(float(data2["Temperature"]) if data2["Temperature"] else np.nan)
                        episode["Weight"].append(float(data2["Weight"]) if data2["Weight"] else np.nan)
                        episode["pH"].append(float(data2["pH"]) if data2["pH"] else np.nan)

                X,Y = preprocess_to_learn(
                    {
                        "episode":episode
                    },
                    code_to_onehot=self.code_to_onehot,
                    episode_filter=self.episode_filter,
                    mode=self.mode,
                    window_size=self.window_size,
                    empty_value=self.empty_value,
                    input_strategy=self.input_strategy,
                    add_mask_columns=self.add_mask_columns,
                    statistics_mode_column_scale=self.statistics_mode_column_scale,
                    window_period_length=period_length
                )
                # print(np.around(X.flatten(),4).tolist())
                # exit(0)
                y_trues["episode"] = X
                yield key, y_trues
                key += 1

    ##################################################################################################################################################
    #### GENERATION D'EXEMPLES COMPLETS MODE TENSOR (CHARTS + INPUTEVENTS + DIAGNOSES) ##### DE THOURIA ##############################################
    ##################################################################################################################################################

    def load_vocab(self):
        if self.full_gens_loaded == False:
            self.full_gens = pd.read_csv(os.path.join(DATASET_SAVE_PATH,"genders_dict.csv"))["GENDER"].tolist()
            self.full_gens_loaded = True
            self.full_gens_len = len(self.full_gens)
            self.full_gens_reverse = {k: v for v, k in enumerate(self.full_gens)}

        if self.full_eths_loaded == False:
            self.full_eths = pd.read_csv(os.path.join(DATASET_SAVE_PATH,"ethnicities_dict.csv"))["ETHNICITY"].tolist()
            self.full_eths_loaded = True
            self.full_eths_len = len(self.full_eths)
            self.full_eths_reverse = {k: v for v, k in enumerate(self.full_eths)}

        if self.full_ins_loaded == False:
            self.full_ins = pd.read_csv(os.path.join(DATASET_SAVE_PATH,"insurances_dict.csv"))["INSURANCE"].tolist()
            self.full_ins_loaded = True
            self.full_ins_len = len(self.full_ins)
            self.full_ins_reverse = {k: v for v, k in enumerate(self.full_ins)}
        
        if self.full_cond_loaded == False:
            self.full_cond = pd.read_csv(os.path.join(DATASET_SAVE_PATH,"icd_dict.csv"),names=["COND","SHORT","LONG"],skiprows=1)
            self.full_cond_loaded = True
            self.full_cond_len = len(self.full_cond)
        
        if self.full_proc_loaded == False:
            self.full_proc = pd.read_csv(os.path.join(DATASET_SAVE_PATH,"pe_itemid_dict.csv"),names=["PROC","SHORT","LONG"],skiprows=1)
            self.full_proc_loaded = True
            self.full_proc_len = len(self.full_proc["PROC"])

        if self.full_meds_loaded == False:
            self.full_meds = pd.read_csv(os.path.join(DATASET_SAVE_PATH,"ie_itemid_dict.csv"),names=["MEDS","LONG","SHORT"],skiprows=1)
            self.full_meds_loaded = True
            self.full_meds_len = len(self.full_meds["MEDS"])

        if self.full_ages_loaded == False:
            self.full_ages = pd.read_csv(os.path.join(DATASET_SAVE_PATH,"ages_dict.csv"),names=["AGE","INDEX"],skiprows=1)["AGE"]
            self.full_ages_loaded = True
            self.full_ages_len = len(self.full_ages)
            self.full_ages_reverse = {k: v for v, k in enumerate(self.full_ages)}
        self.chartDic = pd.DataFrame({"CHART":["Capillary refill rate","Diastolic blood pressure","Fraction inspired oxygen","Glascow coma scale eye opening","Glascow coma scale motor response","Glascow coma scale total","Glascow coma scale verbal response","Glucose","Heart Rate","Height","Mean blood pressure","Oxygen saturation","Respiratory rate","Systolic blood pressure","Temperature","Weight","pH"]})
    
    def generate_deep(self,data):
        dyn,cond_df,demo=self.concat_data(data)
        charts = dyn['CHART'].values
        
        meds = dyn['MEDS'].values

        proc = dyn['PROC'].values

        stat = cond_df.values[0]
        
        y = int(demo['label'])
        demo["gender"].replace(self.full_gens_reverse, inplace=True)
        demo["ethnicity"].replace(self.full_eths_reverse, inplace=True)
        demo["insurance"].replace(self.full_ins_reverse, inplace=True)
        demo["Age"] = demo["Age"].round()
        demo["insurance"].replace(self.full_ages_reverse, inplace=True)

        demo = demo[["gender","ethnicity","insurance","Age"]].values[0]
        return stat, demo, meds, charts, proc, y


    def _generate_examples_deep(self, filepath):

        self.load_vocab()

        with open(filepath, 'rb') as fp:
            dico = pickle.load(fp)

        for key, data in enumerate(dico):   
            stat, demo, meds, chart, proc, y = self.generate_deep(data)
            yielded = {
                'label': y,
                'DEMO': demo,
                'COND': stat,
                'MEDS': meds,
                'PROC': proc,
                'CHART/LAB': chart,
                }
            yield int(key), yielded
                    
    ##################################################################################################################################################
    #### GENERATION D'EXEMPLES COMPLETS MODE CONCAT/AGGREG (CHARTS + INPUTEVENTS + DIAGNOSES) ##### DE THOURIA #######################################
    ##################################################################################################################################################

    def concat_data(self,data):
        meds = data['Med']
        proc = data['Proc']
        chart = codes_to_int(input_values(data['Chart']))
        cond = data['Cond']['fids']
        
        cond_df,proc_df,chart_df,meds_df=pd.DataFrame(),pd.DataFrame(),pd.DataFrame(),pd.DataFrame()

        #demographic
        demo=pd.DataFrame(columns=['Age','gender','ethnicity','label','insurance'])
        new_row = {'Age': data['age'], 'gender': data['gender'], 'ethnicity': data['ethnicity'], 'label': data['label'], 'insurance': data['insurance']}
        demo = demo.append(new_row, ignore_index=True)

        ##########COND#########
        #get all conds
            
        features=pd.DataFrame(np.zeros([1,len(self.full_cond)]),columns=self.full_cond['COND'])

        #onehot encode
        
        cond_df = pd.DataFrame(cond,columns=['COND'])
        cond_df['val'] = 1
        cond_df = (cond_df.drop_duplicates()).pivot(columns='COND',values='val').reset_index(drop=True)
        cond_df = cond_df.fillna(0)
        oneh = cond_df.sum().to_frame().T
        combined_df = pd.concat([features,oneh],ignore_index=True).fillna(0)
        combined_oneh = combined_df.sum().to_frame().T
        cond_df = combined_oneh
        for c in cond_df.columns :
            if c not in features: 
                cond_df = cond_df.drop(columns=[c])

        ##########PROC#########

        
        feat=proc.keys()
        proc_val=[proc[key] for key in feat]
        procedures=pd.DataFrame(self.full_proc["PROC"],columns=['PROC'])
        features=pd.DataFrame(np.zeros([1,len(procedures)]),columns=procedures['PROC'])
        features.columns=pd.MultiIndex.from_product([["PROC"], features.columns])
        procs=pd.DataFrame(columns=feat)
        for p,v in zip(feat,proc_val):
            procs[p]=v
        procs.columns=pd.MultiIndex.from_product([["PROC"], procs.columns])
        proc_df = pd.concat([features,procs],ignore_index=True).fillna(0)

        ##########CHART#########

        
        
        feat=chart.keys()
        chart_val=[chart[key] for key in feat]
        charts=pd.DataFrame(self.chartDic,columns=['CHART'])
        features=pd.DataFrame(np.zeros([1,len(charts)]),columns=charts['CHART'])
        features.columns=pd.MultiIndex.from_product([["CHART"], features.columns])
        
        chart=pd.DataFrame(columns=feat)
        for c,v in zip(feat,chart_val):
            chart[c]=v
        chart.columns=pd.MultiIndex.from_product([["CHART"], chart.columns])
        chart_df = pd.concat([features,chart],ignore_index=True).fillna(0)
        
        ###MEDS
        
        feat=[str(x) for x in meds.keys()]
        med_val=[meds[int(key)] for key in feat]
        meds=[str(x) for x in self.full_meds["MEDS"]]
        features=pd.DataFrame(np.zeros([1,len(meds)]),columns=meds)
        features.columns=pd.MultiIndex.from_product([["MEDS"], features.columns])
        med=pd.DataFrame(columns=feat)
        for m,v in zip(feat,med_val):
            med[m]=v
        med.columns=pd.MultiIndex.from_product([["MEDS"], med.columns])

        meds_df = pd.concat([features,med],ignore_index=True).fillna(0)
        dyn_df = pd.concat([meds_df,proc_df,chart_df], axis=1)
        return dyn_df,cond_df,demo

    def _generate_ml(self,dyn,stat,demo,concat_cols,concat):
        X_df=pd.DataFrame()
        if concat:
            dyna=dyn.copy()
            dyna.columns=dyna.columns.droplevel(0)
            dyna=dyna.to_numpy()
            dyna=np.nan_to_num(dyna, copy=False)
            dyna=dyna.reshape(1,-1)
            #dyn_df=pd.DataFrame(data=dyna,columns=concat_cols)
            dyn_df=pd.DataFrame(data=dyna)
        else:
            dyn_df=pd.DataFrame()
            for key in dyn.columns.levels[0]:     
                dyn_temp=dyn[key]
                if ((key=="CHART") or (key=="MEDS")):
                    agg=dyn_temp.aggregate("mean")
                    agg=agg.reset_index()
                else:
                    agg=dyn_temp.aggregate("max")
                    agg=agg.reset_index()

                if dyn_df.empty:
                    dyn_df=agg
                else:
                    dyn_df=pd.concat([dyn_df,agg],axis=0)
            dyn_df=dyn_df.T
            dyn_df.columns = dyn_df.iloc[0]
            dyn_df=dyn_df.iloc[1:,:]
            
        X_df=pd.concat([dyn_df,stat],axis=1)
        X_df=pd.concat([X_df,demo],axis=1)
        return X_df


    def _generate_examples_encoded(self, filepath, concat):
        self.load_vocab()
        
        gen_encoder,eth_encoder,ins_encoder = LabelEncoder(),LabelEncoder(),LabelEncoder()

        gen_encoder.fit(self.full_gens)
        eth_encoder.fit(self.full_eths)
        ins_encoder.fit(self.full_ins)
        with open(filepath, 'rb') as fp:
            dico = pickle.load(fp)
        df = pd.DataFrame(dico)

        for i, data in df.iterrows():
            concat_cols=[]
            dyn_df,cond_df,demo=self.concat_data(data)
            dyn=dyn_df.copy()
            dyn.columns=dyn.columns.droplevel(0)
            cols=dyn.columns
            time=dyn.shape[0]
            # for t in range(time):
            #     cols_t = [str(x) + "_"+str(t) for x in cols]
            #     concat_cols.extend(cols_t)
            demo['gender']=gen_encoder.transform(demo['gender'])
            demo['ethnicity']=eth_encoder.transform(demo['ethnicity'])
            demo['insurance']=ins_encoder.transform(demo['insurance'])
            label = data['label']
            demo = demo.drop(['label'],axis=1)
            X = self._generate_ml(dyn = dyn_df, stat = cond_df, demo = demo, concat_cols = concat_cols, concat = concat)
            columns = X.columns
            X = X.values.tolist()[0]

            yield int(i), {
                "label": label,
                "features": X,
                "columns":columns
            }

    def _generate_examples_text(self, filepath):
        self.load_vocab()

        with open(filepath, 'rb') as fp:
            dico = pickle.load(fp)

        for i, data in enumerate(dico):
            
        
        
        

            #adding demos informations
            age = str(round(data['age']))
            gender = str(data['gender'])
            if gender == "M":
                gender = "male"
            elif gender == "F":
                gender = "female"
            ethnicity = str(data['ethnicity'])
            insurance = str(data['insurance'])
            X = ""
            if self.mimic4_text_demos or self.mimic4_text_cond:
                X = "The patient "
            if self.mimic4_text_demos:
                if self.mimic4_text_cond:
                    X += "("+ethnicity+" "+gender+", "+age+" years old, covered by "+insurance+") "
                else:
                    X += "is "+ethnicity+" "+gender+", "+age+" years old, covered by "+insurance+". "


            #adding diagnosis
            if self.mimic4_text_cond:
                X += "was diagnosed with "
                cond = data['Cond']['fids']
                for idx,c in enumerate(cond):
                    X += self.full_cond.loc[self.full_cond["COND"] == str(c)]["LONG"].values[0]+("; " if idx+1 < len(cond) else ". ")

            #removing nan charts and aggregation

            if self.mimic4_text_charts:
                for x in data["Chart"]:
                    data["Chart"][x] = [xi for xi in data["Chart"][x] if not (xi == "" or (isinstance(xi,float) and np.isnan(xi)))]
                data["Chart"] = codes_to_int(data["Chart"])
                chart = {x:round(np.mean([it for it in data['Chart'][x]]),3) for x in data["Chart"] if len(data["Chart"][x]) > 0}

                #specials columns for chartevents
                for col in ["Glascow coma scale eye opening","Glascow coma scale motor response","Glascow coma scale verbal response"]:
                    if not col in chart:
                        continue
                    chart[col] = int(round(chart[col]))
                    for dtem in discretizer[col]:
                        if dtem[1] == chart[col]:
                            chart[col] = dtem[0][-1]
                for col in ["Glascow coma scale total"]:
                    if not col in chart:
                        continue
                    chart[col] = int(round(chart[col]))

                X += "The chart events measured were : "
                for idx,c in enumerate(chart):
                    X += str(chart[c]) + " for " + c + ("; " if (idx+1 < len(chart.keys())) else ". ")

            #medications
            if self.mimic4_text_meds:
                meds = data['Med']
                if len(meds.keys()) != 0:
                    X += "The mean amounts of medications administered during the episode were : "
                    meds = {x:round(np.mean([it for it in meds[x]]),3) for x in meds if len(meds[x]) > 0}
                    for idx,c in enumerate(meds):
                        if meds[c] != 0:
                            short = self.full_meds.loc[self.full_meds["MEDS"] == int(c)]["SHORT"].values[0]
                            long = self.full_meds.loc[self.full_meds["MEDS"] == int(c)]["LONG"].values[0]
                            name = long if (long != "nan" and not (isinstance(long,float) and np.isnan(long))) else short
                            if (name != "nan" and not (isinstance(name,float) and np.isnan(name))):
                                X += str(meds[c]) + " of " + name + ("; " if (idx+1 < len(meds.keys())) else ". ")
                else:
                    X += "No medication was administered."

            #procedures
            if self.mimic4_text_procs:
                proc = data['Proc']
                if len(proc.keys()) != 0:
                    X += "The procedures performed were: "
                    for idx,c in enumerate(proc):
                        short = self.full_proc.loc[self.full_proc["PROC"] == int(c)]["SHORT"].values[0]
                        long = self.full_proc.loc[self.full_proc["PROC"] == int(c)]["LONG"].values[0]
                        name = long if (long != "nan" and not (isinstance(long,float) and np.isnan(long))) else short
                        if (name != "nan" and not (isinstance(name,float) and np.isnan(name))):
                            X += str(name) + ("; " if (idx+1 < len(meds.keys())) else ". ")
                else:
                    X += "No procedure was performed."
            yield int(i), {
                "label": data['label'],
                "features": X,
            }


    #### GENERATION D'EXEMPLES ###############################################################

    def _generate_examples(self, filepath, split):
        if "mimic4" in self.config.name:
            if self.mode == "mimic4-aggreg":
                yield from self._generate_examples_encoded(filepath,False)
            elif self.mode == "mimic4-tensor":
                yield from self._generate_examples_deep(filepath)
            elif self.mode == "mimic4-naive-prompt":
                yield from self._generate_examples_text(filepath)
        else:
            yield from self._generate_exemples_CHARTONLY(filepath)