dataset_utils.py

import pandas as pd
import pickle
import numpy as np
import torch


def create_vocab(file,task):
    with open ('./data/dict/'+task+'/'+file, 'rb') as fp:
        condVocab = pickle.load(fp)
    condVocabDict={}
    condVocabDict[0]=0
    for val in range(len(condVocab)):
        condVocabDict[condVocab[val]]= val+1    

    return condVocabDict

def gender_vocab():
    genderVocabDict={}
    genderVocabDict['<PAD>']=0
    genderVocabDict['M']=1
    genderVocabDict['F']=2

    return genderVocabDict

def vocab(task,diag_flag,proc_flag,out_flag,chart_flag,med_flag,lab_flag):
        condVocabDict={}
        procVocabDict={}
        medVocabDict={}
        outVocabDict={}
        chartVocabDict={}
        labVocabDict={}
        ethVocabDict={}
        ageVocabDict={}
        genderVocabDict={}
        insVocabDict={}
        
        ethVocabDict=create_vocab('ethVocab',task)
        with open('./data/dict/'+task+'/ethVocabDict', 'wb') as fp:
            pickle.dump(ethVocabDict, fp)
            
        ageVocabDict=create_vocab('ageVocab',task)
        with open('./data/dict/'+task+'/ageVocabDict', 'wb') as fp:
            pickle.dump(ageVocabDict, fp)
        
        genderVocabDict=gender_vocab()
        with open('./data/dict/'+task+'/genderVocabDict', 'wb') as fp:
            pickle.dump(genderVocabDict, fp)
            
        insVocabDict=create_vocab('insVocab',task)
        with open('./data/dict/'+task+'/insVocabDict', 'wb') as fp:
            pickle.dump(insVocabDict, fp)
        
        if diag_flag:
            file='condVocab'
            with open ('./data/dict/'+task+'/'+file, 'rb') as fp:
                condVocabDict = pickle.load(fp)
        if proc_flag:
            file='procVocab'
            with open ('./data/dict/'+task+'/'+file, 'rb') as fp:
                procVocabDict = pickle.load(fp)
        if med_flag:
            file='medVocab'
            with open ('./data/dict/'+task+'/'+file, 'rb') as fp:
                medVocabDict = pickle.load(fp)
        if out_flag:
            file='outVocab'
            with open ('./data/dict/'+task+'/'+file, 'rb') as fp:
                outVocabDict = pickle.load(fp)
        if chart_flag:
            file='chartVocab'
            with open ('./data/dict/'+task+'/'+file, 'rb') as fp:
                chartVocabDict = pickle.load(fp)
        if lab_flag:
            file='labsVocab'
            with open ('./data/dict/'+task+'/'+file, 'rb') as fp:
                labVocabDict = pickle.load(fp)
        
        return len(condVocabDict),len(procVocabDict),len(medVocabDict),len(outVocabDict),len(chartVocabDict),len(labVocabDict),ethVocabDict,genderVocabDict,ageVocabDict,insVocabDict

def open_dict(task,cond, proc, out, chart, lab, med):
    if cond:
        with open("./data/dict/"+task+"/condVocab", 'rb') as fp:
            condDict = pickle.load(fp)
    else:
        condDict = None
    if proc:
        with open("./data/dict/"+task+"/procVocab", 'rb') as fp:
            procDict = pickle.load(fp)
    else:
        procDict = None
    if out:
        with open("./data/dict/"+task+"/outVocab", 'rb') as fp:
            outDict = pickle.load(fp)
    else:
        outDict = None
    if chart:
        with open("./data/dict/"+task+"/chartVocab", 'rb') as fp:
            chartDict = pickle.load(fp)
    elif lab:
        with open("./data/dict/"+task+"/labsVocab", 'rb') as fp:
            chartDict = pickle.load(fp)
    else:
        chartDict = None
    if med:
        with open("./data/dict/"+task+"/medVocab", 'rb') as fp:
            medDict = pickle.load(fp)
    else:
        medDict = None
    
    return condDict, procDict, outDict, chartDict, medDict

