Update app.py

app.py

@@ -85,6 +85,7 @@ image_description = ""
 
 
 def check_hallucination(assertion, citation):
+    print("Entering check_hallucination function")
     api_url = "https://api-inference.huggingface.co/models/vectara/hallucination_evaluation_model"
     header = {"Authorization": f"Bearer {hf_token}"}
     payload = {"inputs": f"{assertion} [SEP] {citation}"}
@@ -93,6 +94,7 @@ def check_hallucination(assertion, citation):
     output = response.json()
     output = output[0][0]["score"]
 
+    print(f"check_hallucination output: {output}")
     return f"**hallucination score:** {output}"
 
 
@@ -104,29 +106,26 @@ headers = {"Authorization": f"Bearer {hf_token}"}
 
 # Function to query the API
 def query(payload):
+    print("Entering query function")
     response = requests.post(vapi_url, headers=headers, json=payload)
+    print(f"API response: {response.json()}")
     return response.json()
 
-
 # Function to evaluate hallucination
 def evaluate_hallucination(input1, input2):
-    # Combine the inputs
-    combined_input = f"{input1}. {input2}"
+    print("Entering evaluate_hallucination function")
+    combined_input = f"{input1}[SEP]{input2}"
     
-    # Make the API call
     output = query({"inputs": combined_input})
-    
-    # Extract the score from the output
     score = output[0][0]['score']
-    
-    # Generate a label based on the score
+
     if score < 0.5:
         label = f"🔴 High risk. Score: {score:.2f}"
     else:
         label = f"🟢 Low risk. Score: {score:.2f}"
-    
-    return label
 
+    print(f"evaluate_hallucination label: {label}")
+    return label
 
 def save_audio(audio_input, output_dir="saved_audio"):
     if not os.path.exists(output_dir):
@@ -146,39 +145,40 @@ def save_audio(audio_input, output_dir="saved_audio"):
 
 
 def save_image(image_input, output_dir="saved_images"):
+    print("Entering save_image function")
     if not os.path.exists(output_dir):
         os.makedirs(output_dir)
 
-    # Assuming image_input is a NumPy array
     if isinstance(image_input, np.ndarray):
-        # Convert NumPy arrays to PIL Image
         image = Image.fromarray(image_input)
-
-        # Generate a unique file name
         file_name = f"image_{int(time.time())}.png"
         file_path = os.path.join(output_dir, file_name)
-
-        # Save the image file
         image.save(file_path)
 
+        print(f"Image saved at: {file_path}")
         return file_path
     else:
         raise ValueError("Invalid image input type")
 
+
 def process_image(image_file_path):
+    print("Entering process_image function")
     client = Client("https://tonic1-official-qwen-vl-chat.hf.space/--replicas/t5ccx/")  # TruEra
     try:
         result = client.predict(
-            "Describe this image in detail, identify every detail in this image. Describe the image the best you can.",  # TruEra
+            "Describe this image in detail, identify every detail in this image. Describe the image the best you can.",
             image_file_path,
             fn_index=0
         )
+        print(f"Image processing result: {result}")
         return result
     except Exception as e:
+        print(f"Error in process_image: {e}")
         return f"Error occurred during image processing: {e}"
 
 
 def process_speech(audio_input, source_language, target_language="English"):
+    print("Entering process_speech function")
     if audio_input is None:
         return "No audio input provided."
     try:
@@ -188,11 +188,14 @@ def process_speech(audio_input, source_language, target_language="English"):
             target_language,
             api_name="/s2tt"
         )
+        print(f"Speech processing result: {result}")
         return result
     except Exception as e:
+        print(f"Error in process_speech: {str(e)}")
         return f"Error in speech processing: {str(e)}"
 
 def convert_text_to_speech(input_text, source_language, target_language):
