Upload 2 files

Summarization_25Nov2022.py

@@ -0,0 +1,357 @@
+import torch
+import streamlit as st
+from streamlit import components
+import pandas as pd
+from transformers import BartTokenizer, BartForConditionalGeneration
+from transformers import T5Tokenizer, T5ForConditionalGeneration
+import evaluate
+from datasets import load_dataset
+from transformers import AutoTokenizer, LongT5ForConditionalGeneration
+import numpy as np
+from math import ceil
+import en_core_web_lg
+from collections import Counter
+from string import punctuation
+# Gensim
+import gensim
+from gensim.summarization import summarize
+import spacy
+
+nlp = en_core_web_lg.load()
+
+st.set_page_config(page_title ='Clinical Note Summarization', 
+                   #page_icon= "Notes",
+                   layout='wide')
+st.title('Clinical Note Summarization')
+st.sidebar.markdown('Using transformer model')
+
+## Loading in dataset
+#df = pd.read_csv('mtsamples_small.csv',index_col=0)
+df = pd.read_csv("shpi_w_rouge21Nov.csv")
+#df.shape
+df['HADM_ID'] = df['HADM_ID'].astype(str).apply(lambda x: x.replace('.0',''))
+
+##Renaming column
+#df.rename(columns={'patient id':'Patient_ID',
+#                  'hospital admission id':'Admission_ID',
+#                  'transcription':'Original_Text'}, inplace = True)
+
+#Renaming column
+df.rename(columns={'SUBJECT_ID':'Patient_ID',
+                  'HADM_ID':'Admission_ID',
+                  'hpi_input_text':'Original_Text',
+                  'hpi_reference_summary':'Reference_text'}, inplace = True)
+ 
+ #data.rename(columns={'gdp':'log(gdp)'}, inplace=True)
+
+#Filter selection 
+st.sidebar.header("Search for Patient:")
+
+patientid = df['Patient_ID']
+patient = st.sidebar.selectbox('Select Patient ID:', patientid)
+admissionid = df['Admission_ID'].loc[df['Patient_ID'] == patient]
+HospitalAdmission = st.sidebar.selectbox('', admissionid) 
+
+#Another way to for filter selection 
+#patient = st.sidebar.multiselect(
+#        "Select Patient ID:",
+#        options=df['Patient_ID'].unique(),
+#        default= None 
+#)
+
+
+#HospitalAdmission = st.sidebar.multiselect(
+#        "Select Hospital Admission ID:",
+#        options=df['Admission_ID'].unique(),
+#        #default=df['Admission_ID'].unique()
+#        default = None
+#)
+
+
+# List of Model available
+model = st.sidebar.selectbox('Select Model', ('BART','BERT','BertGPT2','Gensim','LexRank','Long T5','Luhn','Pysummarization','SBERT Summary Tokenizer','T5','T5 Seq2Seq','T5-Base','TextRank'))
+
+
+if model == 'BART':
+    _num_beams = 4
+    _no_repeat_ngram_size = 3
+    _length_penalty = 1
+    _min_length = 12
+    _max_length = 128
+    _early_stopping = True
+else:
+    _num_beams = 4
+    _no_repeat_ngram_size = 3
+    _length_penalty = 2
+    _min_length = 30
+    _max_length = 200
+    _early_stopping = True
+    
+
+
+
+col3,col4 = st.columns(2) 
+patientid = col3.write(f"Patient ID:  {patient} ")
+admissionid =col4.write(f"Admission ID:  {HospitalAdmission} ")
+    
+col1, col2 = st.columns(2)
+_min_length = col1.number_input("Minimum Length", value=_min_length)
+_max_length = col2.number_input("Maximun Length", value=_max_length)
+##_early_stopping = col3.number_input("early_stopping", value=_early_stopping)
+
+#text = st.text_area('Input Clinical Note here')
+
+# Query out relevant Clinical notes
+original_text =  df.query(
+    "Patient_ID  == @patient & Admission_ID == @HospitalAdmission"
+)
+
+original_text2 = original_text['Original_Text'].values
+
+runtext =st.text_area('Input Clinical Note here:', str(original_text2), height=300)
+
+reference_text = original_text['Reference_text'].values
+
+
+
+## ===== to highlight text ===== 
+from IPython.core.display import HTML, display
+def visualize(title, sentence_list, best_sentences):
+  text = ''
+
+  #display(HTML(f'<h1>Summary - {title}</h1>'))
+  for sentence in sentence_list:
+    if sentence in best_sentences:
+      #text += ' ' + str(sentence).replace(sentence, f"<mark>{sentence}</mark>")
+      text += ' ' + str(sentence).replace(sentence, f"<span class='highlight yellow'>{sentence}</span>")
+    else:
+      text += ' ' + sentence
+      display(HTML(f""" {text} """))
+
+    output = ''   
+    best_sentences = []
+    for sentence in output:
+       #print(sentence)
+       best_sentences.append(str(sentence))
+    return text     
+# try this web solution https://discuss.streamlit.io/t/colored-boxes-around-sections-of-a-sentence/3201/2    
+
+#===== Pysummarization =====
+from pysummarization.nlpbase.auto_abstractor import AutoAbstractor
+from pysummarization.tokenizabledoc.simple_tokenizer import SimpleTokenizer
+from pysummarization.abstractabledoc.top_n_rank_abstractor import TopNRankAbstractor
+import regex as re
+
+auto_abstractor = AutoAbstractor()
+auto_abstractor.tokenizable_doc = SimpleTokenizer()
+auto_abstractor.delimiter_list = [".", "\n"]
+abstractable_doc = TopNRankAbstractor()
+
+def pysummarizer(input_text):
+#    print(type(text))
+    summary = auto_abstractor.summarize(input_text, abstractable_doc)
+    best_sentences=[]
+    #summary_clean = ''.join([str(sentence).capitalize() for sentence in summary['summarize_result'] for summary['summarize_result'] in auto_abstractor.summarize(text, abstractable_doc)])
+    for sentence in summary['summarize_result']:
+        best_sentences.append(re.sub(r'\s+', ' ', sentence).strip())    
+    clean_summary=''.join(sentence for sentence in best_sentences)
+    return clean_summary
+
+
+
+##===== BERT Summary tokenizer =====
+
+def BertSummarizer(input_text):
+    from transformers import BigBirdTokenizer
+    from summarizer import Summarizer
+
+    bertsummarizer = Summarizer()
+
+    model = Summarizer()
+    result = model(input_text,ratio=0.4)
+    
+    return result
+
+
+##===== SBERT =====
+from summarizer.sbert import SBertSummarizer
+
+
+Sbertmodel = SBertSummarizer('paraphrase-MiniLM-L6-v2')
+
+def Sbert(input_text):
+    
+#     Sbertresult = Sbertmodel(text, num_sentences=3)
+    Sbertresult = Sbertmodel(input_text, ratio=0.4)
+    return Sbertresult
+
+
+
+##===== T5 Seq2Seq =====
+def t5seq2seq(input_text):
+    import torch
+    import torch.nn.functional as F
+    from transformers import AutoModelForSeq2SeqLM, AutoTokenizer
+    
+    model = AutoModelForSeq2SeqLM.from_pretrained("t5-base")
+    tokenizer = AutoTokenizer.from_pretrained("t5-base")
+
+    inputs = tokenizer("summarize: " + input_text, return_tensors="pt", max_length=512, truncation=True)
+    outputs = model.generate(inputs["input_ids"], max_length=150, min_length=40, length_penalty=2.0, num_beams=4, early_stopping=True)
+
+    summary= tokenizer.decode(outputs[0], skip_special_tokens=True)
+    
+    return summary
+
+def BertGPT2(input_text):
+    #import nlp
+
+    # BioClinicalBert with BERT2GPT2 model with GPT2 decoder
+    from transformers import BertTokenizer, GPT2Tokenizer, EncoderDecoderModel
+    from transformers import AutoTokenizer, AutoModel
+
+    device = torch.device("cuda") if torch.cuda.is_available() else torch.device("cpu")
+    model = EncoderDecoderModel.from_pretrained("patrickvonplaten/bert2gpt2-cnn_dailymail-fp16")
+    model.to(device)
+
+    #bert_tokenizer = BertTokenizer.from_pretrained("bert-base-cased")
+    bert_tokenizer= AutoTokenizer.from_pretrained("emilyalsentzer/Bio_ClinicalBERT")
+
+    # CLS token will work as BOS token
+    bert_tokenizer.bos_token = bert_tokenizer.cls_token
+
+    # SEP token will work as EOS token
+    bert_tokenizer.eos_token = bert_tokenizer.sep_token
+
+
+    # make sure GPT2 appends EOS in begin and end
+    def build_inputs_with_special_tokens(self, token_ids_0, token_ids_1=None):
+        outputs = [self.bos_token_id] + token_ids_0 + [self.eos_token_id]
+        return outputs
+
+
+    GPT2Tokenizer.build_inputs_with_special_tokens = build_inputs_with_special_tokens
+    gpt2_tokenizer = GPT2Tokenizer.from_pretrained("gpt2")
+    # set pad_token_id to unk_token_id -> be careful here as unk_token_id == eos_token_id == bos_token_id
+    gpt2_tokenizer.pad_token = gpt2_tokenizer.unk_token
+
+
+    # set decoding params
+    model.config.decoder_start_token_id = gpt2_tokenizer.bos_token_id
+    model.config.eos_token_id = gpt2_tokenizer.eos_token_id
+    model.config.max_length = 142
+    model.config.min_length = 56
+    model.config.no_repeat_ngram_size = 3
+    model.early_stopping = True
+    model.length_penalty = 2.0
+    model.num_beams = 4
+
+    #test_dataset = nlp.load_dataset("cnn_dailymail", "3.0.0", split="test")
+
+    batch_size = 64
+ 
+    def Sbertmodel(batch):
+        # Tokenizer will automatically set [BOS] <text> [EOS]
+        # cut off at BERT max length 512
+        inputs = bert_tokenizer(batch, padding="max_length", truncation=True, max_length=512, return_tensors="pt")
+        input_ids = inputs.input_ids.to("cuda")
+        attention_mask = inputs.attention_mask.to("cuda")
+
+        outputs = model.generate(input_ids, attention_mask=attention_mask)
+
+        # all special tokens including will be removed
+        output_str = gpt2_tokenizer.batch_decode(outputs, skip_special_tokens=True)
+
+        #batch["pred"] = output_str
+
+        return output_str
+    
+    Sbert(input_text)
+
+device = torch.device("cuda") if torch.cuda.is_available() else torch.device("cpu")
+
+
+def run_model(input_text):
+
+    device = torch.device('cuda' if torch.cuda.is_available() else 'cpu')
+
+    if model == "BART":
+        bart_model = BartForConditionalGeneration.from_pretrained("facebook/bart-base")
+        bart_tokenizer = BartTokenizer.from_pretrained("facebook/bart-base")
+        input_text = str(input_text)
+        input_text = ' '.join(input_text.split())
+        input_tokenized = bart_tokenizer.encode(input_text, return_tensors='pt').to(device)
+        summary_ids = bart_model.generate(input_tokenized,
+                                          num_beams=_num_beams,
+                                          no_repeat_ngram_size=_no_repeat_ngram_size,
+                                          length_penalty=_length_penalty,
+                                          min_length=_min_length,
+                                          max_length=_max_length,
+                                          early_stopping=_early_stopping)
+
+        output = [bart_tokenizer.decode(g, skip_special_tokens=True, clean_up_tokenization_spaces=False) for g in summary_ids]
+        st.write('Summary')
+        st.success(output[0])
+      
+    elif model == "T5":
+        t5_model = T5ForConditionalGeneration.from_pretrained("t5-base")
+        t5_tokenizer = T5Tokenizer.from_pretrained("t5-base")
+        input_text = str(input_text).replace('\n', '')
+        input_text = ' '.join(input_text.split())
+        input_tokenized = t5_tokenizer.encode(input_text, return_tensors="pt").to(device)
+        summary_task = torch.tensor([[21603, 10]]).to(device)
+        input_tokenized = torch.cat([summary_task, input_tokenized], dim=-1).to(device)
+        summary_ids = t5_model.generate(input_tokenized,
+                                        num_beams=_num_beams,
+                                        no_repeat_ngram_size=_no_repeat_ngram_size,
+                                        length_penalty=_length_penalty,
+                                        min_length=_min_length,
+                                        max_length=_max_length,
+                                        early_stopping=_early_stopping)
+        output = [t5_tokenizer.decode(g, skip_special_tokens=True, clean_up_tokenization_spaces=False) for g in summary_ids]
+        st.write('Summary')
+        st.success(output[0])
+        
+      
+    elif model == "Gensim": 
+        output=summarize(str(input_text))
+        #visualize('of text', input_text, output)
+        st.write('Summary')
+        st.success(output)
+        
+    elif model == "Pysummarization":
+        output = pysummarizer(input_text)
+        st.write('Summary')
+        st.success(output)
+        
+    elif model == "BERT": 
+        output = BertSummarizer(input_text)
+        st.write('Summary')
+        st.success(output)
+        
+    elif model == "SBERT Summary Tokenizer": 
+        output = Sbert(input_text)
+        st.write('Summary')
+        st.success(output)
+        
+    elif model == "T5 Seq2Seq":
+        output = t5seq2seq(input_text)
+        st.write('Summary')
+        st.success(output)
+        
+    elif model == "BertGPT2": #Not working correctly. to work on it later on 
+        output = BertGPT2(input_text)
+        st.write('Summary')
+        st.success(output)
+
+
+if st.button('Submit'):
+    run_model(runtext)
+    
+#    runtext2=runtext.split('.')
+#    reference_text2=reference_text.split('.')
+    
+    st.write(visualize('of text', runtext ,reference_text))
+    
+    st.text_area('Reference text', str(reference_text))
+    

requirements.txt

@@ -0,0 +1,4 @@
+streamlit==1.14.0
+pandas==1.3.5
+numpy==1.20.0
+regex==2022.9.13