Upload 6 files

cohort.py

@@ -0,0 +1,136 @@
+import ipywidgets as widgets
+import sys
+from pathlib import Path
+import os
+import importlib
+sys.path.append('preprocessing/day_intervals_preproc')
+sys.path.append('utils')
+sys.path.append('preprocessing/hosp_module_preproc')
+sys.path.append('model')
+#print(sys.path)
+root_dir = os.path.dirname(os.path.abspath('UserInterface.ipynb'))
+import day_intervals_cohort_v2
+import day_intervals_cohort
+import feature_selection_icu
+import data_generation_icu_modify
+import time
+import yaml
+
+def task_cohort(task,mimic_path):
+    version_path = mimic_path
+    version = version_path.split('/')[-1][0]
+    start = time.time()
+    #----------------------------------------------config----------------------------------------------------
+    if task=='Mortality':
+        with open('./config/mortality.config') as f:
+            config = yaml.safe_load(f)
+
+    elif task == 'Phenotype':
+        with open('./config/phenotype.config') as f:
+            config = yaml.safe_load(f)
+
+    elif task == 'Length of Stay':
+        with open('./config/los.config') as f:
+            config = yaml.safe_load(f)
+
+    elif task == 'Readmission':
+        with open('./config/readmission.config') as f:
+            config = yaml.safe_load(f)
+
+    disease_label =  config['disease_label']
+    tim = config['time']
+    label = config['label']
+    timeW = config['timeW']
+    include=int(timeW.split()[1])
+    bucket = config['bucket']
+    radimp = config['radimp']
+    predW = config['predW']
+    diag_flag = config['diagnosis']
+    out_flag = config['output']
+    chart_flag = config['chart']
+    proc_flag= config['proc']
+    med_flag = config['meds']
+    disease_filter = config['disease_filter']
+    icu_no_icu = config['icu_no_icu']
+    groupingICD = config['groupingICD']
+    # -------------------------------------------------------------------------------------------------------------
+
+    data_icu=icu_no_icu=="ICU"
+    data_mort=label=="Mortality"
+    data_admn=label=='Readmission'
+    data_los=label=='Length of Stay'
+
+    if (disease_filter=="Heart Failure"):
+        icd_code='I50'
+    elif (disease_filter=="CKD"):
+        icd_code='N18'
+    elif (disease_filter=="COPD"):
+        icd_code='J44'
+    elif (disease_filter=="CAD"):
+        icd_code='I25'
+    else:
+        icd_code='No Disease Filter'
+
+    #-----------------------------------------------EXTRACT MIMIC-----------------------------------------------------
+    if version == '2':
+        cohort_output = day_intervals_cohort_v2.extract_data(icu_no_icu,label,tim,icd_code, root_dir,disease_label)
+    elif version == '1':
+        cohort_output = day_intervals_cohort.extract_data(icu_no_icu,label,tim,icd_code, root_dir,disease_label)
+    end = time.time()
+    print("Time elapsed : ", round((end - start)/60,2),"mins")
+    #----------------------------------------------FEATURES-------------------------------------------------------
+    if data_icu :
+        feature_selection_icu.feature_icu(cohort_output, version_path,diag_flag,out_flag,chart_flag,proc_flag,med_flag)
+    end = time.time()
+    print("Time elapsed : ", round((end - start)/60,2),"mins")
+    #----------------------------------------------GROUPING-------------------------------------------------------
+    group_diag=False
+    group_med=False
+    group_proc=False
+    if data_icu:
+        if diag_flag:
+            group_diag=groupingICD
+        feature_selection_icu.preprocess_features_icu(cohort_output, diag_flag, group_diag,False,False,False,0,0)
+    end = time.time()
+    print("Time elapsed : ", round((end - start)/60,2),"mins")
+    #----------------------------------------------SUMMARY-------------------------------------------------------
+    if data_icu:
+        feature_selection_icu.generate_summary_icu(cohort_output,diag_flag,proc_flag,med_flag,out_flag,chart_flag)
+    end = time.time()
+    print("Time elapsed : ", round((end - start)/60,2),"mins")
+    #----------------------------------------------FEATURE SELECTION---------------------------------------------
+
+    select_diag= config['select_diag']
+    select_med= config['select_med']
+    select_proc=  config['select_proc']
+    #select_lab= config['select_lab']
+    select_out= config['select_out']
+    select_chart=  config['select_chart']
+
+    feature_selection_icu.features_selection_icu(cohort_output, diag_flag,proc_flag,med_flag,out_flag, chart_flag,select_diag,select_med,select_proc,select_out,select_chart)
+    end = time.time()
+    print("Time elapsed : ", round((end - start)/60,2),"mins")
+    #---------------------------------------CLEANING OF FEATURES-----------------------------------------------
+    thresh=0
+    if data_icu:
+        if chart_flag:
+            outlier_removal=config['outlier_removal']
+            clean_chart=outlier_removal!='No outlier detection'
+            impute_outlier_chart=outlier_removal=='Impute Outlier (default:98)'
+            thresh=config['outlier']
+            left_thresh=config['left_outlier']
+        feature_selection_icu.preprocess_features_icu(cohort_output, False, False,chart_flag,clean_chart,impute_outlier_chart,thresh,left_thresh)
+    end = time.time()
+    print("Time elapsed : ", round((end - start)/60,2),"mins")
+    # ---------------------------------------tim-Series Representation--------------------------------------------
+    if radimp == 'forward fill and mean' :
+        impute='Mean'
+    elif radimp =='forward fill and median':
+        impute = 'Median'
+    else :
+        impute = False
+    
+    if data_icu:
+        gen=data_generation_icu_modify.Generator(task,cohort_output,data_mort,data_admn,data_los,diag_flag,proc_flag,out_flag,chart_flag,med_flag,impute,include,bucket,predW)
+    print("[============TASK COHORT SUCCESSFULLY CREATED============]")
+

