Update app.py

app.py

@@ -1,7 +1,7 @@
 import streamlit as st
 from transformers import pipeline
 import re
-
+import time
 import requests
 
 API_URL = "https://api-inference.huggingface.co/models/microsoft/prophetnet-large-uncased-squad-qg"
@@ -81,6 +81,7 @@ if evidence_text:
 
 
 import pandas as pd
+from rouge_score import rouge_scorer
 import numpy as np
 from allennlp.predictors.predictor import Predictor
 import allennlp_models.tagging
@@ -89,11 +90,14 @@ predictor = Predictor.from_path("structured-prediction-srl-bert.tar.gz")
 #---------------------------------------------------------------
 def claim(text):
     import re
-    df = pd.DataFrame({'claim' : [text]})
-    pattern = r'(\d+),(\d+)'
-    def remove_number_commas(match):
-        return match.group(1) + match.group(2)
-    df['claim'] = df['claim'].apply(lambda x: re.sub(pattern, remove_number_commas, x))
+    def remove_special_chars(text):
+        # Remove special characters that are not in between numbers
+        text = re.sub(r'(?<!\d)[^\w\s]+(?!\d)', '', text)
+
+        return text
+
+    df = pd.DataFrame({'claim' : remove_special_chars(text)},index=[0])
+
     def srl_allennlp(sent):
       try:
         #result = predictor.predict(sentence=sent)['verbs'][0]['description']
@@ -160,11 +164,16 @@ def claim(text):
             else:
               substr = substr + val_string[i]
         else:
-          substr = None
-        who.append(substr)
-
-      df['who'][j] = who
-
+          pass
+        if len(substr)!= 0: 
+            who.append(substr)
+        else:
+            pass
+        
+ 
+    df['who'][j] = "<sep>".join(who)
+#     else:
+#         continue
     #----------FOR COLUMN "WHAT"------------#
     df['what'] = ''
     for j in range(len(df['modified'])):
@@ -187,10 +196,15 @@ def claim(text):
             else:
               substr = substr + val_string[i]
         else:
-          substr = None
-        what.append(substr)
-
-      df['what'][j] = what
+          pass
+        if len(substr)!= 0: 
+            what.append(substr)
+        else:
+            pass
+  
+    df['what'][j] = "<sep>".join(what)
+#     else:
+#         continue
 
     #----------FOR COLUMN "WHY"------------#
     df['why'] = ''
@@ -214,10 +228,15 @@ def claim(text):
             else:
               substr = substr + val_string[i]
         else:
-          substr = None
-        why.append(substr)
+          pass
+        if len(substr)!= 0: 
+            why.append(substr)
+        else:
+            pass
 
-      df['why'][j] = why
+    df['why'][j] = "<sep>".join(why)
+#     else:
+#         continue
 
      #----------FOR COLUMN "WHEN"------------#
     df['when'] = ''
@@ -241,10 +260,15 @@ def claim(text):
             else:
               substr = substr + val_string[i]
         else:
-          substr = None
-        when.append(substr)
+          pass
+        if len(substr)!= 0: 
+            when.append(substr)
+        else:
+            pass
 
-      df['when'][j] = when
+    df['when'][j] = "<sep>".join(when)
+#     else:
+#         continue
 
 
     #----------FOR COLUMN "WHERE"------------#
@@ -269,163 +293,337 @@ def claim(text):
             else:
               substr = substr + val_string[i]
         else:
-          substr = None
-        where.append(substr)
+          pass
+        if len(substr)!= 0: 
+            where.append(substr)
+        else:
+            pass
+
+    df['where'][j] = "<sep>".join(where)
 
-      df['where'][j] = where
 
     data=df[["claim","who","what","why","when","where"]].copy()    