+    print("Entering convert_text_to_speech function")
     try:
         result = seamless_client.predict(
             input_text,  
@@ -203,8 +206,10 @@ def convert_text_to_speech(input_text, source_language, target_language):
         audio_file_path = result[0] if result else None
         translated_text = result[1] if result else ""
 
+        print(f"Text-to-speech conversion result: Audio file path: {audio_file_path}, Translated text: {translated_text}")
         return audio_file_path, translated_text
     except Exception as e:
+        print(f"Error in convert_text_to_speech: {str(e)}")
         return None, f"Error in text-to-speech conversion: {str(e)}"
 
 def query_vectara(text):
@@ -310,8 +315,8 @@ def query_vectara(text):
         return f"Error: {response.status_code}"
 
 
-# Functions to Wrap the Prompt Correctly
 def wrap_text(text, width=90):
+    print("Wrapping text...")
     lines = text.split('\n')
     wrapped_lines = [textwrap.fill(line, width=width) for line in lines]
     wrapped_text = '\n'.join(wrapped_lines)
@@ -320,96 +325,82 @@ def wrap_text(text, width=90):
 tokenizer = AutoTokenizer.from_pretrained("Qwen/Qwen-1_8B-Chat", trust_remote_code=True)
 model = AutoModelForCausalLM.from_pretrained("Qwen/Qwen-1_8B-Chat", device_map="auto", trust_remote_code=True).eval()
 
-# TruEra
 class ChatBot:
     def __init__(self):
         self.history = None
 
     def predict(self, user_input, system_prompt=""):
+        print("Generating prediction...")
         response, self.history = model.chat(tokenizer, user_input, history=self.history, system=system_prompt)
         return response
 
 bot = ChatBot()
 
-# TruEra
 def multimodal_prompt(user_input, system_prompt="You are an expert medical analyst:"):
+    print("Processing multimodal prompt...")
     return bot.predict(user_input, system_prompt)
 
-
-def process_summary_with_qwen(summary): # TruEra
-    system_prompt = "You are a medical instructor . Assess and describe the proper options to your students in minute detail. Propose a course of action for them to base their recommendations on based on your description."
+def process_summary_with_qwen(summary):
+    print("Processing summary with Qwen...")
+    system_prompt = "You are a medical instructor. Assess and describe the proper options to your students in minute detail. Propose a course of action for them to base their recommendations on based on your description."
     response_text = bot.predict(summary, system_prompt)
     return response_text
 
 
+
 def process_and_query(input_language=None, audio_input=None, image_input=None, text_input=None):
     try:
-        
+        print("Processing and querying...")
         combined_text = ""
-        markdown_output = ""  
-        image_text = ""  
-        language_code = None
-
-        # Convert input language to its code
-        if input_language and input_language in languages:
-            language_code = languages[input_language]
-
-        # Debugging print statement
+        markdown_output = ""
+        image_text = ""
         print(f"Image Input Type: {type(image_input)}, Audio Input Type: {type(audio_input)}")
-        
-        # Process image input
+
         if image_input is not None:
-            # Convert image_input to a file path
+            print("Processing image input...")
             image_file_path = save_image(image_input)
             image_text = process_image(image_file_path)
             combined_text += "\n\n**Image Input:**\n" + image_text
 
-        # Process audio input
         elif audio_input is not None:
+            print("Processing audio input...")
             sample_rate, audio_data = audio_input
             audio_file_path = save_audio(audio_input)
-            audio_text = process_speech(audio_file_path, language_code, "English")
+            audio_text = process_speech(audio_file_path, input_language, "English")
             combined_text += "\n\n**Audio Input:**\n" + audio_text
 
-        # Process text input
         elif text_input is not None and text_input.strip():
+            print("Processing text input...")
             combined_text += "The user asks the following to his health adviser: " + text_input
 
-        # Check if combined text is empty
         else:
             return "Error: Please provide some input (text, audio, or image)."
 
-        # Append the original image description in Markdown
         if image_text:
             markdown_output += "\n### Original Image Description\n"
             markdown_output += image_text + "\n"
-    
-        # Use the text to query Vectara
-        vectara_response_json = query_vectara(combined_text)
 
-        # Parse the Vectara response
+        print("Querying Vectara...")
+        vectara_response_json = query_vectara(combined_text)
         vectara_response = json.loads(vectara_response_json)
         summary = vectara_response.get('summary', 'No summary available')
         sources_info = vectara_response.get('sources', [])
 
-        # Format Vectara response in Markdown
         markdown_output = "### Vectara Response Summary\n"
         markdown_output += f"* **Summary**: {summary}\n"
         markdown_output += "### Sources Information\n"
         for source in sources_info:
             markdown_output += f"* {source}\n"
 
-        # Process the summary with Qwen
         final_response = process_summary_with_qwen(summary)
 
-        # Convert translated text to speech and get both audio file and text
-        target_language = "English"  
+        print("Converting text to speech...")
+        target_language = "English"
         audio_output, translated_text = convert_text_to_speech(final_response, target_language, input_language)
-        
-        # Evaluate hallucination
+
+        print("Evaluating hallucination...")
         hallucination_label = evaluate_hallucination(final_response, summary)
 
-        # Add final response and hallucination label to Markdown output
         markdown_output += "\n### Processed Summary with Qwen\n"
         markdown_output += final_response + "\n"
         markdown_output += "\n### Hallucination Evaluation\n"
@@ -418,8 +409,9 @@ def process_and_query(input_language=None, audio_input=None, image_input=None, t
         markdown_output += translated_text + "\n"
 
         return markdown_output, audio_output
-        
+
     except Exception as e:
+        print(f"Error occurred: {e}")
         return f"Error occurred during processing: {e}. No hallucination evaluation.", None