data_generation_icu_modify.py

@@ -0,0 +1,581 @@
+import numpy as np
+import pandas as pd
+from tqdm import tqdm
+from datetime import datetime
+from sklearn.preprocessing import LabelEncoder
+import pickle
+import datetime
+import os
+import sys
+from pathlib import Path
+sys.path.append(os.path.dirname(os.path.abspath(__file__)) + './../..')
+if not os.path.exists("./data/dict"):
+    os.makedirs("./data/dict")
+if not os.path.exists("./data/csv"):
+    os.makedirs("./data/csv")
+    
+class Generator():
+    def __init__(self,task,cohort_output,if_mort,if_admn,if_los,feat_cond,feat_proc,feat_out,feat_chart,feat_med,impute,include_time=24,bucket=1,predW=6):
+        self.feat_cond,self.feat_proc,self.feat_out,self.feat_chart,self.feat_med = feat_cond,feat_proc,feat_out,feat_chart,feat_med
+        self.cohort_output=cohort_output
+        self.impute=impute
+        self.task = task
+        self.data = self.generate_adm()
+        if not os.path.exists("./data/dict/"+self.cohort_output):
+            os.makedirs("./data/dict/"+self.cohort_output)
+        print("[ READ COHORT ]")
+        
+        self.generate_feat()
+        print("[ READ ALL FEATURES ]")
+        
+        if if_mort:
+            self.mortality_length(include_time,predW)
+            print("[ PROCESSED TIME SERIES TO EQUAL LENGTH  ]")
+        elif if_admn:
+            self.readmission_length(include_time)
+            print("[ PROCESSED TIME SERIES TO EQUAL LENGTH  ]")
+        elif if_los:
+            self.los_length(include_time)
+            print("[ PROCESSED TIME SERIES TO EQUAL LENGTH  ]")
+        
+        self.smooth_meds(bucket)
+        print("[ SUCCESSFULLY SAVED DATA DICTIONARIES ]")
+    
+    def generate_feat(self):
+        if(self.feat_cond):
+            print("[ ======READING DIAGNOSIS ]")
+            self.generate_cond()
+        if(self.feat_proc):
+            print("[ ======READING PROCEDURES ]")
+            self.generate_proc()
+        if(self.feat_out):
+            print("[ ======READING OUT EVENTS ]")
+            self.generate_out()
+        if(self.feat_chart):
+            print("[ ======READING CHART EVENTS ]")
+            self.generate_chart()
+        if(self.feat_med):
+            print("[ ======READING MEDICATIONS ]")
+            self.generate_meds()
+
+    def generate_adm(self):
+        data=pd.read_csv(f"./data/cohort/{self.cohort_output}.csv.gz", compression='gzip', header=0, index_col=None)
+        data['intime'] = pd.to_datetime(data['intime'])
+        data['outtime'] = pd.to_datetime(data['outtime'])
+        data['los']=pd.to_timedelta(data['outtime']-data['intime'],unit='h')
+        data['los']=data['los'].astype(str)
+        data[['days', 'dummy','hours']] = data['los'].str.split(' ', expand=True)
+        data[['hours','min','sec']] = data['hours'].str.split(':', expand=True)
+        data['los']=pd.to_numeric(data['days'])*24+pd.to_numeric(data['hours'])
+        data=data.drop(columns=['days', 'dummy','hours','min','sec'])
+        data=data[data['los']>0]
+        data['Age']=data['Age'].astype(int)
+        #print(data.head())
+        #print(data.shape)
+        return data
+    
+    def generate_cond(self):
+        cond=pd.read_csv("./data/features/preproc_diag_icu.csv.gz", compression='gzip', header=0, index_col=None)
+        cond=cond[cond['stay_id'].isin(self.data['stay_id'])]
+        cond_per_adm = cond.groupby('stay_id').size().max()
+        self.cond, self.cond_per_adm = cond, cond_per_adm
+    
+    def generate_proc(self):
+        proc=pd.read_csv("./data/features/preproc_proc_icu.csv.gz", compression='gzip', header=0, index_col=None)
+        proc=proc[proc['stay_id'].isin(self.data['stay_id'])]
+        proc[['start_days', 'dummy','start_hours']] = proc['event_time_from_admit'].str.split(' ', -1, expand=True)
+        proc[['start_hours','min','sec']] = proc['start_hours'].str.split(':', -1, expand=True)
+        proc['start_time']=pd.to_numeric(proc['start_days'])*24+pd.to_numeric(proc['start_hours'])
+        proc=proc.drop(columns=['start_days', 'dummy','start_hours','min','sec'])
+        proc=proc[proc['start_time']>=0]
+        
+        ###Remove where event time is after discharge time
+        proc=pd.merge(proc,self.data[['stay_id','los']],on='stay_id',how='left')
+        proc['sanity']=proc['los']-proc['start_time']
+        proc=proc[proc['sanity']>0]
+        del proc['sanity']
+        
+        self.proc=proc
+        
+    def generate_out(self):
+        out=pd.read_csv("./data/features/preproc_out_icu.csv.gz", compression='gzip', header=0, index_col=None)
+        out=out[out['stay_id'].isin(self.data['stay_id'])]
+        out[['start_days', 'dummy','start_hours']] = out['event_time_from_admit'].str.split(' ', -1, expand=True)
+        out[['start_hours','min','sec']] = out['start_hours'].str.split(':', -1, expand=True)
+        out['start_time']=pd.to_numeric(out['start_days'])*24+pd.to_numeric(out['start_hours'])
+        out=out.drop(columns=['start_days', 'dummy','start_hours','min','sec'])
+        out=out[out['start_time']>=0]
+        
+        ###Remove where event time is after discharge time
+        out=pd.merge(out,self.data[['stay_id','los']],on='stay_id',how='left')
+        out['sanity']=out['los']-out['start_time']
+        out=out[out['sanity']>0]
+        del out['sanity']
+        
+        self.out=out
+        
+        
+    def generate_chart(self):
+        chunksize = 5000000
+        final=pd.DataFrame()
+        for chart in tqdm(pd.read_csv("./data/features/preproc_chart_icu.csv.gz", compression='gzip', header=0, index_col=None,chunksize=chunksize)):
+            chart=chart[chart['stay_id'].isin(self.data['stay_id'])]
+            chart[['start_days', 'dummy','start_hours']] = chart['event_time_from_admit'].str.split(' ', -1, expand=True)
+            chart[['start_hours','min','sec']] = chart['start_hours'].str.split(':', -1, expand=True)
+            chart['start_time']=pd.to_numeric(chart['start_days'])*24+pd.to_numeric(chart['start_hours'])
+            chart=chart.drop(columns=['start_days', 'dummy','start_hours','min','sec','event_time_from_admit'])
+            chart=chart[chart['start_time']>=0]
+
+            ###Remove where event time is after discharge time
+            chart=pd.merge(chart,self.data[['stay_id','los']],on='stay_id',how='left')
+            chart['sanity']=chart['los']-chart['start_time']
+            chart=chart[chart['sanity']>0]
+            del chart['sanity']
+            del chart['los']
+            
+            if final.empty:
+                final=chart
+            else:
+                final=final.append(chart, ignore_index=True)
+        
+        self.chart=final
+        
+        
+        
+    def generate_meds(self):
+        meds=pd.read_csv("./data/features/preproc_med_icu.csv.gz", compression='gzip', header=0, index_col=None)
+        meds[['start_days', 'dummy','start_hours']] = meds['start_hours_from_admit'].str.split(' ', -1, expand=True)
+        meds[['start_hours','min','sec']] = meds['start_hours'].str.split(':', -1, expand=True)
+        meds['start_time']=pd.to_numeric(meds['start_days'])*24+pd.to_numeric(meds['start_hours'])
+        meds[['start_days', 'dummy','start_hours']] = meds['stop_hours_from_admit'].str.split(' ', -1, expand=True)
+        meds[['start_hours','min','sec']] = meds['start_hours'].str.split(':', -1, expand=True)
+        meds['stop_time']=pd.to_numeric(meds['start_days'])*24+pd.to_numeric(meds['start_hours'])
+        meds=meds.drop(columns=['start_days', 'dummy','start_hours','min','sec'])
+        #####Sanity check
+        meds['sanity']=meds['stop_time']-meds['start_time']
+        meds=meds[meds['sanity']>0]
+        del meds['sanity']
+        #####Select hadm_id as in main file
+        meds=meds[meds['stay_id'].isin(self.data['stay_id'])]
+        meds=pd.merge(meds,self.data[['stay_id','los']],on='stay_id',how='left')
+
+        #####Remove where start time is after end of visit
+        meds['sanity']=meds['los']-meds['start_time']
+        meds=meds[meds['sanity']>0]
+        del meds['sanity']
+        ####Any stop_time after end of visit is set at end of visit
+        meds.loc[meds['stop_time'] > meds['los'],'stop_time']=meds.loc[meds['stop_time'] > meds['los'],'los']
+        del meds['los']
+        
+        meds['rate']=meds['rate'].apply(pd.to_numeric, errors='coerce')
+        meds['amount']=meds['amount'].apply(pd.to_numeric, errors='coerce')
+        
+        self.meds=meds
+    
+    def mortality_length(self,include_time,predW):
+        print("include_time",include_time)
+        self.los=include_time
+        self.data=self.data[(self.data['los']>=include_time+predW)]
+        self.hids=self.data['stay_id'].unique()
+        
+        if(self.feat_cond):
+            self.cond=self.cond[self.cond['stay_id'].isin(self.data['stay_id'])]
+        
+        self.data['los']=include_time
+
+        ####Make equal length input time series and remove data for pred window if needed
+        
+        ###MEDS
+        if(self.feat_med):
+            self.meds=self.meds[self.meds['stay_id'].isin(self.data['stay_id'])]
+            self.meds=self.meds[self.meds['start_time']<=include_time]
+            self.meds.loc[self.meds.stop_time >include_time, 'stop_time']=include_time
+                    
+        
+        ###PROCS
+        if(self.feat_proc):
+            self.proc=self.proc[self.proc['stay_id'].isin(self.data['stay_id'])]
+            self.proc=self.proc[self.proc['start_time']<=include_time]
+            
+        ###OUT
+        if(self.feat_out):
+            self.out=self.out[self.out['stay_id'].isin(self.data['stay_id'])]
+            self.out=self.out[self.out['start_time']<=include_time]
+            
+       ###CHART
+        if(self.feat_chart):
+            self.chart=self.chart[self.chart['stay_id'].isin(self.data['stay_id'])]
+            self.chart=self.chart[self.chart['start_time']<=include_time]
+        
+        #self.los=include_time
+    def los_length(self,include_time):
+        print("include_time",include_time)
+        self.los=include_time
+        self.data=self.data[(self.data['los']>=include_time)]
+        self.hids=self.data['stay_id'].unique()
+        
+        if(self.feat_cond):
+            self.cond=self.cond[self.cond['stay_id'].isin(self.data['stay_id'])]
+        
+        self.data['los']=include_time
+
+        ####Make equal length input time series and remove data for pred window if needed
+        
+        ###MEDS
+        if(self.feat_med):
+            self.meds=self.meds[self.meds['stay_id'].isin(self.data['stay_id'])]
+            self.meds=self.meds[self.meds['start_time']<=include_time]
+            self.meds.loc[self.meds.stop_time >include_time, 'stop_time']=include_time
+                    
+        
+        ###PROCS
+        if(self.feat_proc):
+            self.proc=self.proc[self.proc['stay_id'].isin(self.data['stay_id'])]
+            self.proc=self.proc[self.proc['start_time']<=include_time]
+            
+        ###OUT
+        if(self.feat_out):
+            self.out=self.out[self.out['stay_id'].isin(self.data['stay_id'])]
+            self.out=self.out[self.out['start_time']<=include_time]
+            
+       ###CHART
+        if(self.feat_chart):
+            self.chart=self.chart[self.chart['stay_id'].isin(self.data['stay_id'])]
+            self.chart=self.chart[self.chart['start_time']<=include_time]
+            
+    def readmission_length(self,include_time):
+        self.los=include_time
+        self.data=self.data[(self.data['los']>=include_time)]
+        self.hids=self.data['stay_id'].unique()
+        
+        if(self.feat_cond):
+            self.cond=self.cond[self.cond['stay_id'].isin(self.data['stay_id'])]
+        self.data['select_time']=self.data['los']-include_time
+        self.data['los']=include_time
+
+        ####Make equal length input time series and remove data for pred window if needed
+        
+        ###MEDS
+        if(self.feat_med):
+            self.meds=self.meds[self.meds['stay_id'].isin(self.data['stay_id'])]
+            self.meds=pd.merge(self.meds,self.data[['stay_id','select_time']],on='stay_id',how='left')
+            self.meds['stop_time']=self.meds['stop_time']-self.meds['select_time']
+            self.meds['start_time']=self.meds['start_time']-self.meds['select_time']
+            self.meds=self.meds[self.meds['stop_time']>=0]
+            self.meds.loc[self.meds.start_time <0, 'start_time']=0
+        
+        ###PROCS
+        if(self.feat_proc):
+            self.proc=self.proc[self.proc['stay_id'].isin(self.data['stay_id'])]
+            self.proc=pd.merge(self.proc,self.data[['stay_id','select_time']],on='stay_id',how='left')
+            self.proc['start_time']=self.proc['start_time']-self.proc['select_time']
+            self.proc=self.proc[self.proc['start_time']>=0]
+            
+        ###OUT
+        if(self.feat_out):
+            self.out=self.out[self.out['stay_id'].isin(self.data['stay_id'])]
+            self.out=pd.merge(self.out,self.data[['stay_id','select_time']],on='stay_id',how='left')
+            self.out['start_time']=self.out['start_time']-self.out['select_time']
+            self.out=self.out[self.out['start_time']>=0]
+            
+       ###CHART
+        if(self.feat_chart):
+            self.chart=self.chart[self.chart['stay_id'].isin(self.data['stay_id'])]
+            self.chart=pd.merge(self.chart,self.data[['stay_id','select_time']],on='stay_id',how='left')
+            self.chart['start_time']=self.chart['start_time']-self.chart['select_time']
+            self.chart=self.chart[self.chart['start_time']>=0]
+        
+            
+    def smooth_meds(self,bucket):
+        final_meds=pd.DataFrame()
+        final_proc=pd.DataFrame()
+        final_out=pd.DataFrame()
+        final_chart=pd.DataFrame()
+        
+        if(self.feat_med):
+            self.meds=self.meds.sort_values(by=['start_time'])
+        if(self.feat_proc):
+            self.proc=self.proc.sort_values(by=['start_time'])
+        if(self.feat_out):
+            self.out=self.out.sort_values(by=['start_time'])
+        if(self.feat_chart):
+            self.chart=self.chart.sort_values(by=['start_time'])
+        
+        t=0
+        for i in tqdm(range(0,self.los,bucket)): 
+            ###MEDS
+             if(self.feat_med):
+                sub_meds=self.meds[(self.meds['start_time']>=i) & (self.meds['start_time']<i+bucket)].groupby(['stay_id','itemid','orderid']).agg({'stop_time':'max','subject_id':'max','rate':np.nanmean,'amount':np.nanmean})
+                sub_meds=sub_meds.reset_index()
+                sub_meds['start_time']=t
+                sub_meds['stop_time']=sub_meds['stop_time']/bucket
+                if final_meds.empty:
+                    final_meds=sub_meds
+                else:
+                    final_meds=final_meds.append(sub_meds)
+            
+            ###PROC
+             if(self.feat_proc):
+                sub_proc=self.proc[(self.proc['start_time']>=i) & (self.proc['start_time']<i+bucket)].groupby(['stay_id','itemid']).agg({'subject_id':'max'})
+                sub_proc=sub_proc.reset_index()
+                sub_proc['start_time']=t
+                if final_proc.empty:
+                    final_proc=sub_proc
+                else:    
+                    final_proc=final_proc.append(sub_proc)
+                    
+              ###OUT
+             if(self.feat_out):
+                sub_out=self.out[(self.out['start_time']>=i) & (self.out['start_time']<i+bucket)].groupby(['stay_id','itemid']).agg({'subject_id':'max'})
+                sub_out=sub_out.reset_index()
+                sub_out['start_time']=t
+                if final_out.empty:
+                    final_out=sub_out
+                else:    
+                    final_out=final_out.append(sub_out)
+                    
+                    
+              ###CHART
+             if(self.feat_chart):
+                sub_chart=self.chart[(self.chart['start_time']>=i) & (self.chart['start_time']<i+bucket)].groupby(['stay_id','itemid']).agg({'valuenum':np.nanmean})
+                sub_chart=sub_chart.reset_index()
+                sub_chart['start_time']=t
+                if final_chart.empty:
+                    final_chart=sub_chart
+                else:    
+                    final_chart=final_chart.append(sub_chart)
+            
+             t=t+1
+        print("bucket",bucket)
+        los=int(self.los/bucket)
+        
+        
+        ###MEDS
+        if(self.feat_med):
+            f2_meds=final_meds.groupby(['stay_id','itemid','orderid']).size()
+            self.med_per_adm=f2_meds.groupby('stay_id').sum().reset_index()[0].max()                 
+            self.medlength_per_adm=final_meds.groupby('stay_id').size().max()
+        
+        ###PROC
+        if(self.feat_proc):
+            f2_proc=final_proc.groupby(['stay_id','itemid']).size()
+            self.proc_per_adm=f2_proc.groupby('stay_id').sum().reset_index()[0].max()       
+            self.proclength_per_adm=final_proc.groupby('stay_id').size().max()
+            
+        ###OUT
+        if(self.feat_out):
+            f2_out=final_out.groupby(['stay_id','itemid']).size()
+            self.out_per_adm=f2_out.groupby('stay_id').sum().reset_index()[0].max() 
+            self.outlength_per_adm=final_out.groupby('stay_id').size().max()
+            
+            
+        ###chart
+        if(self.feat_chart):
+            f2_chart=final_chart.groupby(['stay_id','itemid']).size()
+            self.chart_per_adm=f2_chart.groupby('stay_id').sum().reset_index()[0].max()             
+            self.chartlength_per_adm=final_chart.groupby('stay_id').size().max()
+        
+        print("[ PROCESSED TIME SERIES TO EQUAL TIME INTERVAL ]")
+        ###CREATE DICT
+#         if(self.feat_chart):
+#             self.create_chartDict(final_chart,los)
+#         else:
+        self.create_Dict(final_meds,final_proc,final_out,final_chart,los)
+        
+
+    def create_Dict(self,meds,proc,out,chart,los):
+        dataDic={}
+
+        for hid in self.hids:
+            grp=self.data[self.data['stay_id']==hid]
+            dataDic[hid]={'Cond':{},'Proc':{},'Med':{},'Out':{},'Chart':{},'ethnicity':grp['ethnicity'].iloc[0],'age':int(grp['Age']),'gender':grp['gender'].iloc[0],'label':int(grp['label'])}
+            
+
+        for hid in tqdm(self.hids):
+            grp=self.data[self.data['stay_id']==hid]
+            
+            ###MEDS
+            if(self.feat_med):
+                feat=meds['itemid'].unique()
+                df2=meds[meds['stay_id']==hid]
+                if df2.shape[0]==0:
+                    amount=pd.DataFrame(np.zeros([los,len(feat)]),columns=feat)
+                    amount=amount.fillna(0)
+                    amount.columns=pd.MultiIndex.from_product([["MEDS"], amount.columns])
+                else:
+                    rate=df2.pivot_table(index='start_time',columns='itemid',values='rate')
+                    #print(rate)
+                    amount=df2.pivot_table(index='start_time',columns='itemid',values='amount')
+                    df2=df2.pivot_table(index='start_time',columns='itemid',values='stop_time')
+                    #print(df2.shape)
+                    add_indices = pd.Index(range(los)).difference(df2.index)
+                    add_df = pd.DataFrame(index=add_indices, columns=df2.columns).fillna(np.nan)
+                    df2=pd.concat([df2, add_df])
+                    df2=df2.sort_index()
+                    df2=df2.ffill()
+                    df2=df2.fillna(0)
+
+                    rate=pd.concat([rate, add_df])
+                    rate=rate.sort_index()
+                    rate=rate.ffill()
+                    rate=rate.fillna(-1)
+
+                    amount=pd.concat([amount, add_df])
+                    amount=amount.sort_index()
+                    amount=amount.ffill()
+                    amount=amount.fillna(-1)
+                    #print(df2.head())
+                    df2.iloc[:,0:]=df2.iloc[:,0:].sub(df2.index,0)
+                    df2[df2>0]=1
+                    df2[df2<0]=0
+                    rate.iloc[:,0:]=df2.iloc[:,0:]*rate.iloc[:,0:]
+                    amount.iloc[:,0:]=df2.iloc[:,0:]*amount.iloc[:,0:]
+                    #print(df2.head())
+                    dataDic[hid]['Med']['signal']=df2.iloc[:,0:].to_dict(orient="list")
+                    dataDic[hid]['Med']['rate']=rate.iloc[:,0:].to_dict(orient="list")
+                    dataDic[hid]['Med']['amount']=amount.iloc[:,0:].to_dict(orient="list")
+    
+            ###PROCS
+            if(self.feat_proc):
+                feat=proc['itemid'].unique()
+                df2=proc[proc['stay_id']==hid]
+                if df2.shape[0]==0:
+                    df2=pd.DataFrame(np.zeros([los,len(feat)]),columns=feat)
+                    df2=df2.fillna(0)
+                    df2.columns=pd.MultiIndex.from_product([["PROC"], df2.columns])
+                else:
+                    df2['val']=1
+                    #print(df2)
+                    df2=df2.pivot_table(index='start_time',columns='itemid',values='val')
+                    #print(df2.shape)
+                    add_indices = pd.Index(range(los)).difference(df2.index)
+                    add_df = pd.DataFrame(index=add_indices, columns=df2.columns).fillna(np.nan)
+                    df2=pd.concat([df2, add_df])
+                    df2=df2.sort_index()
+                    df2=df2.fillna(0)
+                    df2[df2>0]=1
+                    #print(df2.head())
+                    dataDic[hid]['Proc']=df2.to_dict(orient="list")
+    
+            ###OUT
+            if(self.feat_out):
+                feat=out['itemid'].unique()
+                df2=out[out['stay_id']==hid]
+                if df2.shape[0]==0:
+                    df2=pd.DataFrame(np.zeros([los,len(feat)]),columns=feat)
+                    df2=df2.fillna(0)
+                    df2.columns=pd.MultiIndex.from_product([["OUT"], df2.columns])
+                else:
+                    df2['val']=1
+                    df2=df2.pivot_table(index='start_time',columns='itemid',values='val')
+                    #print(df2.shape)
+                    add_indices = pd.Index(range(los)).difference(df2.index)
+                    add_df = pd.DataFrame(index=add_indices, columns=df2.columns).fillna(np.nan)
+                    df2=pd.concat([df2, add_df])
+                    df2=df2.sort_index()
+                    df2=df2.fillna(0)
+                    df2[df2>0]=1
+                    #print(df2.head())
+                    dataDic[hid]['Out']=df2.to_dict(orient="list")
+        
+            ###CHART
+            if(self.feat_chart):
+                feat=chart['itemid'].unique()
+                df2=chart[chart['stay_id']==hid]
+                if df2.shape[0]==0:
+                    val=pd.DataFrame(np.zeros([los,len(feat)]),columns=feat)
+                    val=val.fillna(0)
+                    val.columns=pd.MultiIndex.from_product([["CHART"], val.columns])
+                else:
+                    val=df2.pivot_table(index='start_time',columns='itemid',values='valuenum')
+                    df2['val']=1
+                    df2=df2.pivot_table(index='start_time',columns='itemid',values='val')
+                    #print(df2.shape)
+                    add_indices = pd.Index(range(los)).difference(df2.index)
+                    add_df = pd.DataFrame(index=add_indices, columns=df2.columns).fillna(np.nan)
+                    df2=pd.concat([df2, add_df])
+                    df2=df2.sort_index()
+                    df2=df2.fillna(0)
+
+                    val=pd.concat([val, add_df])
+                    val=val.sort_index()
+                    if self.impute=='Mean':
+                        val=val.ffill()
+                        val=val.bfill()
+                        val=val.fillna(val.mean())
+                    elif self.impute=='Median':
+                        val=val.ffill()
+                        val=val.bfill()
+                        val=val.fillna(val.median())
+                    val=val.fillna(0)
+
+
+                    df2[df2>0]=1
+                    df2[df2<0]=0
+                    #print(df2.head())
+                    dataDic[hid]['Chart']['signal']=df2.iloc[:,0:].to_dict(orient="list")
+                    dataDic[hid]['Chart']['val']=val.iloc[:,0:].to_dict(orient="list")
+            
+            ##########COND#########
+            if(self.feat_cond):
+                feat=self.cond['new_icd_code'].unique()
+                grp=self.cond[self.cond['stay_id']==hid]
+                if(grp.shape[0]==0):
+                    dataDic[hid]['Cond']={'fids':list(['<PAD>'])}
+                else:
+                    dataDic[hid]['Cond']={'fids':list(grp['new_icd_code'])}
+            
+                
+        ######SAVE DICTIONARIES##############
+        metaDic={'Cond':{},'Proc':{},'Med':{},'Out':{},'Chart':{},'LOS':{}}
+        metaDic['LOS']=los
+        with open("./data/dict/dataDic", 'wb') as fp:
+            pickle.dump(dataDic, fp)
+
+        with open("./data/dict/hadmDic", 'wb') as fp:
+            pickle.dump(self.hids, fp)
+        
+        with open("./data/dict/ethVocab", 'wb') as fp:
+            pickle.dump(list(self.data['ethnicity'].unique()), fp)
+            self.eth_vocab = self.data['ethnicity'].nunique()
+            
+        with open("./data/dict/ageVocab", 'wb') as fp:
+            pickle.dump(list(self.data['Age'].unique()), fp)
+            self.age_vocab = self.data['Age'].nunique()
+            
+        with open("./data/dict/insVocab", 'wb') as fp:
+            pickle.dump(list(self.data['insurance'].unique()), fp)
+            self.ins_vocab = self.data['insurance'].nunique()
+            
+        if(self.feat_med):
+            with open("./data/dict/medVocab", 'wb') as fp:
+                pickle.dump(list(meds['itemid'].unique()), fp)
+            self.med_vocab = meds['itemid'].nunique()
+            metaDic['Med']=self.med_per_adm
+            
+        if(self.feat_out):
+            with open("./data/dict/outVocab", 'wb') as fp:
+                pickle.dump(list(out['itemid'].unique()), fp)
+            self.out_vocab = out['itemid'].nunique()
+            metaDic['Out']=self.out_per_adm
+            
+        if(self.feat_chart):
+            with open("./data/dict/chartVocab", 'wb') as fp:
+                pickle.dump(list(chart['itemid'].unique()), fp)
+            self.chart_vocab = chart['itemid'].nunique()
+            metaDic['Chart']=self.chart_per_adm
+        
+        if(self.feat_cond):
+            with open("./data/dict/condVocab", 'wb') as fp:
+                pickle.dump(list(self.cond['new_icd_code'].unique()), fp)
+            self.cond_vocab = self.cond['new_icd_code'].nunique()
+            metaDic['Cond']=self.cond_per_adm
+        
+        if(self.feat_proc):    
+            with open("./data/dict/procVocab", 'wb') as fp:
+                pickle.dump(list(proc['itemid'].unique()), fp)
+            self.proc_vocab = proc['itemid'].nunique()
+            metaDic['Proc']=self.proc_per_adm
+            
+        with open("./data/dict/metaDic", 'wb') as fp:
+            pickle.dump(metaDic, fp)

