Update Mimic4Dataset.py

Mimic4Dataset.py

@@ -8,6 +8,11 @@ import pickle
 import subprocess
 import shutil
 from urllib.request import urlretrieve
+from sklearn.model_selection import train_test_split
+from sklearn.preprocessing import LabelEncoder
+import numpy as np
+import tqdm
+import yaml
 
 
 _DESCRIPTION = """\
@@ -29,6 +34,201 @@ _CONFIG_URLS = {'los' : 'https://huggingface.co/datasets/thbndi/Mimic4Dataset/re
                 'phenotype' : 'https://huggingface.co/datasets/thbndi/Mimic4Dataset/resolve/main/config/phenotype.config',
                 'readmission' : 'https://huggingface.co/datasets/thbndi/Mimic4Dataset/resolve/main/config/readmission.config'
         }
+
+  
+
+def onehot(data,task,feat_cond=False,feat_proc=False,feat_out=False,feat_chart=False,feat_meds=False):
+    meds=data['MEDS']
+    proc = data['PROC']
+    out = data['OUT']
+    chart = data['CHART']
+    cond= data['COND']
+
+    cond_df=pd.DataFrame()
+    proc_df=pd.DataFrame()
+    out_df=pd.DataFrame()
+    chart_df=pd.DataFrame()
+    meds_df=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#########
+    if (feat_cond):
+        #get all conds
+        with open("./data/dict/"+task+"/condVocab", 'rb') as fp:
+            conDict = pickle.load(fp)
+        conds=pd.DataFrame(conDict,columns=['COND'])
+        features=pd.DataFrame(np.zeros([1,len(conds)]),columns=conds['COND'])
+
+        #onehot encode
+        if(cond ==[]):
+            cond_df=pd.DataFrame(np.zeros([1,len(features)]),columns=features['COND'])
+            cond_df=cond_df.fillna(0)
+        else:
+            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
+
+    ##########PROC#########
+    if (feat_proc):
+        with open("./data/dict/"+task+"/procVocab", 'rb') as fp:
+            procDic = pickle.load(fp)
+
+        feat=proc['id']
+        proc_val=proc['value']
+        procedures=pd.DataFrame(procDic,columns=['PROC'])
+        features=pd.DataFrame(np.zeros([1,len(procedures)]),columns=procedures['PROC'])
+        features.columns=pd.MultiIndex.from_product([["PROC"], features.columns])
+        if feat==[]:
+            proc_df=features.fillna(0)
+        else:
+            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)
+
+    ##########OUT#########
+    if (feat_out):
+        with open("./data/dict/"+task+"/outVocab", 'rb') as fp:
+            outDic = pickle.load(fp)
+
+        feat=out['id']
+        out_val=out['value']
+        outputs=pd.DataFrame(outDic,columns=['OUT'])
+        features=pd.DataFrame(np.zeros([1,len(outputs)]),columns=outputs['OUT'])
+        features.columns=pd.MultiIndex.from_product([["OUT"], features.columns])
+        if feat==[]:
+            out_df=features.fillna(0)
+        else:
+            outs=pd.DataFrame(columns=feat)
+            for o,v in zip(feat,out_val):
+                outs[o]=v
+            outs.columns=pd.MultiIndex.from_product([["OUT"], outs.columns])
+            out_df = pd.concat([features,outs],ignore_index=True).fillna(0)
+
+    ##########CHART#########
+    if (feat_chart):
+        with open("./data/dict/"+task+"/chartVocab", 'rb') as fp:
+            chartDic = pickle.load(fp)
+
+        charts=chart['val']
+        feat=charts['id']
+        chart_val=charts['value']
+        charts=pd.DataFrame(chartDic,columns=['CHART'])
+        features=pd.DataFrame(np.zeros([1,len(charts)]),columns=charts['CHART'])
+        features.columns=pd.MultiIndex.from_product([["CHART"], features.columns])
+        if feat==[]:
+            chart_df=features.fillna(0)
+        else:
+            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
+    if (feat_meds):
+        with open("./data/dict/"+task+"/medVocab", 'rb') as fp:
+                medDic = pickle.load(fp)
+
+        feat=meds['signal']['id']
+        med_val=meds['amount']['value']
+        meds=pd.DataFrame(medDic,columns=['MEDS'])
+        features=pd.DataFrame(np.zeros([1,len(meds)]),columns=meds['MEDS'])
+        features.columns=pd.MultiIndex.from_product([["MEDS"], features.columns])
+        if feat==[]:
+                meds_df=features.fillna(0)
+        else:
+                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,out_df,chart_df], axis=1)
+    return dyn_df,cond_df,demo
+
+def getXY(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=dyna.reshape(1,-1)
+        dyn_df=pd.DataFrame(data=dyna,columns=concat_cols)
+    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 encoding(X_data):
+    gen_encoder = LabelEncoder()
+    eth_encoder = LabelEncoder()
+    ins_encoder = LabelEncoder()
+    gen_encoder.fit(X_data['gender'])
+    eth_encoder.fit(X_data['ethnicity'])
+    ins_encoder.fit(X_data['insurance'])
+    X_data['gender']=gen_encoder.transform(X_data['gender'])
+    X_data['ethnicity']=eth_encoder.transform(X_data['ethnicity'])
+    X_data['insurance']=ins_encoder.transform(X_data['insurance'])
+    return X_data
+
+def generate_split(df,task,concat,feat_cond=True,feat_chart=True,feat_proc=True, feat_meds=True, feat_out=False):
+    task=task.replace(" ","_")
+    X_df=pd.DataFrame()   
+    #y_df=pd.DataFrame(df['label'],columns=['label'])
+    
+    for hid, data in tqdm(df.iterrows()):
+        concat_cols=[]
+        sample=data
+        dyn_df,cond_df,demo=onehot(sample,task,feat_cond,feat_chart,feat_proc, feat_meds, feat_out)
+        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)
+        
+        X= getXY(dyn_df,cond_df,demo,concat_cols,concat)
+        if X_df.empty:
+             X_df=pd.concat([X_df,X],axis=1)
+        else:
+            X_df = pd.concat([X_df, X], axis=0)
+    
+    X_df=X_df.fillna(0) 
+    X_df = encoding(X_df)
+    #X_df=X_df.drop(['label'], axis=1)
+    return X_df
+
+
 class Mimic4DatasetConfig(datasets.BuilderConfig):
     """BuilderConfig for Mimic4Dataset."""
 
@@ -43,9 +243,12 @@ class Mimic4Dataset(datasets.GeneratorBasedBuilder):
 
     def __init__(self, **kwargs):
         self.mimic_path = kwargs.pop("mimic_path", None)
-       
-        
+        self.encoding = kwargs.pop("encoding",True)
         self.config_path = kwargs.pop("config_path",None)
+        self.test_size = kwargs.pop("test_size",0.2)
+        self.val_size = kwargs.pop("val_size",0.1)
+
+        self.feat_cond, self.feat_chart, self.feat_proc, self.feat_meds, self.feat_out = self.create_cohort()
         super().__init__(**kwargs)
         
 
@@ -94,72 +297,23 @@ class Mimic4Dataset(datasets.GeneratorBasedBuilder):
 
     DEFAULT_CONFIG_NAME = "Mortality"
 
-    def _info(self):
-
-        features = datasets.Features(
-            {
-                "label": datasets.ClassLabel(names=["0", "1"]),
-                "gender": datasets.Value("string"),
-                "ethnicity": datasets.Value("string"),
-                "insurance": datasets.Value("string"),
-                "age": datasets.Value("int32"),
-                "COND": datasets.Sequence(datasets.Value("string")),
-                "MEDS": {
-                            "signal": 
-                                {
-                                    "id": datasets.Sequence(datasets.Value("int32")),
-                                    "value": datasets.Sequence(datasets.Sequence(datasets.Value("float32")))
-                                }
-                            ,
-                            "rate": 
-                                {
-                                    "id": datasets.Sequence(datasets.Value("int32")),
-                                    "value": datasets.Sequence(datasets.Sequence(datasets.Value("float32")))
-                                }
-                            ,
-                            "amount": 
-                                {
-                                    "id": datasets.Sequence(datasets.Value("int32")),
-                                    "value": datasets.Sequence(datasets.Sequence(datasets.Value("float32")))
-                                }
-                            
-                        },
-                "PROC":  {
-                            "id": datasets.Sequence(datasets.Value("int32")),
-                            "value": datasets.Sequence(datasets.Sequence(datasets.Value("float32")))
-                                },
-                "CHART":
-                    {
-                        "signal" : {
-                            "id": datasets.Sequence(datasets.Value("int32")),
-                            "value": datasets.Sequence(datasets.Sequence(datasets.Value("float32")))
-                                },
-                        "val" : {
-                            "id": datasets.Sequence(datasets.Value("int32")),
-                            "value": datasets.Sequence(datasets.Sequence(datasets.Value("float32")))
-                                },
-                    },
-                "OUT":  {
-                            "id": datasets.Sequence(datasets.Value("int32")),
-                            "value": datasets.Sequence(datasets.Sequence(datasets.Value("float32")))
-                                },
-                
-            }
-        )
-        return datasets.DatasetInfo(
-            description=_DESCRIPTION,
-            features=features,
-            homepage=_HOMEPAGE,
-            citation=_CITATION,
-        )
-
-    def _split_generators(self, dl_manager: datasets.DownloadManager()):
+    def map_dtype(self,dtype):
+        if pd.api.types.is_integer_dtype(dtype):
+            return datasets.Value('int64')
+        elif pd.api.types.is_float_dtype(dtype):
+            return datasets.Value('float64')
+        elif pd.api.types.is_string_dtype(dtype):
+            return datasets.Value('string')
+        else:
+            raise ValueError(f"Unsupported dtype: {dtype}")
+        
+    def create_cohort(self):
         if self.config.name == 'Phenotype' : self.config_path = _CONFIG_URLS['phenotype'] 
         if self.config.name == 'Readmission' : self.config_path = _CONFIG_URLS['readmission'] 
         if self.config.name == 'Length of Stay' : self.config_path = _CONFIG_URLS['los'] 
         if self.config.name == 'Mortality' : self.config_path = _CONFIG_URLS['mortality']
         if self.config.name in ['Phenotype Custom','Readmission Custom','Length of Stay Custom','Mortality Custom'] and self.config.name==None:
-            raise ValueError('Please select a config file')
+            raise ValueError('Please provide a config file')
         
         version = self.mimic_path.split('/')[-1]
         m = self.mimic_path.split('/')[-2]
@@ -226,18 +380,104 @@ class Mimic4Dataset(datasets.GeneratorBasedBuilder):
         config = self.config_path.split('/')[-1]
 
         script = 'python cohort.py '+ self.config.name.replace(" ","_") +" "+ self.mimic_path+ " "+path_bench+ " "+config
-        print(script)
+        
+        #####################################CHANGE##########
         if not os.path.exists(data_dir) :
-            os.system(script)
-        return [
-            datasets.SplitGenerator(name=datasets.Split.TRAIN, gen_kwargs={"filepath": data_dir}),
-        ]
-
+            os.system(script)       
+        #####################################CHANGE##########
+        config_path='./config/'+config
+        with open(config_path) as f:
+            config = yaml.safe_load(f)
+        feat_cond, feat_chart, feat_proc, feat_meds, feat_out = config['diagnosis'], config['chart'], config['proc'],  config['meds'], config['output']
 
-    def _generate_examples(self, filepath):
-        with open(filepath, 'rb') as fp:
+        with open(data_dir, 'rb') as fp:
             dataDic = pickle.load(fp)
-        for hid, data in dataDic.items():
+        data = pd.DataFrame.from_dict(dataDic)
+       
+        data=data.T
+        train_data, test_data = train_test_split(data, test_size=self.test_size, random_state=42)
+        train_data, val_data = train_test_split(test_data, test_size=self.val_size, random_state=42)
+        csv_dir = "./data/dict/"+self.config.name.replace(" ","_")
+
+        train_data.to_csv(csv_dir+'/train_data.csv',index=False)
+        val_data.to_csv(csv_dir+'/val_data.csv',index=False)
+        test_data.to_csv(csv_dir+'/test_data.csv',index=False)
+        return feat_cond, feat_chart, feat_proc, feat_meds, feat_out
+  
+###########################################################RAW##################################################################
+
+    def _info_raw(self):
+        features = datasets.Features(
+            {
+                "label": datasets.ClassLabel(num_classes=2,names=["0", "1"]),
+                "gender": datasets.Value("string"),
+                "ethnicity": datasets.Value("string"),
+                "insurance": datasets.Value("string"),
+                "age": datasets.Value("int32"),
+                "COND": datasets.Sequence(datasets.Value("string")),
+                "MEDS": {
+                            "signal": 
+                                {
+                                    "id": datasets.Sequence(datasets.Value("int32")),
+                                    "value": datasets.Sequence(datasets.Sequence(datasets.Value("float32")))
+                                }
+                            ,
+                            "rate": 
+                                {
+                                    "id": datasets.Sequence(datasets.Value("int32")),
+                                    "value": datasets.Sequence(datasets.Sequence(datasets.Value("float32")))
+                                }
+                            ,
+                            "amount": 
+                                {
+                                    "id": datasets.Sequence(datasets.Value("int32")),
+                                    "value": datasets.Sequence(datasets.Sequence(datasets.Value("float32")))
+                                }
+                            
+                        },
+                "PROC":  {
+                            "id": datasets.Sequence(datasets.Value("int32")),
+                            "value": datasets.Sequence(datasets.Sequence(datasets.Value("float32")))
+                                },
+                "CHART":
+                    {
+                        "signal" : {
+                            "id": datasets.Sequence(datasets.Value("int32")),
+                            "value": datasets.Sequence(datasets.Sequence(datasets.Value("float32")))
+                                },
+                        "val" : {
+                            "id": datasets.Sequence(datasets.Value("int32")),
+                            "value": datasets.Sequence(datasets.Sequence(datasets.Value("float32")))
+                                },
+                    },
+                "OUT":  {
+                            "id": datasets.Sequence(datasets.Value("int32")),
+                            "value": datasets.Sequence(datasets.Sequence(datasets.Value("float32")))
+                                },
+                
+            }
+        )
+        return datasets.DatasetInfo(
+            description=_DESCRIPTION,
+            features=features,
+            homepage=_HOMEPAGE,
+            citation=_CITATION,
+        )
+
+    def _split_generators_raw(self):
+        
+        csv_dir = "./data/dict/"+self.config.name.replace(" ","_")
+
+        split_generators = {
+            "train": datasets.SplitGenerator(name=datasets.Split.TRAIN, gen_kwargs={"filepath": csv_dir+'/train_data.csv'}),
+            "val": datasets.SplitGenerator(name=datasets.Split.VALIDATION, gen_kwargs={"filepath": csv_dir+'/val_data.csv'}),
+            "test": datasets.SplitGenerator(name=datasets.Split.TEST, gen_kwargs={"filepath": csv_dir+'/test_data.csv'}),
+        }
+        return split_generators
+
+    def _generate_examples_raw(self, filepath):
+        df = pd.read_csv(filepath, header=0)
+        for hid, data in df.iterrows():
             proc_features = data['Proc']
             chart_features = data['Chart']
             meds_features = data['Med']
@@ -326,3 +566,50 @@ class Mimic4Dataset(datasets.GeneratorBasedBuilder):
                 "MEDS" : meds
             }
 
+
+###########################################################ENCODED##################################################################
+       
+    def _info_encoded(self):
+        X_df = pd.read_csv("./data/dict/"+self.config.name.replace(" ","_")+'/train_data_encoded.csv', header=0)
+        columns = {col: self.map_dtype(X_df[col].dtype) for col in X_df.columns}
+        features = datasets.Features(columns)
+        return datasets.DatasetInfo(
+            description=_DESCRIPTION,
+            features=features,
+            homepage=_HOMEPAGE,
+            citation=_CITATION,
+        )
+    
+    def _split_generators_encoded(self):
+        csv_dir = "./data/dict/"+self.config.name.replace(" ","_")
+
+        split_generators = {
+            "train": datasets.SplitGenerator(name=datasets.Split.TRAIN, gen_kwargs={"filepath": csv_dir+'/train_data_encoded.csv'}),
+            "val": datasets.SplitGenerator(name=datasets.Split.VALIDATION, gen_kwargs={"filepath": csv_dir+'/val_data_encoded.csv'}),
+            "test": datasets.SplitGenerator(name=datasets.Split.TEST, gen_kwargs={"filepath": csv_dir+'/test_data_encoded.csv'}),
+        }
+        return split_generators
+
+    def _generate_examples_encoded(self, filepath):
+        df = pd.read_csv(filepath, header=0)
+        X_df=generate_split(df,self.config.name,True,self.feat_cond, self.feat_chart, self.feat_proc, self.feat_meds, self.feat_out)
+
+#############################################################################################################################
+    def _info(self):
+        if self.encoding :
+            return self._info_encoded()
+        else:
+            return self._info_raw()
+
+    def _split_generators(self, dl_manager):
+        if self.encoding :
+            return self._split_generators_encoded()
+        else:
+            return self._split_generators_raw()
+
+    def _generate_examples(self, filepath):
+        if not self.encoding :
+            yield from self._generate_examples_raw(filepath)
+        else:
+            yield from self._generate_examples_encoded(filepath)
+