def concat_data(data,task,feat_cond,feat_proc,feat_out,feat_chart,feat_meds,feat_lab,condDict, procDict, outDict, chartDict, medDict):
    meds=data['Med']
    proc = data['Proc']
    out = data['Out']
    chart = data['Chart']
    cond= data['Cond']['fids']

    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):
        conds=pd.DataFrame(condDict,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
            for c in cond_df.columns :
                if c not in features: 
                    cond_df=cond_df.drop(columns=[c])

    ##########PROC#########
    if (feat_proc):
        if proc :
            feat=proc.keys()
            proc_val=[proc[key] for key in feat]
            procedures=pd.DataFrame(procDict,columns=['PROC'])
            features=pd.DataFrame(np.zeros([1,len(procedures)]),columns=procedures['PROC'])
            procs=pd.DataFrame(columns=feat)
            for p,v in zip(feat,proc_val):
                procs[p]=v
            features=features.drop(columns=procs.columns.to_list())
            proc_df = pd.concat([features,procs],axis=1).fillna(0)
            proc_df.columns=pd.MultiIndex.from_product([["PROC"], proc_df.columns])
        else:
            procedures=pd.DataFrame(procDict,columns=['PROC'])
            features=pd.DataFrame(np.zeros([1,len(procedures)]),columns=procedures['PROC'])
            features.columns=pd.MultiIndex.from_product([["PROC"], features.columns])
            proc_df=features.fillna(0)

    ##########OUT#########
    if (feat_out):
        if out :
            feat=out.keys()
            out_val=[out[key] for key in feat]
            outputs=pd.DataFrame(outDict,columns=['OUT'])
            features=pd.DataFrame(np.zeros([1,len(outputs)]),columns=outputs['OUT'])
            outs=pd.DataFrame(columns=feat)
            for o,v in zip(feat,out_val):
                outs[o]=v
            features=features.drop(columns=outs.columns.to_list())
            out_df = pd.concat([features,outs],axis=1).fillna(0)
            out_df.columns=pd.MultiIndex.from_product([["OUT"], out_df.columns])
        else:
            outputs=pd.DataFrame(outDict,columns=['OUT'])
            features=pd.DataFrame(np.zeros([1,len(outputs)]),columns=outputs['OUT'])
            features.columns=pd.MultiIndex.from_product([["OUT"], features.columns])
            out_df=features.fillna(0)

    ##########CHART#########
    if (feat_chart):
        if chart:
            charts=chart['val']
            feat=charts.keys()
            chart_val=[charts[key] for key in feat]
            charts=pd.DataFrame(chartDict,columns=['CHART'])
            features=pd.DataFrame(np.zeros([1,len(charts)]),columns=charts['CHART'])
            chart=pd.DataFrame(columns=feat)
            for c,v in zip(feat,chart_val):
                chart[c]=v
            features=features.drop(columns=chart.columns.to_list())
            chart_df = pd.concat([features,chart],axis=1).fillna(0)
            chart_df.columns=pd.MultiIndex.from_product([["CHART"], chart_df.columns])
        else:
            charts=pd.DataFrame(chartDict,columns=['CHART'])
            features=pd.DataFrame(np.zeros([1,len(charts)]),columns=charts['CHART'])
            features.columns=pd.MultiIndex.from_product([["CHART"], features.columns])
            chart_df=features.fillna(0)
        ##########LAB#########
    
    if (feat_lab):
        if chart:
            charts=chart['val']
            feat=charts.keys()
            chart_val=[charts[key] for key in feat]
            charts=pd.DataFrame(chartDict,columns=['LAB'])
            features=pd.DataFrame(np.zeros([1,len(charts)]),columns=charts['LAB'])
            chart=pd.DataFrame(columns=feat)
            for c,v in zip(feat,chart_val):
                chart[c]=v
            features=features.drop(columns=chart.columns.to_list())
            chart.columns=pd.MultiIndex.from_product([["LAB"], chart.columns])
            chart_df = pd.concat([features,chart],axis=1).fillna(0)
            chart_df.columns=pd.MultiIndex.from_product([["LAB"], chart_df.columns])
        else:
            charts=pd.DataFrame(chartDict,columns=['LAB'])
            features=pd.DataFrame(np.zeros([1,len(charts)]),columns=charts['LAB'])
            features.columns=pd.MultiIndex.from_product([["LAB"], features.columns])
            chart_df=features.fillna(0)
    
    ###MEDS
    if (feat_meds):
        if meds:
            feat=meds['signal'].keys()
            med_val=[meds['amount'][key] for key in feat]
            meds=pd.DataFrame(medDict,columns=['MEDS'])
            features=pd.DataFrame(np.zeros([1,len(meds)]),columns=meds['MEDS'])
            med=pd.DataFrame(columns=feat)
            for m,v in zip(feat,med_val):
                med[m]=v
            features=features.drop(columns=med.columns.to_list())
            meds_df = pd.concat([features,med],axis=1).fillna(0)
            meds_df.columns=pd.MultiIndex.from_product([["MEDS"], meds_df.columns])
        else:
            meds=pd.DataFrame(medDict,columns=['MEDS'])
            features=pd.DataFrame(np.zeros([1,len(meds)]),columns=meds['MEDS'])
            features.columns=pd.MultiIndex.from_product([["MEDS"], features.columns])
            meds_df=features.fillna(0)

    dyn_df = pd.concat([meds_df,proc_df,out_df,chart_df], axis=1)
    return dyn_df,cond_df,demo



def generate_deep(data,task,feat_cond,feat_proc,feat_out,feat_chart,feat_meds,feat_lab,condDict, procDict, outDict, chartDict, medDict):
    meds = []
    charts = []
    proc = []
    out = []
    lab = []
    stat = []
    demo = []
    
    size_cond, size_proc, size_meds, size_out, size_chart, size_lab, eth_vocab,gender_vocab,age_vocab,ins_vocab=vocab(task.replace(" ","_"),feat_cond,feat_proc,feat_out,feat_chart,feat_meds,False)
    dyn,cond_df,demo=concat_data(data,task.replace(" ","_"),feat_cond,feat_proc,feat_out,feat_chart,feat_meds,feat_lab,condDict, procDict, outDict, chartDict, medDict)
    if feat_chart:
        charts = dyn['CHART'].values
    if feat_meds:
        meds = dyn['MEDS'].values
    if feat_proc:
        proc = dyn['PROC'].values
        print(proc)
    if feat_out:
        out = dyn['OUT'].values
    if feat_lab:
        lab = dyn['LAB'].values
    if feat_cond:
        stat=cond_df.values[0]
    y = int(demo['label'])
    
    demo["gender"].replace(gender_vocab, inplace=True)
    demo["ethnicity"].replace(eth_vocab, inplace=True)
    demo["insurance"].replace(ins_vocab, inplace=True)
    demo["Age"].replace(age_vocab, inplace=True)
    demo=demo[["gender","ethnicity","insurance","Age"]]
    demo = demo.values[0]
    return stat, demo, meds, charts, out, proc, lab, y


def generate_ml(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)
    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_text(data,icd,items,feat_cond,feat_chart,feat_meds, feat_proc, feat_out):
    #Diagnosis
    if feat_cond:
        conds = data.get('Cond', {}).get('fids', [])
        conds=[icd[icd['code'] == code]['description'].to_string(index=False) for code in conds if not icd[icd['code'] == code].empty]
        cond_text = '; '.join(conds)
        cond_text = f"The patient was diagnosed with {cond_text}." if cond_text else ''
    else:
        cond_text = ''
            
    #chart
    if feat_chart:
        chart = data.get('Chart', {})
        if chart:
            charts = chart.get('val', {})
            feat = charts.keys()
            chart_val = [charts[key] for key in feat]
            chart_mean = [round(np.mean(c), 3) for c in chart_val]
            feat_text = [(items[items['itemid'] == f]['label']).to_string(index=False) for f in feat]
            chart_text = '; '.join(f"{mean_val} for {feat_label}" for mean_val, feat_label in zip(chart_mean, feat_text))
            chart_text = f"The chart events measured were: {chart_text}."
        else:
            chart_text = ''
    else:
        chart_text = ''
        
        
    #meds
    if feat_meds:
        meds = data.get('Med', {})
        if meds:
            feat = meds['signal'].keys()
            meds_val = [meds['amount'][key] for key in feat]
            meds_mean = [round(np.mean(c), 3) for c in meds_val]
            feat_text = [(items[items['itemid'] == f]['label']).to_string(index=False) for f in feat]
            meds_text = '; '.join(f"{mean_val} of {feat_label}" for mean_val, feat_label in zip(meds_mean, feat_text))
            meds_text = f"The mean amounts of medications administered during the episode were: {meds_text}."
        else:
            meds_text = ''
    else:
        meds_text = ''

    #proc
    if feat_proc:  
        proc = data['Proc']
        if proc:
            feat=proc.keys()
            feat_text = [(items[items['itemid']==f]['label']).to_string(index=False) for f in feat]
            template = 'The procedures performed were: {}.'
            proc_text= template.format(';'.join(feat_text))
        else:
            proc_text=''
    else:
        proc_text=''
    
    #out
    if feat_out:  
        out = data['Out']
        if out:
            feat=out.keys()
            feat_text = [(items[items['itemid']==f]['label']).to_string(index=False) for f in feat]
            template ='The outputs collected were: {}.'
            out_text = template.format('; '.join(feat_text))
        else:
            out_text=''
    else:
        out_text=''

    return cond_text,chart_text,meds_text,proc_text,out_text