-    import re
-    def remove_trail_comma(text):
-        x = re.sub(",\s*$", "", text)
-        return x
-
-
-    data['claim']=data['claim'].apply(lambda x: str(x).replace('\'','').replace('\'',''))
-    data['claim']=data['claim'].apply(lambda x: str(x).replace('[','').replace(']','')) 
-
-
-
-    data['who']=data['who'].apply(lambda x: str(x).replace(" 's","'s"))
-    data['who']=data['who'].apply(lambda x: str(x).replace("s ’","s’"))
-    data['who']=data['who'].apply(lambda x: str(x).replace(" - ","-"))
-    data['who']=data['who'].apply(lambda x: str(x).replace('\'','').replace('\'',''))
-#     data['who']=data['who'].apply(lambda x: str(x).replace('"','').replace('"',''))
-    data['who']=data['who'].apply(lambda x: str(x).replace('[','').replace(']','')) 
-    data['who']=data['who'].apply(lambda x: str(x).rstrip(','))
-    data['who']=data['who'].apply(lambda x: str(x).lstrip(','))
-    data['who']=data['who'].apply(lambda x: str(x).replace('None,','').replace('None','')) 
-    data['who']=data['who'].apply(remove_trail_comma)
-
-
-
-    data['what']=data['what'].apply(lambda x: str(x).replace(" 's","'s"))
-    data['what']=data['what'].apply(lambda x: str(x).replace("s ’","s’"))
-    data['what']=data['what'].apply(lambda x: str(x).replace(" - ","-"))
-    data['what']=data['what'].apply(lambda x: str(x).replace('\'','').replace('\'',''))
-#     data['what']=data['what'].apply(lambda x: str(x).replace('"','').replace('"',''))
-    data['what']=data['what'].apply(lambda x: str(x).replace('[','').replace(']','')) 
-    data['what']=data['what'].apply(lambda x: str(x).rstrip(','))
-    data['what']=data['what'].apply(lambda x: str(x).lstrip(','))
-    data['what']=data['what'].apply(lambda x: str(x).replace('None,','').replace('None','')) 
-    data['what']=data['what'].apply(remove_trail_comma)
-
-    data['why']=data['why'].apply(lambda x: str(x).replace(" 's","'s"))
-    data['why']=data['why'].apply(lambda x: str(x).replace("s ’","s’"))
-    data['why']=data['why'].apply(lambda x: str(x).replace(" - ","-"))
-    data['why']=data['why'].apply(lambda x: str(x).replace('\'','').replace('\'',''))
-#     data['why']=data['why'].apply(lambda x: str(x).replace('"','').replace('"',''))
-    data['why']=data['why'].apply(lambda x: str(x).replace('[','').replace(']',''))
-    data['why']=data['why'].apply(lambda x: str(x).rstrip(','))
-    data['why']=data['why'].apply(lambda x: str(x).lstrip(','))
-    data['why']=data['why'].apply(lambda x: str(x).replace('None,','').replace('None','')) 
-    data['why']=data['why'].apply(remove_trail_comma)
-
-    data['when']=data['when'].apply(lambda x: str(x).replace(" 's","'s"))
-    data['when']=data['when'].apply(lambda x: str(x).replace("s ’","s’"))
-    data['when']=data['when'].apply(lambda x: str(x).replace(" - ","-"))
-    data['when']=data['when'].apply(lambda x: str(x).replace('\'','').replace('\'',''))
-#     data['when']=data['when'].apply(lambda x: str(x).replace('"','').replace('"',''))
-    data['when']=data['when'].apply(lambda x: str(x).replace('[','').replace(']',''))
-    data['when']=data['when'].apply(lambda x: str(x).rstrip(','))
-    data['when']=data['when'].apply(lambda x: str(x).lstrip(','))
-    data['when']=data['when'].apply(lambda x: str(x).replace('None,','').replace('None','')) 
-    data['when']=data['when'].apply(remove_trail_comma)
-
-    data['where']=data['where'].apply(lambda x: str(x).replace(" 's","'s"))
-    data['where']=data['where'].apply(lambda x: str(x).replace("s ’","s’"))
-    data['where']=data['where'].apply(lambda x: str(x).replace(" - ","-"))
-    data['where']=data['where'].apply(lambda x: str(x).replace('\'','').replace('\'',''))
-#     data['where']=data['where'].apply(lambda x: str(x).replace('"','').replace('"',''))
-    data['where']=data['where'].apply(lambda x: str(x).replace('[','').replace(']','')) 
-    data['where']=data['where'].apply(lambda x: str(x).rstrip(','))
-    data['where']=data['where'].apply(lambda x: str(x).lstrip(','))
-    data['where']=data['where'].apply(lambda x: str(x).replace('None,','').replace('None','')) 
-    data['where']=data['where'].apply(remove_trail_comma)
     return data
 #-------------------------------------------------------------------------
