Update app.py

app.py

@@ -6,6 +6,7 @@ import re
 import time
 import requests
 from PIL import Image
+import itertools
 
 
 HF_SPACES_API_KEY = st.secrets["HF_token"]
@@ -148,7 +149,7 @@ list_of_pronouns = ["I", "you", "he", "she", "it", "we", "they", "me", "him", "h
             "one", "other", "several", "some", "somebody", "someone", "something"]
 #---------------------------------------------------------------
 # @st.cache
-def claim(text):
+def srl(text):
     import re
     def remove_special_chars(text):
         # Remove special characters that are not in between numbers
@@ -349,21 +350,7 @@ def claim(text):
                 pass
 
         df['where'][j] = "<sep>".join(where)
-
-
-    data=df[["claim","who","what","why","when","where"]].copy()    
-    return data
-#-------------------------------------------------------------------------
-# @st.cache
-def split_ws(input_list, delimiter="<sep>"):
-    output_list = []
-    for item in input_list:
-        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
+    return who,what,when,where,why
 
 #--------------------------------------------------------------------------    
 # @st.cache
@@ -372,336 +359,81 @@ def calc_rouge_l_score(list_of_evidence, list_of_ans):
     scores = scorer.score(' '.join(list_of_evidence), ' '.join(list_of_ans))
     return scores['rougeL'].fmeasure
 #-------------------------------------------------------------------------
