Trial and error.

app.py

@@ -4,10 +4,8 @@ import requests
 import inspect
 import pandas as pd
 from huggingface_hub import InferenceClient  # Import Hugging Face InferenceClient
-
-# (Keep Constants as is)
-# --- Constants ---
-DEFAULT_API_URL = "https://agents-course-unit4-scoring.hf.space"
+import torch
+from transformers import AutoModelForCausalLM, AutoTokenizer
 
 # --- Basic Agent Definition ---
 # ----- THIS IS WERE YOU CAN BUILD WHAT YOU WANT ------
@@ -16,190 +14,67 @@ DEFAULT_API_URL = "https://agents-course-unit4-scoring.hf.space"
 class BasicAgent:
     def __init__(self):
         print("BasicAgent initialized.")
-        # Use Qwen2.5-7B-Instruct model
-        self.model_name = "Qwen/Qwen2.5-7B-Instruct"
-        self.hf_token = os.getenv("HF_TOKEN")  # Get token from environment if available
 
+        print("Loading Qwen2.5-7B-Instruct model...")
+        self.model_name = "Qwen/Qwen2.5-7B-Instruct"
+        
+        # Load model and tokenizer
         try:
-            print(f"Initializing model: {self.model_name}")
-            self.hf_client = InferenceClient(
-                model=self.model_name,
-                token=self.hf_token
+            self.tokenizer = AutoTokenizer.from_pretrained(self.model_name)
+            self.model = AutoModelForCausalLM.from_pretrained(
+                self.model_name,
+                torch_dtype="auto",
+                device_map="auto"
             )
-            print(f"Model initialized successfully: {self.model_name}")
+            print(f"Successfully loaded {self.model_name}")
         except Exception as e:
-            print(f"Error initializing model ({self.model_name}): {e}")
-            self.hf_client = None
-            print("WARNING: Model initialization failed. Agent may not function properly.")
-
-    def break_down_question(self, question: str) -> list:
-        """
-        Use an LLM to break down a complex question into key search terms or sub-questions.
-
-        Args:
-            question (str): The original question
-
-        Returns:
-            list: A list of key search terms or sub-questions
-        """
-        try:
-            print(f"Breaking down question with LLM: {question[:50]}...")
-
-            # Create a prompt that asks the LLM to break down the question
-            prompt = f"""
-            Please break down this question into 2-3 key search queries that would help find information to answer it.
-            Return ONLY the search queries, one per line, with no additional text or explanations.
-
-            Question: {question}
-            """
-
-            # Call the Hugging Face model to get the breakdown
-            response = self.hf_client.text_generation(
-                prompt=prompt,
-                max_new_tokens=150,
-                temperature=0.3,
-                repetition_penalty=1.1,
-                do_sample=True
-            )
-
-            # Extract the search terms from the response
-            search_terms = response.strip().split('\n')
-            search_terms = [term.strip() for term in search_terms if term.strip()]
-
-            # Limit to 3 search terms maximum
-            search_terms = search_terms[:3]
-
-            print(f"Question broken down into {len(search_terms)} search terms: {search_terms}")
-            return search_terms
-
-        except Exception as e:
-            print(f"Error breaking down question: {e}")
-            # If there's an error, return the original question as a fallback
-            return [question]
-
-    def search_internet(self, query: str) -> str:
-        """
-        Search the internet for information using Wikipedia's API.
-        This is a simple implementation that returns search results as text.
-
-        Args:
-            query (str): The search query
-
-        Returns:
-            str: Search results as text
-        """
-        print(f"Searching internet for: {query}")
-        try:
-            # Use Wikipedia API to search for information
-            headers = {
-                'User-Agent': 'Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/91.0.4472.124 Safari/537.36'
-            }
-
-            # Step 1: Search for relevant articles
-            search_url = f"https://en.wikipedia.org/w/api.php?action=query&list=search&srsearch={query}&format=json"
-            search_response = requests.get(search_url, headers=headers, timeout=10)
-            search_response.raise_for_status()
-            search_data = search_response.json()
-
-            # Check if we found any search results
-            if 'query' not in search_data or 'search' not in search_data['query'] or not search_data['query']['search']:
-                return "No relevant information found."
-
-            # Get the title of the first (most relevant) result
-            first_result = search_data['query']['search'][0]
-            page_title = first_result['title']
-
-            # Step 2: Fetch the content of the most relevant article
-            content_url = f"https://en.wikipedia.org/w/api.php?action=query&prop=extracts&exintro=1&explaintext=1&titles={page_title}&format=json"
-            content_response = requests.get(content_url, headers=headers, timeout=10)
-            content_response.raise_for_status()
-            content_data = content_response.json()
-
-            # Extract the page content
-            pages = content_data['query']['pages']
-            page_id = list(pages.keys())[0]
-
-            if 'extract' in pages[page_id]:
-                extract = pages[page_id]['extract']
-                # Limit extract length to avoid very long responses
-                if len(extract) > 1000:
-                    extract = extract[:1000] + "..."
-
-                result = f"Wikipedia article: {page_title}\n\n{extract}"
-
-                # Also get a few more related article titles
-                related_titles = []
-                for item in search_data['query']['search'][1:4]:  # Get next 3 results
-                    related_titles.append(item['title'])
-
-                if related_titles:
-                    result += "\n\nRelated topics:\n"
-                    for title in related_titles:
-                        result += f"- {title}\n"
-
-                return result
-            else:
-                return "Found a relevant page, but couldn't extract its content."
-
-        except Exception as e:
-            print(f"Error searching internet: {e}")
-            return f"Error performing internet search: {str(e)}"
+            print(f"Error loading model: {e}")
+            # Fallback to HuggingFace Inference API if local loading fails
+            print("Falling back to InferenceClient")
+            self.client = InferenceClient(model=self.model_name)
+            self.tokenizer = None
+            self.model = None
 
     def __call__(self, question: str) -> str:
         print(f"Agent received question (first 50 chars): {question[:50]}...")
-
-        # Use LLM to break down the question into key search terms
-        search_terms = self.break_down_question(question)
-
-        # Search for information using each search term
-        all_results = []
-        for term in search_terms:
-            result = self.search_internet(term)
-            if result and result != "No relevant information found." and not result.startswith("Error"):
-                all_results.append(result)
-
-        # Create a response based on collected search results
-        if all_results:
-            # Join the results with clear separation
-            combined_results = "\n\n--- Next Search Result ---\n\n".join(all_results)
-
-            # Use Hugging Face model to synthesize a coherent answer from the search results
-            try:
-                synthesis_prompt = f"""
-                Based on the following search results, please provide a comprehensive answer to this question:
-
-                Question: {question}
-
-                Search Results:
-                {combined_results}
-
-                Answer:
-                """
-
-                # Call the Hugging Face model to synthesize an answer
-                response = self.hf_client.text_generation(
-                    prompt=synthesis_prompt,
-                    max_new_tokens=500,
-                    temperature=0.5,
-                    repetition_penalty=1.05,
-                    do_sample=True
+        
+        try:
+            # Create messages for the model
+            messages = [
+                {"role": "system", "content": "You are Qwen, created by Alibaba Cloud. You are a helpful assistant."},
+                {"role": "user", "content": question}
+            ]
+            
+            # Generate response
+            if self.model and self.tokenizer:
+                # Local model generation
+                text = self.tokenizer.apply_chat_template(
+                    messages,
+                    tokenize=False,
+                    add_generation_prompt=True
                 )
+                model_inputs = self.tokenizer([text], return_tensors="pt").to(self.model.device)
 
-                answer = response.strip()
-                print("Agent returning synthesized answer from search results.")
-                return answer
+                generated_ids = self.model.generate(
+                    **model_inputs,
+                    max_new_tokens=512
+                )
+                generated_ids = [
+                    output_ids[len(input_ids):] for input_ids, output_ids in zip(model_inputs.input_ids, generated_ids)
+                ]
 
-            except Exception as e:
-                print(f"Error synthesizing answer: {e}")
-                # Fallback to returning the raw search results
-                answer = f"Based on my searches, I found this information:\n\n{combined_results}"
-                print("Agent returning raw search results due to synthesis error.")
-                return answer
-        else:
-            # Fallback to default answer if all searches fail
-            answer = "I couldn't find specific information about that question."
-            print("Agent returning default answer as searches found no useful information.")
+                answer = self.tokenizer.batch_decode(generated_ids, skip_special_tokens=True)[0]
+            else:
+                # Fallback to Inference API
+                answer = self.client.chat(messages=messages)
+                
+            print(f"Agent generated response (first 50 chars): {answer[:50]}...")
             return answer
+        except Exception as e:
+            print(f"Error generating response: {e}")
+            fallback_answer = "I apologize, but I encountered an error when trying to answer your question."
+            print(f"Agent returning fallback answer: {fallback_answer}")
+            return fallback_answer
 
 
 def run_and_submit_all(profile: gr.OAuthProfile | None):
@@ -327,7 +202,7 @@ def run_and_submit_all(profile: gr.OAuthProfile | None):
 
 # --- Build Gradio Interface using Blocks ---
 with gr.Blocks() as demo:
-    gr.Markdown("# Basic Agent Evaluation Runner (Attempt #3)")
+    gr.Markdown("# Basic Agent Evaluation Runner #")
     gr.Markdown(
         """
         **Instructions:**

requirements.txt

@@ -1,3 +1,5 @@
 gradio
 requests
-huggingface_hub
+huggingface_hub
+transformers
+torch