Update app.py

app.py

@@ -2,96 +2,305 @@ import os
 import gradio as gr
 import requests
 import pandas as pd
-from smolagents import ToolCallingAgent, Tool
+import json
+import time
+from typing import Dict, List, Any, Optional
 
 # Config
 DEFAULT_API_URL = "https://agents-course-unit4-scoring.hf.space"
-MODEL_NAME = "google/flan-t5-small"
+MODEL_NAME = "microsoft/DialoGPT-medium"  # Better conversational model
 SPACE_ID = os.getenv("SPACE_ID", "sirine1712/Final_Assignment_Template")
 HF_TOKEN = os.getenv("HF_TOKEN")
 
-# Define a simple Hugging Face Inference Agent
-class HuggingFaceAPIAgent(Agent):
-    def __init__(self, model=MODEL_NAME):
+class HuggingFaceAPIAgent:
+    """Enhanced Hugging Face Inference Agent with better question processing"""
+    
+    def __init__(self, model: str = MODEL_NAME):
         self.model = model
         self.api_url = f"https://api-inference.huggingface.co/models/{model}"
         self.headers = {"Authorization": f"Bearer {HF_TOKEN}"}
-
+        
+    def preprocess_question(self, question: str) -> str:
+        """Preprocess question to improve model understanding"""
+        # Add context markers for better comprehension
+        processed = f"Question: {question.strip()}"
+        
+        # Handle specific question types
+        if any(word in question.lower() for word in ['calculate', 'compute', 'math', 'number']):
+            processed = f"Math problem: {question.strip()} Please provide the numerical answer."
+        elif any(word in question.lower() for word in ['when', 'what year', 'date']):
+            processed = f"Factual question about time: {question.strip()} Please provide the specific date or year."
+        elif any(word in question.lower() for word in ['who', 'person', 'people']):
+            processed = f"Question about people: {question.strip()} Please provide the name(s)."
+        elif any(word in question.lower() for word in ['where', 'location', 'place']):
+            processed = f"Location question: {question.strip()} Please provide the specific location."
+        elif any(word in question.lower() for word in ['how many', 'count', 'quantity']):
+            processed = f"Counting question: {question.strip()} Please provide the exact number."
+            
+        return processed
+    
+    def postprocess_answer(self, raw_answer: str, question: str) -> str:
+        """Clean and format the model's response"""
+        if not raw_answer:
+            return "Unable to generate answer"
+            
+        # Remove common prefixes/suffixes
+        answer = raw_answer.strip()
+        prefixes_to_remove = [
+            "Question:", "Answer:", "Response:", "Output:", 
+            "The answer is:", "Based on the question:",
+            "Math problem:", "Factual question about time:",
+            "Question about people:", "Location question:",
+            "Counting question:"
+        ]
+        
+        for prefix in prefixes_to_remove:
+            if answer.lower().startswith(prefix.lower()):
+                answer = answer[len(prefix):].strip()
+        
+        # Extract specific answer patterns
+        if any(word in question.lower() for word in ['calculate', 'compute', 'math']):
+            # Try to extract numbers from the response
+            import re
+            numbers = re.findall(r'-?\d+\.?\d*', answer)
+            if numbers:
+                return numbers[-1]  # Return the last number found
+        
+        # Limit answer length for conciseness
+        if len(answer) > 200:
+            sentences = answer.split('.')
+            answer = sentences[0] + '.' if sentences else answer[:200]
+            
+        return answer
+    
     def __call__(self, question: str) -> str:
-        print(f"⏳ Sending question to HF model: {question[:60]}")
+        """Main method to process questions"""
+        print(f"⏳ Processing question: {question[:80]}...")
+        
         try:
