|
import os |
|
import gradio as gr |
|
import requests |
|
import inspect |
|
import pandas as pd |
|
from huggingface_hub import InferenceClient |
|
|
|
|
|
|
|
DEFAULT_API_URL = "https://agents-course-unit4-scoring.hf.space" |
|
|
|
|
|
|
|
|
|
|
|
class BasicAgent: |
|
def __init__(self): |
|
print("BasicAgent initialized.") |
|
|
|
self.model_name = "Qwen/Qwen2.5-7B-Instruct" |
|
self.hf_token = os.getenv("HF_TOKEN") |
|
|
|
try: |
|
print(f"Initializing model: {self.model_name}") |
|
self.hf_client = InferenceClient( |
|
model=self.model_name, |
|
token=self.hf_token |
|
) |
|
print(f"Model initialized successfully: {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]}...") |
|
|
|
|
|
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} |
|
""" |
|
|
|
|
|
response = self.hf_client.text_generation( |
|
prompt=prompt, |
|
max_new_tokens=150, |
|
temperature=0.3, |
|
repetition_penalty=1.1, |
|
do_sample=True |
|
) |
|
|
|
|
|
search_terms = response.strip().split('\n') |
|
search_terms = [term.strip() for term in search_terms if term.strip()] |
|
|
|
|
|
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}") |
|
|
|
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: |
|
|
|
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' |
|
} |
|
|
|
|
|
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() |
|
|
|
|
|
if 'query' not in search_data or 'search' not in search_data['query'] or not search_data['query']['search']: |
|
return "No relevant information found." |
|
|
|
|
|
first_result = search_data['query']['search'][0] |
|
page_title = first_result['title'] |
|
|
|
|
|
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() |
|
|
|
|
|
pages = content_data['query']['pages'] |
|
page_id = list(pages.keys())[0] |
|
|
|
if 'extract' in pages[page_id]: |
|
extract = pages[page_id]['extract'] |
|
|
|
if len(extract) > 1000: |
|
extract = extract[:1000] + "..." |
|
|
|
result = f"Wikipedia article: {page_title}\n\n{extract}" |
|
|
|
|
|
related_titles = [] |
|
for item in search_data['query']['search'][1:4]: |
|
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)}" |
|
|
|
def __call__(self, question: str) -> str: |
|
print(f"Agent received question (first 50 chars): {question[:50]}...") |
|
|
|
|
|
search_terms = self.break_down_question(question) |
|
|
|
|
|
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) |
|
|
|
|
|
if all_results: |
|
|
|
combined_results = "\n\n--- Next Search Result ---\n\n".join(all_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: |
|
""" |
|
|
|
|
|
response = self.hf_client.text_generation( |
|
prompt=synthesis_prompt, |
|
max_new_tokens=500, |
|
temperature=0.5, |
|
repetition_penalty=1.05, |
|
do_sample=True |
|
) |
|
|
|
answer = response.strip() |
|
print("Agent returning synthesized answer from search results.") |
|
return answer |
|
|
|
except Exception as e: |
|
print(f"Error synthesizing answer: {e}") |
|
|
|
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: |
|
|
|
answer = "I couldn't find specific information about that question." |
|
print("Agent returning default answer as searches found no useful information.") |
|
return answer |
|
|
|
|
|
def run_and_submit_all(profile: gr.OAuthProfile | None): |
|
""" |
|
Fetches all questions, runs the BasicAgent on them, submits all answers, |
|
and displays the results. |
|
""" |
|
|
|
space_id = os.getenv("SPACE_ID") |
|
|
|
if profile: |
|
username = f"{profile.username}" |
|
print(f"User logged in: {username}") |
|
else: |
|
print("User not logged in.") |
|
return "Please Login to Hugging Face with the button.", None |
|
|
|
api_url = DEFAULT_API_URL |
|
questions_url = f"{api_url}/questions" |
|
submit_url = f"{api_url}/submit" |
|
|
|
|
|
try: |
|
agent = BasicAgent() |
|
except Exception as e: |
|
print(f"Error instantiating agent: {e}") |
|
return f"Error initializing agent: {e}", None |
|
|
|
agent_code = f"https://huggingface.co/spaces/{space_id}/tree/main" |
|
print(agent_code) |
|
|
|
return |
|
|
|
|
|
print(f"Fetching questions from: {questions_url}") |
|
try: |
|
response = requests.get(questions_url, timeout=15) |
|
response.raise_for_status() |
|
questions_data = response.json() |
|
if not questions_data: |
|
print("Fetched questions list is empty.") |
|
return "Fetched questions list is empty or invalid format.", None |
|
print(f"Fetched {len(questions_data)} questions.") |
|
except requests.exceptions.RequestException as e: |
|
print(f"Error fetching questions: {e}") |
|
return f"Error fetching questions: {e}", None |
|
except requests.exceptions.JSONDecodeError as e: |
|
print(f"Error decoding JSON response from questions endpoint: {e}") |
|
print(f"Response text: {response.text[:500]}") |
|
return f"Error decoding server response for questions: {e}", None |
|
except Exception as e: |
|
print(f"An unexpected error occurred fetching questions: {e}") |
|
return f"An unexpected error occurred fetching questions: {e}", None |
|
|
|
|
|
results_log = [] |
|
answers_payload = [] |
|
print(f"Running agent on {len(questions_data)} questions...") |
|
for item in questions_data: |
|
task_id = item.get("task_id") |
|
question_text = item.get("question") |
|
if not task_id or question_text is None: |
|
print(f"Skipping item with missing task_id or question: {item}") |
|
continue |
|
try: |
|
submitted_answer = agent(question_text) |
|
answers_payload.append({"task_id": task_id, "submitted_answer": submitted_answer}) |
|
results_log.append({"Task ID": task_id, "Question": question_text, "Submitted Answer": submitted_answer}) |
|
except Exception as e: |
|
print(f"Error running agent on task {task_id}: {e}") |
|
results_log.append({"Task ID": task_id, "Question": question_text, "Submitted Answer": f"AGENT ERROR: {e}"}) |
|
|
|
return |
|
|
|
if not answers_payload: |
|
print("Agent did not produce any answers to submit.") |
|
return "Agent did not produce any answers to submit.", pd.DataFrame(results_log) |
|
|
|
|
|
submission_data = {"username": username.strip(), "agent_code": agent_code, "answers": answers_payload} |
|
status_update = f"Agent finished. Submitting {len(answers_payload)} answers for user '{username}'..." |
|
print(status_update) |
|
|
|
|
|
print(f"Submitting {len(answers_payload)} answers to: {submit_url}") |
|
try: |
|
response = requests.post(submit_url, json=submission_data, timeout=60) |
|
response.raise_for_status() |
|
result_data = response.json() |
|
final_status = ( |
|
f"Submission Successful!\n" |
|
f"User: {result_data.get('username')}\n" |
|
f"Overall Score: {result_data.get('score', 'N/A')}% " |
|
f"({result_data.get('correct_count', '?')}/{result_data.get('total_attempted', '?')} correct)\n" |
|
f"Message: {result_data.get('message', 'No message received.')}" |
|
) |
|
print("Submission successful.") |
|
results_df = pd.DataFrame(results_log) |
|
return final_status, results_df |
|
except requests.exceptions.HTTPError as e: |
|
error_detail = f"Server responded with status {e.response.status_code}." |
|
try: |
|
error_json = e.response.json() |
|
error_detail += f" Detail: {error_json.get('detail', e.response.text)}" |
|
except requests.exceptions.JSONDecodeError: |
|
error_detail += f" Response: {e.response.text[:500]}" |
|
status_message = f"Submission Failed: {error_detail}" |
|
print(status_message) |
|
results_df = pd.DataFrame(results_log) |
|
return status_message, results_df |
|
except requests.exceptions.Timeout: |
|
status_message = "Submission Failed: The request timed out." |
|
print(status_message) |
|
results_df = pd.DataFrame(results_log) |
|
return status_message, results_df |
|
except requests.exceptions.RequestException as e: |
|
status_message = f"Submission Failed: Network error - {e}" |
|
print(status_message) |
|
results_df = pd.DataFrame(results_log) |
|
return status_message, results_df |
|
except Exception as e: |
|
status_message = f"An unexpected error occurred during submission: {e}" |
|
print(status_message) |
|
results_df = pd.DataFrame(results_log) |
|
return status_message, results_df |
|
|
|
|
|
|
|
with gr.Blocks() as demo: |
|
gr.Markdown("# Basic Agent Evaluation Runner (Attempt #3)") |
|
gr.Markdown( |
|
""" |
|
**Instructions:** |
|
|
|
1. Please clone this space, then modify the code to define your agent's logic, the tools, the necessary packages, etc ... |
|
2. Log in to your Hugging Face account using the button below. This uses your HF username for submission. |
|
3. Click 'Run Evaluation & Submit All Answers' to fetch questions, run your agent, submit answers, and see the score. |
|
|
|
--- |
|
**Disclaimers:** |
|
Once clicking on the "submit button, it can take quite some time ( this is the time for the agent to go through all the questions). |
|
This space provides a basic setup and is intentionally sub-optimal to encourage you to develop your own, more robust solution. For instance for the delay process of the submit button, a solution could be to cache the answers and submit in a seperate action or even to answer the questions in async. |
|
""" |
|
) |
|
|
|
gr.LoginButton() |
|
|
|
run_button = gr.Button("Run Evaluation & Submit All Answers") |
|
|
|
status_output = gr.Textbox(label="Run Status / Submission Result", lines=5, interactive=False) |
|
|
|
results_table = gr.DataFrame(label="Questions and Agent Answers", wrap=True) |
|
|
|
run_button.click( |
|
fn=run_and_submit_all, |
|
outputs=[status_output, results_table] |
|
) |
|
|
|
if __name__ == "__main__": |
|
print("\n" + "-" * 30 + " App Starting " + "-" * 30) |
|
|
|
space_host_startup = os.getenv("SPACE_HOST") |
|
space_id_startup = os.getenv("SPACE_ID") |
|
|
|
if space_host_startup: |
|
print(f"✅ SPACE_HOST found: {space_host_startup}") |
|
print(f" Runtime URL should be: https://{space_host_startup}.hf.space") |
|
else: |
|
print("ℹ️ SPACE_HOST environment variable not found (running locally?).") |
|
|
|
if space_id_startup: |
|
print(f"✅ SPACE_ID found: {space_id_startup}") |
|
print(f" Repo URL: https://huggingface.co/spaces/{space_id_startup}") |
|
print(f" Repo Tree URL: https://huggingface.co/spaces/{space_id_startup}/tree/main") |
|
else: |
|
print("ℹ️ SPACE_ID environment variable not found (running locally?). Repo URL cannot be determined.") |
|
|
|
print("-" * (60 + len(" App Starting ")) + "\n") |
|
|
|
print("Launching Gradio Interface for Basic Agent Evaluation...") |
|
demo.launch(debug=True, share=False) |
|
|