Update app.py

app.py

@@ -13,17 +13,28 @@ import gradio as gr
 from transformers import TextIteratorStreamer, AutoModelForSeq2SeqLM, AutoTokenizer, AutoConfig
 from huggingface_hub import InferenceClient
 
+import logging
+
+# Set up logging
+logging.basicConfig(level=logging.DEBUG)
+logger = logging.getLogger(__name__)
+
 # Define device and load model and tokenizer
 DEVICE = torch.device("cuda" if torch.cuda.is_available() else "cpu")
 MODEL_NAME = "microsoft/Phi-3-mini-4k-instruct"
 
+# Update transformers library
+!pip install --upgrade transformers
+
 # Load model and tokenizer, with specific handling for the Phi-3 model
 try:
+    logger.debug("Attempting to load the model and tokenizer")
     config = AutoConfig.from_pretrained(MODEL_NAME)
     model = AutoModelForSeq2SeqLM.from_pretrained(MODEL_NAME, config=config).to(DEVICE)
     tokenizer = AutoTokenizer.from_pretrained(MODEL_NAME)
+    logger.debug("Model and tokenizer loaded successfully")
 except ValueError as e:
-    print(f"Error loading model: {e}")
+    logger.error(f"Error loading model: {e}")
     # Fallback to using InferenceClient from Hugging Face Hub
     client = InferenceClient(model=MODEL_NAME)
     model = None
@@ -65,6 +76,7 @@ def extract_text_from_webpage(html_content):
 
 # Function to perform a Google search and return the results
 def search(term, num_results=2, lang="en", timeout=5, safe="active", ssl_verify=None):
+    logger.debug(f"Starting search for term: {term}")
     escaped_term = urllib.parse.quote_plus(term)
     start = 0
     all_results = []