-    
-# @st.cache
-def rephrase_question_who(question):
-    if not question.lower().startswith("who"):
-        words = question.split()
-        words[0] = "Who"
-        return " ".join(words)
-    else:
-        return question
-#------------------------------------------------------------------------    
-# @st.cache
-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]
-        if srl!="":
-            try:
-                for j in range(0,len(answer)):
-                    question_ids = model_load_qg(answer[j],claim)
-                    question_ids = rephrase_question_who(question_ids)
-                    list_of_ques_who.append(f"""Q{j+1} :\n {question_ids}""")
-                    list_of_ans_who.append(f"""Claim :\n {answer[j]}""")
-                    answer_evidence = model_load_qa(question_ids,evidence)
-                    if answer_evidence.lower() in evidence.lower():
-                        list_of_evidence_answer_who.append(f"""Answer retrieved from evidence :\n {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
-        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,list_of_evidence_answer_who,rouge_l_scores
-#------------------------------------------------------------    
-# @st.cache
-def rephrase_question_what(question):
-    if not question.lower().startswith("what"):
-        words = question.split()
-        words[0] = "What"
-        return " ".join(words)
-    else:
-        return question
-#----------------------------------------------------------        
-# @st.cache
-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]
-        if srl!="":
-            try:
-                for j in range(0,len(answer)):
-                    question_ids = model_load_qg(answer[j],claim)
-                    question_ids = rephrase_question_what(question_ids)
-                    list_of_ques_what.append(f"""Q{j+1}:{question_ids}""")
-                    list_of_ans_what.append(f"""Claim :\n {answer[j]}""")
-                    answer_evidence = model_load_qa(question_ids,evidence)
-                    if answer_evidence.lower() in evidence.lower():
-                        list_of_evidence_answer_what.append(f"""Answer retrieved from evidence :\n {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
+def qa_list_gen(claim,srl,evidence):
+    list_of_qa_pipeline=[]    
+    for index,answer_claim in enumerate(combined_list):
+        question = model_load_qg(answer_claim,claim)
+        answer_evidence = model_load_qa(question,evidence)
+        if answer_evidence.lower() in evidence.lower():
+            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,list_of_evidence_answer_what,rouge_l_scores
-#----------------------------------------------------------    
-# @st.cache
-def rephrase_question_why(question):
-    if not question.lower().startswith("why"):
-        words = question.split()
-        words[0] = "Why"
-        return " ".join(words)
-    else:
-        return question
-
-#---------------------------------------------------------        
-# @st.cache
-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]
-        if srl!="":
-            try:
-                for j in range(0,len(answer)):
-                    question_ids = model_load_qg(answer[j],claim)
-                    question_ids = rephrase_question_why(question_ids)
-                    list_of_ques_why.append(f"""Q{j+1}:{question_ids}""")
-                    list_of_ans_why.append(f"""Claim :\n {answer[j]}""")
-                    answer_evidence = model_load_qa(question_ids,evidence)
-                    if answer_evidence.lower() in evidence.lower():
-                        list_of_evidence_answer_why.append(f"""Answer retrieved from evidence :\n {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
+            answer_evidence=""
+        threshold = 0.2
+        list_of_pairs = [(answer_evidence, answer_claim)]
+        rouge_l_score = calc_rouge_l_score(answer_evidence, answer_claim)
+        if rouge_l_score >= threshold:
+            verification_status = '✅ Verified Valid'
+        elif rouge_l_score == 0:
+            verification_status = '❔ Not verifiable'
         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,list_of_evidence_answer_why,rouge_l_scores
-
-#---------------------------------------------------------    
-# @st.cache
-def rephrase_question_when(question):
-    if not question.lower().startswith("when"):
-        words = question.split()
-        words[0] = "When"
-        return " ".join(words)
-    else:
-        return question
-#---------------------------------------------------------        
-# @st.cache
-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]
-        if srl!="":
-            try:
-                for j in range(0,len(answer)):
-                    question_ids = model_load_qg(answer[j],claim)
-                    question_ids = rephrase_question_when(question_ids)
-                    list_of_ques_when.append(f"""Q{j+1}:{question_ids}""")
-                    list_of_ans_when.append(f"""Claim :\n {answer[j]}""")
-                    answer_evidence = model_load_qa(question_ids,evidence)
-                    if answer_evidence.lower() in evidence.lower():
-                        list_of_evidence_answer_when.append(f"""Answer retrieved from evidence :\n {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,list_of_evidence_answer_when,rouge_l_scores
-
-#------------------------------------------------------   
-# @st.cache
-def rephrase_question_where(question):
-    if not question.lower().startswith("where"):
-        words = question.split()
-        words[0] = "Where"
-        return " ".join(words)
-    else:
-        return question
-#------------------------------------------------------      
-# @st.cache
-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]
-        if srl!="":
-            try:
-                for j in range(0,len(answer)):
-                    question_ids = model_load_qg(answer[j],claim)
-                    question_ids = rephrase_question_where(question_ids)
-                    list_of_ques_where.append(f"""Q{j+1}:{question_ids}""")
-                    list_of_ans_where.append(f"""Claim :\n {answer[j]}""")
-                    answer_evidence = model_load_qa(question_ids,evidence)
-                    if answer_evidence.lower() in evidence.lower():
-                        list_of_evidence_answer_where.append(f"""Answer retrieved from evidence :\n {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,list_of_evidence_answer_where,rouge_l_scores
-#------------------------------------------------------    
-
+            verification_status = '❌ Verified False'
+        qa_pipeline=[question,answer_claim,answer_evidence,verification_status]
+        list_of_qa_pipeline.append(qa_pipeline)    
+    return list_of_qa_pipeline    
+    
+#-------------------------------------------------------------------------
 
+    
 if claim_text and evidence_text:
     st.caption(':green[Kindly hold on for a few minutes while the QA pairs are being generated]')
-    df=claim(claim_text)
-    df["evidence"]=evidence_text
-    lst1=gen_qa_who(df)
-    lst2=gen_qa_what(df)
-    lst3=gen_qa_when(df)
-    lst4=gen_qa_where(df)
-    lst5=gen_qa_why(df)
-
-    output1=[]
-    if 'No claims' in lst1[0]:
-        output1=[item for item in lst1]
-    else:
-        for i in range(len(lst1[0])):
-            output1.append(lst1[0][i])
-            output1.append(lst1[1][i])
-            output1.append(lst1[2][i])
-            output1.append(lst1[3][i])
-    output2=[]
-    if 'No claims' in lst2[0]:
-        output2=[item for item in lst2]
-    else:
-        for i in range(len(lst2[0])):
-            output2.append(lst2[0][i])
-            output2.append(lst2[1][i])
-            output2.append(lst2[2][i])
-            output2.append(lst2[3][i])
-    output3=[]
-    if 'No claims' in lst3[0]:
-        output3=[item for item in lst3]
-    else:
-        for i in range(len(lst3[0])):
-            output3.append(lst3[0][i])
-            output3.append(lst3[1][i])
-            output3.append(lst3[2][i])
-            output3.append(lst3[3][i])
-    output4=[]
-    if 'No claims' in lst4[0]:
-        output4=[item for item in lst4]
-    else:
-        for i in range(len(lst4[0])):
-            output4.append(lst4[0][i])
-            output4.append(lst4[1][i])
-            output4.append(lst4[2][i])
-            output4.append(lst4[3][i])
-    output5=[]
-    if 'No claims' in lst5[0]:
-        output5=[item for item in lst5]
-    else:
-        for i in range(len(lst5[0])):
-            output5.append(lst5[0][i])
-            output5.append(lst5[1][i])
-            output5.append(lst5[2][i])
-            output5.append(lst5[3][i])
-    max_rows = max(len(output1), len(output2), len(output3), len(output4), len(output5))
-    final_df = pd.DataFrame(columns=['Who Claims', 'What Claims', 'When Claims', 'Where Claims', 'Why Claims'])
-    # add the data to the dataframe
-    final_df['Who Claims'] = output1 + [''] * (max_rows - len(output1))
-    final_df['What Claims'] = output2 + [''] * (max_rows - len(output2))
-    final_df['When Claims'] = output3 + [''] * (max_rows - len(output3))
-    final_df['Where Claims'] = output4 + [''] * (max_rows - len(output4))
-    final_df['Why Claims'] = output5 + [''] * (max_rows - len(output5))  
+    srl_list = list(itertools.chain(*[list(s) for s in srl(claim_text)]))
+    qa_list=qa_list_gen(claim_text,srl_list,evidence)
+    list_who = []
+    list_what = []
+    list_when = []
+    list_where = []
+    list_why = []
+    list_misc = []
+    
+    for item in qa_list:
+        question = item[0]
+        if any(x in question.lower() for x in ['who', 'what', 'when', 'where', 'why']):
+            if 'who' in question.lower():
+                list_who.append(item)
+            elif 'what' in question.lower():
+                list_what.append(item)
+            elif 'when' in question.lower():
+                list_when.append(item)
+            elif 'where' in question.lower():
+                list_where.append(item)
+            elif 'why' in question.lower():
+                list_why.append(item)
+        else:
+            list_misc.append(item)
+    lists = [list_who, list_when, list_why, list_where, list_what]
+
+    for i in range(len(lists)):
+        if not lists[i]:
+            lists[i].extend([["No claims", "", f"No mention of '{['who', 'when', 'why', 'where', 'what'][i]}' in any related documents.", "❔ Not verifiable"]])
+    
+    final_df = pd.DataFrame(columns=['Who Claims', 'What Claims', 'When Claims', 'Where Claims', 'Why Claims', 'Misc Claims'])
+    
+    all_items_who = [item for item_list in list_who for item in item_list]
+    all_items_what = [item for item_list in list_what for item in item_list]
+    all_items_when = [item for item_list in list_when for item in item_list]
+    all_items_where = [item for item_list in list_where for item in item_list]
+    all_items_why = [item for item_list in list_why for item in item_list]
+    all_items_misc = [item for item_list in list_misc for item in item_list]
+    
+    
+    max_rows = max(len(all_items_who), len(all_items_what), len(all_items_when), len(all_items_where), len(all_items_why), len(all_items_misc))
+    
+    final_df['Who Claims'] = all_items_who + [''] * (max_rows - len(all_items_who))
+    final_df['What Claims'] = all_items_what + [''] * (max_rows - len(all_items_what))
+    final_df['When Claims'] = all_items_when + [''] * (max_rows - len(all_items_when))
+    final_df['Where Claims'] = all_items_where + [''] * (max_rows - len(all_items_where))
+    final_df['Why Claims'] = all_items_why + [''] * (max_rows - len(all_items_why))  
+    final_df['Misc Claims'] = all_items_misc + [''] * (max_rows - len(all_items_misc))  
     st.write(f"""Claim : {claim_text}""")
     st.write(f"""Evidence : {evidence_text}""")  
     st.table(final_df)