los.config

@@ -0,0 +1,23 @@
+disease_label: null
+time: 3
+label: Length of Stay
+timeW: First 24 hours
+bucket: 2
+radimp: forward fill and mean
+predW: 0
+diagnosis: True
+output: True
+chart: True
+proc: True
+meds: True
+disease_filter: No Disease Filter
+icu_no_icu: ICU
+groupingICD: Convert ICD-9 to ICD-10 and group ICD-10 codes
+select_diag: False
+select_med: False
+select_proc: False
+select_out: False
+select_chart: False
+outlier_removal: Impute Outlier (default:98)
+outlier: 98
+left_outlier: 0

mortality.config

@@ -0,0 +1,23 @@
+disease_label: null
+time: 0
+label: Mortality
+timeW: First 48 hours
+bucket: 2
+radimp: forward fill and mean
+predW: 6
+diagnosis: True
+output: True
+chart: True
+proc: True
+meds: True
+disease_filter: No Disease Filter
+icu_no_icu: ICU
+groupingICD: Convert ICD-9 to ICD-10 and group ICD-10 codes
+select_diag: False
+select_med: False
+select_proc: False
+select_out: False
+select_chart: False
+outlier_removal: Impute Outlier (default:98)
+outlier: 98
+left_outlier: 0

phenotype.config

@@ -0,0 +1,23 @@
+disease_label: I50
+time: 30
+label: Readmission
+timeW: Last 72 hours
+bucket: 2
+radimp: forward fill and mean
+predW: 0
+diagnosis: True
+output: True
+chart: True
+proc: True
+meds: True
+disease_filter: No Disease Filter
+icu_no_icu: ICU
+groupingICD: Convert ICD-9 to ICD-10 and group ICD-10 codes
+select_diag: False
+select_med: False
+select_proc: False
+select_out: False
+select_chart: False
+outlier_removal: Impute Outlier (default:98)
+outlier: 98
+left_outlier: 0

readmission.config

@@ -0,0 +1,23 @@
+disease_label: null
+time: 30
+label: Readmission
+timeW: Last 72 hours
+bucket: 2
+radimp: forward fill and mean
+predW: 0
+diagnosis: True
+output: True
+chart: True
+proc: True
+meds: True
+disease_filter: No Disease Filter
+icu_no_icu: ICU
+groupingICD: Convert ICD-9 to ICD-10 and group ICD-10 codes
+select_diag: False
+select_med: False
+select_proc: False
+select_out: False
+select_chart: False
+outlier_removal: Impute Outlier (default:98)
+outlier: 98
+left_outlier: 0