@@ -72,46 +84,52 @@ def search(term, num_results=2, lang="en", timeout=5, safe="active", ssl_verify=
 
     with requests.Session() as session:
         while start < num_results:
-            resp = session.get(
-                url="https://www.google.com/search",
-                headers={"User-Agent": "Mozilla/5.0 (Windows NT 10.0; Win64; x64; rv:109.0) Gecko/20100101 Firefox/111.0"},
-                params={
-                    "q": term,
-                    "num": num_results - start,
-                    "hl": lang,
-                    "start": start,
-                    "safe": safe,
-                },
-                timeout=timeout,
-                verify=ssl_verify,
-            )
-            resp.raise_for_status()
-            soup = BeautifulSoup(resp.text, "html.parser")
-            result_block = soup.find_all("div", attrs={"class": "g"})
-            if not result_block:
-                start += 1
-                continue
-            for result in result_block:
-                link = result.find("a", href=True)
-                if link:
-                    link = link["href"]
-                    try:
-                        webpage = session.get(link, headers={"User-Agent": "Mozilla/5.0 (Windows NT 10.0; Win64; x64; rv:109.0) Gecko/20100101 Firefox/111.0"})
-                        webpage.raise_for_status()
-                        visible_text = extract_text_from_webpage(webpage.text)
-                        if len(visible_text) > max_chars_per_page:
-                            visible_text = visible_text[:max_chars_per_page] + "..."
-                        all_results.append({"link": link, "text": visible_text})
-                    except requests.exceptions.RequestException as e:
-                        print(f"Error fetching or processing {link}: {e}")
-                        all_results.append({"link": link, "text": None})
-                else:
-                    all_results.append({"link": None, "text": None})
-            start += len(result_block)
+            try:
+                resp = session.get(
+                    url="https://www.google.com/search",
+                    headers={"User-Agent": "Mozilla/5.0 (Windows NT 10.0; Win64; x64; rv:109.0) Gecko/20100101 Firefox/111.0"},
+                    params={
+                        "q": term,
+                        "num": num_results - start,
+                        "hl": lang,
+                        "start": start,
+                        "safe": safe,
+                    },
+                    timeout=timeout,
+                    verify=ssl_verify,
+                )
+                resp.raise_for_status()
+                soup = BeautifulSoup(resp.text, "html.parser")
+                result_block = soup.find_all("div", attrs={"class": "g"})
+                if not result_block:
+                    start += 1
+                    continue
+                for result in result_block:
+                    link = result.find("a", href=True)
+                    if link:
+                        link = link["href"]
+                        try:
+                            webpage = session.get(link, headers={"User-Agent": "Mozilla/5.0 (Windows NT 10.0; Win64; x64; rv:109.0) Gecko/20100101 Firefox/111.0"})
+                            webpage.raise_for_status()
+                            visible_text = extract_text_from_webpage(webpage.text)
+                            if len(visible_text) > max_chars_per_page:
+                                visible_text = visible_text[:max_chars_per_page] + "..."
+                            all_results.append({"link": link, "text": visible_text})
+                        except requests.exceptions.RequestException as e:
+                            logger.error(f"Error fetching or processing {link}: {e}")
+                            all_results.append({"link": link, "text": None})
+                    else:
+                        all_results.append({"link": None, "text": None})
+                start += len(result_block)
+            except Exception as e:
+                logger.error(f"Error during search: {e}")
+                break
+    logger.debug(f"Search results: {all_results}")
     return all_results
 
 # Function to format the prompt for the language model
 def format_prompt(user_prompt, chat_history):
+    logger.debug(f"Formatting prompt with user prompt: {user_prompt} and chat history: {chat_history}")
     prompt = "<s>"
     for item in chat_history:
         if isinstance(item, tuple):
@@ -119,6 +137,7 @@ def format_prompt(user_prompt, chat_history):
         else:
             prompt += f" [Image] "
     prompt += f"[INST] {user_prompt} [/INST]"
+    logger.debug(f"Formatted prompt: {prompt}")
     return prompt
 
 # Function for model inference
@@ -132,7 +151,9 @@ def model_inference(
         repetition_penalty,
         top_p,
 ):
+    logger.debug(f"Starting model inference with user prompt: {user_prompt}, chat history: {chat_history}, web_search: {web_search}")
     if not isinstance(user_prompt, dict):
+        logger.error("Invalid input format. Expected a dictionary.")
         return "Invalid input format. Expected a dictionary."
 
     if "files" not in user_prompt:
@@ -140,6 +161,7 @@ def model_inference(
 
     if not user_prompt["files"]:
         if web_search:
+            logger.debug("Performing web search")
             web_results = search(user_prompt["text"])
             web2 = ' '.join([f"Link: {res['link']}\nText: {res['text']}\n\n" for res in web_results])
             formatted_prompt = format_prompt(f"{user_prompt['text']} [WEB] {web2}", chat_history)
@@ -156,6 +178,7 @@ def model_inference(
                 response = tokenizer.decode(outputs[0], skip_special_tokens=True)
             else:
                 response = client.generate(formatted_prompt)
+            logger.debug(f"Model response: {response}")
             return response
         else:
             formatted_prompt = format_prompt(user_prompt["text"], chat_history)
@@ -172,6 +195,7 @@ def model_inference(
                 response = tokenizer.decode(outputs[0], skip_special_tokens=True)
             else:
                 response = client.generate(formatted_prompt)
+            logger.debug(f"Model response: {response}")
             return response
     else:
         return "Image input not supported in this implementation."
@@ -235,10 +259,11 @@ chatbot = gr.Chatbot(
 
 # Define Gradio interface
 def chat_interface(user_input, history, web_search, decoding_strategy, temperature, max_new_tokens, repetition_penalty, top_p):
-    # Ensure user_input is a dictionary
-    user_input_dict = {"text": user_input, "files": []}
+    logger.debug(f"Chat interface called with user_input: {user_input}")
+    if isinstance(user_input, str):
+        user_input = {"text": user_input, "files": []}
     response = model_inference(
-        user_input_dict,
+        user_input,
         history,
         web_search,
         decoding_strategy,
@@ -247,7 +272,8 @@ def chat_interface(user_input, history, web_search, decoding_strategy, temperatu
         repetition_penalty,
         top_p,
     )
-    history.append((user_input, response))
+    history.append((user_input["text"], response))
+    logger.debug(f"Updated chat history: {history}")
     return history, history
 
 # Create Gradio interface
@@ -272,4 +298,5 @@ interface = gr.Interface(
 )
 
 if __name__ == "__main__":
+    logger.debug("Launching Gradio interface")
     interface.launch()