-def split_ws(input_list):
-    import re
+def split_ws(input_list, delimiter="<sep>"):
     output_list = []
     for item in input_list:
-        split_item = re.findall(r'[^",]+|"[^"]*"', item)
-        output_list += split_item
-    result = [x.strip() for x in output_list]
-    return result
+        split_item = item.split(delimiter)
+        for sub_item in split_item:
+            sub_item = sub_item.strip()
+            if sub_item:
+                output_list.append(sub_item)
+    return output_list
 
 #--------------------------------------------------------------------------    
-def gen_qq(df):
-    w_list=["who","when","where","what","why"]
-    ans=[]
-    cl=[]
-    ind=[]
-    ques=[]
-    evid=[]
-    for index,value in enumerate(w_list):
-        for i,row in df.iterrows():
-            srl=df[value][i]
-            claim=df['claim'][i]
-            evidence_text=df['evidence'][i]
-            answer= split_ws(df[value])
+def calc_rouge_l_score(list_of_evidence, list_of_ans):
+    scorer = rouge_scorer.RougeScorer(['rougeL'], use_stemmer=True)
+    scores = scorer.score(' '.join(list_of_evidence), ' '.join(list_of_ans))
+    return scores['rougeL'].fmeasure
+#-------------------------------------------------------------------------
+    
+
+def rephrase_question_who(question):
+    if not question.lower().startswith("who"):
+        words = question.split()
+        words[0] = "Who"
+        return " ".join(words)
+    else:
+        return question
+#------------------------------------------------------------------------    
+def gen_qa_who(df):
+    list_of_ques_who=[]
+    list_of_ans_who=[]
+    list_of_evidence_answer_who=[]
+    rouge_l_scores=[]
+    for i,row in df.iterrows():
+        srl=df["who"][i]
+        claim=df['claim'][i]
+        answer= split_ws(df["who"])
+        evidence=df["evidence"][i]
+        #time.sleep(10)
+        if srl!="":
             try:
-                if len(srl.split())>0 and len(srl.split(","))>0:
-                    for j in range(0,len(answer)):
-                        FACT_TO_GENERATE_QUESTION_FROM = f"""{answer[j]} [SEP] {claim}"""
-                        question_ids = query({"inputs":FACT_TO_GENERATE_QUESTION_FROM, 
-                                  "num_beams":5, 
-                                  "early_stopping":True})
-                        #print("claim : {}".format(claim))
-                        #print("answer : {}".format(answer[j]))
-                        #print("question : {}".format(question_ids[0]['generated_text']))
-                        ind.append(i)
-                        cl.append(claim)
-                        ans.append(answer[j])
-                        ques.append(question_ids[0]['generated_text'].capitalize())
-                        evid.append(evidence_text)
-                        #print("-----------------------------------------")
+                for j in range(0,len(answer)):
+                    FACT_TO_GENERATE_QUESTION_FROM = f"""generate_the_question_from_context_using_the_next_answer:{answer[j]} [SEP] context:{claim}"""
+                    #FACT_TO_GENERATE_QUESTION_FROM = f"""generate_who_based_question_from_context_using_the_next_answer:{answer[j]} [SEP] context:{claim}"""
+                    #time.sleep(10)
+                    question_ids = query({"inputs":FACT_TO_GENERATE_QUESTION_FROM, 
+                              "num_beams":5, 
+                              "early_stopping":True,
+                                         "min_length": 100,"wait_for_model":True})[0]['generated_text'].capitalize()
+                    question_ids = rephrase_question_who(question_ids)
+                    list_of_ques_who.append(f"""Q{j+1}:{question_ids}""")
+                    list_of_ans_who.append(f"""Ans{j+1}:{answer[j]}""")
+                    input_evidence = f"answer_the_next_question_from_context: {question_ids} context: {evidence}"
+                    #time.sleep(10)
+                    answer_evidence = query_evidence({"inputs":input_evidence,"truncation":True,"wait_for_model":True})[0]['generated_text']
+                    if answer_evidence.lower() in evidence.lower():
+                        list_of_evidence_answer_who.append(f"""Evidence{j+1}:{answer_evidence}""")
+                    else:
+                        answer_evidence=""
+                        list_of_evidence_answer_who.append(f"""No mention of 'who'in any related documents.""")
+                    threshold = 0.2
+                    list_of_pairs = [(answer_evidence, answer[j])]
+                    rouge_l_score = calc_rouge_l_score(answer_evidence, answer[j])
+                    if rouge_l_score >= threshold:
+                        verification_status = 'Verified Valid'
+                    elif rouge_l_score == 0:
+                        verification_status = 'Not verifiable'
+                    else:
+                        verification_status = 'Verified False'
+                    rouge_l_scores.append(verification_status)
             except:
                 pass
-    return cl,ques,ans,evid
+        else:
+            list_of_ques_who="No claims"
+            list_of_ans_who=""
+            list_of_evidence_answer_who="No mention of 'who'in any related documents."
+            rouge_l_scores="Not verifiable"
+    return list_of_ques_who,list_of_ans_who,rouge_l_scores,list_of_evidence_answer_who
 #------------------------------------------------------------    
