Spaces:
Running
Running
| import json | |
| from random import random | |
| from smolagents import CodeAgent,DuckDuckGoSearchTool, HfApiModel,load_tool,tool | |
| import datetime | |
| import requests | |
| import pytz | |
| import yaml | |
| import numpy as np | |
| from tools.final_answer import FinalAnswerTool | |
| from tools.visit_webpage import VisitWebpageTool | |
| from tools.web_search import DuckDuckGoSearchTool | |
| from typing import Optional, Tuple | |
| from Gradio_UI import GradioUI | |
| # Below is an example of a tool that does nothing. Amaze us with your creativity ! | |
| def calculate_risk_metrics( | |
| returns: np.ndarray, | |
| var_level: float = 0.95, | |
| n_simulations: int = 10000, | |
| bootstrap: bool = False, | |
| random_seed: Optional[int] = None | |
| ) -> Tuple[float, float]: | |
| """ | |
| Calculate Value at Risk (VaR) and Expected Shortfall (ES) using the historical method, with an option for bootstrapped historical simulation. | |
| Args: | |
| returns: Array of daily returns. Each value represents the percentage return for a single day. | |
| var_level: VaR level (e.g., 0.95 for 95% confidence). Defaults to 0.95. | |
| n_simulations: Number of bootstrap simulations. Defaults to 10000. | |
| bootstrap: If True, use bootstrapped historical simulation. Defaults to False. | |
| random_seed: Seed for random number generation to ensure reproducibility. Defaults to None. | |
| Returns: | |
| Tuple[float, float]: A tuple containing the VaR and Expected Shortfall (ES) values. | |
| """ | |
| if random_seed is not None: | |
| np.random.seed(random_seed) | |
| if bootstrap: | |
| # Perform bootstrapped historical simulation | |
| simulated_var = np.zeros(n_simulations) | |
| simulated_es = np.zeros(n_simulations) | |
| for i in range(n_simulations): | |
| # Resample returns with replacement | |
| resampled_returns = np.random.choice(returns, size=len(returns), replace=True) | |
| # Sort the resampled returns | |
| sorted_returns = np.sort(resampled_returns) | |
| # Determine the index for the VaR level | |
| index = int((1 - var_level) * len(sorted_returns)) | |
| # Calculate VaR for this simulation | |
| simulated_var[i] = sorted_returns[index] | |
| # Calculate ES for this simulation (average of returns below VaR) | |
| simulated_es[i] = np.mean(sorted_returns[:index]) | |
| # Calculate the average VaR and ES across all simulations | |
| var_value = np.mean(simulated_var) | |
| es_value = np.mean(simulated_es) | |
| else: | |
| # Use the standard historical method | |
| sorted_returns = np.sort(returns) | |
| index = int((1 - var_level) * len(returns)) | |
| # Calculate VaR | |
| var_value = sorted_returns[index] | |
| # Calculate ES (average of returns below VaR) | |
| es_value = np.mean(sorted_returns[:index]) | |
| return var_value, es_value | |
| def provide_my_information(query: str) -> str: | |
| """ | |
| Provide information about me (Tianqing LIU)based on the user's query. | |
| Args: | |
| query: The user's question or request for information. | |
| Returns: | |
| str: A response containing the requested information. | |
| """ | |
| # Convert the query to lowercase for case-insensitive matching | |
| query = query.lower() | |
| my_info = None | |
| with open("info/info.json", 'r') as file: | |
| my_info = json.load(file) | |
| # Check for specific keywords in the query and return the corresponding information | |
| if "who" in query or "about" in query or "introduce" in query or "presentation" in query: | |
| return f" {my_info['introduction']}." | |
| if "name" in query: | |
| return f"My name is {my_info['name']}." | |
| elif "location" in query: | |
| return f"I am located in {my_info['location']}." | |
| elif "occupation" in query or "job" in query or "work" in query: | |
| return f"I work as a {my_info['occupation']}." | |
| elif "education" in query or "educational" in query: | |
| return f"I have a {my_info['education']}." | |
| elif "skills" in query or "what can you do" in query: | |
| return f"My skills include: {', '.join(my_info['skills'])}." | |
| elif "hobbies" in query or "interests" in query: | |
| return f"My hobbies are: {', '.join(my_info['hobbies'])}." | |
| elif "contact" in query or "email" in query or "linkedin" in query or "github" in query or "cv" in query or "resume" in query: | |
| contact_info = my_info["contact"] | |
| return ( | |
| f"You can contact me via email at {contact_info['email']}, " | |
| f"connect with me on LinkedIn at {contact_info['linkedin']}, " | |
| f"or check out my GitHub profile at {contact_info['github']}." | |
| f"or check out my website at {contact_info['website']}." | |
| ) | |
| else: | |
| return "I'm sorry, I don't have information on that. Please ask about my name, location, occupation, education, skills, hobbies, or contact details." | |
| def qcm_tool(json_file: str, user_answer: Optional[str] = None) -> str: | |
| """ | |
| A tool that picks a random QCM (Multiple Choice Question) from a JSON file and checks the user's answer. | |
| Args: | |
| json_file: Path to the JSON file containing questions. | |
| user_answer: The user's answer (optional). If not provided, the tool returns a question and options. | |
| Returns: | |
| If no user_answer is provided: | |
| A string containing the question and options. | |
| If user_answer is provided: | |
| A string indicating whether the answer is correct and providing an explanation. | |
| """ | |
| try: | |
| # Load questions from the JSON file | |
| with open("info/questions.json", 'r') as file: | |
| questions = json.load(file) | |
| # Pick a random question | |
| question = random.choice(questions) | |
| if user_answer is None: | |
| # Return the question and options | |
| options_str = "\n".join([f"{chr(65 + i)}. {opt}" for i, opt in enumerate(question['options'])]) | |
| return f"Question: {question['question']}\nOptions:\n{options_str}" | |
| else: | |
| # Check the user's answer | |
| if user_answer.strip().upper() == question['correct_answer'].strip().upper(): | |
| return f"Correct! 🎉\nExplanation: {question['explanation']}" | |
| else: | |
| return f"Incorrect! 😞\nExplanation: {question['explanation']}" | |
| except Exception as e: | |
| return f"Error in QCM tool: {str(e)}" | |
| final_answer = FinalAnswerTool() | |
| visit_webpage = VisitWebpageTool() | |
| web_search = DuckDuckGoSearchTool() | |
| # If the agent does not answer, the model is overloaded, please use another model or the following Hugging Face Endpoint that also contains qwen2.5 coder: | |
| # model_id='https://pflgm2locj2t89co.us-east-1.aws.endpoints.huggingface.cloud' | |
| model = HfApiModel( | |
| max_tokens=2096, | |
| temperature=0.5, | |
| model_id='Qwen/Qwen2.5-Coder-32B-Instruct',# it is possible that this model may be overloaded | |
| custom_role_conversions=None, | |
| ) | |
| # Import tool from Hub | |
| image_generation_tool = load_tool("agents-course/text-to-image", trust_remote_code=True) | |
| with open("prompts.yaml", 'r') as stream: | |
| prompt_templates = yaml.safe_load(stream) | |
| agent = CodeAgent( | |
| model=model, | |
| tools=[final_answer,calculate_risk_metrics,qcm_tool,visit_webpage,web_search,provide_my_information], ## add your tools here (don't remove final answer) | |
| max_steps=6, | |
| verbosity_level=1, | |
| grammar=None, | |
| planning_interval=None, | |
| name=None, | |
| description=None, | |
| prompt_templates=prompt_templates | |
| ) | |
| GradioUI(agent).launch() |