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)