-def qa_evidence(final_data):
-    ans=[]
-    cl=[]
-    #ind=[]
-    ques=[]
-    evi=[]
-    srl_ans=[]
-
-
-    for i,row in final_data.iterrows():
-        question=final_data['gen_question'][i]
-        evidence=final_data['evidence'][i]
-        claim=final_data['actual_claim'][i]
-        srl_answer=final_data['actual_answer'][i]
-        #index=df["index"][i]
-
-        input_evidence = f"question: {question} context: {evidence}"
-
-        answer = query_evidence({
-            "inputs":input_evidence,
-            "truncation":True})
-
-        #ind.append(index)
-        cl.append(claim)
-        ans.append(answer[0]["generated_text"])
-        ques.append(question)
-        evi.append(evidence)
-        srl_ans.append(srl_answer)
-
-        #print(f"""index: {index}""")
-#         print(f"""evidence: {evidence}""")
-#         print(f"""claim: {claim}""")
-#         print(f"""Question: {question}""")
-#         print(f"""Answer: {answer}""")
-#         print(f"""SRL Answer: {srl_answer}""")
-#         print("------------------------------------")
-#     return list(zip(cl,ques,srl_ans)),list(zip(evi,ques,ans))
-#     return cl,ques
-    return list(zip(ques,srl_ans)),list(zip(ques,ans))
+
+def rephrase_question_what(question):
+    if not question.lower().startswith("what"):
+        words = question.split()
+        words[0] = "What"
+        return " ".join(words)
+    else:
+        return question
+#----------------------------------------------------------        
+def gen_qa_what(df):
+    list_of_ques_what=[]
+    list_of_ans_what=[]
+    list_of_evidence_answer_what=[]
+    rouge_l_scores=[]
+    for i,row in df.iterrows():
+        srl=df["what"][i]
+        claim=df['claim'][i]
+        answer= split_ws(df["what"])
+        evidence=df["evidence"][i]
+        #time.sleep(10)
+        if srl!="":
+            try:
+                for j in range(0,len(answer)):
+                    FACT_TO_GENERATE_QUESTION_FROM = f"""generate_the_question_from_context_using_the_next_answer:{answer[j]} [SEP] context:{claim}"""
+                    #time.sleep(10)
+                    question_ids = query({"inputs":FACT_TO_GENERATE_QUESTION_FROM, 
+                              "num_beams":5, 
+                              "early_stopping":True,
+                                         "min_length": 100,"wait_for_model":True})[0]['generated_text'].capitalize()
+                    question_ids = rephrase_question_what(question_ids)
+                    list_of_ques_what.append(f"""Q{j+1}:{question_ids}""")
+                    list_of_ans_what.append(f"""Ans{j+1}:{answer[j]}""")
+                    input_evidence = f"answer_the_next_question_from_context: {question_ids} context: {evidence}"
+                    #time.sleep(10)
+                    answer_evidence = query_evidence({"inputs":input_evidence,"truncation":True,"wait_for_model":True})[0]['generated_text']
+                    if answer_evidence.lower() in evidence.lower():
+                        list_of_evidence_answer_what.append(f"""Evidence{j+1}:{answer_evidence}""")
+                        
+                    else:
+                        answer_evidence=""
+                        list_of_evidence_answer_what.append(f"""No mention of 'what'in any related documents.""")
+                    threshold = 0.2
+                    list_of_pairs = [(answer_evidence, answer[j])]
+                    rouge_l_score = calc_rouge_l_score(answer_evidence, answer[j])
+                    if rouge_l_score >= threshold:
+                        verification_status = 'Verified Valid'
+                    elif rouge_l_score == 0:
+                        verification_status = 'Not verifiable'
+                    else:
+                        verification_status = 'Verified False'
+                    rouge_l_scores.append(verification_status)
+            except:
+                pass
+        else:
+            list_of_ques_what="No claims"
+            list_of_ans_what=""
+            list_of_evidence_answer_what="No mention of 'what'in any related documents."
+            rouge_l_scores="Not verifiable"
+    return list_of_ques_what,list_of_ans_what,rouge_l_scores,list_of_evidence_answer_what
+#----------------------------------------------------------    
+
+def rephrase_question_why(question):
+    if not question.lower().startswith("why"):
+        words = question.split()
+        words[0] = "Why"
+        return " ".join(words)
+    else:
+        return question
+
+#---------------------------------------------------------        
+def gen_qa_why(df):
+    list_of_ques_why=[]
+    list_of_ans_why=[]
+    list_of_evidence_answer_why=[]
+    rouge_l_scores=[]
+    for i,row in df.iterrows():
+        srl=df["why"][i]
+        claim=df['claim'][i]
+        answer= split_ws(df["why"])
+        evidence=df["evidence"][i]
+        #time.sleep(10)
+        if srl!="":
+            try:
+                for j in range(0,len(answer)):
+                    FACT_TO_GENERATE_QUESTION_FROM = f"""generate_the_question_from_context_using_the_next_answer:{answer[j]} [SEP] context:{claim}"""
+                    #time.sleep(10)
+                    question_ids = query({"inputs":FACT_TO_GENERATE_QUESTION_FROM, 
+                              "num_beams":5, 
+                              "early_stopping":True,
+                                         "min_length": 100,"wait_for_model":True})[0]['generated_text'].capitalize()
+                    question_ids = rephrase_question_why(question_ids)
+                    list_of_ques_why.append(f"""Q{j+1}:{question_ids}""")
+                    list_of_ans_why.append(f"""Ans{j+1}:{answer[j]}""")
+                    input_evidence = f"answer_the_next_question_from_context: {question_ids} context: {evidence}"
+                    #time.sleep(10)
+                    answer_evidence = query_evidence({"inputs":input_evidence,"truncation":True,"wait_for_model":True})[0]['generated_text']
+                    if answer_evidence.lower() in evidence.lower():
+                        list_of_evidence_answer_why.append(f"""Evidence{j+1}:{answer_evidence}""")
+                    else:
+                        answer_evidence=""
+                        list_of_evidence_answer_why.append(f"""No mention of 'why'in any related documents.""")
+                    threshold = 0.2
+                    list_of_pairs = [(answer_evidence, answer[j])]
+                    rouge_l_score = calc_rouge_l_score(answer_evidence, answer[j])
+                    if rouge_l_score >= threshold:
+                        verification_status = 'Verified Valid'
+                    elif rouge_l_score == 0:
+                        verification_status = 'Not verifiable'
+                    else:
+                        verification_status = 'Verified False'
+                    rouge_l_scores.append(verification_status)
+            except:
+                pass
+        else:
+            list_of_ques_why="No claims"
+            list_of_ans_why=""
+            list_of_evidence_answer_why="No mention of 'why'in any related documents."
+            rouge_l_scores="Not verifiable"
+    return list_of_ques_why,list_of_ans_why,rouge_l_scores,list_of_evidence_answer_why
+
+#---------------------------------------------------------    
+
+def rephrase_question_when(question):
+    if not question.lower().startswith("when"):
+        words = question.split()
+        words[0] = "When"
+        return " ".join(words)
+    else:
+        return question
+#---------------------------------------------------------        
+def gen_qa_when(df):
+    list_of_ques_when=[]
+    list_of_ans_when=[]
+    list_of_evidence_answer_when=[]
+    rouge_l_scores=[]
+    for i,row in df.iterrows():
+        srl=df["when"][i]
+        claim=df['claim'][i]
+        answer= split_ws(df["when"])
+        evidence=df["evidence"][i]
+        #time.sleep(10)
+        if srl!="":
+            try:
+                for j in range(0,len(answer)):
+                    FACT_TO_GENERATE_QUESTION_FROM = f"""generate_the_question_from_context_using_the_next_answer:{answer[j]} [SEP] context:{claim}"""
+                    #time.sleep(10)
+                    question_ids = query({"inputs":FACT_TO_GENERATE_QUESTION_FROM, 
+                              "num_beams":5, 
+                              "early_stopping":True,
+                                         "min_length": 100,"wait_for_model":True})[0]['generated_text'].capitalize()
+                    question_ids = rephrase_question_when(question_ids)
+                    list_of_ques_when.append(f"""Q{j+1}:{question_ids}""")
+                    list_of_ans_when.append(f"""Ans{j+1}:{answer[j]}""")
+                    input_evidence = f"answer_the_next_question_from_context: {question_ids} context: {evidence}"
+                    #time.sleep(10)
+                    answer_evidence = query_evidence({"inputs":input_evidence,"truncation":True,"wait_for_model":True})[0]['generated_text']
+                    if answer_evidence.lower() in evidence.lower():
+                        list_of_evidence_answer_when.append(f"""Evidence{j+1}:{answer_evidence}""")
+                    else:
+                        answer_evidence=""
+                        list_of_evidence_answer_when.append(f"""No mention of 'when'in any related documents.""")
+                    threshold = 0.2
+                    list_of_pairs = [(answer_evidence, answer[j])]
+                    rouge_l_score = calc_rouge_l_score(answer_evidence, answer[j])
+                    if rouge_l_score >= threshold:
+                        verification_status = 'Verified Valid'
+                    elif rouge_l_score == 0:
+                        verification_status = 'Not verifiable'
+                    else:
+                        verification_status = 'Verified False'
+                    rouge_l_scores.append(verification_status)
+            except:
+                pass
+        else:
+            list_of_ques_when="No claims"
+            list_of_ans_when=""
+            list_of_evidence_answer_when="No mention of 'when'in any related documents."
+            rouge_l_scores="Not verifiable"
+    return list_of_ques_when,list_of_ans_when,rouge_l_scores,list_of_evidence_answer_when
+
+#------------------------------------------------------   
+
+def rephrase_question_where(question):
+    if not question.lower().startswith("where"):
+        words = question.split()
+        words[0] = "Where"
+        return " ".join(words)
+    else:
+        return question
+#------------------------------------------------------      
+def gen_qa_where(df):
+    list_of_ques_where=[]
+    list_of_ans_where=[]
+    list_of_evidence_answer_where=[]
+    rouge_l_scores=[]
+    for i,row in df.iterrows():
+        srl=df["where"][i]
+        claim=df['claim'][i]
+        answer= split_ws(df["where"])
+        evidence=df["evidence"][i]
+        #time.sleep(10)
+        if srl!="":
+            try:
+                for j in range(0,len(answer)):
+                    FACT_TO_GENERATE_QUESTION_FROM = f"""generate_the_question_from_context_using_the_next_answer:{answer[j]} [SEP] context:{claim}"""
+                    #time.sleep(10)
+                    question_ids = query({"inputs":FACT_TO_GENERATE_QUESTION_FROM, 
+                              "num_beams":5, 
+                              "early_stopping":True,
+                                         "min_length": 100,"wait_for_model":True})[0]['generated_text'].capitalize()
+                    question_ids = rephrase_question_where(question_ids)
+                    list_of_ques_where.append(f"""Q{j+1}:{question_ids}""")
+                    list_of_ans_where.append(f"""Ans{j+1}:{answer[j]}""")
+                    input_evidence = f"answer_the_next_question_from_context: {question_ids} context: {evidence}"
+                    #time.sleep(10)
+                    answer_evidence = query_evidence({"inputs":input_evidence,"truncation":True,"wait_for_model":True})[0]['generated_text']
+                    if answer_evidence.lower() in evidence.lower():
+                        list_of_evidence_answer_where.append(f"""Evidence{j+1}:{answer_evidence}""")
+                    else:
+                        answer_evidence=""
+                        list_of_evidence_answer_where.append(f"""No mention of 'where'in any related documents.""")
+                    threshold = 0.2
+                    list_of_pairs = [(answer_evidence, answer[j])]
+                    rouge_l_score = calc_rouge_l_score(answer_evidence, answer[j])
+                    if rouge_l_score >= threshold:
+                        verification_status = 'Verified Valid'
+                    elif rouge_l_score == 0:
+                        verification_status = 'Not verifiable'
+                    else:
+                        verification_status = 'Verified False'
+                    rouge_l_scores.append(verification_status)
+            except:
+                pass
+        else:
+            list_of_ques_where="No claims"
+            list_of_ans_where=""
+            list_of_evidence_answer_where="No mention of 'where'in any related documents."
+            rouge_l_scores="Not verifiable"
+    return list_of_ques_where,list_of_ans_where,rouge_l_scores,list_of_evidence_answer_where
+
+#------------------------------------------------------    
+
 
 #------------------------------------------------------------  
 
@@ -433,10 +631,13 @@ if claim_text:
     if evidence_text:
         df=claim(claim_text)
         df["evidence"]=evidence_text
-        actual_claim,gen_question,actual_answer,evidence=gen_qq(df)
-        final_data=pd.DataFrame([actual_claim,gen_question,actual_answer,evidence]).T
-        final_data.columns=["actual_claim","gen_question","actual_answer","evidence"]
-        st.dataframe(final_data)
+        final_df = pd.DataFrame(columns=['Who Claims', 'What Claims', 'When Claims', 'Where Claims', 'Why Claims'])
+        final_df["Who Claims"]=gen_qa_who(df)
+        final_df["What Claims"]=gen_qa_what(df)
+        final_df["When Claims"]=gen_qa_when(df)
+        final_df["Where Claims"]=gen_qa_where(df)
+        final_df["Why Claims"]=gen_qa_why(df)
+        st.dataframe(final_df)
         # a,b=qa_evidence(final_data)
 #         qa_evidence(final_data)
 #         st.json(qa_evidence(final_data))