-            response = requests.post(
-                self.api_url,
-                headers=self.headers,
-                json={"inputs": question},
-                timeout=10
-            )
-            response.raise_for_status()
-            output = response.json()
-            if isinstance(output, list):
-                return output[0].get("generated_text", "No answer generated.")
-            else:
-                return output.get("generated_text", "No answer generated.")
+            # Preprocess the question
+            processed_question = self.preprocess_question(question)
+            
+            # Make API call with retry logic
+            max_retries = 3
+            for attempt in range(max_retries):
+                try:
+                    response = requests.post(
+                        self.api_url,
+                        headers=self.headers,
+                        json={
+                            "inputs": processed_question,
+                            "parameters": {
+                                "max_length": 150,
+                                "temperature": 0.3,  # Lower temperature for more focused answers
+                                "do_sample": True,
+                                "top_p": 0.9
+                            }
+                        },
+                        timeout=15
+                    )
+                    
+                    if response.status_code == 503:  # Model loading
+                        print(f"⏳ Model loading, waiting... (attempt {attempt + 1})")
+                        time.sleep(10)
+                        continue
+                        
+                    response.raise_for_status()
+                    output = response.json()
+                    
+                    # Extract generated text
+                    if isinstance(output, list) and len(output) > 0:
+                        raw_answer = output[0].get("generated_text", "")
+                    elif isinstance(output, dict):
+                        raw_answer = output.get("generated_text", "")
+                    else:
+                        raw_answer = str(output)
+                    
+                    # Postprocess the answer
+                    final_answer = self.postprocess_answer(raw_answer, question)
+                    print(f"✅ Generated answer: {final_answer[:60]}...")
+                    return final_answer
+                    
+                except requests.exceptions.RequestException as e:
+                    if attempt == max_retries - 1:
+                        raise e
+                    print(f"⚠️ Request failed (attempt {attempt + 1}), retrying...")
+                    time.sleep(2)
+                    
         except Exception as e:
-            print(f"⚠️ Error calling model: {e}")
-            return f"Error: {e}"
+            error_msg = f"Error processing question: {str(e)}"
+            print(f"❌ {error_msg}")
+            return error_msg
 
-# Function to run agent and submit to GAIA scoring API
 def run_and_submit_all(profile: gr.OAuthProfile | None):
+    """Main function to run agent on all questions and submit results"""
     if not profile:
-        return "❌ Please log in first.", None
-
+        return "❌ Please log in with your Hugging Face account first.", None
+    
     username = profile.username or "anonymous"
     agent_code = f"https://huggingface.co/spaces/{SPACE_ID}/tree/main"
+    
+    print(f"🚀 Starting agent run for user: {username}")
+    
+    # Initialize the agent
     agent = HuggingFaceAPIAgent()
-
+    
+    # Fetch questions from GAIA API
     try:
-        questions = requests.get(f"{DEFAULT_API_URL}/questions", timeout=15).json()
+        print("📥 Fetching questions from GAIA API...")
+        questions_response = requests.get(f"{DEFAULT_API_URL}/questions", timeout=20)
+        questions_response.raise_for_status()
+        questions = questions_response.json()
+        print(f"✅ Retrieved {len(questions)} questions")
     except Exception as e:
-        return f"❌ Failed to fetch questions: {e}", None
-
-    answers, log = [], []
-
-    for q in questions:
+        error_msg = f"❌ Failed to fetch questions: {str(e)}"
+        print(error_msg)
+        return error_msg, None
+    
+    # Process each question
+    answers = []
+    log_entries = []
+    
+    for i, q in enumerate(questions, 1):
+        print(f"\n🔄 Processing question {i}/{len(questions)}")
+        print(f"Task ID: {q.get('task_id', 'Unknown')}")
+        
         try:
+            # Get answer from agent
             answer = agent(q["question"])
         except Exception as e:
-            answer = f"Error: {e}"
-        answers.append({"task_id": q["task_id"], "submitted_answer": answer})
-        log.append({
+            answer = f"Error: {str(e)}"
+            print(f"❌ Error processing question: {e}")
+        
+        # Prepare submission format
+        answers.append({
+            "task_id": q["task_id"],
+            "submitted_answer": answer
+        })
+        
+        # Log for display
+        log_entries.append({
             "Task ID": q["task_id"],
-            "Question": q["question"],
-            "Submitted Answer": answer
+            "Question": q["question"][:100] + "..." if len(q["question"]) > 100 else q["question"],
+            "Submitted Answer": answer[:100] + "..." if len(str(answer)) > 100 else str(answer),
+            "Status": "✅ Completed" if "Error:" not in str(answer) else "❌ Failed"
         })
-
+    
+    # Submit answers to GAIA scoring API
     try:
-        result = requests.post(
+        print(f"\n📤 Submitting {len(answers)} answers to GAIA API...")
+        submission_data = {
+            "username": username,
+            "agent_code": agent_code,
+            "answers": answers
+        }
+        
+        submit_response = requests.post(
             f"{DEFAULT_API_URL}/submit",
-            json={
-                "username": username,
-                "agent_code": agent_code,
-                "answers": answers
-            },
-            timeout=10
-        ).json()
+            json=submission_data,
+            timeout=30
+        )
+        submit_response.raise_for_status()
+        result = submit_response.json()
+        
+        print(f"✅ Submission successful!")
+        print(f"Score: {result.get('score', 'N/A')}%")
+        
     except Exception as e:
-        return f"❌ Submission failed: {e}", pd.DataFrame(log)
+        error_msg = f"❌ Submission failed: {str(e)}"
+        print(error_msg)
+        return error_msg, pd.DataFrame(log_entries)
+    
+    # Format success message
+    score = result.get('score', 'N/A')
+    correct_count = result.get('correct_count', 'N/A')
+    total_attempted = result.get('total_attempted', 'N/A')
+    message = result.get('message', 'No additional message')
+    
+    success_message = f"""✅ **Submission Complete!**
+
+**📊 Results:**
+- **Score:** {score}%
+- **Correct Answers:** {correct_count}/{total_attempted}
+- **Total Questions:** {len(questions)}
 
-    message = (
-        f"✅ **Submission complete!**\n"
-        f"**Score:** {result.get('score')}%\n"
-        f"**Correct:** {result.get('correct_count')}/{result.get('total_attempted')}\n"
-        f"**Message:** {result.get('message')}"
-    )
-    return message, pd.DataFrame(log)
+**📝 Message:** {message}
 
-# Gradio UI
-with gr.Blocks() as demo:
-    gr.Markdown("# 🤖 HuggingFace Inference Agent\nA minimal agent using FLAN-T5 on HuggingFace Inference API.")
-    gr.LoginButton()
-    btn = gr.Button("🚀 Run Agent & Submit")
-    status = gr.Textbox(label="Status", lines=4)
-    results = gr.DataFrame(label="Agent Output Log")
-    btn.click(fn=run_and_submit_all, outputs=[status, results])
+**🎯 Target:** 30% ({"✅ ACHIEVED!" if isinstance(score, (int, float)) and score >= 30 else "Keep trying!"})
+"""
+    
+    print(success_message)
+    return success_message, pd.DataFrame(log_entries)
+
+# Create Gradio Interface
+def create_interface():
+    """Create the Gradio interface"""
+    with gr.Blocks(
+        title="🤖 GAIA Challenge Agent",
+        theme=gr.themes.Soft()
+    ) as demo:
+        
+        gr.Markdown("""
+        # 🤖 GAIA Challenge Agent
+        
+        An AI agent built to tackle the GAIA benchmark questions using Hugging Face models.
+        
+        **Target:** Achieve 30% accuracy on GAIA evaluation questions.
+        
+        **Instructions:**
+        1. Log in with your Hugging Face account
+        2. Click "🚀 Run Agent & Submit" to start the evaluation
+        3. Wait for the agent to process all questions and submit results
+        """)
+        
+        # Login section
+        gr.Markdown("### 🔐 Authentication")
+        gr.LoginButton(value="Login with Hugging Face")
+        
+        # Control section
+        gr.Markdown("### 🎮 Controls")
+        with gr.Row():
+            run_button = gr.Button(
+                "🚀 Run Agent & Submit", 
+                variant="primary",
+                size="lg"
+            )
+        
+        # Results section
+        gr.Markdown("### 📊 Results")
+        status_output = gr.Textbox(
+            label="📋 Status & Results",
+            lines=8,
+            max_lines=15,
+            placeholder="Results will appear here after submission..."
+        )
+        
+        gr.Markdown("### 📝 Detailed Log")
+        results_table = gr.DataFrame(
+            label="Agent Processing Log",
+            headers=["Task ID", "Question", "Submitted Answer", "Status"],
+            wrap=True
+        )
+        
+        # Event handlers
+        run_button.click(
+            fn=run_and_submit_all,
+            outputs=[status_output, results_table]
+        )
+        
+        # Footer
+        gr.Markdown("""
+        ---
+        **Note:** Make sure your `HF_TOKEN` is set in the Space secrets for API access.
+        """)
+    
+    return demo
 
-demo.launch()
+# Launch the app
+if __name__ == "__main__":
+    demo = create_interface()
+    demo.launch(
+        server_name="0.0.0.0",
+        server_port=7860,
+        share=False
+    )