From 7ddb171cd9d80175d32658a75ad4280802707f63 Mon Sep 17 00:00:00 2001 From: Chi Wang Date: Fri, 28 Jul 2023 21:17:51 -0700 Subject: [PATCH] autogen.agent -> autogen.agentchat (#1148) * autogen.agent -> autogen.agentchat * bug fix in portfolio * notebook * timeout * timeout * infer lang; close #1150 * timeout * message context * context handling * add sender to generate_reply * clean up the receive function * move mathchat to contrib * contrib * last_message --- README.md | 6 +- .../autogen/{agent => agentchat}/__init__.py | 0 flaml/autogen/{agent => agentchat}/agent.py | 10 +- .../{agent => agentchat}/assistant_agent.py | 2 +- .../contrib}/math_user_proxy_agent.py | 29 +- .../{agent => agentchat}/responsive_agent.py | 135 +- .../{agent => agentchat}/user_proxy_agent.py | 0 flaml/autogen/code_utils.py | 32 +- flaml/autogen/oai/completion.py | 22 +- flaml/automl/model.py | 12 +- flaml/default/estimator.py | 11 +- flaml/default/portfolio.py | 5 +- notebook/autogen_agent_MathChat.ipynb | 1146 ----------------- ...nt_auto_feedback_from_code_execution.ipynb | 1060 --------------- notebook/autogen_agent_function_call.ipynb | 458 ------- notebook/autogen_agentchat_MathChat.ipynb | 894 +++++++++++++ ...at_auto_feedback_from_code_execution.ipynb | 1001 ++++++++++++++ .../autogen_agentchat_function_call.ipynb | 444 +++++++ ...=> autogen_agentchat_human_feedback.ipynb} | 201 +-- ...ipynb => autogen_agentchat_planning.ipynb} | 204 ++- ...pynb => autogen_agentchat_two_users.ipynb} | 527 ++------ ...ipynb => autogen_agentchat_web_info.ipynb} | 603 ++++----- test/autogen/oai/test_completion.py | 6 +- test/autogen/test_assistant_agent.py | 4 +- test/autogen/test_code.py | 8 +- test/autogen/test_function_call.py | 4 +- test/autogen/test_math_user_proxy_agent.py | 8 +- test/autogen/test_notebook.py | 18 +- test/autogen/test_responsive_agent.py | 7 +- website/docs/Getting-Started.md | 4 +- website/docs/Use-Cases/Auto-Generation.md | 20 +- 31 files changed, 3119 insertions(+), 3762 deletions(-) rename flaml/autogen/{agent => agentchat}/__init__.py (100%) rename flaml/autogen/{agent => agentchat}/agent.py (80%) rename flaml/autogen/{agent => agentchat}/assistant_agent.py (98%) rename flaml/autogen/{agent => agentchat/contrib}/math_user_proxy_agent.py (96%) rename flaml/autogen/{agent => agentchat}/responsive_agent.py (76%) rename flaml/autogen/{agent => agentchat}/user_proxy_agent.py (100%) delete mode 100644 notebook/autogen_agent_MathChat.ipynb delete mode 100644 notebook/autogen_agent_auto_feedback_from_code_execution.ipynb delete mode 100644 notebook/autogen_agent_function_call.ipynb create mode 100644 notebook/autogen_agentchat_MathChat.ipynb create mode 100644 notebook/autogen_agentchat_auto_feedback_from_code_execution.ipynb create mode 100644 notebook/autogen_agentchat_function_call.ipynb rename notebook/{autogen_agent_human_feedback.ipynb => autogen_agentchat_human_feedback.ipynb} (63%) rename notebook/{autogen_agent_planning.ipynb => autogen_agentchat_planning.ipynb} (68%) rename notebook/{autogen_agent_two_users.ipynb => autogen_agentchat_two_users.ipynb} (55%) rename notebook/{autogen_agent_web_info.ipynb => autogen_agentchat_web_info.ipynb} (54%) diff --git a/README.md b/README.md index 333769e56a..73bc50e7b2 100644 --- a/README.md +++ b/README.md @@ -82,11 +82,11 @@ Use the following guides to get started with FLAML in .NET: # perform inference for a test instance response = oai.Completion.create(context=test_instance, **config) ``` - - LLM-driven intelligent agents which can perform tasks autonomously or with human feedback, including tasks that require using tools via code. + - LLM-driven intelligent agents which can collaborately perform tasks autonomously or with human feedback, including tasks that require using tools via code. ```python assistant = AssistantAgent("assistant") - user = UserProxyAgent("user", human_input_mode="TERMINATE") - assistant.receive("Draw a rocket and save to a file named 'rocket.svg'") + user_proxy = UserProxyAgent("user_proxy") + user_proxy.initiate_chat("Show me the YTD gain of 10 largest technology companies as of today.") ``` * With three lines of code, you can start using this economical and fast AutoML engine as a [scikit-learn style estimator](https://microsoft.github.io/FLAML/docs/Use-Cases/Task-Oriented-AutoML). diff --git a/flaml/autogen/agent/__init__.py b/flaml/autogen/agentchat/__init__.py similarity index 100% rename from flaml/autogen/agent/__init__.py rename to flaml/autogen/agentchat/__init__.py diff --git a/flaml/autogen/agent/agent.py b/flaml/autogen/agentchat/agent.py similarity index 80% rename from flaml/autogen/agent/agent.py rename to flaml/autogen/agentchat/agent.py index aa563a983e..c62ed29ab4 100644 --- a/flaml/autogen/agent/agent.py +++ b/flaml/autogen/agentchat/agent.py @@ -1,4 +1,4 @@ -from typing import Dict, List, Union +from typing import Dict, List, Optional, Union class Agent: @@ -33,12 +33,18 @@ def receive(self, message: Union[Dict, str], sender: "Agent"): def reset(self): """(Abstract method) Reset the agent.""" - def generate_reply(self, messages: List[Dict], default_reply: Union[str, Dict] = "") -> Union[str, Dict]: + def generate_reply( + self, + messages: Optional[List[Dict]] = None, + default_reply: Optional[Union[str, Dict]] = "", + sender: Optional["Agent"] = None, + ) -> Union[str, Dict]: """(Abstract method) Generate a reply based on the received messages. Args: messages (list[dict]): a list of messages received. default_reply (str or dict): the default reply if no other reply is generated. + sender: sender of an Agent instance. Returns: str or dict: the generated reply. """ diff --git a/flaml/autogen/agent/assistant_agent.py b/flaml/autogen/agentchat/assistant_agent.py similarity index 98% rename from flaml/autogen/agent/assistant_agent.py rename to flaml/autogen/agentchat/assistant_agent.py index 10469bc189..00f027edb7 100644 --- a/flaml/autogen/agent/assistant_agent.py +++ b/flaml/autogen/agentchat/assistant_agent.py @@ -15,7 +15,7 @@ class AssistantAgent(ResponsiveAgent): DEFAULT_SYSTEM_MESSAGE = """You are a helpful AI assistant. In the following cases, suggest python code (in a python coding block) or shell script (in a sh coding block) for the user to execute. You must indicate the script type in the code block. The user cannot provide any other feedback or perform any other action beyond executing the code you suggest. The user can't modify your code. So do not suggest incomplete code which requires users to modify. Don't use a code block if it's not intended to be executed by the user. - 1. When you need to collect info, use the code to output the info you need, for example, browse or search the web, download/read a file, print the content of a webpage or a file. + 1. When you need to collect info, use the code to output the info you need, for example, browse or search the web, download/read a file, print the content of a webpage or a file, get the current date/time. 2. When you need to perform some task with code, use the code to perform the task and output the result. Finish the task smartly. Solve the task step by step if you need to. If you want the user to save the code in a file before executing it, put # filename: inside the code block as the first line. Don't include multiple code blocks in one response. Do not ask users to copy and paste the result. Instead, use 'print' function for the output when relevant. Check the execution result returned by the user. If the result indicates there is an error, fix the error and output the code again. Suggest the full code instead of partial code or code changes. If the error can't be fixed or if the task is not solved even after the code is executed successfully, analyze the problem, revisit your assumption, collect additional info you need, and think of a different approach to try. diff --git a/flaml/autogen/agent/math_user_proxy_agent.py b/flaml/autogen/agentchat/contrib/math_user_proxy_agent.py similarity index 96% rename from flaml/autogen/agent/math_user_proxy_agent.py rename to flaml/autogen/agentchat/contrib/math_user_proxy_agent.py index cdc60af83d..2533f9be41 100644 --- a/flaml/autogen/agent/math_user_proxy_agent.py +++ b/flaml/autogen/agentchat/contrib/math_user_proxy_agent.py @@ -3,7 +3,8 @@ from pydantic import BaseModel, Extra, root_validator from typing import Any, Callable, Dict, List, Optional, Union from time import sleep -from flaml.autogen.agent import UserProxyAgent + +from flaml.autogen.agentchat import Agent, UserProxyAgent from flaml.autogen.code_utils import UNKNOWN, extract_code, execute_code, infer_lang from flaml.autogen.math_utils import get_answer @@ -96,16 +97,16 @@ def _is_termination_msg_mathchat(message): return not contain_code and get_answer(message) is not None and get_answer(message) != "" -def _add_print_to_last_line(s): +def _add_print_to_last_line(code): """Add print() to the last line of a string.""" # 1. check if there is already a print statement - if "print(" in s: - return s + if "print(" in code: + return code # 2. extract the last line, enclose it in print() and return the new string - lines = s.splitlines() + lines = code.splitlines() last_line = lines[-1] if "\t" in last_line or "=" in last_line: - return s + return code if "=" in last_line: last_line = "print(" + last_line.split(" = ")[0] + ")" lines.append(last_line) @@ -115,9 +116,9 @@ def _add_print_to_last_line(s): return "\n".join(lines) -def _remove_print(s): +def _remove_print(code): """remove all print statements from a string.""" - lines = s.splitlines() + lines = code.splitlines() lines = [line for line in lines if not line.startswith("print(")] return "\n".join(lines) @@ -126,6 +127,7 @@ class MathUserProxyAgent(UserProxyAgent): """(Experimental) A MathChat agent that can handle math problems.""" MAX_CONSECUTIVE_AUTO_REPLY = 15 # maximum number of consecutive auto replies (subject to future change) + DEFAULT_REPLY = "Continue. Please keep solving the problem until you need to query. (If you get to the answer, put it in \\boxed{}.)" def __init__( self, @@ -279,16 +281,21 @@ def execute_one_wolfram_query(self, query: str): is_success = False return output, is_success - def generate_reply(self, messages: List[Dict], default_reply: Union[str, Dict] = "") -> Union[str, Dict]: + def generate_reply( + self, + messages: Optional[List[Dict]] = None, + default_reply: Optional[Union[str, Dict]] = DEFAULT_REPLY, + sender: Optional["Agent"] = None, + ) -> Union[str, Dict]: """Generate an auto reply.""" + if messages is None: + messages = self._oai_conversations[sender.name] message = messages[-1] message = message.get("content", "") code_blocks = extract_code(message) if len(code_blocks) == 1 and code_blocks[0][0] == UNKNOWN: # no code block is found, lang should be `UNKNOWN`` - if default_reply == "": - default_reply = "Continue. Please keep solving the problem until you need to query. (If you get to the answer, put it in \\boxed{}.)" return default_reply is_success, all_success = True, True reply = "" diff --git a/flaml/autogen/agent/responsive_agent.py b/flaml/autogen/agentchat/responsive_agent.py similarity index 76% rename from flaml/autogen/agent/responsive_agent.py rename to flaml/autogen/agentchat/responsive_agent.py index 085754aa32..c240052dcb 100644 --- a/flaml/autogen/agent/responsive_agent.py +++ b/flaml/autogen/agentchat/responsive_agent.py @@ -46,7 +46,7 @@ def __init__( The dict can contain the following keys: "content", "role", "name", "function_call". max_consecutive_auto_reply (int): the maximum number of consecutive auto replies. default to None (no limit provided, class attribute MAX_CONSECUTIVE_AUTO_REPLY will be used as the limit in this case). - The limit only plays a role when human_input_mode is not "ALWAYS". + When set to 0, no auto reply will be generated. human_input_mode (str): whether to ask for human inputs every time a message is received. Possible values are "ALWAYS", "TERMINATE", "NEVER". (1) When "ALWAYS", the agent prompts for human input every time a message is received. @@ -104,6 +104,27 @@ def oai_conversations(self) -> Dict[str, List[Dict]]: """A dictionary of conversations from name to list of oai messages.""" return self._oai_conversations + def last_message(self, agent: Optional[Agent] = None) -> Dict: + """The last message exchanged with the agent. + + Args: + agent (Agent): The agent in the conversation. + If None and more than one agent's conversations are found, an error will be raised. + If None and only one conversation is found, the last message of the only conversation will be returned. + + Returns: + The last message exchanged with the agent. + """ + if agent is None: + n_conversations = len(self._oai_conversations) + if n_conversations == 0: + return None + if n_conversations == 1: + for conversation in self._oai_conversations.values(): + return conversation[-1] + raise ValueError("More than one conversation is found. Please specify the sender to get the last message.") + return self._oai_conversations[agent.name][-1] + @property def use_docker(self) -> Union[bool, str, None]: """Bool value of whether to use docker to execute the code, @@ -147,11 +168,43 @@ def _append_oai_message(self, message: Union[Dict, str], role, conversation_id) return True def send(self, message: Union[Dict, str], recipient: "Agent"): - """Send a message to another agent.""" - # When the agent composes and sends the message, the role of the message is "assistant". (If 'role' exists and is 'function', it will remain unchanged.) + """Send a message to another agent. + + Args: + message (dict or str): message to be sent. + The message could contain the following fields (either content or function_call must be provided): + - content (str): the content of the message. + - function_call (str): the name of the function to be called. + - name (str): the name of the function to be called. + - role (str): the role of the message, any role that is not "function" + will be modified to "assistant". + - context (dict): the context of the message, which will be passed to + [oai.Completion.create](../oai/Completion#create). + For example, one agent can send a message A as: + ```python + { + "content": "{use_tool_msg}", + "context": { + "use_tool_msg": "Use tool X if they are relevant." + } + } + ``` + Next time, one agent can send a message B with a different "use_tool_msg". + Then the content of message A will be refreshed to the new "use_tool_msg". + So effectively, this provides a way for an agent to send a "link" and modify + the content of the "link" later. + recipient (Agent): the recipient of the message. + + Raises: + ValueError: if the message is not a valid oai message. + """ + # When the agent composes and sends the message, the role of the message is "assistant" + # unless it's "function". valid = self._append_oai_message(message, "assistant", recipient.name) if valid: recipient.receive(message, self) + else: + raise ValueError("Message is not a valid oai message. Either content or function_call must be provided.") def _print_received_message(self, message: Union[Dict, str], sender: "Agent"): # print the message received @@ -200,35 +253,63 @@ def receive(self, message: Union[Dict, str], sender: "Agent"): # default reply is empty (i.e., no reply, in this case we will try to generate auto reply) reply = "" + no_human_input_msg = "" if self.human_input_mode == "ALWAYS": reply = self.get_human_input( - "Provide feedback to the sender. Press enter to skip and use auto-reply, or type 'exit' to end the conversation: " + f"Provide feedback to {sender.name}. Press enter to skip and use auto-reply, or type 'exit' to end the conversation: " ) - elif self._consecutive_auto_reply_counter[ - sender.name - ] >= self.max_consecutive_auto_reply or self._is_termination_msg(message): - if self.human_input_mode == "TERMINATE": - reply = self.get_human_input( - "Please give feedback to the sender. (Press enter or type 'exit' to stop the conversation): " - ) - reply = reply if reply else "exit" - else: - # this corresponds to the case when self._human_input_mode == "NEVER" - reply = "exit" - if reply == "exit" or (self._is_termination_msg(message) and not reply): + no_human_input_msg = "NO HUMAN INPUT RECEIVED." if not reply else "" + # if the human input is empty, and the message is a termination message, then we will terminate the conversation + reply = reply if reply or not self._is_termination_msg(message) else "exit" + else: + if self._consecutive_auto_reply_counter[sender.name] >= self.max_consecutive_auto_reply: + if self.human_input_mode == "NEVER": + reply = "exit" + else: + # self.human_input_mode == "TERMINATE": + terminate = self._is_termination_msg(message) + reply = self.get_human_input( + f"Please give feedback to {sender.name}. Press enter or type 'exit' to stop the conversation: " + if terminate + else f"Please give feedback to {sender.name}. Press enter to skip and use auto-reply, or type 'exit' to stop the conversation: " + ) + no_human_input_msg = "NO HUMAN INPUT RECEIVED." if not reply else "" + # if the human input is empty, and the message is a termination message, then we will terminate the conversation + reply = reply if reply or not terminate else "exit" + elif self._is_termination_msg(message): + if self.human_input_mode == "NEVER": + reply = "exit" + else: + # self.human_input_mode == "TERMINATE": + reply = self.get_human_input( + f"Please give feedback to {sender.name}. Press enter or type 'exit' to stop the conversation: " + ) + no_human_input_msg = "NO HUMAN INPUT RECEIVED." if not reply else "" + # if the human input is empty, and the message is a termination message, then we will terminate the conversation + reply = reply or "exit" + + # print the no_human_input_msg + if no_human_input_msg: + print(f"\n>>>>>>>> {no_human_input_msg}", flush=True) + + # stop the conversation + if reply == "exit": # reset the consecutive_auto_reply_counter self._consecutive_auto_reply_counter[sender.name] = 0 return - if reply: + + # send the human reply + if reply or self.max_consecutive_auto_reply == 0: # reset the consecutive_auto_reply_counter self._consecutive_auto_reply_counter[sender.name] = 0 self.send(reply, sender) return + # send the auto reply self._consecutive_auto_reply_counter[sender.name] += 1 if self.human_input_mode != "NEVER": - print("\n>>>>>>>> NO HUMAN INPUT RECEIVED. USING AUTO REPLY FOR THE USER...", flush=True) - self.send(self.generate_reply(self._oai_conversations[sender.name], default_reply=reply), sender) + print("\n>>>>>>>> USING AUTO REPLY...", flush=True) + self.send(self.generate_reply(sender=sender), sender) def reset(self): """Reset the agent.""" @@ -237,23 +318,35 @@ def reset(self): def _oai_reply(self, messages: List[Dict]) -> Union[str, Dict]: # TODO: #1143 handle token limit exceeded error - response = oai.ChatCompletion.create(messages=self._oai_system_message + messages, **self.oai_config) + response = oai.ChatCompletion.create( + context=messages[-1].get("context"), messages=self._oai_system_message + messages, **self.oai_config + ) return oai.ChatCompletion.extract_text_or_function_call(response)[0] - def generate_reply(self, messages: List[Dict], default_reply: Union[str, Dict] = "") -> Union[str, Dict]: + def generate_reply( + self, + messages: Optional[List[Dict]] = None, + default_reply: Optional[Union[str, Dict]] = "", + sender: Optional["Agent"] = None, + ) -> Union[str, Dict]: """Reply based on the conversation history. First, execute function or code and return the result. AI replies are generated only when no code execution is performed. Subclasses can override this method to customize the reply. + Either messages or sender must be provided. Args: messages: a list of messages in the conversation history. default_reply (str or dict): default reply. + sender: sender of an Agent instance. Returns: str or dict: reply. """ + assert messages is not None or sender is not None, "Either messages or sender must be provided." + if messages is None: + messages = self._oai_conversations[sender.name] message = messages[-1] if "function_call" in message: _, func_return = self.execute_function(message["function_call"]) diff --git a/flaml/autogen/agent/user_proxy_agent.py b/flaml/autogen/agentchat/user_proxy_agent.py similarity index 100% rename from flaml/autogen/agent/user_proxy_agent.py rename to flaml/autogen/agentchat/user_proxy_agent.py diff --git a/flaml/autogen/code_utils.py b/flaml/autogen/code_utils.py index 0e182970eb..f721e93e0b 100644 --- a/flaml/autogen/code_utils.py +++ b/flaml/autogen/code_utils.py @@ -7,6 +7,7 @@ import re import time from hashlib import md5 +import logging from flaml.autogen import oai, DEFAULT_MODEL, FAST_MODEL # Regular expression for finding a code block @@ -21,7 +22,7 @@ def infer_lang(code): """infer the language for the code. TODO: make it robust. """ - if code.startswith("python ") or code.startswith("pip"): + if code.startswith("python ") or code.startswith("pip") or code.startswith("python3 "): return "sh" return "python" @@ -148,6 +149,7 @@ def execute_code( If None, the code from the file specified by filename will be executed. Either code or filename must be provided. timeout (Optional, int): The maximum execution time in seconds. + If None, a default timeout will be used. The default timeout is 600 seconds. On Windows, the timeout is not enforced when use_docker=False. filename (Optional, str): The file name to save the code or where the code is stored when `code` is None. If None, a file with a randomly generated name will be created. The randomly generated file will be deleted after execution. @@ -158,7 +160,7 @@ def execute_code( "path_to_flaml/autogen". use_docker (Optional, list, str or bool): The docker image to use for code execution. If a list or a str of image name(s) is provided, the code will be executed in a docker container - with the first image successfully pulled. + with the first image successfully pulled. If None, False or empty, the code will be executed in the current environment. Default is True, which will be converted into a list. If the code is executed in the current environment, @@ -190,20 +192,28 @@ def execute_code( if not use_docker or in_docker_container: # already running in a docker container cmd = [sys.executable if lang.startswith("python") else _cmd(lang), filename] - signal.signal(signal.SIGALRM, timeout_handler) - try: - signal.alarm(timeout) - # run the code in a subprocess in the current docker container in the working directory + if sys.platform == "win32": + logging.warning("SIGALRM is not supported on Windows. No timeout will be enforced.") result = subprocess.run( cmd, cwd=work_dir, capture_output=True, ) - signal.alarm(0) - except TimeoutError: - if original_filename is None: - os.remove(filepath) - return 1, TIMEOUT_MSG, None + else: + signal.signal(signal.SIGALRM, timeout_handler) + try: + signal.alarm(timeout) + # run the code in a subprocess in the current docker container in the working directory + result = subprocess.run( + cmd, + cwd=work_dir, + capture_output=True, + ) + signal.alarm(0) + except TimeoutError: + if original_filename is None: + os.remove(filepath) + return 1, TIMEOUT_MSG, None if original_filename is None: os.remove(filepath) return result.returncode, result.stderr if result.returncode else result.stdout, None diff --git a/flaml/autogen/oai/completion.py b/flaml/autogen/oai/completion.py index 409ab3fa6d..200ecdcaf1 100644 --- a/flaml/autogen/oai/completion.py +++ b/flaml/autogen/oai/completion.py @@ -1,10 +1,10 @@ from time import sleep import logging -import numpy as np import time -from typing import List, Optional, Dict, Callable, Any +from typing import List, Optional, Dict, Callable, Union import sys import shutil +import numpy as np from flaml import tune, BlendSearch from flaml.tune.space import is_constant from flaml.automl.logger import logger_formatter @@ -792,15 +792,15 @@ def yes_or_no_filter(context, config, response): return cls._get_response(params, raise_on_ratelimit_or_timeout=raise_on_ratelimit_or_timeout) @classmethod - def _instantiate(cls, template: str, context: Optional[Dict] = None): - if not context: + def _instantiate(cls, template: Union[str, None], context: Optional[Dict] = None): + if not context or template is None: return template if isinstance(template, str): return template.format(**context) return template(context) @classmethod - def _construct_params(cls, data_instance, config, prompt=None, messages=None): + def _construct_params(cls, context, config, prompt=None, messages=None): params = config.copy() model = config["model"] prompt = config.get("prompt") if prompt is None else prompt @@ -814,12 +814,14 @@ def _construct_params(cls, data_instance, config, prompt=None, messages=None): params["messages"] = ( [ { - "role": m["role"], - "content": cls._instantiate(m["content"], data_instance), + **m, + "content": cls._instantiate(m["content"], context), } + if m.get("content") + else m for m in messages ] - if data_instance + if context else messages ) elif model in cls.chat_models or issubclass(cls, ChatCompletion): @@ -827,12 +829,12 @@ def _construct_params(cls, data_instance, config, prompt=None, messages=None): params["messages"] = [ { "role": "user", - "content": cls._instantiate(prompt, data_instance), + "content": cls._instantiate(prompt, context), }, ] params.pop("prompt", None) else: - params["prompt"] = cls._instantiate(prompt, data_instance) + params["prompt"] = cls._instantiate(prompt, context) return params @classmethod diff --git a/flaml/automl/model.py b/flaml/automl/model.py index 31f14bf24e..d4970895e5 100644 --- a/flaml/automl/model.py +++ b/flaml/automl/model.py @@ -60,6 +60,11 @@ except ImportError: resource = None +try: + from lightgbm import LGBMClassifier, LGBMRegressor, LGBMRanker +except ImportError: + LGBMClassifier = LGBMRegressor = LGBMRanker = None + logger = logging.getLogger("flaml.automl") # FREE_MEM_RATIO = 0.2 @@ -1300,17 +1305,10 @@ def __init__(self, task="binary", **config): self.params["verbose"] = -1 if self._task.is_classification(): - from lightgbm import LGBMClassifier - self.estimator_class = LGBMClassifier - elif task == "rank": - from lightgbm import LGBMRanker - self.estimator_class = LGBMRanker else: - from lightgbm import LGBMRegressor - self.estimator_class = LGBMRegressor self._time_per_iter = None diff --git a/flaml/default/estimator.py b/flaml/default/estimator.py index 9056c7d5ee..d8aaa989f3 100644 --- a/flaml/default/estimator.py +++ b/flaml/default/estimator.py @@ -38,10 +38,10 @@ def __init__(self, **params): self._params = params super().__init__(**params) - @classmethod - @wraps(super_class._get_param_names) - def _get_param_names(cls): - return super_class._get_param_names() + # @classmethod + # @wraps(super_class._get_param_names) + # def _get_param_names(cls): + # return super_class._get_param_names() if hasattr(super_class, "_get_param_names") else [] def suggest_hyperparams(self, X, y): """Suggest hyperparameters. @@ -179,3 +179,6 @@ def predict_proba(self, X, *args, **params): "classification", [("max_depth", 0, "xgboost")], ) + # if hasattr(xgboost.XGBRegressor, "_get_param_names"): + # XGBRegressor._get_param_names = xgboost.XGBRegressor._get_param_names + # XGBClassifier._get_param_names = xgboost.XGBClassifier._get_param_names diff --git a/flaml/default/portfolio.py b/flaml/default/portfolio.py index 59165784ec..6ed6bf8719 100644 --- a/flaml/default/portfolio.py +++ b/flaml/default/portfolio.py @@ -42,7 +42,7 @@ def config_predictor_tuple(tasks, configs, meta_features, regret_matrix): .apply(lambda row: row.apply(lambda x: (x, row.name)), axis=1) ) print(regret) - preferences = np.argsort(regret, axis=0) + preferences = pd.DataFrame(np.argsort(regret, axis=0), columns=regret.columns) print(preferences) return (meta_features_norm, preferences, proc) @@ -119,12 +119,11 @@ def serialize(configs, regret, meta_features, output_file, config_path): "portfolio": portfolio, "preprocessing": proc, "neighbors": [ - {"features": tuple(x), "choice": _filter(preferences[y], regret[y])} + {"features": x.tolist(), "choice": _filter(preferences[y], regret[y])} for x, y in zip(meta_features_norm.to_records(index=False), preferences.columns) ], "configsource": list(configs), } - with open(output_file, "w+") as f: json.dump(meta_predictor, f, indent=4) return meta_predictor diff --git a/notebook/autogen_agent_MathChat.ipynb b/notebook/autogen_agent_MathChat.ipynb deleted file mode 100644 index 35aede2073..0000000000 --- a/notebook/autogen_agent_MathChat.ipynb +++ /dev/null @@ -1,1146 +0,0 @@ -{ - "cells": [ - { - "attachments": {}, - "cell_type": "markdown", - "metadata": {}, - "source": [ - "\"Open" - ] - }, - { - "attachments": {}, - "cell_type": "markdown", - "metadata": {}, - "source": [ - "# Using MathChat to Solve Math Problems\n", - "\n", - "MathChat is a convesational framework for math problem solving. In this notebook, we demonstrate how to use MathChat to solve math problems. MathChat uses the `AssistantAgent` and `MathUserProxyAgent`, which is similar to the usage of `AssistantAgent` and `UserProxyAgent` in other notebooks (e.g., [Interactive LLM Agent with Auto Feedback from Code Execution](https://github.com/microsoft/FLAML/blob/main/notebook/autogen_agent_auto_feedback_from_code_execution.ipynb)). Essentially, `MathUserProxyAgent` implements a different auto reply mechanism corresponding to the MathChat prompts. The original implementation and exeperiments of MathChat are in this [branch](https://github.com/kevin666aa/FLAML/tree/gpt_math_solver/flaml/autogen/math), and you can find more details in our paper [An Empirical Study on Challenging Math Problem Solving with GPT-4](https://arxiv.org/abs/2306.01337).\n", - "\n", - "## Requirements\n", - "\n", - "FLAML requires `Python>=3.8`. To run this notebook example, please install flaml with the [mathchat] option.\n", - "```bash\n", - "pip install flaml[mathchat]\n", - "```" - ] - }, - { - "cell_type": "code", - "execution_count": 1, - "metadata": {}, - "outputs": [], - "source": [ - "# %pip install flaml[mathchat]~=2.0.0rc4" - ] - }, - { - "attachments": {}, - "cell_type": "markdown", - "metadata": {}, - "source": [ - "## Set your API Endpoint\n", - "\n", - "The [`config_list_from_json`](https://microsoft.github.io/FLAML/docs/reference/autogen/oai/openai_utils#config_list_from_json) function loads a list of configurations from an environment variable or a json file.\n" - ] - }, - { - "cell_type": "code", - "execution_count": 2, - "metadata": {}, - "outputs": [], - "source": [ - "from flaml import oai\n", - "\n", - "config_list = oai.config_list_from_json(\n", - " \"OAI_CONFIG_LIST\",\n", - " filter_dict={\n", - " \"model\": {\n", - " \"gpt-4\",\n", - " \"gpt4\",\n", - " \"gpt-4-32k\",\n", - " \"gpt-4-32k-0314\",\n", - " \"gpt-3.5-turbo\",\n", - " \"gpt-3.5-turbo-16k\",\n", - " \"gpt-3.5-turbo-0301\",\n", - " \"chatgpt-35-turbo-0301\",\n", - " \"gpt-35-turbo-v0301\",\n", - " }\n", - " }\n", - ")" - ] - }, - { - "attachments": {}, - "cell_type": "markdown", - "metadata": {}, - "source": [ - "It first looks for environment variable \"OAI_CONFIG_LIST\" which needs to be a valid json string. If that variable is not found, it then looks for a json file named \"OAI_CONFIG_LIST\". It filters the configs by models (you can filter by other keys as well). Only the gpt-4 and gpt-3.5-turbo models are kept in the list based on the filter condition.\n", - "\n", - "The config list looks like the following:\n", - "```python\n", - "config_list = [\n", - " {\n", - " 'model': 'gpt-4',\n", - " 'api_key': '',\n", - " },\n", - " {\n", - " 'model': 'gpt-4',\n", - " 'api_key': '',\n", - " 'api_base': '',\n", - " 'api_type': 'azure',\n", - " 'api_version': '2023-06-01-preview',\n", - " },\n", - " {\n", - " 'model': 'gpt-3.5-turbo',\n", - " 'api_key': '',\n", - " 'api_base': '',\n", - " 'api_type': 'azure',\n", - " 'api_version': '2023-06-01-preview',\n", - " },\n", - "]\n", - "```\n", - "\n", - "If you open this notebook in colab, you can upload your files by clicking the file icon on the left panel and then choose \"upload file\" icon.\n", - "\n", - "You can set the value of config_list in other ways you prefer, e.g., loading from a YAML file." - ] - }, - { - "attachments": {}, - "cell_type": "markdown", - "metadata": {}, - "source": [ - "## Construct agents for MathChat\n", - "\n", - "We start by initialzing the `AssistantAgent` and `MathUserProxyAgent`. The system message needs to be set to \"You are a helpful assistant.\" for MathChat. The detailed instructions are given in the user message. Later we will use the `MathUserProxyAgent.generate_init_message` to combine the instructions and a math problem for an initial message to be sent to the LLM assistant." - ] - }, - { - "cell_type": "code", - "execution_count": 3, - "metadata": {}, - "outputs": [], - "source": [ - "from flaml.autogen.agent.assistant_agent import AssistantAgent\n", - "from flaml.autogen.agent.math_user_proxy_agent import MathUserProxyAgent\n", - "\n", - "oai.ChatCompletion.start_logging()\n", - "\n", - "# 1. create an AssistantAgent instance named \"assistant\"\n", - "assistant = AssistantAgent(\n", - " name=\"assistant\", \n", - " system_message=\"You are a helpful assistant.\",\n", - " oai_config={\n", - " \"request_timeout\": 600,\n", - " \"seed\": 42,\n", - " \"config_list\": config_list,\n", - " }\n", - ")\n", - "\n", - "# 2. create the MathUserProxyAgent instance named \"mathproxyagent\"\n", - "# By default, the human_input_mode is \"NEVER\", which means the agent will not ask for human input.\n", - "mathproxyagent = MathUserProxyAgent(\n", - " name=\"MathChatAgent\", \n", - " human_input_mode=\"NEVER\",\n", - " code_execution_config={\"use_docker\": False},\n", - ")" - ] - }, - { - "attachments": {}, - "cell_type": "markdown", - "metadata": {}, - "source": [ - "### Example 1\n", - "\n", - "Problem: Find all $x$ that satisfy the inequality $(2x+10)(x+3)<(3x+9)(x+8)$. Express your answer in interval notation.\n", - "\n", - "Correct Solution: \n", - "We have \\begin{align*} (2x+10)(x+3)&<(3x+9)(x+8) \\quad \\Rightarrow\n", - "\\\\ 2(x+5)(x+3)&<3(x+3)(x+8) \\quad \\Rightarrow\n", - "\\\\ 2(x+5)(x+3)-3(x+3)(x+8)&<0 \\quad \\Rightarrow\n", - "\\\\ (2x+10-(3x+24))(x+3)&<0 \\quad \\Rightarrow\n", - "\\\\ (-x-14)(x+3)&<0 \\quad \\Rightarrow\n", - "\\\\ (x+14)(x+3)&>0.\n", - "\\end{align*} This inequality is satisfied if and only if $(x+14)$ and $(x+3)$ are either both positive or both negative. Both factors are positive for $x>-3$ and both factors are negative for $x<-14$. When $-14>>>>>>> NO HUMAN INPUT RECEIVED. USING AUTO REPLY FOR THE USER...\n", - "MathChatAgent (to assistant):\n", - "\n", - "2*tan(theta)**2 + 2\n", - "\n", - "--------------------------------------------------------------------------------\n", - "assistant (to MathChatAgent):\n", - "\n", - "Now we have $dx = (2\\tan{\\theta}^2 + 2)d\\theta$. Let's rewrite the integral in terms of $\\theta$. We substitute $x = 2\\tan{\\theta}$ and $dx = (2\\tan{\\theta}^2 + 2)d\\theta$ in the given integral:\n", - "\n", - "$$\\int_{0}^{1} \\frac{d x}{\\left(4+x^{2}\\right)^{3 / 2}} = \\int \\frac{(2\\tan{\\theta}^2 + 2)d\\theta}{\\left(4 + (2\\tan{\\theta})^2\\right)^{3 / 2}}$$\n", - "\n", - "Next, we will find the new integral's limits by solving for $\\theta$ when $x = 0$ and $x = 1$:\n", - "\n", - "For $x = 0$:\n", - "```\n", - "theta_lower = 0 # tangent is 0 when theta is 0\n", - "```\n", - "\n", - "For $x = 1$:\n", - "```python\n", - "from sympy import solve, Eq\n", - "\n", - "theta_upper = solve(Eq(x_substitution, 1), theta)[0]\n", - "theta_upper\n", - "```\n", - "\n", - "Now we can compute the integral with respect to $\\theta$ and the new limits.\n", - "\n", - "--------------------------------------------------------------------------------\n", - "\n", - ">>>>>>>> NO HUMAN INPUT RECEIVED. USING AUTO REPLY FOR THE USER...\n", - "MathChatAgent (to assistant):\n", - "\n", - "No output found. Make sure you print the results.\n", - "atan(1/2)\n", - "\n", - "--------------------------------------------------------------------------------\n", - "assistant (to MathChatAgent):\n", - "\n", - "Apologies for the confusion. We have $\\theta$ in the range:\n", - "\n", - "$$ \\theta = \\left[0, \\arctan\\left(\\frac{1}{2}\\right)\\right] $$\n", - "\n", - "Now we can perform the substitution and compute the integral.\n", - "\n", - "Next, we will evaluate the new integral:\n", - "\n", - "```python\n", - "from sympy import integrate, sec\n", - "\n", - "integral_theta = (2*tan(theta)**2 + 2) / (4 + 2**2 * tan(theta)**2)**(3/2)\n", - "integral_result = integrate(integral_theta, (theta, 0, atan(1/2)))\n", - "integral_result\n", - "```\n", - "\n", - "Finally, let's find the value of the integral and put it in the \\(\\boxed{}\\).\n", - "\n", - "--------------------------------------------------------------------------------\n", - "\n", - ">>>>>>>> NO HUMAN INPUT RECEIVED. USING AUTO REPLY FOR THE USER...\n", - "MathChatAgent (to assistant):\n", - "\n", - "Error: Traceback (most recent call last):\n", - " integral_result = integrate(integral_theta, (theta, 0, atan(1/2)))\n", - "NameError: name 'atan' is not defined\n", - "\n", - "--------------------------------------------------------------------------------\n", - "assistant (to MathChatAgent):\n", - "\n", - "Apologies for the mistake. I forgot to import the `atan` function from sympy. Let's correct the code:\n", - "\n", - "```python\n", - "from sympy import atan\n", - "\n", - "integral_theta = (2 * tan(theta)**2 + 2) / (4 + 4 * tan(theta)**2)**(3/2)\n", - "integral_result = integrate(integral_theta, (theta, 0, atan(1/2)))\n", - "integral_result\n", - "```\n", - "\n", - "Now, we will find the value of the integral and put it in the \\(\\boxed{}\\).\n", - "\n", - "--------------------------------------------------------------------------------\n", - "\n", - ">>>>>>>> NO HUMAN INPUT RECEIVED. USING AUTO REPLY FOR THE USER...\n", - "MathChatAgent (to assistant):\n", - "\n", - "Error: Traceback (most recent call last):\n", - " integral_result = integrate(integral_theta, (theta, 0, atan(1/2)))\n", - " return integral.doit(**doit_flags)\n", - " did = self.xreplace(reps).doit(**hints)\n", - " evalued = Add(*others)._eval_interval(x, a, b)\n", - " singularities = solveset(self.cancel().as_numer_denom()[1], x,\n", - " rv = solveset(f.xreplace({symbol: x}), x, domain)\n", - " return _solveset(f, symbol, domain, _check=True)\n", - " result = _solve_trig(f, symbol, domain)\n", - " sol = _solve_trig1(f, symbol, domain)\n", - " solns = solveset_complex(g, y) - solveset_complex(h, y)\n", - " return solveset(f, symbol, S.Complexes)\n", - " rv = solveset(f.xreplace({symbol: x}), x, domain)\n", - " return _solveset(f, symbol, domain, _check=True)\n", - " result += _solve_abs(f, symbol, domain)\n", - " raise ValueError(filldedent('''\n", - "ValueError: \n", - "Absolute values cannot be inverted in the complex domain.\n", - "\n", - "--------------------------------------------------------------------------------\n", - "assistant (to MathChatAgent):\n", - "\n", - "Apologies for the oversight. In order to avoid the error, let's find the bounds of $\\theta$ using another approach and calculate the integral again:\n", - "\n", - "```python\n", - "from sympy import pi\n", - "\n", - "theta_lower = 0\n", - "theta_upper = atan(1/2).evalf()\n", - "\n", - "integral_theta = (2 * tan(theta)**2 + 2) / (4 + 4 * tan(theta)**2)**(3/2)\n", - "integral_result = integrate(integral_theta, (theta, theta_lower, theta_upper))\n", - "integral_result\n", - "```\n", - "\n", - "Now, we have the value of the integral and put it in the \\(\\boxed{}\\).\n", - "\n", - "--------------------------------------------------------------------------------\n", - "\n", - ">>>>>>>> NO HUMAN INPUT RECEIVED. USING AUTO REPLY FOR THE USER...\n", - "MathChatAgent (to assistant):\n", - "\n", - "Please revisit the problem statement and your reasoning. If you think this step is correct, solve it yourself and continue the next step. Otherwise, correct this step.\n", - "\n", - "--------------------------------------------------------------------------------\n", - "assistant (to MathChatAgent):\n", - "\n", - "My apologies for the confusion in the previous steps. Let's revisit the problem statement and reasoning:\n", - "\n", - "Problem:\n", - "Use a trigonometric substitution to evaluate $\\int_{0}^{1} \\frac{d x}{\\left(4+x^{2}\\right)^{3 / 2}}$ (Be careful evaluating the limits)\n", - "\n", - "We already used the substitution $x = 2\\tan{\\theta}$, found $dx$, and rewrote the integral in terms of $\\theta$. We will proceed with evaluating the integral for $\\theta$ in the determined range:\n", - "\n", - "$$ \\theta = [0, \\arctan(\\frac{1}{2})] $$\n", - "\n", - "So, let's compute the new integral with respect to $\\theta$ and the new limits using symbolic evaluation instead of numerical evaluation as done earlier:\n", - "\n", - "```python\n", - "integral_theta = (2 * tan(theta)**2 + 2) / (4 + 4 * tan(theta)**2)**(3/2)\n", - "integral_result = integrate(integral_theta, (theta, 0, atan(1/2)))\n", - "integral_result\n", - "```\n", - "\n", - "Now, we should get the correct value for the integral, and we will put it in the \\(\\boxed{}\\).\n", - "\n", - "--------------------------------------------------------------------------------\n", - "\n", - ">>>>>>>> NO HUMAN INPUT RECEIVED. USING AUTO REPLY FOR THE USER...\n", - "MathChatAgent (to assistant):\n", - "\n", - "Error: Traceback (most recent call last):\n", - " integral_result = integrate(integral_theta, (theta, 0, atan(1/2)))\n", - " return integral.doit(**doit_flags)\n", - " did = self.xreplace(reps).doit(**hints)\n", - " evalued = Add(*others)._eval_interval(x, a, b)\n", - " singularities = solveset(self.cancel().as_numer_denom()[1], x,\n", - " rv = solveset(f.xreplace({symbol: x}), x, domain)\n", - " return _solveset(f, symbol, domain, _check=True)\n", - " result = _solve_trig(f, symbol, domain)\n", - " sol = _solve_trig1(f, symbol, domain)\n", - " solns = solveset_complex(g, y) - solveset_complex(h, y)\n", - " return solveset(f, symbol, S.Complexes)\n", - " rv = solveset(f.xreplace({symbol: x}), x, domain)\n", - " return _solveset(f, symbol, domain, _check=True)\n", - " result += _solve_abs(f, symbol, domain)\n", - " raise ValueError(filldedent('''\n", - "ValueError: \n", - "Absolute values cannot be inverted in the complex domain.\n", - "\n", - "--------------------------------------------------------------------------------\n", - "assistant (to MathChatAgent):\n", - "\n", - "Apologies for the confusion. It seems like there's an issue with solving the integral symbolically. Let's use an alternative approach to solve the integral:\n", - "\n", - "1. Perform a trigonometric substitution and simplify the integrand.\n", - "2. Use a numeric method to evaluate the integral instead of symbolic integration.\n", - "\n", - "So far, we've already performed the trigonometric substitution $x = 2\\tan{\\theta}$, resulting in $dx = (2\\tan{\\theta}^2 + 2)d\\theta$. We've also determined the bounds for $\\theta$: $[0, \\arctan(\\frac{1}{2})]$.\n", - "\n", - "Now let's simplify the integrand:\n", - "\n", - "```python\n", - "from sympy import simplify\n", - "\n", - "integral_theta = (2 * tan(theta)**2 + 2) / (4 + 4 * tan(theta)**2)**(3/2)\n", - "simplified_integral_theta = simplify(integral_theta)\n", - "simplified_integral_theta\n", - "```\n", - "\n", - "Next, we'll evaluate the integral using numerical integration:\n", - "\n", - "```python\n", - "from scipy.integrate import quad\n", - "from sympy import lambdify\n", - "import numpy as np\n", - "\n", - "theta_numerical = np.linspace(0, atan(1/2).evalf(), 1000)\n", - "integrand_numerical = lambdify(theta, simplified_integral_theta, \"numpy\")\n", - "integral_result_numerical, _ = quad(integrand_numerical, 0, atan(1/2).evalf())\n", - "integral_result_numerical\n", - "```\n", - "\n", - "Now, we have the value of the integral, and we can put it in the \\(\\boxed{}\\).\n", - "\n", - "--------------------------------------------------------------------------------\n", - "\n", - ">>>>>>>> NO HUMAN INPUT RECEIVED. USING AUTO REPLY FOR THE USER...\n", - "MathChatAgent (to assistant):\n", - "\n", - "0.25/(cos(theta)**(-2))**0.5\n", - "\n", - "Error: Traceback (most recent call last):\n", - " theta_numerical = np.linspace(0, atan(1/2).evalf(), 1000)\n", - " File \"<__array_function__ internals>\", line 180, in linspace\n", - " dt = result_type(start, stop, float(num))\n", - " File \"<__array_function__ internals>\", line 180, in result_type\n", - "TypeError: Cannot interpret '0.463647609000806' as a data type\n", - "\n", - "--------------------------------------------------------------------------------\n", - "assistant (to MathChatAgent):\n", - "\n", - "Apologies for the confusion. It seems there is a mistake in the code when creating the linspace. Let's fix this and also use the new integrand you provided:\n", - "\n", - "$$\\frac{1}{4\\cos(\\theta)^{3}}$$\n", - "\n", - "Now, let's perform the numerical integration:\n", - "\n", - "```python\n", - "from sympy import cos\n", - "\n", - "integrand_simplified = 1 / (4 * cos(theta)**3)\n", - "\n", - "theta_numerical = np.linspace(float(0), float(atan(1/2).evalf()), 1000)\n", - "integrand_numerical = lambdify(theta, integrand_simplified, \"numpy\")\n", - "integral_result_numerical, _ = quad(integrand_numerical, float(0), float(atan(1/2).evalf()))\n", - "integral_result_numerical\n", - "```\n", - "\n", - "Now, we have the value of the integral, and we can put it in the \\(\\boxed{}\\).\n", - "\n", - "--------------------------------------------------------------------------------\n", - "\n", - ">>>>>>>> NO HUMAN INPUT RECEIVED. USING AUTO REPLY FOR THE USER...\n", - "MathChatAgent (to assistant):\n", - "\n", - "0.13002860242931885\n", - "\n", - "--------------------------------------------------------------------------------\n", - "assistant (to MathChatAgent):\n", - "\n", - "Yes! The value of the integral is:\n", - "\n", - "$$\\int_{0}^{1} \\frac{d x}{\\left(4+x^{2}\\right)^{3 / 2}} = \\boxed{0.13002860242931885}$$\n", - "\n", - "--------------------------------------------------------------------------------\n" - ] - } - ], - "source": [ - "# reset the assistant. Always reset the assistant before starting a new conversation.\n", - "assistant.reset()\n", - "\n", - "# given a math problem, we use the mathproxyagent to generate a prompt to be sent to the assistant as the initial message.\n", - "# the assistant receives the message and generates a response. The response will be sent back to the mathproxyagent for processing.\n", - "# The conversation continues until the termination condition is met, in MathChat, the termination condition is the detect of \"\\boxed{}\" in the response.\n", - "math_problem = \"Find all $x$ that satisfy the inequality $(2x+10)(x+3)<(3x+9)(x+8)$. Express your answer in interval notation.\"\n", - "mathproxyagent.initiate_chat(assistant, problem=math_problem)" - ] - }, - { - "attachments": {}, - "cell_type": "markdown", - "metadata": {}, - "source": [ - "### Example 2\n", - "Problem: For what negative value of $k$ is there exactly one solution to the system of equations \\begin{align*}\n", - "y &= 2x^2 + kx + 6 \\\\\n", - "y &= -x + 4?\n", - "\\end{align*}\n", - "\n", - "Correct Solution: Setting the two expressions for $y$ equal to each other, it follows that $2x^2 + kx + 6 = -x + 4$. Re-arranging, $2x^2 + (k+1)x + 2 = 0$. For there to be exactly one solution for $x$, then the discriminant of the given quadratic must be equal to zero. Thus, $(k+1)^2 - 4 \\cdot 2 \\cdot 2 = (k+1)^2 - 16 = 0$, so $k+1 = \\pm 4$. Taking the negative value, $k = \\boxed{-5}$." - ] - }, - { - "cell_type": "code", - "execution_count": 27, - "metadata": {}, - "outputs": [ - { - "name": "stdout", - "output_type": "stream", - "text": [ - "\n", - "**** assistant received message from MathChatAgent ****\n", - "\n", - "\n", - "Let's use Python to solve a math problem.\n", - "\n", - "Query requirements:\n", - "You should always use the 'print' function for the output and use fractions/radical forms instead of decimals.\n", - "You can use packages like sympy to help you.\n", - "You must follow the formats below to write your code:\n", - "```python\n", - "# your code\n", - "```\n", - "\n", - "You may choose from three ways to solve the problem:\n", - "Case 1: If the problem can be solved with Python code directly, please write a program to solve it. You can enumerate all possible arrangements if needed.\n", - "Case 2: If the problem cannot be handled in the above two ways, please follow this process:\n", - "1. Solve the problem step by step (do not over-divide the steps).\n", - "2. Take out any queries that can be asked through Python (for example, any calculations or equations that can be calculated).\n", - "3. Wait for me to give the results.\n", - "4. Continue if you think the result is correct. If the result is invalid or unexpected, please correct your query or reasoning.\n", - "\n", - "After all the queries are run and you get the answer, put the answer in \\boxed{}.\n", - "\n", - "Problem: For what negative value of $k$ is there exactly one solution to the system of equations \\begin{align*}\n", - "y &= 2x^2 + kx + 6 \\\\\n", - "y &= -x + 4?\n", - "\\end{align*}\n", - "\n", - "**** MathChatAgent received message from assistant ****\n", - "\n", - "To find the value of k for which there is exactly one solution to the system, we need to solve the two equations for y and set them equal to each other. Then, we will find the discriminant and set it equal to 0. The discriminant will be equal to 0 if there is exactly one solution.\n", - "\n", - "Step 1: Set the equations equal to each other\n", - "$$2x^2 + kx + 6 = -x + 4$$\n", - "\n", - "Step 2: Rearrange the equation to get a quadratic equation\n", - "We can rearrange the equation to get a quadratic equation in terms of x:\n", - "$$2x^2 + (k+1)x + 2 = 0$$\n", - "\n", - "Step 3: Calculate the discriminant\n", - "The discriminant of a quadratic equation $ax^2 + bx + c = 0$ is given by $\\Delta = b^2 - 4ac$. In our case, $a=2$, $b=k+1$, and $c=2$.\n", - "\n", - "Now, let's compute the discriminant using Python:\n", - "\n", - "```python\n", - "from sympy import symbols, Eq, solve\n", - "\n", - "a, b, c, k = 2, k+1, 2, symbols('k')\n", - "delta = b**2 - 4*a*c\n", - "delta\n", - "```\n", - "\n", - "\n", - ">>>>>>>> NO HUMAN INPUT RECEIVED. USING AUTO REPLY FOR THE USER...\n", - "\n", - "**** assistant received message from MathChatAgent ****\n", - "\n", - "Error: Traceback (most recent call last):\n", - " a, b, c, k = 2, k+1, 2, symbols('k')\n", - "NameError: name 'k' is not defined\n", - "\n", - "\n", - "**** MathChatAgent received message from assistant ****\n", - "\n", - "Apologies for the mistake. I made an error in the code. Let me correct it and compute the discriminant again. Here's the corrected code:\n", - "\n", - "```python\n", - "from sympy import symbols, Eq, solve\n", - "\n", - "k = symbols('k')\n", - "a, b, c = 2, k + 1, 2\n", - "delta = b**2 - 4*a*c\n", - "delta\n", - "```\n", - "\n", - ">>>>>>>> NO HUMAN INPUT RECEIVED. USING AUTO REPLY FOR THE USER...\n", - "\n", - "**** assistant received message from MathChatAgent ****\n", - "\n", - "(k + 1)**2 - 16\n", - "\n", - "\n", - "**** MathChatAgent received message from assistant ****\n", - "\n", - "Yes, that's correct. So the discriminant is $\\Delta = (k+1)^2 - 16$. Since we want exactly one solution, the discriminant must be equal to 0:\n", - "\n", - "$$(k+1)^2 - 16 = 0$$\n", - "\n", - "Now let's solve this equation for k using Python:\n", - "\n", - "```python\n", - "k_val = solve(delta, k)\n", - "k_val\n", - "```\n", - "\n", - ">>>>>>>> NO HUMAN INPUT RECEIVED. USING AUTO REPLY FOR THE USER...\n", - "\n", - "**** assistant received message from MathChatAgent ****\n", - "\n", - "[-5, 3]\n", - "\n", - "\n", - "**** MathChatAgent received message from assistant ****\n", - "\n", - "The solutions for k are $k=-5$ and $k=3$. However, we are looking for the negative value of k, so the answer is:\n", - "\n", - "$$\\boxed{k = -5}$$\n", - "\n", - "For k = -5, there is exactly one solution to the given system of equations.\n" - ] - } - ], - "source": [ - "assistant.reset()\n", - "\n", - "math_problem = \"For what negative value of $k$ is there exactly one solution to the system of equations \\\\begin{align*}\\ny &= 2x^2 + kx + 6 \\\\\\\\\\ny &= -x + 4?\\n\\\\end{align*}\"\n", - "mathproxyagent.initiate_chat(assistant, problem=math_problem)" - ] - }, - { - "attachments": {}, - "cell_type": "markdown", - "metadata": {}, - "source": [ - "### Example 3\n", - "Problem: Find all positive integer values of $c$ such that the equation $x^2-7x+c=0$ only has roots that are real and rational. Express them in decreasing order, separated by commas.\n", - "\n", - "Correct Solution: For the roots to be real and rational, the discriminant must be a perfect square. Therefore, $(-7)^2-4 \\cdot 1 \\cdot c = 49-4c$ must be a perfect square. The only positive perfect squares less than 49 are $1$, $4$, $9$, $16$, $25$, and $36$. The perfect squares that give a integer value of $c$ are $1$, $9$, and $25$. Thus, we have the equations $49-4c=1$, $49-4c=9$, and $49-4c=25$. Solving, we get that the positive integer values of c are $\\boxed{12, 10, 6}$." - ] - }, - { - "cell_type": "code", - "execution_count": 30, - "metadata": {}, - "outputs": [ - { - "name": "stdout", - "output_type": "stream", - "text": [ - "\n", - "**** assistant received message from MathChatAgent ****\n", - "\n", - "\n", - "Let's use Python to solve a math problem.\n", - "\n", - "Query requirements:\n", - "You should always use the 'print' function for the output and use fractions/radical forms instead of decimals.\n", - "You can use packages like sympy to help you.\n", - "You must follow the formats below to write your code:\n", - "```python\n", - "# your code\n", - "```\n", - "\n", - "You may choose from three ways to solve the problem:\n", - "Case 1: If the problem can be solved with Python code directly, please write a program to solve it. You can enumerate all possible arrangements if needed.\n", - "Case 2: If the problem cannot be handled in the above two ways, please follow this process:\n", - "1. Solve the problem step by step (do not over-divide the steps).\n", - "2. Take out any queries that can be asked through Python (for example, any calculations or equations that can be calculated).\n", - "3. Wait for me to give the results.\n", - "4. Continue if you think the result is correct. If the result is invalid or unexpected, please correct your query or reasoning.\n", - "\n", - "After all the queries are run and you get the answer, put the answer in \\boxed{}.\n", - "\n", - "Problem: Find all positive integer values of $c$ such that the equation $x^2-7x+c=0$ only has roots that are real and rational. Express them in decreasing order, separated by commas.\n", - "\n", - "**** MathChatAgent received message from assistant ****\n", - "\n", - "To solve this problem, we'll use the discriminant formula, which is $\\Delta = b^2 - 4ac$. For the roots to be real and rational, the discriminant must be non-negative and a perfect square. In our case, the equation is $x^2 - 7x + c = 0$, so $a = 1, b = -7, c = c$.\n", - "\n", - "The discriminant formula becomes $\\Delta = (-7)^2 - 4(1)(c) = 49 - 4c$. We want to find all possible positive integer values of $c$ such that $\\Delta \\geq 0$ and is a perfect square.\n", - "\n", - "```python\n", - "from sympy import *\n", - "\n", - "# List for storing c values that satisfy the conditions\n", - "c_values = []\n", - "\n", - "# Check for all c values from 1 to 49\n", - "for c in range(1, 50):\n", - " delta = 49 - 4*c\n", - " # Condition for the discriminant to be non-negative and a perfect square\n", - " if delta >= 0 and sqrt(delta).is_integer():\n", - " c_values.append(c)\n", - "\n", - "# Reverse the list to get decreasing order\n", - "c_values.reverse()\n", - "\n", - "# Printing the result\n", - "print(\"The values of c that make the roots real and rational are:\", \",\".join(map(str, c_values)))\n", - "```\n", - "\n", - "Let's run this code to find the valid values of $c$.\n", - "\n", - ">>>>>>>> NO HUMAN INPUT RECEIVED. USING AUTO REPLY FOR THE USER...\n", - "\n", - "**** assistant received message from MathChatAgent ****\n", - "\n", - "Error: Traceback (most recent call last):\n", - " if delta >= 0 and sqrt(delta).is_integer():\n", - "TypeError: 'bool' object is not callable\n", - "\n", - "\n", - "**** MathChatAgent received message from assistant ****\n", - "\n", - "I apologize for the error in my code. I used the wrong function to check if the square root is an integer. I will correct the code and try again.\n", - "\n", - "```python\n", - "import math\n", - "\n", - "# List for storing c values that satisfy the conditions\n", - "c_values = []\n", - "\n", - "# Check for all c values from 1 to 49\n", - "for c in range(1, 50):\n", - " delta = 49 - 4*c\n", - " # Condition for the discriminant to be non-negative and a perfect square\n", - " if delta >= 0 and (math.sqrt(delta) % 1 == 0):\n", - " c_values.append(c)\n", - "\n", - "# Reverse the list to get decreasing order\n", - "c_values.reverse()\n", - "\n", - "# Printing the result\n", - "print(\"The values of c that make the roots real and rational are:\", \",\".join(map(str, c_values)))\n", - "```\n", - "\n", - "Let's run this corrected code to find the valid values of $c$.\n", - "\n", - ">>>>>>>> NO HUMAN INPUT RECEIVED. USING AUTO REPLY FOR THE USER...\n", - "\n", - "**** assistant received message from MathChatAgent ****\n", - "\n", - "The values of c that make the roots real and rational are: 12,10,6\n", - "\n", - "\n", - "**** MathChatAgent received message from assistant ****\n", - "\n", - "Great! So, the positive integer values of $c$ such that the equation $x^2 - 7x + c = 0$ only has roots that are real and rational are $\\boxed{12, 10, 6}$ in decreasing order.\n" - ] - } - ], - "source": [ - "assistant.reset()\n", - "\n", - "math_problem = \"Find all positive integer values of $c$ such that the equation $x^2-7x+c=0$ only has roots that are real and rational. Express them in decreasing order, separated by commas.\"\n", - "mathproxyagent.initiate_chat(assistant, problem=math_problem)" - ] - }, - { - "attachments": {}, - "cell_type": "markdown", - "metadata": {}, - "source": [ - "------------------------------------\n", - "### Using other prompts\n", - "\n", - "MathChat allows different prompts that instruct assistant to solve the problem.\n", - "\n", - "Check out `MathUserProxyAgent.generate_init_message(problem, prompt_type='default', customized_prompt=None)`:\n", - "- You may choose from `['default', 'python', 'two_tools']` for parameter `prompt_type`. We include two more prompts in the paper: \n", - " 1. `'python'` is a simplified prompt from the default prompt that uses Python only. \n", - " 2. `'two_tools'` further allows the selection of Python or Wolfram Alpha based on this simplified `python` prompt. Note that this option requries a Wolfram Alpha API key and put it in `wolfram.txt`.\n", - "\n", - "- You can also input your customized prompt if needed: `mathproxyagent.generate_init_message(problem, customized_prompt=\"Your customized prompt\")`. Since this mathproxyagent detects '\\boxed{}' as termination, you need to have a similar termination sentence in the prompt: \"If you get the answer, put the answer in \\\\boxed{}.\". If the customized is provided, the `prompt_type` will be ignored.\n", - "\n", - "\n", - "### Example 4 (Use the \"python\" prompt):\n", - "\n", - "Problem: If $725x + 727y = 1500$ and $729x+ 731y = 1508$, what is the value of $x - y$ ?\n", - "\n", - "Correct Solution: Subtracting the two equations gives: \n", - "\\begin{align*}\n", - "(729x+731y)-(725x+727y) &= 1508-1500\\\\\n", - "\\Rightarrow\\qquad 4x+4y &= 8\\\\\n", - "\\Rightarrow\\qquad x+y &= 2.\n", - "\\end{align*}\n", - "\n", - "Multiplying this equation by 725 and subtracting this equation from $725x+727y=1500$ gives \\begin{align*}\n", - "(725x+727y) - 725(x+y) &= 1500-725(x+y) \\implies \\\\\n", - "2y &= 50.\n", - "\\end{align*}So we can write $x-y$ as $(x+y) - 2y$, which equals $2 - 50 = \\boxed{-48}$.\n" - ] - }, - { - "cell_type": "code", - "execution_count": 13, - "metadata": {}, - "outputs": [ - { - "name": "stdout", - "output_type": "stream", - "text": [ - "\n", - " -------------------------------------------------------------------------------- \n", - "\n", - "MathChatAgent (to assistant):\n", - "Let's use Python to solve a math problem.\n", - "\n", - "Query requirements:\n", - "You should always use the 'print' function for the output and use fractions/radical forms instead of decimals.\n", - "You can use packages like sympy to help you.\n", - "You must follow the formats below to write your code:\n", - "```python\n", - "# your code\n", - "```\n", - "\n", - "Please follow this process:\n", - "1. Solve the problem step by step (do not over-divide the steps).\n", - "2. Take out any queries that can be asked through Python (for example, any calculations or equations that can be calculated).\n", - "3. Wait for me to give the results.\n", - "4. Continue if you think the result is correct. If the result is invalid or unexpected, please correct your query or reasoning.\n", - "\n", - "After all the queries are run and you get the answer, put the answer in \\boxed{}.\n", - "\n", - "Problem: Problem: If $725x + 727y = 1500$ and $729x+ 731y = 1508$, what is the value of $x - y$ ?\n", - "\n", - " -------------------------------------------------------------------------------- \n", - "\n", - "assistant (to MathChatAgent):\n", - "First, let's solve these two linear equations step by step. We can start by eliminating one variable by subtracting one equation from the other.\n", - "\n", - "So, let's subtract the first equation from the second:\n", - "\n", - "(729x + 731y) - (725x + 727y) = (1508 - 1500)\n", - "\n", - "Now let's simplify this:\n", - "\n", - "```python\n", - "from sympy import symbols, Eq, simplify\n", - "\n", - "x, y = symbols('x y')\n", - "eq1 = Eq(729*x + 731*y - (725*x + 727*y), 1508 - 1500)\n", - "eq1_simplified = simplify(eq1)\n", - "eq1_simplified\n", - "```\n", - "\n", - ">>>>>>>> NO HUMAN INPUT RECEIVED. USING AUTO REPLY FOR THE USER...\n", - "\n", - " -------------------------------------------------------------------------------- \n", - "\n", - "MathChatAgent (to assistant):\n", - "Eq(x + y, 2)\n", - "\n", - " -------------------------------------------------------------------------------- \n", - "\n", - "assistant (to MathChatAgent):\n", - "Now we have the simplified equation:\n", - "\n", - "x + y = 2\n", - "\n", - "Next, we need to use this equation to eliminate either x or y from one of the given equations. Let's eliminate y by expressing y in terms of x, and then substitute it into the second given equation.\n", - "\n", - "y = 2 - x\n", - "\n", - "Now let's substitute this into the second equation:\n", - "\n", - "729x + 731(2 - x) = 1508\n", - "\n", - "Now let's simplify this equation:\n", - "\n", - "```python\n", - "eq2 = Eq(729*x + 731*(2 - x), 1508)\n", - "eq2_simplified = simplify(eq2)\n", - "eq2_simplified\n", - "```\n", - "\n", - ">>>>>>>> NO HUMAN INPUT RECEIVED. USING AUTO REPLY FOR THE USER...\n", - "\n", - " -------------------------------------------------------------------------------- \n", - "\n", - "MathChatAgent (to assistant):\n", - "Eq(x, -23)\n", - "\n", - " -------------------------------------------------------------------------------- \n", - "\n", - "assistant (to MathChatAgent):\n", - "Now we have found the value of x:\n", - "\n", - "x = -23\n", - "\n", - "We can now find the value of y using the simplified equation x + y = 2:\n", - "\n", - "y = 2 - x\n", - "\n", - "Let's calculate the value of y:\n", - "\n", - "```python\n", - "y_value = 2 - (-23)\n", - "y_value\n", - "```\n", - "\n", - ">>>>>>>> NO HUMAN INPUT RECEIVED. USING AUTO REPLY FOR THE USER...\n", - "\n", - " -------------------------------------------------------------------------------- \n", - "\n", - "MathChatAgent (to assistant):\n", - "25\n", - "\n", - " -------------------------------------------------------------------------------- \n", - "\n", - "assistant (to MathChatAgent):\n", - "Now we have found the value of y:\n", - "\n", - "y = 25\n", - "\n", - "Now we can find the value of x - y:\n", - "\n", - "x - y = -23 - 25\n", - "\n", - "Let's calculate the value of x - y:\n", - "\n", - "```python\n", - "x_minus_y = -23 - 25\n", - "x_minus_y\n", - "```\n", - "\n", - ">>>>>>>> NO HUMAN INPUT RECEIVED. USING AUTO REPLY FOR THE USER...\n", - "\n", - " -------------------------------------------------------------------------------- \n", - "\n", - "MathChatAgent (to assistant):\n", - "-48\n", - "\n", - " -------------------------------------------------------------------------------- \n", - "\n", - "assistant (to MathChatAgent):\n", - "So, the value of x - y is:\n", - "\n", - "x - y = -48\n", - "\n", - "Thus, the final answer is:\n", - "\n", - "$\\boxed{-48}$\n" - ] - } - ], - "source": [ - "assistant.reset() # clear LLM assistant's message history\n", - "\n", - "# we set the prompt_type to \"python\", which is a simplied version of the default prompt.\n", - "math_problem = \"Problem: If $725x + 727y = 1500$ and $729x+ 731y = 1508$, what is the value of $x - y$ ?\"\n", - "mathproxyagent.initiate_chat(assistant, problem=math_problem, prompt_type=\"python\")" - ] - }, - { - "attachments": {}, - "cell_type": "markdown", - "metadata": {}, - "source": [ - "## Example 5 (Use the \"two_tools\" prompt)\n", - "\n", - "Problem: Find all numbers $a$ for which the graph of $y=x^2+a$ and the graph of $y=ax$ intersect. Express your answer in interval notation.\n", - "\n", - "\n", - "Correct Solution: If these two graphs intersect then the points of intersection occur when \\[x^2+a=ax,\\] or \\[x^2-ax+a=0.\\] This quadratic has solutions exactly when the discriminant is nonnegative: \\[(-a)^2-4\\cdot1\\cdot a\\geq0.\\] This simplifies to \\[a(a-4)\\geq0.\\] This quadratic (in $a$) is nonnegative when $a$ and $a-4$ are either both $\\ge 0$ or both $\\le 0$. This is true for $a$ in $$(-\\infty,0]\\cup[4,\\infty).$$ Therefore the line and quadratic intersect exactly when $a$ is in $\\boxed{(-\\infty,0]\\cup[4,\\infty)}$.\n" - ] - }, - { - "cell_type": "code", - "execution_count": 15, - "metadata": {}, - "outputs": [ - { - "name": "stdout", - "output_type": "stream", - "text": [ - "\n", - " -------------------------------------------------------------------------------- \n", - "\n", - "MathChatAgent (to assistant):\n", - "Let's use two tools (Python and Wolfram alpha) to solve a math problem.\n", - "\n", - "Query requirements:\n", - "You must follow the formats below to write your query:\n", - "For Wolfram Alpha:\n", - "```wolfram\n", - "# one wolfram query\n", - "```\n", - "For Python:\n", - "```python\n", - "# your code\n", - "```\n", - "When using Python, you should always use the 'print' function for the output and use fractions/radical forms instead of decimals. You can use packages like sympy to help you.\n", - "When using wolfram, give one query in each code block.\n", - "\n", - "Please follow this process:\n", - "1. Solve the problem step by step (do not over-divide the steps).\n", - "2. Take out any queries that can be asked through Python or Wolfram Alpha, select the most suitable tool to be used (for example, any calculations or equations that can be calculated).\n", - "3. Wait for me to give the results.\n", - "4. Continue if you think the result is correct. If the result is invalid or unexpected, please correct your query or reasoning.\n", - "\n", - "After all the queries are run and you get the answer, put the final answer in \\boxed{}.\n", - "\n", - "Problem: Find all numbers $a$ for which the graph of $y=x^2+a$ and the graph of $y=ax$ intersect. Express your answer in interval notation.\n", - "\n", - " -------------------------------------------------------------------------------- \n", - "\n", - "assistant (to MathChatAgent):\n", - "First, we need to find the intersection points of the two given equations, i.e., when $y = x^2 + a$ and $y = ax$ are equal. So, we will set the two equations equal to each other and solve for $x$:\n", - "\n", - "$x^2 + a = ax$\n", - "\n", - "Now, let's rearrange the equation to get a quadratic equation in terms of $x$:\n", - "\n", - "$x^2 - ax + a = 0$\n", - "\n", - "We can use the quadratic formula to solve for $x$ in terms of $a$:\n", - "\n", - "$x = \\frac{-(-a) \\pm \\sqrt{(-a)^2 - 4(1)(a)}}{2(1)}$\n", - "\n", - "```wolfram\n", - "x = (a + sqrt(a^2 - 4*a)) / 2, x = (a - sqrt(a^2 - 4*a)) / 2\n", - "```\n", - "\n", - ">>>>>>>> NO HUMAN INPUT RECEIVED. USING AUTO REPLY FOR THE USER...\n", - "\n", - " -------------------------------------------------------------------------------- \n", - "\n", - "MathChatAgent (to assistant):\n", - "Assumption: {x = 1/2 (a + sqrt(a^2 - 4 a)), x = 1/2 (a - sqrt(a^2 - 4 a))} \n", - "Answer: ans 0: a = 0, x = 0\n", - "ans 1: a = 4, x = 2\n", - "\n", - " -------------------------------------------------------------------------------- \n", - "\n", - "assistant (to MathChatAgent):\n", - "We found two solutions for $x$ in terms of $a$: \n", - "\n", - "$x = \\frac{1}{2}(a + \\sqrt{a^2 - 4a})$\n", - "\n", - "$x = \\frac{1}{2}(a - \\sqrt{a^2 - 4a})$\n", - "\n", - "And we have two possible answers: \n", - "\n", - "1) When $a=0$, $x=0$.\n", - "\n", - "2) When $a=4$, $x=2$.\n", - "\n", - "Now, we need to find the interval of $a$ for which the two graphs intersect. As we know the roots of the quadratic equation, we can look for the conditions under which the discriminant is greater or equal to zero:\n", - "\n", - "$D = a^2 - 4a \\ge 0$\n", - "\n", - "Let's solve this inequality to find the interval of $a$:\n", - "\n", - "```wolfram\n", - "solve a^2 - 4a >= 0 for a\n", - "```\n", - "\n", - ">>>>>>>> NO HUMAN INPUT RECEIVED. USING AUTO REPLY FOR THE USER...\n", - "\n", - " -------------------------------------------------------------------------------- \n", - "\n", - "MathChatAgent (to assistant):\n", - "Assumption: solve a^2 - 4 a>=0 for a \n", - "Answer: ans 0: a<=0\n", - "ans 1: a>=4\n", - "\n", - " -------------------------------------------------------------------------------- \n", - "\n", - "assistant (to MathChatAgent):\n", - "We found the intervals for $a$ that satisfy the inequality $a^2 - 4a \\ge 0$:\n", - "\n", - "1) $a \\le 0$\n", - "\n", - "2) $a \\ge 4$\n", - "\n", - "So, the graph of $y=x^2+a$ and the graph of $y=ax$ intersect when $a$ is in these intervals. Therefore, the final answer is:\n", - "\n", - "$\\boxed{(-\\infty, 0] \\cup [4, \\infty)}$\n" - ] - } - ], - "source": [ - "assistant.reset() # clear LLM assistant's message history\n", - "\n", - "# The wolfram alpha appid is required for this example (the assistant may choose to query Wolfram Alpha).\n", - "import os\n", - "if \"WOLFRAM_ALPHA_APPID\" not in os.environ:\n", - " os.environ[\"WOLFRAM_ALPHA_APPID\"] = open(\"wolfram.txt\").read().strip()\n", - "\n", - "# we set the prompt_type to \"two_tools\", which allows the assistant to select wolfram alpha when necessary.\n", - "math_problem = \"Find all numbers $a$ for which the graph of $y=x^2+a$ and the graph of $y=ax$ intersect. Express your answer in interval notation.\"\n", - "mathproxyagent.initiate_chat(assistant, problem=math_problem, prompt_type=\"two_tools\")" - ] - } - ], - "metadata": { - "kernelspec": { - "display_name": "flaml_dev", - "language": "python", - "name": "python3" - }, - "language_info": { - "codemirror_mode": { - "name": "ipython", - "version": 3 - }, - "file_extension": ".py", - "mimetype": "text/x-python", - "name": "python", - "nbconvert_exporter": "python", - "pygments_lexer": "ipython3", - "version": "3.9.15" - }, - "orig_nbformat": 4 - }, - "nbformat": 4, - "nbformat_minor": 2 -} diff --git a/notebook/autogen_agent_auto_feedback_from_code_execution.ipynb b/notebook/autogen_agent_auto_feedback_from_code_execution.ipynb deleted file mode 100644 index f185c60ca5..0000000000 --- a/notebook/autogen_agent_auto_feedback_from_code_execution.ipynb +++ /dev/null @@ -1,1060 +0,0 @@ -{ - "cells": [ - { - "attachments": {}, - "cell_type": "markdown", - "metadata": {}, - "source": [ - "\"Open" - ] - }, - { - "attachments": {}, - "cell_type": "markdown", - "metadata": { - "slideshow": { - "slide_type": "slide" - } - }, - "source": [ - "# Interactive LLM Agent with Auto Feedback from Code Execution\n", - "\n", - "FLAML offers an experimental feature of interactive LLM agents, which can be used to solve various tasks with human or automatic feedback, including tasks that require using tools via code.\n", - "Please find documentation about this feature [here](https://microsoft.github.io/FLAML/docs/Use-Cases/Auto-Generation#agents-experimental).\n", - "\n", - "In this notebook, we demonstrate how to use `AssistantAgent` and `UserProxyAgent` to write code and execute the code. Here `AssistantAgent` is an LLM-based agent that can write Python code (in a Python coding block) for a user to execute for a given task. `UserProxyAgent` is an agent which serves as a proxy for the human user to execute the code written by `AssistantAgent`, or automatically execute the code. Depending on the setting of `human_input_mode` and `max_consecutive_auto_reply`, the `UserProxyAgent` either solicits feedback from the human user or uses auto-feedback based on the result of code execution. For example, when `human_input_mode` is set to \"ALWAYS\", the `UserProxyAgent` will always prompt the user for feedback. When user feedback is provided, the `UserProxyAgent` will directly pass the feedback to `AssistantAgent` without doing any additional steps. When no user feedback is provided, the `UserProxyAgent` will execute the code written by `AssistantAgent` directly and return the execution results (success or failure and corresponding outputs) to `AssistantAgent`.\n", - "\n", - "## Requirements\n", - "\n", - "FLAML requires `Python>=3.8`. To run this notebook example, please install flaml with the [autogen] option:\n", - "```bash\n", - "pip install flaml[autogen]\n", - "```" - ] - }, - { - "cell_type": "code", - "execution_count": 1, - "metadata": { - "execution": { - "iopub.execute_input": "2023-02-13T23:40:52.317406Z", - "iopub.status.busy": "2023-02-13T23:40:52.316561Z", - "iopub.status.idle": "2023-02-13T23:40:52.321193Z", - "shell.execute_reply": "2023-02-13T23:40:52.320628Z" - } - }, - "outputs": [], - "source": [ - "# %pip install flaml[autogen]~=2.0.0rc4" - ] - }, - { - "attachments": {}, - "cell_type": "markdown", - "metadata": {}, - "source": [ - "## Set your API Endpoint\n", - "\n", - "The [`config_list_from_json`](https://microsoft.github.io/FLAML/docs/reference/autogen/oai/openai_utils#config_list_from_json) function loads a list of configurations from an environment variable or a json file.\n" - ] - }, - { - "cell_type": "code", - "execution_count": 2, - "metadata": {}, - "outputs": [], - "source": [ - "from flaml import oai\n", - "\n", - "config_list = oai.config_list_from_json(\n", - " \"OAI_CONFIG_LIST\",\n", - " filter_dict={\n", - " \"model\": [\"gpt-4\", \"gpt4\", \"gpt-4-32k\", \"gpt-4-32k-0314\"],\n", - " },\n", - ")" - ] - }, - { - "attachments": {}, - "cell_type": "markdown", - "metadata": {}, - "source": [ - "It first looks for environment variable \"OAI_CONFIG_LIST\" which needs to be a valid json string. If that variable is not found, it then looks for a json file named \"OAI_CONFIG_LIST\". It filters the configs by models (you can filter by other keys as well). Only the gpt-4 models are kept in the list based on the filter condition.\n", - "\n", - "The config list looks like the following:\n", - "```python\n", - "config_list = [\n", - " {\n", - " 'model': 'gpt-4',\n", - " 'api_key': '',\n", - " },\n", - " {\n", - " 'model': 'gpt-4',\n", - " 'api_key': '',\n", - " 'api_base': '',\n", - " 'api_type': 'azure',\n", - " 'api_version': '2023-06-01-preview',\n", - " },\n", - " {\n", - " 'model': 'gpt-4-32k',\n", - " 'api_key': '',\n", - " 'api_base': '',\n", - " 'api_type': 'azure',\n", - " 'api_version': '2023-06-01-preview',\n", - " },\n", - "]\n", - "```\n", - "\n", - "If you open this notebook in colab, you can upload your files by clicking the file icon on the left panel and then choose \"upload file\" icon.\n", - "\n", - "You can set the value of config_list in other ways you prefer, e.g., loading from a YAML file." - ] - }, - { - "attachments": {}, - "cell_type": "markdown", - "metadata": {}, - "source": [ - "## Example Task: Check Stock Price Change\n", - "\n", - "In the example below, let's see how to use the agents in FLAML to write a python script and execute the script. This process involves constructing a `AssistantAgent` to serve as the assistant, along with a `UserProxyAgent` that acts as a proxy for the human user. In this example demonstrated below, when constructing the `UserProxyAgent`, we select the `human_input_mode` to \"NEVER\". This means that the `UserProxyAgent` will not solicit feedback from the human user. It stops replying when the limit defined by `max_consecutive_auto_reply` is reached, or when `is_termination_msg()` returns true for the received message." - ] - }, - { - "cell_type": "code", - "execution_count": 3, - "metadata": {}, - "outputs": [ - { - "name": "stdout", - "output_type": "stream", - "text": [ - "user (to assistant):\n", - "\n", - "What date is today? Compare the year-to-date gain for META and TESLA.\n", - "\n", - "--------------------------------------------------------------------------------\n", - "assistant (to user):\n", - "\n", - "# filename: stock_comparison.py\n", - "```python\n", - "import datetime\n", - "import yfinance as yf\n", - "\n", - "# Get today's date\n", - "today = datetime.date.today()\n", - "print(\"Today's date:\", today)\n", - "\n", - "# Get the start of the year\n", - "start_of_year = datetime.date(today.year, 1, 1)\n", - "\n", - "# Download the historical data for META and TESLA\n", - "meta_data = yf.download('META', start=start_of_year, end=today)\n", - "tesla_data = yf.download('TSLA', start=start_of_year, end=today)\n", - "\n", - "# Calculate the year-to-date gain for META and TESLA\n", - "meta_gain = (meta_data['Close'][-1] - meta_data['Close'][0]) / meta_data['Close'][0]\n", - "tesla_gain = (tesla_data['Close'][-1] - tesla_data['Close'][0]) / tesla_data['Close'][0]\n", - "\n", - "# Print the year-to-date gain for META and TESLA\n", - "print(\"Year-to-date gain for META:\", round(meta_gain * 100, 2), \"%\")\n", - "print(\"Year-to-date gain for TESLA:\", round(tesla_gain * 100, 2), \"%\")\n", - "```\n", - "Please save this code in a file named `stock_comparison.py` and run it. This script will print today's date and compare the year-to-date gain for META and TESLA. It uses the `yfinance` library to download the historical data for the stocks. If you haven't installed `yfinance`, please install it by running `pip install yfinance`.\n", - "\n", - "--------------------------------------------------------------------------------\n", - "\n", - ">>>>>>>> USING AUTO REPLY FOR THE USER...\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "user (to assistant):\n", - "\n", - "exitcode: 0 (execution succeeded)\n", - "Code output: \n", - "Today's date: 2023-07-24\n", - "[*********************100%***********************] 1 of 1 completed\n", - "[*********************100%***********************] 1 of 1 completed\n", - "Year-to-date gain for META: 135.9 %\n", - "Year-to-date gain for TESLA: 140.54 %\n", - "\n", - "\n", - "--------------------------------------------------------------------------------\n", - "assistant (to user):\n", - "\n", - "Great! The script has successfully executed and provided the year-to-date gain for both META and TESLA stocks. As of today's date (July 24, 2023), the year-to-date gain for META is 135.9%, and for TESLA, it's 140.54%. \n", - "\n", - "Please let me know if you need help with anything else. \n", - "\n", - "TERMINATE\n", - "\n", - "--------------------------------------------------------------------------------\n" - ] - } - ], - "source": [ - "from flaml.autogen.agent import AssistantAgent, UserProxyAgent\n", - "\n", - "# create an AssistantAgent named \"assistant\"\n", - "assistant = AssistantAgent(\n", - " \"assistant\",\n", - " oai_config={\n", - " \"seed\": 42,\n", - " \"config_list\": config_list,\n", - " \"temperature\": 0,\n", - " }\n", - ")\n", - "# create a UserProxyAgent instance named \"user\"\n", - "user = UserProxyAgent(\n", - " \"user\",\n", - " human_input_mode=\"NEVER\",\n", - " max_consecutive_auto_reply=10,\n", - " is_termination_msg=lambda x: x.get(\"content\", \"\").rstrip().endswith(\"TERMINATE\") or x.get(\"content\", \"\").rstrip().endswith('\"TERMINATE\".'),\n", - " code_execution_config={\n", - " \"work_dir\": \"coding\",\n", - " \"use_docker\": False, # set to True or image name like \"python:3\" to use docker\n", - " },\n", - ")\n", - "# the assistant receives a message from the user, which contains the task description\n", - "user.initiate_chat(\n", - " assistant,\n", - " message=\"\"\"What date is today? Compare the year-to-date gain for META and TESLA.\"\"\",\n", - ")" - ] - }, - { - "attachments": {}, - "cell_type": "markdown", - "metadata": {}, - "source": [ - "The example above involves code execution. In FLAML, code execution is triggered automatically by the `UserProxyAgent` when it detects an executable code block in a received message and no human user input is provided. This process occurs in a designated working directory, using a Docker container by default. Unless a specific directory is specified, FLAML defaults to the `flaml/autogen/extensions` directory. Users have the option to specify a different working directory by setting the `work_dir` argument when constructing a new instance of the `UserProxyAgent`.\n" - ] - }, - { - "attachments": {}, - "cell_type": "markdown", - "metadata": {}, - "source": [ - "All the feedback is auto generated." - ] - }, - { - "attachments": {}, - "cell_type": "markdown", - "metadata": {}, - "source": [ - "## Example Task: Plot Chart" - ] - }, - { - "cell_type": "code", - "execution_count": 4, - "metadata": {}, - "outputs": [ - { - "name": "stdout", - "output_type": "stream", - "text": [ - "user (to assistant):\n", - "\n", - "Plot a chart of their stock price change YTD and save to stock_price_ytd.png.\n", - "\n", - "--------------------------------------------------------------------------------\n", - "assistant (to user):\n", - "\n", - "# filename: stock_plot.py\n", - "```python\n", - "import matplotlib.pyplot as plt\n", - "\n", - "# Plot the close price of META and TESLA\n", - "plt.figure(figsize=(14,7))\n", - "plt.plot(meta_data['Close'], label='META')\n", - "plt.plot(tesla_data['Close'], label='TESLA')\n", - "\n", - "# Set the title and labels\n", - "plt.title('Year-to-date stock price change for META and TESLA')\n", - "plt.xlabel('Date')\n", - "plt.ylabel('Close Price')\n", - "\n", - "# Show the legend\n", - "plt.legend()\n", - "\n", - "# Save the plot as a PNG file\n", - "plt.savefig('stock_price_ytd.png')\n", - "```\n", - "Please save this code in a file named `stock_plot.py` and run it. This script will plot the year-to-date stock price change for META and TESLA and save the plot as a PNG file named `stock_price_ytd.png`. It uses the `matplotlib` library to create the plot. If you haven't installed `matplotlib`, please install it by running `pip install matplotlib`.\n", - "\n", - "--------------------------------------------------------------------------------\n", - "\n", - ">>>>>>>> USING AUTO REPLY FOR THE USER...\n", - "user (to assistant):\n", - "\n", - "exitcode: 1 (execution failed)\n", - "Code output: \n", - "Traceback (most recent call last):\n", - " File \"/workspaces/FLAML/notebook/coding/tmp_code_0e68902a38546d82fddf9b82f39278e3.py\", line 5, in \n", - " plt.plot(meta_data['Close'], label='META')\n", - "NameError: name 'meta_data' is not defined\n", - "\n", - "\n", - "--------------------------------------------------------------------------------\n", - "assistant (to user):\n", - "\n", - "I apologize for the oversight. The error occurred because the `meta_data` and `tesla_data` variables, which hold the stock data, were not defined in this script. We need to fetch the stock data again in this script. Here is the corrected code:\n", - "\n", - "# filename: stock_plot.py\n", - "```python\n", - "import datetime\n", - "import yfinance as yf\n", - "import matplotlib.pyplot as plt\n", - "\n", - "# Get today's date\n", - "today = datetime.date.today()\n", - "\n", - "# Get the start of the year\n", - "start_of_year = datetime.date(today.year, 1, 1)\n", - "\n", - "# Download the historical data for META and TESLA\n", - "meta_data = yf.download('META', start=start_of_year, end=today)\n", - "tesla_data = yf.download('TSLA', start=start_of_year, end=today)\n", - "\n", - "# Plot the close price of META and TESLA\n", - "plt.figure(figsize=(14,7))\n", - "plt.plot(meta_data['Close'], label='META')\n", - "plt.plot(tesla_data['Close'], label='TESLA')\n", - "\n", - "# Set the title and labels\n", - "plt.title('Year-to-date stock price change for META and TESLA')\n", - "plt.xlabel('Date')\n", - "plt.ylabel('Close Price')\n", - "\n", - "# Show the legend\n", - "plt.legend()\n", - "\n", - "# Save the plot as a PNG file\n", - "plt.savefig('stock_price_ytd.png')\n", - "```\n", - "Please save this code in a file named `stock_plot.py` and run it. This script will plot the year-to-date stock price change for META and TESLA and save the plot as a PNG file named `stock_price_ytd.png`.\n", - "\n", - "--------------------------------------------------------------------------------\n", - "\n", - ">>>>>>>> USING AUTO REPLY FOR THE USER...\n", - "user (to assistant):\n", - "\n", - "exitcode: 0 (execution succeeded)\n", - "Code output: \n", - "[*********************100%***********************] 1 of 1 completed\n", - "[*********************100%***********************] 1 of 1 completed\n", - "\n", - "\n", - "--------------------------------------------------------------------------------\n", - "assistant (to user):\n", - "\n", - "Great! The script has successfully executed and the plot of the year-to-date stock price change for META and TESLA has been saved as a PNG file named `stock_price_ytd.png`. You can find this file in the same directory where you ran the script.\n", - "\n", - "Please let me know if you need help with anything else.\n", - "\n", - "TERMINATE\n", - "\n", - "--------------------------------------------------------------------------------\n" - ] - } - ], - "source": [ - "# followup of the previous question\n", - "user.send(\n", - " recipient=assistant,\n", - " message=\"\"\"Plot a chart of their stock price change YTD and save to stock_price_ytd.png.\"\"\",\n", - ")" - ] - }, - { - "attachments": {}, - "cell_type": "markdown", - "metadata": {}, - "source": [ - "Let's display the generated figure." - ] - }, - { - "cell_type": "code", - "execution_count": 5, - "metadata": {}, - "outputs": [ - { - "data": { - "image/png": "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", - "text/plain": [ - "" - ] - }, - "execution_count": 5, - "metadata": {}, - "output_type": "execute_result" - } - ], - "source": [ - "from IPython.display import Image\n", - "\n", - "Image(filename='coding/stock_price_ytd.png')" - ] - }, - { - "cell_type": "markdown", - "metadata": {}, - "source": [ - "## Use a Different Code Execution Environment\n", - "\n", - "The code execution happened in a separate process, so the plot is not directly displayed in the notebook. Is it possible to change the code execution environment into IPython?\n", - "\n", - "Yes! In the following we demonstrate how to extend the `UserProxyAgent` to use a different code execution environment." - ] - }, - { - "cell_type": "code", - "execution_count": 6, - "metadata": {}, - "outputs": [], - "source": [ - "from typing import Dict, Union\n", - "from IPython import get_ipython\n", - "\n", - "class IPythonUserProxyAgent(UserProxyAgent):\n", - " def __init__(self, name: str, **kwargs):\n", - " super().__init__(name, **kwargs)\n", - " self._ipython = get_ipython()\n", - "\n", - " def generate_init_message(self, *args, **kwargs) -> Union[str, Dict]:\n", - " return super().generate_init_message(*args, **kwargs) + \"\"\"\n", - "If you suggest code, the code will be executed in IPython.\"\"\"\n", - "\n", - " def run_code(self, code, **kwargs):\n", - " result = self._ipython.run_cell(code)\n", - " log = str(result.result)\n", - " exitcode = 0 if result.success else 1\n", - " if result.error_before_exec is not None:\n", - " log += f\"\\n{result.error_before_exec}\"\n", - " exitcode = 1\n", - " if result.error_in_exec is not None:\n", - " log += f\"\\n{result.error_in_exec}\"\n", - " exitcode = 1\n", - " return exitcode, bytes(log, \"utf-8\"), None" - ] - }, - { - "cell_type": "markdown", - "metadata": {}, - "source": [ - "The implementation overrides three functions in `UserProxyAgent`:\n", - "* constructor. We get the ipython instance as the code execution environment.\n", - "* `generate_init_message`. We generate a modified initial message to send to the assistant agent, by adding the info that the execution will be performed in IPython.\n", - "* `run_code`. We execute the code with the ipython instance.\n", - "\n", - "With the new `IPythonUserProxyAgent`, we are able to run the code within the current notebook environment and display plot directly." - ] - }, - { - "cell_type": "code", - "execution_count": 7, - "metadata": {}, - "outputs": [ - { - "name": "stdout", - "output_type": "stream", - "text": [ - "ipython_user (to assistant):\n", - "\n", - "Plot a chart of META and TESLA stock price change YTD\n", - "If you suggest code, the code will be executed in IPython.\n", - "\n", - "--------------------------------------------------------------------------------\n", - "assistant (to ipython_user):\n", - "\n", - "Sure, we can use the `yfinance` library in Python to download the stock price data and `matplotlib` to plot the data. If you don't have `yfinance` installed, you can install it using pip:\n", - "\n", - "```python\n", - "!pip install yfinance\n", - "```\n", - "\n", - "Here is the Python code to plot the YTD stock price change for META (Facebook) and TESLA.\n", - "\n", - "```python\n", - "# Python code\n", - "import yfinance as yf\n", - "import matplotlib.pyplot as plt\n", - "from datetime import datetime\n", - "\n", - "# Define the ticker symbol\n", - "tickerSymbols = ['META', 'TSLA']\n", - "\n", - "# Get data on this ticker\n", - "start_date = datetime(datetime.now().year, 1, 1)\n", - "end_date = datetime.now()\n", - "\n", - "# Fetch the data\n", - "data = yf.download(tickerSymbols, start=start_date, end=end_date)\n", - "\n", - "# Plot the close prices\n", - "plt.figure(figsize=(14,7))\n", - "plt.plot(data['Close'])\n", - "plt.title('YTD Stock Price Change for META and TESLA')\n", - "plt.xlabel('Date')\n", - "plt.ylabel('Price (USD)')\n", - "plt.legend(tickerSymbols)\n", - "plt.grid(True)\n", - "plt.show()\n", - "```\n", - "\n", - "This code will plot the closing prices of META and TESLA stocks from the start of this year to the current date. The prices are in USD.\n", - "\n", - "--------------------------------------------------------------------------------\n", - "\n", - ">>>>>>>> USING AUTO REPLY FOR THE USER...\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "Defaulting to user installation because normal site-packages is not writeable\n", - "Requirement already satisfied: yfinance in /home/vscode/.local/lib/python3.9/site-packages (0.2.26)\n", - "Requirement already satisfied: pandas>=1.3.0 in /home/vscode/.local/lib/python3.9/site-packages (from yfinance) (2.0.3)\n", - "Requirement already satisfied: lxml>=4.9.1 in /home/vscode/.local/lib/python3.9/site-packages (from yfinance) (4.9.3)\n", - "Requirement already satisfied: appdirs>=1.4.4 in /home/vscode/.local/lib/python3.9/site-packages (from yfinance) (1.4.4)\n", - "Requirement already satisfied: numpy>=1.16.5 in /home/vscode/.local/lib/python3.9/site-packages (from yfinance) (1.25.1)\n", - "Requirement already satisfied: html5lib>=1.1 in /home/vscode/.local/lib/python3.9/site-packages (from yfinance) (1.1)\n", - "Requirement already satisfied: pytz>=2022.5 in /home/vscode/.local/lib/python3.9/site-packages (from yfinance) (2023.3)\n", - "Requirement already satisfied: beautifulsoup4>=4.11.1 in /home/vscode/.local/lib/python3.9/site-packages (from yfinance) (4.12.2)\n", - "Requirement already satisfied: frozendict>=2.3.4 in /home/vscode/.local/lib/python3.9/site-packages (from yfinance) (2.3.8)\n", - "Requirement already satisfied: requests>=2.31 in /usr/local/lib/python3.9/site-packages (from yfinance) (2.31.0)\n", - "Requirement already satisfied: multitasking>=0.0.7 in /home/vscode/.local/lib/python3.9/site-packages (from yfinance) (0.0.11)\n", - "Requirement already satisfied: soupsieve>1.2 in /home/vscode/.local/lib/python3.9/site-packages (from beautifulsoup4>=4.11.1->yfinance) (2.4.1)\n", - "Requirement already satisfied: webencodings in /home/vscode/.local/lib/python3.9/site-packages (from html5lib>=1.1->yfinance) (0.5.1)\n", - "Requirement already satisfied: six>=1.9 in /usr/local/lib/python3.9/site-packages (from html5lib>=1.1->yfinance) (1.16.0)\n", - "Requirement already satisfied: tzdata>=2022.1 in /home/vscode/.local/lib/python3.9/site-packages (from pandas>=1.3.0->yfinance) (2023.3)\n", - "Requirement already satisfied: python-dateutil>=2.8.2 in /home/vscode/.local/lib/python3.9/site-packages (from pandas>=1.3.0->yfinance) (2.8.2)\n", - "Requirement already satisfied: charset-normalizer<4,>=2 in /usr/local/lib/python3.9/site-packages (from requests>=2.31->yfinance) (3.2.0)\n", - "Requirement already satisfied: certifi>=2017.4.17 in /usr/local/lib/python3.9/site-packages (from requests>=2.31->yfinance) (2023.5.7)\n", - "Requirement already satisfied: idna<4,>=2.5 in /usr/local/lib/python3.9/site-packages (from requests>=2.31->yfinance) (3.4)\n", - "Requirement already satisfied: urllib3<3,>=1.21.1 in /usr/local/lib/python3.9/site-packages (from requests>=2.31->yfinance) (2.0.3)\n", - "\n", - "\u001b[1m[\u001b[0m\u001b[34;49mnotice\u001b[0m\u001b[1;39;49m]\u001b[0m\u001b[39;49m A new release of pip is available: \u001b[0m\u001b[31;49m23.0.1\u001b[0m\u001b[39;49m -> \u001b[0m\u001b[32;49m23.2\u001b[0m\n", - "\u001b[1m[\u001b[0m\u001b[34;49mnotice\u001b[0m\u001b[1;39;49m]\u001b[0m\u001b[39;49m To update, run: \u001b[0m\u001b[32;49mpip install --upgrade pip\u001b[0m\n", - "[*********************100%***********************] 2 of 2 completed\n" - ] - }, - { - "data": { - "image/png": "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", - "text/plain": [ - "
" - ] - }, - "metadata": {}, - "output_type": "display_data" - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "ipython_user (to assistant):\n", - "\n", - "exitcode: 0 (execution succeeded)\n", - "Code output: \n", - "None\n", - "None\n", - "\n", - "--------------------------------------------------------------------------------\n", - "assistant (to ipython_user):\n", - "\n", - "It seems like the code executed successfully but didn't produce any output. This could be due to the fact that the IPython environment you're using might not support matplotlib's interactive mode. \n", - "\n", - "Let's try a different approach using pandas' built-in plotting function, which should work in any environment. \n", - "\n", - "```python\n", - "# Python code\n", - "import yfinance as yf\n", - "import pandas as pd\n", - "from datetime import datetime\n", - "\n", - "# Define the ticker symbol\n", - "tickerSymbols = ['META', 'TSLA']\n", - "\n", - "# Get data on this ticker\n", - "start_date = datetime(datetime.now().year, 1, 1)\n", - "end_date = datetime.now()\n", - "\n", - "# Fetch the data\n", - "data = yf.download(tickerSymbols, start=start_date, end=end_date)\n", - "\n", - "# Plot the close prices\n", - "data['Close'].plot(title='YTD Stock Price Change for META and TESLA', figsize=(14,7), grid=True)\n", - "```\n", - "\n", - "This code does the same thing as the previous one, but uses pandas' built-in plot function instead of matplotlib. The plot should appear directly in your IPython environment.\n", - "\n", - "--------------------------------------------------------------------------------\n", - "\n", - ">>>>>>>> USING AUTO REPLY FOR THE USER...\n", - "[*********************100%***********************] 2 of 2 completed\n" - ] - }, - { - "data": { - "text/plain": [ - "" - ] - }, - "execution_count": 7, - "metadata": {}, - "output_type": "execute_result" - }, - { - "data": { - "image/png": "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", - "text/plain": [ - "
" - ] - }, - "metadata": {}, - "output_type": "display_data" - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "ipython_user (to assistant):\n", - "\n", - "exitcode: 0 (execution succeeded)\n", - "Code output: \n", - "Axes(0.125,0.2;0.775x0.68)\n", - "\n", - "--------------------------------------------------------------------------------\n", - "assistant (to ipython_user):\n", - "\n", - "Great! The code executed successfully. The output `Axes(0.125,0.2;0.775x0.68)` is just a representation of the plot object. The actual plot should be displayed in your IPython environment. \n", - "\n", - "The plot should show the YTD stock price change for META and TESLA. The x-axis represents the date and the y-axis represents the closing price in USD. \n", - "\n", - "If you can see the plot and it meets your requirements, then we are done here. \n", - "\n", - "TERMINATE\n", - "\n", - "--------------------------------------------------------------------------------\n" - ] - } - ], - "source": [ - "ipy_user = IPythonUserProxyAgent(\n", - " \"ipython_user\",\n", - " human_input_mode=\"NEVER\",\n", - " max_consecutive_auto_reply=10,\n", - " is_termination_msg=lambda x: x.get(\"content\", \"\").rstrip().endswith(\"TERMINATE\") or x.get(\"content\", \"\").rstrip().endswith('\"TERMINATE\".'),\n", - ")\n", - "assistant.reset()\n", - "# the assistant receives a message from the user, which contains the task description\n", - "ipy_user.initiate_chat(\n", - " assistant,\n", - " message=\"\"\"Plot a chart of META and TESLA stock price change YTD\"\"\",\n", - ")" - ] - } - ], - "metadata": { - "kernelspec": { - "display_name": "Python 3", - "language": "python", - "name": "python3" - }, - "language_info": { - "codemirror_mode": { - "name": "ipython", - "version": 3 - }, - "file_extension": ".py", - "mimetype": "text/x-python", - "name": "python", - "nbconvert_exporter": "python", - "pygments_lexer": "ipython3", - "version": "3.9.17" - }, - "vscode": { - "interpreter": { - "hash": "949777d72b0d2535278d3dc13498b2535136f6dfe0678499012e853ee9abcab1" - } - }, - "widgets": { - "application/vnd.jupyter.widget-state+json": { - "state": { - "2d910cfd2d2a4fc49fc30fbbdc5576a7": { - "model_module": "@jupyter-widgets/base", - "model_module_version": "2.0.0", - "model_name": "LayoutModel", - "state": { - "_model_module": "@jupyter-widgets/base", - "_model_module_version": "2.0.0", - "_model_name": "LayoutModel", - "_view_count": null, - "_view_module": "@jupyter-widgets/base", - "_view_module_version": "2.0.0", - "_view_name": "LayoutView", - "align_content": null, - "align_items": null, - "align_self": null, - "border_bottom": null, - "border_left": null, - "border_right": null, - "border_top": null, - "bottom": null, - "display": null, - "flex": null, - "flex_flow": null, - "grid_area": null, - "grid_auto_columns": null, - "grid_auto_flow": null, - "grid_auto_rows": null, - "grid_column": null, - "grid_gap": null, - "grid_row": null, - "grid_template_areas": null, - "grid_template_columns": null, - "grid_template_rows": null, - "height": null, - "justify_content": null, - "justify_items": null, - "left": null, - "margin": null, - "max_height": null, - "max_width": null, - "min_height": null, - "min_width": null, - "object_fit": null, - "object_position": null, - "order": null, - "overflow": null, - "padding": null, - "right": null, - "top": null, - "visibility": null, - "width": null - } - }, - "454146d0f7224f038689031002906e6f": { - "model_module": "@jupyter-widgets/controls", - "model_module_version": "2.0.0", - "model_name": "HBoxModel", - "state": { - "_dom_classes": [], - "_model_module": "@jupyter-widgets/controls", - "_model_module_version": "2.0.0", - "_model_name": "HBoxModel", - "_view_count": null, - "_view_module": "@jupyter-widgets/controls", - "_view_module_version": "2.0.0", - "_view_name": "HBoxView", - "box_style": "", - "children": [ - "IPY_MODEL_e4ae2b6f5a974fd4bafb6abb9d12ff26", - "IPY_MODEL_577e1e3cc4db4942b0883577b3b52755", - "IPY_MODEL_b40bdfb1ac1d4cffb7cefcb870c64d45" - ], - "layout": "IPY_MODEL_dc83c7bff2f241309537a8119dfc7555", - "tabbable": null, - "tooltip": null - } - }, - "577e1e3cc4db4942b0883577b3b52755": { - "model_module": "@jupyter-widgets/controls", - "model_module_version": "2.0.0", - "model_name": "FloatProgressModel", - "state": { - "_dom_classes": [], - "_model_module": "@jupyter-widgets/controls", - "_model_module_version": "2.0.0", - "_model_name": "FloatProgressModel", - "_view_count": null, - "_view_module": "@jupyter-widgets/controls", - "_view_module_version": "2.0.0", - "_view_name": "ProgressView", - "bar_style": "success", - "description": "", - "description_allow_html": false, - "layout": "IPY_MODEL_2d910cfd2d2a4fc49fc30fbbdc5576a7", - "max": 1, - "min": 0, - "orientation": "horizontal", - "style": "IPY_MODEL_74a6ba0c3cbc4051be0a83e152fe1e62", - "tabbable": null, - "tooltip": null, - "value": 1 - } - }, - "6086462a12d54bafa59d3c4566f06cb2": { - "model_module": "@jupyter-widgets/base", - "model_module_version": "2.0.0", - "model_name": "LayoutModel", - "state": { - "_model_module": "@jupyter-widgets/base", - "_model_module_version": "2.0.0", - "_model_name": "LayoutModel", - "_view_count": null, - "_view_module": "@jupyter-widgets/base", - "_view_module_version": "2.0.0", - "_view_name": "LayoutView", - "align_content": null, - "align_items": null, - "align_self": null, - "border_bottom": null, - "border_left": null, - "border_right": null, - "border_top": null, - "bottom": null, - "display": null, - "flex": null, - "flex_flow": null, - "grid_area": null, - "grid_auto_columns": null, - "grid_auto_flow": null, - "grid_auto_rows": null, - "grid_column": null, - "grid_gap": null, - "grid_row": null, - "grid_template_areas": null, - "grid_template_columns": null, - "grid_template_rows": null, - "height": null, - "justify_content": null, - "justify_items": null, - "left": null, - "margin": null, - "max_height": null, - "max_width": null, - "min_height": null, - "min_width": null, - "object_fit": null, - "object_position": null, - "order": null, - "overflow": null, - "padding": null, - "right": null, - "top": null, - "visibility": null, - "width": null - } - }, - "74a6ba0c3cbc4051be0a83e152fe1e62": { - "model_module": "@jupyter-widgets/controls", - "model_module_version": "2.0.0", - "model_name": "ProgressStyleModel", - "state": { - "_model_module": "@jupyter-widgets/controls", - "_model_module_version": "2.0.0", - "_model_name": "ProgressStyleModel", - "_view_count": null, - "_view_module": "@jupyter-widgets/base", - "_view_module_version": "2.0.0", - "_view_name": "StyleView", - "bar_color": null, - "description_width": "" - } - }, - "7d3f3d9e15894d05a4d188ff4f466554": { - "model_module": "@jupyter-widgets/controls", - "model_module_version": "2.0.0", - "model_name": "HTMLStyleModel", - "state": { - "_model_module": "@jupyter-widgets/controls", - "_model_module_version": "2.0.0", - "_model_name": "HTMLStyleModel", - "_view_count": null, - "_view_module": "@jupyter-widgets/base", - "_view_module_version": "2.0.0", - "_view_name": "StyleView", - "background": null, - "description_width": "", - "font_size": null, - "text_color": null - } - }, - "b40bdfb1ac1d4cffb7cefcb870c64d45": { - "model_module": "@jupyter-widgets/controls", - "model_module_version": "2.0.0", - "model_name": "HTMLModel", - "state": { - "_dom_classes": [], - "_model_module": "@jupyter-widgets/controls", - "_model_module_version": "2.0.0", - "_model_name": "HTMLModel", - "_view_count": null, - "_view_module": "@jupyter-widgets/controls", - "_view_module_version": "2.0.0", - "_view_name": "HTMLView", - "description": "", - "description_allow_html": false, - "layout": "IPY_MODEL_f1355871cc6f4dd4b50d9df5af20e5c8", - "placeholder": "​", - "style": "IPY_MODEL_ca245376fd9f4354af6b2befe4af4466", - "tabbable": null, - "tooltip": null, - "value": " 1/1 [00:00<00:00, 44.69it/s]" - } - }, - "ca245376fd9f4354af6b2befe4af4466": { - "model_module": "@jupyter-widgets/controls", - "model_module_version": "2.0.0", - "model_name": "HTMLStyleModel", - "state": { - "_model_module": "@jupyter-widgets/controls", - "_model_module_version": "2.0.0", - "_model_name": "HTMLStyleModel", - "_view_count": null, - "_view_module": "@jupyter-widgets/base", - "_view_module_version": "2.0.0", - "_view_name": "StyleView", - "background": null, - "description_width": "", - "font_size": null, - "text_color": null - } - }, - "dc83c7bff2f241309537a8119dfc7555": { - "model_module": "@jupyter-widgets/base", - "model_module_version": "2.0.0", - "model_name": "LayoutModel", - "state": { - "_model_module": "@jupyter-widgets/base", - "_model_module_version": "2.0.0", - "_model_name": "LayoutModel", - "_view_count": null, - "_view_module": "@jupyter-widgets/base", - "_view_module_version": "2.0.0", - "_view_name": "LayoutView", - "align_content": null, - "align_items": null, - "align_self": null, - "border_bottom": null, - "border_left": null, - "border_right": null, - "border_top": null, - "bottom": null, - "display": null, - "flex": null, - "flex_flow": null, - "grid_area": null, - "grid_auto_columns": null, - "grid_auto_flow": null, - "grid_auto_rows": null, - "grid_column": null, - "grid_gap": null, - "grid_row": null, - "grid_template_areas": null, - "grid_template_columns": null, - "grid_template_rows": null, - "height": null, - "justify_content": null, - "justify_items": null, - "left": null, - "margin": null, - "max_height": null, - "max_width": null, - "min_height": null, - "min_width": null, - "object_fit": null, - "object_position": null, - "order": null, - "overflow": null, - "padding": null, - "right": null, - "top": null, - "visibility": null, - "width": null - } - }, - "e4ae2b6f5a974fd4bafb6abb9d12ff26": { - "model_module": "@jupyter-widgets/controls", - "model_module_version": "2.0.0", - "model_name": "HTMLModel", - "state": { - "_dom_classes": [], - "_model_module": "@jupyter-widgets/controls", - "_model_module_version": "2.0.0", - "_model_name": "HTMLModel", - "_view_count": null, - "_view_module": "@jupyter-widgets/controls", - "_view_module_version": "2.0.0", - "_view_name": "HTMLView", - "description": "", - "description_allow_html": false, - "layout": "IPY_MODEL_6086462a12d54bafa59d3c4566f06cb2", - "placeholder": "​", - "style": "IPY_MODEL_7d3f3d9e15894d05a4d188ff4f466554", - "tabbable": null, - "tooltip": null, - "value": "100%" - } - }, - "f1355871cc6f4dd4b50d9df5af20e5c8": { - "model_module": "@jupyter-widgets/base", - "model_module_version": "2.0.0", - "model_name": "LayoutModel", - "state": { - "_model_module": "@jupyter-widgets/base", - "_model_module_version": "2.0.0", - "_model_name": "LayoutModel", - "_view_count": null, - "_view_module": "@jupyter-widgets/base", - "_view_module_version": "2.0.0", - "_view_name": "LayoutView", - "align_content": null, - "align_items": null, - "align_self": null, - "border_bottom": null, - "border_left": null, - "border_right": null, - "border_top": null, - "bottom": null, - "display": null, - "flex": null, - "flex_flow": null, - "grid_area": null, - "grid_auto_columns": null, - "grid_auto_flow": null, - "grid_auto_rows": null, - "grid_column": null, - "grid_gap": null, - "grid_row": null, - "grid_template_areas": null, - "grid_template_columns": null, - "grid_template_rows": null, - "height": null, - "justify_content": null, - "justify_items": null, - "left": null, - "margin": null, - "max_height": null, - "max_width": null, - "min_height": null, - "min_width": null, - "object_fit": null, - "object_position": null, - "order": null, - "overflow": null, - "padding": null, - "right": null, - "top": null, - "visibility": null, - "width": null - } - } - }, - "version_major": 2, - "version_minor": 0 - } - } - }, - "nbformat": 4, - "nbformat_minor": 2 -} diff --git a/notebook/autogen_agent_function_call.ipynb b/notebook/autogen_agent_function_call.ipynb deleted file mode 100644 index 2e8cf555ff..0000000000 --- a/notebook/autogen_agent_function_call.ipynb +++ /dev/null @@ -1,458 +0,0 @@ -{ - "cells": [ - { - "attachments": {}, - "cell_type": "markdown", - "id": "ae1f50ec", - "metadata": {}, - "source": [ - "\"Open" - ] - }, - { - "attachments": {}, - "cell_type": "markdown", - "id": "9a71fa36", - "metadata": {}, - "source": [ - "# Interative LLM Agent with Function Calls\n", - "\n", - "FLAML offers an experimental feature of interactive LLM agents, which can be used to solve various tasks with human or automatic feedback, including tasks that require using tools via code. Please find documentation about this feature [here](https://microsoft.github.io/FLAML/docs/Use-Cases/Auto-Generation#agents-experimental).\n", - "\n", - "In this notebook, we demonstrate how to use `AssistantAgent` and `UserProxyAgent` to make function calls with the new feature of OpenAI models (in model version 0613). A specified prompt and function configs need to be passed to `AssistantAgent` to initialize the agent. The corresponding functions need to be passed to `UserProxyAgent`, which will be responsible for executing any function calls made by `AssistantAgent`. Besides this requirement of matching descriptions with functions, we recommend checking the system prompt to make sure the instructions align with the function call descriptions.\n", - "\n", - "## Requirements\n", - "\n", - "FLAML requires `Python>=3.8`. To run this notebook example, please install flaml with the [mathchat] option since we will import functions from `MathUserProxyAgent`:\n", - "```bash\n", - "pip install flaml[mathchat]\n", - "```" - ] - }, - { - "cell_type": "code", - "execution_count": 1, - "id": "2b803c17", - "metadata": {}, - "outputs": [], - "source": [ - "# %pip install flaml[mathchat]~=2.0.0rc4" - ] - }, - { - "attachments": {}, - "cell_type": "markdown", - "id": "5ebd2397", - "metadata": {}, - "source": [ - "## Set your API Endpoint\n", - "\n", - "The [`config_list_from_models`](https://microsoft.github.io/FLAML/docs/reference/autogen/oai/openai_utils#config_list_from_models) function tries to create a list of configurations using Azure OpenAI endpoints and OpenAI endpoints for the provided list of models. It assumes the api keys and api bases are stored in the corresponding environment variables or local txt files:\n", - "\n", - "- OpenAI API key: os.environ[\"OPENAI_API_KEY\"] or `openai_api_key_file=\"key_openai.txt\"`.\n", - "- Azure OpenAI API key: os.environ[\"AZURE_OPENAI_API_KEY\"] or `aoai_api_key_file=\"key_aoai.txt\"`. Multiple keys can be stored, one per line.\n", - "- Azure OpenAI API base: os.environ[\"AZURE_OPENAI_API_BASE\"] or `aoai_api_base_file=\"base_aoai.txt\"`. Multiple bases can be stored, one per line.\n", - "\n", - "It's OK to have only the OpenAI API key, or only the Azure OpenAI API key + base.\n", - "If you open this notebook in google colab, you can upload your files by click the file icon on the left panel and then choose \"upload file\" icon.\n", - "\n", - "The following code excludes Azure OpenAI endpoints from the config list because they don't support functions yet. Remove the `exclude` argument after they do." - ] - }, - { - "cell_type": "code", - "execution_count": 3, - "id": "dca301a4", - "metadata": {}, - "outputs": [], - "source": [ - "from flaml import oai\n", - "\n", - "config_list = oai.config_list_from_models(model_list=[\"gpt-4\", \"gpt-3.5-turbo\", \"gpt-3.5-turbo-16k\"], exclude=\"aoai\")" - ] - }, - { - "attachments": {}, - "cell_type": "markdown", - "id": "92fde41f", - "metadata": {}, - "source": [ - "The config list looks like the following:\n", - "```python\n", - "config_list = [\n", - " {\n", - " 'model': 'gpt-4',\n", - " 'api_key': '',\n", - " }, # OpenAI API endpoint for gpt-4\n", - " {\n", - " 'model': 'gpt-3.5-turbo',\n", - " 'api_key': '',\n", - " }, # OpenAI API endpoint for gpt-3.5-turbo\n", - " {\n", - " 'model': 'gpt-3.5-turbo-16k',\n", - " 'api_key': '',\n", - " }, # OpenAI API endpoint for gpt-3.5-turbo-16k\n", - "]\n", - "```\n" - ] - }, - { - "attachments": {}, - "cell_type": "markdown", - "id": "2b9526e7", - "metadata": {}, - "source": [ - "## Making Function Calls\n", - "\n", - "In this example, we demonstrate function call execution with `AssistantAgent` and `UserProxyAgent`. With the default system prompt of `AssistantAgent`, we allow the LLM assistant to perform tasks with code, and the `UserProxyAgent` would extract code blocks from the LLM response and execute them. With the new \"function_call\" feature, we define a new function using the pre-defined `execute_code` from `UserProxyAgent` and specify the description of the function in the OpenAI config. \n", - "\n", - "Then, the model has two paths to execute code:\n", - "1. Put the code blocks in the response. `UserProxyAgent` will extract and execute the code through `execute_code` method in the class.\n", - "2. As we put a function description to OpenAI config and register a function `exec_code` in `UserProxyAgent`, the model can also make function calls (will be put in `function_call` field of the API reply). `UserProxyAgent` will execute the function call through the registered `exec_code` method." - ] - }, - { - "cell_type": "code", - "execution_count": 2, - "id": "9fb85afb", - "metadata": {}, - "outputs": [ - { - "name": "stdout", - "output_type": "stream", - "text": [ - "user (to chatbot):\n", - "\n", - "Draw a rocket and save to a file named 'rocket.svg'\n", - "\n", - "--------------------------------------------------------------------------------\n", - "chatbot (to user):\n", - "\n", - "You can use the `svgwrite` library for Python to draw images into SVG format. Before we draw the rocket, you need to install the library. Use the code below to install it.\n", - "\n", - "```sh\n", - "pip install svgwrite\n", - "```\n", - "\n", - "After installing the library, here is the python code you can use to draw a rocket and save it to a file named 'rocket.svg':\n", - "\n", - "```python\n", - "# filename: draw_rocket.py\n", - "\n", - "import svgwrite\n", - "\n", - "def draw_rocket():\n", - " dwg = svgwrite.Drawing('rocket.svg', profile='tiny')\n", - "\n", - " # Draw rocket body\n", - " dwg.add(dwg.rect((50, 20), (20, 40), fill='grey'))\n", - "\n", - " # Draw top of rocket\n", - " dwg.add(dwg.polygon(points=[(50, 20), (60, 0), (70, 20)], fill='red'))\n", - "\n", - " # Draw bottom of rocket\n", - " dwg.add(dwg.polygon(points=[(50, 60), (60, 80), (70, 60)], fill='red'))\n", - "\n", - " # Draw rocket window\n", - " dwg.add(dwg.circle(center=(60, 40), r=5, fill='blue'))\n", - "\n", - " dwg.save()\n", - "\n", - "draw_rocket()\n", - "```\n", - "You can run this code using Python by calling `python draw_rocket.py`. After running this script, you will have a file named `rocket.svg` in your current directory. The SVG picture represents a simple rocket with a gray body, red top and bottom, and a blue window. \n", - "\n", - "Please replace the `draw_rocket.py` with your actual python filename when you execute the script.\n", - "\n", - "--------------------------------------------------------------------------------\n", - "\n", - ">>>>>>>> NO HUMAN INPUT RECEIVED. USING AUTO REPLY FOR THE USER...\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "user (to chatbot):\n", - "\n", - "exitcode: 0 (execution succeeded)\n", - "Code output: \n", - "Collecting svgwrite\n", - " Downloading svgwrite-1.4.3-py3-none-any.whl (67 kB)\n", - " ━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━ 67.1/67.1 kB 3.2 MB/s eta 0:00:00\n", - "Installing collected packages: svgwrite\n", - "Successfully installed svgwrite-1.4.3\n", - "WARNING: Running pip as the 'root' user can result in broken permissions and conflicting behaviour with the system package manager. It is recommended to use a virtual environment instead: https://pip.pypa.io/warnings/venv\n", - "\n", - "\n", - "\n", - "--------------------------------------------------------------------------------\n", - "chatbot (to user):\n", - "\n", - "***** Suggested function Call: execute_code *****\n", - "Arguments: \n", - "{\n", - " \"code_type\": \"python\",\n", - " \"code\": \"import svgwrite\\n\\ndef draw_rocket():\\n dwg = svgwrite.Drawing('rocket.svg', profile='tiny')\\n\\n # Draw rocket body\\n dwg.add(dwg.rect((50, 20), (20, 40), fill='grey'))\\n\\n # Draw top of rocket\\n dwg.add(dwg.polygon(points=[(50, 20), (60, 0), (70, 20)], fill='red'))\\n\\n # Draw bottom of rocket\\n dwg.add(dwg.polygon(points=[(50, 60), (60, 80), (70, 60)], fill='red'))\\n\\n # Draw rocket window\\n dwg.add(dwg.circle(center=(60, 40), r=5, fill='blue'))\\n\\n dwg.save()\\n\\ndraw_rocket()\"\n", - "}\n", - "*************************************************\n", - "\n", - "--------------------------------------------------------------------------------\n", - "\n", - ">>>>>>>> NO HUMAN INPUT RECEIVED. USING AUTO REPLY FOR THE USER...\n", - "user (to chatbot):\n", - "\n", - "***** Response from calling function \"execute_code\" *****\n", - "(0, '\\n')\n", - "*********************************************************\n", - "\n", - "--------------------------------------------------------------------------------\n", - "chatbot (to user):\n", - "\n", - "Great! The code to draw the rocket and save it to 'rocket.svg' should have successfully executed. \n", - "\n", - "You should now be able to find the file 'rocket.svg' in your current directory and open it with an application that can handle SVG files (a web browser, for instance).\n", - "\n", - "Is there anything else you need help with? If not, please reply 'TERMINATE'.\n", - "\n", - "--------------------------------------------------------------------------------\n", - "\n", - ">>>>>>>> NO HUMAN INPUT RECEIVED. USING AUTO REPLY FOR THE USER...\n", - "user (to chatbot):\n", - "\n", - "\n", - "\n", - "--------------------------------------------------------------------------------\n", - "chatbot (to user):\n", - "\n", - "TERMINATE\n", - "\n", - "--------------------------------------------------------------------------------\n" - ] - } - ], - "source": [ - "from flaml.autogen.agent import AssistantAgent, UserProxyAgent\n", - "\n", - "oai_config = {\n", - " \"functions\": [\n", - " {\n", - " \"name\": \"execute_code\",\n", - " \"description\": \"Receive a python code or shell script and return the execution result.\",\n", - " \"parameters\": {\n", - " \"type\": \"object\",\n", - " \"properties\": {\n", - " \"code_type\": {\n", - " \"type\": \"string\",\n", - " \"description\": \"Code type, 'python' or 'sh'.\",\n", - " },\n", - " \"code\": {\n", - " \"type\": \"string\",\n", - " \"description\": \"Valid Python code to execute.\",\n", - " }\n", - " },\n", - " \"required\": [\"code_type\", \"code\"],\n", - " },\n", - " }\n", - " ],\n", - " \"config_list\": config_list,\n", - "}\n", - "chatbot = AssistantAgent(\"chatbot\", oai_config=oai_config)\n", - "\n", - "# create a UserProxyAgent instance named \"user\"\n", - "user = UserProxyAgent(\n", - " \"user\",\n", - " human_input_mode=\"NEVER\",\n", - " code_execution_config={\"work_dir\": \"coding\"},\n", - ")\n", - "\n", - "# define an `execute_code` function according to the function desription\n", - "def exec_code(code_type, code):\n", - " # here we reuse the method in the user proxy agent\n", - " # in general, this is not necessary\n", - " return user.execute_code_blocks([(code_type, code)])\n", - "\n", - "# register the `execute_code` function\n", - "user.register_function(function_map={\"execute_code\": exec_code})\n", - "\n", - "# start the conversation\n", - "user.initiate_chat(\n", - " chatbot,\n", - " message=\"Draw a rocket and save to a file named 'rocket.svg'\",\n", - ")\n" - ] - }, - { - "cell_type": "code", - "execution_count": 10, - "id": "42cee331", - "metadata": {}, - "outputs": [ - { - "data": { - "image/svg+xml": [ - "" - ], - "text/plain": [ - "" - ] - }, - "metadata": {}, - "output_type": "display_data" - } - ], - "source": [ - "# uncomment the following to render the svg file\n", - "# from IPython.display import SVG, display\n", - "\n", - "# display(SVG(\"coding/rocket.svg\"))" - ] - }, - { - "attachments": {}, - "cell_type": "markdown", - "id": "e9531d55", - "metadata": {}, - "source": [ - "## Another example with Wolfram Alpha API\n", - "\n", - "We give another example of query Wolfram Alpha API to solve math problem. We use the predefined function `MathUserProxyAgent().execute_one_wolfram_query` as the function to be called." - ] - }, - { - "cell_type": "code", - "execution_count": 5, - "id": "4a917492", - "metadata": {}, - "outputs": [ - { - "name": "stdout", - "output_type": "stream", - "text": [ - "user (to chatbot):\n", - "\n", - "Problem: Find all $x$ that satisfy the inequality $(2x+10)(x+3)<(3x+9)(x+8)$. Express your answer in interval notation.\n", - "\n", - "--------------------------------------------------------------------------------\n", - "chatbot (to user):\n", - "\n", - "***** Suggested function Call: query_wolfram *****\n", - "Arguments: \n", - "{\n", - " \"query\": \"solve (2x+10)(x+3) < (3x+9)(x+8) for x\"\n", - "}\n", - "**************************************************\n", - "\n", - "--------------------------------------------------------------------------------\n", - "\n", - ">>>>>>>> NO HUMAN INPUT RECEIVED. USING AUTO REPLY FOR THE USER...\n", - "user (to chatbot):\n", - "\n", - "***** Response from calling function \"query_wolfram\" *****\n", - "('Assumption: solve (2 x + 10) (x + 3)<(3 x + 9) (x + 8) for x \\nAnswer: ans 0: x<-14\\nans 1: x>-3\\n', True)\n", - "**********************************************************\n", - "\n", - "--------------------------------------------------------------------------------\n", - "chatbot (to user):\n", - "\n", - "The solution to the inequality $(2x+10)(x+3)<(3x+9)(x+8)$ is $x \\in (-\\infty, -14) \\cup (-3, +\\infty)$.\n", - "\n", - "To express in interval notation, the answer is $(-\\infty, -14) \\cup (-3, \\infty)$. \n", - "\n", - "TERMINATE.\n", - "\n", - "--------------------------------------------------------------------------------\n", - "\n", - ">>>>>>>> NO HUMAN INPUT RECEIVED. USING AUTO REPLY FOR THE USER...\n", - "user (to chatbot):\n", - "\n", - "\n", - "\n", - "--------------------------------------------------------------------------------\n", - "chatbot (to user):\n", - "\n", - "TERMINATE\n", - "\n", - "--------------------------------------------------------------------------------\n" - ] - } - ], - "source": [ - "import os\n", - "from flaml.autogen.agent import AssistantAgent, UserProxyAgent\n", - "from flaml.autogen.agent.math_user_proxy_agent import MathUserProxyAgent\n", - "\n", - "# you need to provide a wolfram alpha appid to run this example\n", - "if not os.environ.get(\"WOLFRAM_ALPHA_APPID\"):\n", - " os.environ[\"WOLFRAM_ALPHA_APPID\"] = open(\"wolfram.txt\").read().strip()\n", - "\n", - "\n", - "sys_prompt = \"\"\"You are an advanced AI with the capability to solve complex math problems.\n", - "Wolfram alpha is provided as an external service to help you solve math problems.\n", - "\n", - "When the user gives a math problem, please use the most efficient way to solve the problem.\n", - "You are encouraged to use Wolfram alpha whenever it is possible during the solving process. For example, simplications, calculations, equation solving, etc.\n", - "However, if the operation requires little computation (very simple calculations, etc), you can also solve it directly.\n", - "Reply \"TERMINATE\" in the end when everything is done.\n", - "\"\"\"\n", - "oai_config = {\n", - " \"model\": \"gpt-4-0613\",\n", - " \"functions\": [\n", - " {\n", - " \"name\": \"query_wolfram\",\n", - " \"description\": \"Return the API query result from the Wolfram Alpha. the ruturn is a tuple of (result, is_success).\",\n", - " \"parameters\": {\n", - " \"type\": \"object\",\n", - " \"properties\": {\n", - " \"query\": {\n", - " \"type\": \"string\",\n", - " \"description\": \"The Wolfram Alpha code to be executed.\",\n", - " }\n", - " },\n", - " \"required\": [\"query\"],\n", - " },\n", - " }\n", - " ],\n", - " \"config_list\": config_list,\n", - "}\n", - "chatbot = AssistantAgent(\"chatbot\", system_message=sys_prompt, oai_config=oai_config)\n", - "\n", - "# the key in `function_map` should match the function name in \"functions\" above\n", - "# we register a class instance method directly\n", - "user = UserProxyAgent(\n", - " \"user\",\n", - " max_consecutive_auto_reply=2,\n", - " human_input_mode=\"NEVER\",\n", - " function_map={\"query_wolfram\": MathUserProxyAgent().execute_one_wolfram_query},\n", - ")\n", - "\n", - "# start the conversation\n", - "user.initiate_chat(\n", - " chatbot,\n", - " message=\"Problem: Find all $x$ that satisfy the inequality $(2x+10)(x+3)<(3x+9)(x+8)$. Express your answer in interval notation.\",\n", - ")\n" - ] - } - ], - "metadata": { - "kernelspec": { - "display_name": "flaml_dev", - "language": "python", - "name": "python3" - }, - "language_info": { - "codemirror_mode": { - "name": "ipython", - "version": 3 - }, - "file_extension": ".py", - "mimetype": "text/x-python", - "name": "python", - "nbconvert_exporter": "python", - "pygments_lexer": "ipython3", - "version": "3.9.15" - } - }, - "nbformat": 4, - "nbformat_minor": 5 -} diff --git a/notebook/autogen_agentchat_MathChat.ipynb b/notebook/autogen_agentchat_MathChat.ipynb new file mode 100644 index 0000000000..8550e67ab7 --- /dev/null +++ b/notebook/autogen_agentchat_MathChat.ipynb @@ -0,0 +1,894 @@ +{ + "cells": [ + { + "attachments": {}, + "cell_type": "markdown", + "metadata": {}, + "source": [ + "\"Open" + ] + }, + { + "attachments": {}, + "cell_type": "markdown", + "metadata": {}, + "source": [ + "# Auto Generated Agent Chat: Using MathChat to Solve Math Problems\n", + "\n", + "MathChat is a convesational framework for math problem solving. In this notebook, we demonstrate how to use MathChat to solve math problems. MathChat uses the `AssistantAgent` and `MathUserProxyAgent`, which is similar to the usage of `AssistantAgent` and `UserProxyAgent` in other notebooks (e.g., [Automated Task Solving with Code Generation, Execution & Debugging](https://github.com/microsoft/FLAML/blob/main/notebook/autogen_agentchat_auto_feedback_from_code_execution.ipynb)). Essentially, `MathUserProxyAgent` implements a different auto reply mechanism corresponding to the MathChat prompts. The original implementation and exeperiments of MathChat are in this [branch](https://github.com/kevin666aa/FLAML/tree/gpt_math_solver/flaml/autogen/math), and you can find more details in our paper [An Empirical Study on Challenging Math Problem Solving with GPT-4](https://arxiv.org/abs/2306.01337).\n", + "\n", + "## Requirements\n", + "\n", + "FLAML requires `Python>=3.8`. To run this notebook example, please install flaml with the [mathchat] option.\n", + "```bash\n", + "pip install flaml[mathchat]\n", + "```" + ] + }, + { + "cell_type": "code", + "execution_count": 1, + "metadata": {}, + "outputs": [], + "source": [ + "# %pip install flaml[mathchat]~=2.0.0rc4" + ] + }, + { + "attachments": {}, + "cell_type": "markdown", + "metadata": {}, + "source": [ + "## Set your API Endpoint\n", + "\n", + "The [`config_list_from_json`](https://microsoft.github.io/FLAML/docs/reference/autogen/oai/openai_utils#config_list_from_json) function loads a list of configurations from an environment variable or a json file.\n" + ] + }, + { + "cell_type": "code", + "execution_count": 2, + "metadata": {}, + "outputs": [], + "source": [ + "from flaml import oai\n", + "\n", + "config_list = oai.config_list_from_json(\n", + " \"OAI_CONFIG_LIST\",\n", + " filter_dict={\n", + " \"model\": {\n", + " \"gpt-4\",\n", + " \"gpt4\",\n", + " \"gpt-4-32k\",\n", + " \"gpt-4-32k-0314\",\n", + " \"gpt-3.5-turbo\",\n", + " \"gpt-3.5-turbo-16k\",\n", + " \"gpt-3.5-turbo-0301\",\n", + " \"chatgpt-35-turbo-0301\",\n", + " \"gpt-35-turbo-v0301\",\n", + " }\n", + " }\n", + ")" + ] + }, + { + "attachments": {}, + "cell_type": "markdown", + "metadata": {}, + "source": [ + "It first looks for environment variable \"OAI_CONFIG_LIST\" which needs to be a valid json string. If that variable is not found, it then looks for a json file named \"OAI_CONFIG_LIST\". It filters the configs by models (you can filter by other keys as well). Only the gpt-4 and gpt-3.5-turbo models are kept in the list based on the filter condition.\n", + "\n", + "The config list looks like the following:\n", + "```python\n", + "config_list = [\n", + " {\n", + " 'model': 'gpt-4',\n", + " 'api_key': '',\n", + " },\n", + " {\n", + " 'model': 'gpt-4',\n", + " 'api_key': '',\n", + " 'api_base': '',\n", + " 'api_type': 'azure',\n", + " 'api_version': '2023-06-01-preview',\n", + " },\n", + " {\n", + " 'model': 'gpt-3.5-turbo',\n", + " 'api_key': '',\n", + " 'api_base': '',\n", + " 'api_type': 'azure',\n", + " 'api_version': '2023-06-01-preview',\n", + " },\n", + "]\n", + "```\n", + "\n", + "If you open this notebook in colab, you can upload your files by clicking the file icon on the left panel and then choose \"upload file\" icon.\n", + "\n", + "You can set the value of config_list in other ways you prefer, e.g., loading from a YAML file." + ] + }, + { + "attachments": {}, + "cell_type": "markdown", + "metadata": {}, + "source": [ + "## Construct agents for MathChat\n", + "\n", + "We start by initialzing the `AssistantAgent` and `MathUserProxyAgent`. The system message needs to be set to \"You are a helpful assistant.\" for MathChat. The detailed instructions are given in the user message. Later we will use the `MathUserProxyAgent.generate_init_message` to combine the instructions and a math problem for an initial message to be sent to the LLM assistant." + ] + }, + { + "cell_type": "code", + "execution_count": 3, + "metadata": {}, + "outputs": [], + "source": [ + "from flaml.autogen.agentchat import AssistantAgent\n", + "from flaml.autogen.agentchat.contrib.math_user_proxy_agent import MathUserProxyAgent\n", + "\n", + "oai.ChatCompletion.start_logging()\n", + "\n", + "# 1. create an AssistantAgent instance named \"assistant\"\n", + "assistant = AssistantAgent(\n", + " name=\"assistant\", \n", + " system_message=\"You are a helpful assistant.\",\n", + " oai_config={\n", + " \"request_timeout\": 600,\n", + " \"seed\": 42,\n", + " \"config_list\": config_list,\n", + " }\n", + ")\n", + "\n", + "# 2. create the MathUserProxyAgent instance named \"mathproxyagent\"\n", + "# By default, the human_input_mode is \"NEVER\", which means the agent will not ask for human input.\n", + "mathproxyagent = MathUserProxyAgent(\n", + " name=\"mathproxyagent\", \n", + " human_input_mode=\"NEVER\",\n", + " code_execution_config={\"use_docker\": False},\n", + ")" + ] + }, + { + "attachments": {}, + "cell_type": "markdown", + "metadata": {}, + "source": [ + "### Example 1\n", + "\n", + "Problem: Find all $x$ that satisfy the inequality $(2x+10)(x+3)<(3x+9)(x+8)$. Express your answer in interval notation.\n", + "\n", + "Correct Solution: \n", + "We have \\begin{align*} (2x+10)(x+3)&<(3x+9)(x+8) \\quad \\Rightarrow\n", + "\\\\ 2(x+5)(x+3)&<3(x+3)(x+8) \\quad \\Rightarrow\n", + "\\\\ 2(x+5)(x+3)-3(x+3)(x+8)&<0 \\quad \\Rightarrow\n", + "\\\\ (2x+10-(3x+24))(x+3)&<0 \\quad \\Rightarrow\n", + "\\\\ (-x-14)(x+3)&<0 \\quad \\Rightarrow\n", + "\\\\ (x+14)(x+3)&>0.\n", + "\\end{align*} This inequality is satisfied if and only if $(x+14)$ and $(x+3)$ are either both positive or both negative. Both factors are positive for $x>-3$ and both factors are negative for $x<-14$. When $-14\"Open" + ] + }, + { + "attachments": {}, + "cell_type": "markdown", + "metadata": { + "slideshow": { + "slide_type": "slide" + } + }, + "source": [ + "# Auto Generated Agent Chat: Task Solving with Code Generation, Execution & Debugging\n", + "\n", + "FLAML offers an experimental feature of interactive LLM agents, which can be used to solve various tasks with human or automatic feedback, including tasks that require using tools via code.\n", + "Please find documentation about this feature [here](https://microsoft.github.io/FLAML/docs/Use-Cases/Auto-Generation#agents-experimental).\n", + "\n", + "In this notebook, we demonstrate how to use `AssistantAgent` and `UserProxyAgent` to write code and execute the code. Here `AssistantAgent` is an LLM-based agent that can write Python code (in a Python coding block) for a user to execute for a given task. `UserProxyAgent` is an agent which serves as a proxy for the human user to execute the code written by `AssistantAgent`, or automatically execute the code. Depending on the setting of `human_input_mode` and `max_consecutive_auto_reply`, the `UserProxyAgent` either solicits feedback from the human user or returns auto-feedback based on the result of code execution (success or failure and corresponding outputs) to `AssistantAgent`. `AssistantAgent` will debug the code and suggest new code if the result contains error. The two agents keep communicating to each other until the task is done.\n", + "\n", + "## Requirements\n", + "\n", + "FLAML requires `Python>=3.8`. To run this notebook example, please install flaml with the [autogen] option:\n", + "```bash\n", + "pip install flaml[autogen]\n", + "```" + ] + }, + { + "cell_type": "code", + "execution_count": 1, + "metadata": { + "execution": { + "iopub.execute_input": "2023-02-13T23:40:52.317406Z", + "iopub.status.busy": "2023-02-13T23:40:52.316561Z", + "iopub.status.idle": "2023-02-13T23:40:52.321193Z", + "shell.execute_reply": "2023-02-13T23:40:52.320628Z" + } + }, + "outputs": [], + "source": [ + "# %pip install flaml[autogen]~=2.0.0rc4" + ] + }, + { + "attachments": {}, + "cell_type": "markdown", + "metadata": {}, + "source": [ + "## Set your API Endpoint\n", + "\n", + "The [`config_list_from_json`](https://microsoft.github.io/FLAML/docs/reference/autogen/oai/openai_utils#config_list_from_json) function loads a list of configurations from an environment variable or a json file.\n" + ] + }, + { + "cell_type": "code", + "execution_count": 2, + "metadata": {}, + "outputs": [], + "source": [ + "from flaml import oai\n", + "\n", + "config_list = oai.config_list_from_json(\n", + " \"OAI_CONFIG_LIST\",\n", + " filter_dict={\n", + " \"model\": [\"gpt-4\", \"gpt4\", \"gpt-4-32k\", \"gpt-4-32k-0314\"],\n", + " },\n", + ")" + ] + }, + { + "attachments": {}, + "cell_type": "markdown", + "metadata": {}, + "source": [ + "It first looks for environment variable \"OAI_CONFIG_LIST\" which needs to be a valid json string. If that variable is not found, it then looks for a json file named \"OAI_CONFIG_LIST\". It filters the configs by models (you can filter by other keys as well). Only the gpt-4 models are kept in the list based on the filter condition.\n", + "\n", + "The config list looks like the following:\n", + "```python\n", + "config_list = [\n", + " {\n", + " 'model': 'gpt-4',\n", + " 'api_key': '',\n", + " },\n", + " {\n", + " 'model': 'gpt-4',\n", + " 'api_key': '',\n", + " 'api_base': '',\n", + " 'api_type': 'azure',\n", + " 'api_version': '2023-06-01-preview',\n", + " },\n", + " {\n", + " 'model': 'gpt-4-32k',\n", + " 'api_key': '',\n", + " 'api_base': '',\n", + " 'api_type': 'azure',\n", + " 'api_version': '2023-06-01-preview',\n", + " },\n", + "]\n", + "```\n", + "\n", + "If you open this notebook in colab, you can upload your files by clicking the file icon on the left panel and then choose \"upload file\" icon.\n", + "\n", + "You can set the value of config_list in other ways you prefer, e.g., loading from a YAML file." + ] + }, + { + "attachments": {}, + "cell_type": "markdown", + "metadata": {}, + "source": [ + "## Example Task: Check Stock Price Change\n", + "\n", + "In the example below, let's see how to use the agents in FLAML to write a python script and execute the script. This process involves constructing a `AssistantAgent` to serve as the assistant, along with a `UserProxyAgent` that acts as a proxy for the human user. In this example demonstrated below, when constructing the `UserProxyAgent`, we select the `human_input_mode` to \"NEVER\". This means that the `UserProxyAgent` will not solicit feedback from the human user. It stops replying when the limit defined by `max_consecutive_auto_reply` is reached, or when `is_termination_msg()` returns true for the received message." + ] + }, + { + "cell_type": "code", + "execution_count": 3, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "user_proxy (to assistant):\n", + "\n", + "What date is today? Compare the year-to-date gain for META and TESLA.\n", + "\n", + "--------------------------------------------------------------------------------\n", + "assistant (to user_proxy):\n", + "\n", + "# filename: stock_comparison.py\n", + "```python\n", + "import datetime\n", + "import yfinance as yf\n", + "\n", + "# Get today's date\n", + "today = datetime.date.today()\n", + "print(\"Today's date:\", today)\n", + "\n", + "# Get the start of the year\n", + "start_of_year = datetime.date(today.year, 1, 1)\n", + "\n", + "# Download the historical data for META and TESLA\n", + "meta_data = yf.download('META', start=start_of_year, end=today)\n", + "tesla_data = yf.download('TSLA', start=start_of_year, end=today)\n", + "\n", + "# Calculate the year-to-date gain for META and TESLA\n", + "meta_gain = (meta_data['Close'][-1] - meta_data['Close'][0]) / meta_data['Close'][0]\n", + "tesla_gain = (tesla_data['Close'][-1] - tesla_data['Close'][0]) / tesla_data['Close'][0]\n", + "\n", + "# Print the year-to-date gain for META and TESLA\n", + "print(\"Year-to-date gain for META:\", round(meta_gain * 100, 2), \"%\")\n", + "print(\"Year-to-date gain for TESLA:\", round(tesla_gain * 100, 2), \"%\")\n", + "```\n", + "Please save this code in a file named `stock_comparison.py` and run it. This script will print today's date and compare the year-to-date gain for META and TESLA. It uses the `yfinance` library to download the historical data for the stocks. If you haven't installed `yfinance`, please install it by running `pip install yfinance`.\n", + "\n", + "--------------------------------------------------------------------------------\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "user_proxy (to assistant):\n", + "\n", + "exitcode: 0 (execution succeeded)\n", + "Code output: \n", + "Today's date: 2023-07-26\n", + "[*********************100%***********************] 1 of 1 completed\n", + "[*********************100%***********************] 1 of 1 completed\n", + "Year-to-date gain for META: 136.07 %\n", + "Year-to-date gain for TESLA: 145.4 %\n", + "\n", + "\n", + "--------------------------------------------------------------------------------\n", + "assistant (to user_proxy):\n", + "\n", + "Great! The code executed successfully. Today's date is July 26, 2023. The year-to-date gain for META is 136.07%, and the year-to-date gain for TESLA is 145.4%. Please let me know if you need any further assistance.\n", + "\n", + "TERMINATE\n", + "\n", + "--------------------------------------------------------------------------------\n" + ] + } + ], + "source": [ + "from flaml.autogen.agentchat import AssistantAgent, UserProxyAgent\n", + "\n", + "# create an AssistantAgent named \"assistant\"\n", + "assistant = AssistantAgent(\n", + " name=\"assistant\",\n", + " oai_config={\n", + " \"seed\": 42, # seed for caching and reproducibility\n", + " \"config_list\": config_list, # a list of OpenAI API configurations\n", + " \"temperature\": 0, # temperature for sampling\n", + " }, # configuration for flaml.oai, an enhanced inference API compatible with OpenAI API\n", + ")\n", + "# create a UserProxyAgent instance named \"user_proxy\"\n", + "user_proxy = UserProxyAgent(\n", + " name=\"user_proxy\",\n", + " human_input_mode=\"NEVER\",\n", + " max_consecutive_auto_reply=10,\n", + " is_termination_msg=lambda x: x.get(\"content\", \"\").rstrip().endswith(\"TERMINATE\"),\n", + " code_execution_config={\n", + " \"work_dir\": \"coding\",\n", + " \"use_docker\": False, # set to True or image name like \"python:3\" to use docker\n", + " },\n", + ")\n", + "# the assistant receives a message from the user_proxy, which contains the task description\n", + "user_proxy.initiate_chat(\n", + " assistant,\n", + " message=\"\"\"What date is today? Compare the year-to-date gain for META and TESLA.\"\"\",\n", + ")" + ] + }, + { + "attachments": {}, + "cell_type": "markdown", + "metadata": {}, + "source": [ + "The example above involves code execution. In FLAML, code execution is triggered automatically by the `UserProxyAgent` when it detects an executable code block in a received message and no human user input is provided. This process occurs in a designated working directory, using a Docker container by default. Unless a specific directory is specified, FLAML defaults to the `flaml/autogen/extensions` directory. Users have the option to specify a different working directory by setting the `work_dir` argument when constructing a new instance of the `UserProxyAgent`.\n", + "\n", + "The whole chat is auto generated." + ] + }, + { + "attachments": {}, + "cell_type": "markdown", + "metadata": {}, + "source": [ + "## Example Task: Plot Chart" + ] + }, + { + "cell_type": "code", + "execution_count": 4, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "user_proxy (to assistant):\n", + "\n", + "Plot a chart of their stock price change YTD and save to stock_price_ytd.png.\n", + "\n", + "--------------------------------------------------------------------------------\n", + "assistant (to user_proxy):\n", + "\n", + "# filename: stock_price_chart.py\n", + "```python\n", + "import datetime\n", + "import yfinance as yf\n", + "import matplotlib.pyplot as plt\n", + "\n", + "# Get today's date\n", + "today = datetime.date.today()\n", + "\n", + "# Get the start of the year\n", + "start_of_year = datetime.date(today.year, 1, 1)\n", + "\n", + "# Download the historical data for META and TESLA\n", + "meta_data = yf.download('META', start=start_of_year, end=today)\n", + "tesla_data = yf.download('TSLA', start=start_of_year, end=today)\n", + "\n", + "# Plot the stock price change YTD for META and TESLA\n", + "plt.figure(figsize=(10, 6))\n", + "plt.plot(meta_data['Close'], label='META')\n", + "plt.plot(tesla_data['Close'], label='TSLA')\n", + "plt.xlabel('Date')\n", + "plt.ylabel('Stock Price')\n", + "plt.title('Stock Price Change YTD for META and TESLA')\n", + "plt.legend()\n", + "\n", + "# Save the chart to stock_price_ytd.png\n", + "plt.savefig('stock_price_ytd.png')\n", + "plt.show()\n", + "```\n", + "\n", + "Please save this code in a file named `stock_price_chart.py` and run it. This script will plot the stock price change YTD for META and TESLA and save the chart to a file named `stock_price_ytd.png`. It uses the `matplotlib` library to create the chart. If you haven't installed `matplotlib`, please install it by running `pip install matplotlib`.\n", + "\n", + "--------------------------------------------------------------------------------\n", + "user_proxy (to assistant):\n", + "\n", + "exitcode: 0 (execution succeeded)\n", + "Code output: \n", + "[*********************100%***********************] 1 of 1 completed\n", + "[*********************100%***********************] 1 of 1 completed\n", + "Figure(1000x600)\n", + "\n", + "\n", + "--------------------------------------------------------------------------------\n", + "assistant (to user_proxy):\n", + "\n", + "Great! The code executed successfully, and the chart of the stock price change YTD for META and TESLA has been saved to a file named `stock_price_ytd.png`. You can now view the chart in the saved file. If you need any further assistance, please let me know.\n", + "\n", + "TERMINATE\n", + "\n", + "--------------------------------------------------------------------------------\n" + ] + } + ], + "source": [ + "# followup of the previous question\n", + "user_proxy.send(\n", + " recipient=assistant,\n", + " message=\"\"\"Plot a chart of their stock price change YTD and save to stock_price_ytd.png.\"\"\",\n", + ")" + ] + }, + { + "attachments": {}, + "cell_type": "markdown", + "metadata": {}, + "source": [ + "Let's display the generated figure." + ] + }, + { + "cell_type": "code", + "execution_count": 5, + "metadata": {}, + "outputs": [ + { + "data": { + "image/png": "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", + "text/plain": [ + "" + ] + }, + "execution_count": 5, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "from IPython.display import Image\n", + "\n", + "Image(filename='coding/stock_price_ytd.png')" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "## Use a Different Code Execution Environment\n", + "\n", + "The code execution happened in a separate process, so the plot is not directly displayed in the notebook. Is it possible to change the code execution environment into IPython?\n", + "\n", + "Yes! In the following we demonstrate how to extend the `UserProxyAgent` to use a different code execution environment." + ] + }, + { + "cell_type": "code", + "execution_count": 6, + "metadata": {}, + "outputs": [], + "source": [ + "from typing import Dict, Union\n", + "from IPython import get_ipython\n", + "\n", + "class IPythonUserProxyAgent(UserProxyAgent):\n", + " def __init__(self, name: str, **kwargs):\n", + " super().__init__(name, **kwargs)\n", + " self._ipython = get_ipython()\n", + "\n", + " def generate_init_message(self, *args, **kwargs) -> Union[str, Dict]:\n", + " return super().generate_init_message(*args, **kwargs) + \"\"\"\n", + "If you suggest code, the code will be executed in IPython.\"\"\"\n", + "\n", + " def run_code(self, code, **kwargs):\n", + " result = self._ipython.run_cell(code)\n", + " log = str(result.result)\n", + " exitcode = 0 if result.success else 1\n", + " if result.error_before_exec is not None:\n", + " log += f\"\\n{result.error_before_exec}\"\n", + " exitcode = 1\n", + " if result.error_in_exec is not None:\n", + " log += f\"\\n{result.error_in_exec}\"\n", + " exitcode = 1\n", + " return exitcode, bytes(log, \"utf-8\"), None" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "The implementation overrides three functions in `UserProxyAgent`:\n", + "* constructor. We get the ipython instance as the code execution environment.\n", + "* `generate_init_message`. We generate a modified initial message to send to the assistant agent, by adding the info that the execution will be performed in IPython.\n", + "* `run_code`. We execute the code with the ipython instance.\n", + "\n", + "With the new `IPythonUserProxyAgent`, we are able to run the code within the current notebook environment and display plot directly." + ] + }, + { + "cell_type": "code", + "execution_count": 7, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "ipython_user_proxy (to assistant):\n", + "\n", + "Plot a chart of META and TESLA stock price change YTD\n", + "If you suggest code, the code will be executed in IPython.\n", + "\n", + "--------------------------------------------------------------------------------\n", + "assistant (to ipython_user_proxy):\n", + "\n", + "Sure, we can use the `yfinance` library in Python to download the stock price data and `matplotlib` to plot the data. If you don't have `yfinance` installed, you can install it using pip:\n", + "\n", + "```python\n", + "!pip install yfinance\n", + "```\n", + "\n", + "Here is the Python code to plot the YTD stock price change for META (Facebook) and TESLA.\n", + "\n", + "```python\n", + "# Python code\n", + "import yfinance as yf\n", + "import matplotlib.pyplot as plt\n", + "from datetime import datetime\n", + "\n", + "# Define the ticker symbol\n", + "tickerSymbols = ['META', 'TSLA']\n", + "\n", + "# Get data on this ticker\n", + "start_date = datetime(datetime.now().year, 1, 1)\n", + "end_date = datetime.now()\n", + "\n", + "# Fetch the data\n", + "data = yf.download(tickerSymbols, start=start_date, end=end_date)\n", + "\n", + "# Plot the close prices\n", + "plt.figure(figsize=(14,7))\n", + "plt.plot(data['Close'])\n", + "plt.title('YTD Stock Price Change for META and TESLA')\n", + "plt.xlabel('Date')\n", + "plt.ylabel('Price (USD)')\n", + "plt.legend(tickerSymbols)\n", + "plt.grid(True)\n", + "plt.show()\n", + "```\n", + "\n", + "This code will plot the closing prices of META and TESLA stocks from the start of this year to the current date. The prices are in USD.\n", + "\n", + "--------------------------------------------------------------------------------\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Defaulting to user installation because normal site-packages is not writeable\n", + "Requirement already satisfied: yfinance in /home/vscode/.local/lib/python3.9/site-packages (0.2.26)\n", + "Requirement already satisfied: pandas>=1.3.0 in /home/vscode/.local/lib/python3.9/site-packages (from yfinance) (2.0.3)\n", + "Requirement already satisfied: numpy>=1.16.5 in /home/vscode/.local/lib/python3.9/site-packages (from yfinance) (1.25.1)\n", + "Requirement already satisfied: multitasking>=0.0.7 in /home/vscode/.local/lib/python3.9/site-packages (from yfinance) (0.0.11)\n", + "Requirement already satisfied: frozendict>=2.3.4 in /home/vscode/.local/lib/python3.9/site-packages (from yfinance) (2.3.8)\n", + "Requirement already satisfied: requests>=2.31 in /usr/local/lib/python3.9/site-packages (from yfinance) (2.31.0)\n", + "Requirement already satisfied: html5lib>=1.1 in /home/vscode/.local/lib/python3.9/site-packages (from yfinance) (1.1)\n", + "Requirement already satisfied: appdirs>=1.4.4 in /home/vscode/.local/lib/python3.9/site-packages (from yfinance) (1.4.4)\n", + "Requirement already satisfied: lxml>=4.9.1 in /home/vscode/.local/lib/python3.9/site-packages (from yfinance) (4.9.3)\n", + "Requirement already satisfied: pytz>=2022.5 in /home/vscode/.local/lib/python3.9/site-packages (from yfinance) (2023.3)\n", + "Requirement already satisfied: beautifulsoup4>=4.11.1 in /home/vscode/.local/lib/python3.9/site-packages (from yfinance) (4.12.2)\n", + "Requirement already satisfied: soupsieve>1.2 in /home/vscode/.local/lib/python3.9/site-packages (from beautifulsoup4>=4.11.1->yfinance) (2.4.1)\n", + "Requirement already satisfied: six>=1.9 in /usr/local/lib/python3.9/site-packages (from html5lib>=1.1->yfinance) (1.16.0)\n", + "Requirement already satisfied: webencodings in /home/vscode/.local/lib/python3.9/site-packages (from html5lib>=1.1->yfinance) (0.5.1)\n", + "Requirement already satisfied: python-dateutil>=2.8.2 in /home/vscode/.local/lib/python3.9/site-packages (from pandas>=1.3.0->yfinance) (2.8.2)\n", + "Requirement already satisfied: tzdata>=2022.1 in /home/vscode/.local/lib/python3.9/site-packages (from pandas>=1.3.0->yfinance) (2023.3)\n", + "Requirement already satisfied: certifi>=2017.4.17 in /usr/local/lib/python3.9/site-packages (from requests>=2.31->yfinance) (2023.5.7)\n", + "Requirement already satisfied: urllib3<3,>=1.21.1 in /usr/local/lib/python3.9/site-packages (from requests>=2.31->yfinance) (2.0.3)\n", + "Requirement already satisfied: idna<4,>=2.5 in /usr/local/lib/python3.9/site-packages (from requests>=2.31->yfinance) (3.4)\n", + "Requirement already satisfied: charset-normalizer<4,>=2 in /usr/local/lib/python3.9/site-packages (from requests>=2.31->yfinance) (3.2.0)\n", + "\n", + "\u001b[1m[\u001b[0m\u001b[34;49mnotice\u001b[0m\u001b[1;39;49m]\u001b[0m\u001b[39;49m A new release of pip is available: \u001b[0m\u001b[31;49m23.0.1\u001b[0m\u001b[39;49m -> \u001b[0m\u001b[32;49m23.2.1\u001b[0m\n", + "\u001b[1m[\u001b[0m\u001b[34;49mnotice\u001b[0m\u001b[1;39;49m]\u001b[0m\u001b[39;49m To update, run: \u001b[0m\u001b[32;49mpip install --upgrade pip\u001b[0m\n", + "[*********************100%***********************] 2 of 2 completed\n" + ] + }, + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "ipython_user_proxy (to assistant):\n", + "\n", + "exitcode: 0 (execution succeeded)\n", + "Code output: \n", + "None\n", + "None\n", + "\n", + "--------------------------------------------------------------------------------\n", + "assistant (to ipython_user_proxy):\n", + "\n", + "It seems like the code executed successfully but didn't produce any output. This could be due to the fact that the IPython environment you're using might not support matplotlib's interactive mode. \n", + "\n", + "Let's try a different approach using pandas' built-in plotting function, which should work in any environment. \n", + "\n", + "```python\n", + "# Python code\n", + "import yfinance as yf\n", + "import pandas as pd\n", + "from datetime import datetime\n", + "\n", + "# Define the ticker symbol\n", + "tickerSymbols = ['META', 'TSLA']\n", + "\n", + "# Get data on this ticker\n", + "start_date = datetime(datetime.now().year, 1, 1)\n", + "end_date = datetime.now()\n", + "\n", + "# Fetch the data\n", + "data = yf.download(tickerSymbols, start=start_date, end=end_date)\n", + "\n", + "# Plot the close prices\n", + "data['Close'].plot(title='YTD Stock Price Change for META and TESLA', figsize=(14,7), grid=True)\n", + "```\n", + "\n", + "This code does the same thing as the previous one, but uses pandas' built-in plot function instead of matplotlib. The plot should appear directly in your IPython environment.\n", + "\n", + "--------------------------------------------------------------------------------\n", + "[*********************100%***********************] 2 of 2 completed\n" + ] + }, + { + "data": { + "text/plain": [ + "" + ] + }, + "execution_count": 7, + "metadata": {}, + "output_type": "execute_result" + }, + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "ipython_user_proxy (to assistant):\n", + "\n", + "exitcode: 0 (execution succeeded)\n", + "Code output: \n", + "Axes(0.125,0.2;0.775x0.68)\n", + "\n", + "--------------------------------------------------------------------------------\n", + "assistant (to ipython_user_proxy):\n", + "\n", + "Great! The code executed successfully. The output `Axes(0.125,0.2;0.775x0.68)` is just a representation of the plot object. The actual plot should be displayed in your IPython environment. \n", + "\n", + "The plot should show the YTD stock price change for META and TESLA. The x-axis represents the date and the y-axis represents the closing price in USD. \n", + "\n", + "If you can see the plot and it meets your requirements, then we are done here. \n", + "\n", + "TERMINATE\n", + "\n", + "--------------------------------------------------------------------------------\n" + ] + } + ], + "source": [ + "ipy_user = IPythonUserProxyAgent(\n", + " \"ipython_user_proxy\",\n", + " human_input_mode=\"NEVER\",\n", + " max_consecutive_auto_reply=10,\n", + " is_termination_msg=lambda x: x.get(\"content\", \"\").rstrip().endswith(\"TERMINATE\") or x.get(\"content\", \"\").rstrip().endswith('\"TERMINATE\".'),\n", + ")\n", + "assistant.reset()\n", + "# the assistant receives a message from the user, which contains the task description\n", + "ipy_user.initiate_chat(\n", + " assistant,\n", + " message=\"\"\"Plot a chart of META and TESLA stock price change YTD\"\"\",\n", + ")" + ] + } + ], + "metadata": { + "kernelspec": { + "display_name": "Python 3", + "language": "python", + "name": "python3" + }, + "language_info": { + "codemirror_mode": { + "name": "ipython", + "version": 3 + }, + "file_extension": ".py", + "mimetype": "text/x-python", + "name": "python", + "nbconvert_exporter": "python", + "pygments_lexer": "ipython3", + "version": "3.9.17" + }, + "vscode": { + "interpreter": { + "hash": "949777d72b0d2535278d3dc13498b2535136f6dfe0678499012e853ee9abcab1" + } + }, + "widgets": { + "application/vnd.jupyter.widget-state+json": { + "state": { + "2d910cfd2d2a4fc49fc30fbbdc5576a7": { + "model_module": "@jupyter-widgets/base", + "model_module_version": "2.0.0", + "model_name": "LayoutModel", + "state": { + "_model_module": "@jupyter-widgets/base", + "_model_module_version": "2.0.0", + "_model_name": "LayoutModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "2.0.0", + "_view_name": "LayoutView", + "align_content": null, + "align_items": null, + "align_self": null, + "border_bottom": null, + "border_left": null, + "border_right": null, + "border_top": null, + "bottom": null, + "display": null, + "flex": null, + "flex_flow": null, + "grid_area": null, + "grid_auto_columns": null, + "grid_auto_flow": null, + "grid_auto_rows": null, + "grid_column": null, + "grid_gap": null, + "grid_row": null, + "grid_template_areas": null, + "grid_template_columns": null, + "grid_template_rows": null, + "height": null, + "justify_content": null, + "justify_items": null, + "left": null, + "margin": null, + "max_height": null, + "max_width": null, + "min_height": null, + "min_width": null, + "object_fit": null, + "object_position": null, + "order": null, + "overflow": null, + "padding": null, + "right": null, + "top": null, + "visibility": null, + "width": null + } + }, + "454146d0f7224f038689031002906e6f": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "2.0.0", + "model_name": "HBoxModel", + "state": { + "_dom_classes": [], + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "2.0.0", + "_model_name": "HBoxModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/controls", + "_view_module_version": "2.0.0", + "_view_name": "HBoxView", + "box_style": "", + "children": [ + "IPY_MODEL_e4ae2b6f5a974fd4bafb6abb9d12ff26", + "IPY_MODEL_577e1e3cc4db4942b0883577b3b52755", + "IPY_MODEL_b40bdfb1ac1d4cffb7cefcb870c64d45" + ], + "layout": "IPY_MODEL_dc83c7bff2f241309537a8119dfc7555", + "tabbable": null, + "tooltip": null + } + }, + "577e1e3cc4db4942b0883577b3b52755": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "2.0.0", + "model_name": "FloatProgressModel", + "state": { + "_dom_classes": [], + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "2.0.0", + "_model_name": "FloatProgressModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/controls", + "_view_module_version": "2.0.0", + "_view_name": "ProgressView", + "bar_style": "success", + "description": "", + "description_allow_html": false, + "layout": "IPY_MODEL_2d910cfd2d2a4fc49fc30fbbdc5576a7", + "max": 1, + "min": 0, + "orientation": "horizontal", + "style": "IPY_MODEL_74a6ba0c3cbc4051be0a83e152fe1e62", + "tabbable": null, + "tooltip": null, + "value": 1 + } + }, + "6086462a12d54bafa59d3c4566f06cb2": { + "model_module": "@jupyter-widgets/base", + "model_module_version": "2.0.0", + "model_name": "LayoutModel", + "state": { + "_model_module": "@jupyter-widgets/base", + "_model_module_version": "2.0.0", + "_model_name": "LayoutModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "2.0.0", + "_view_name": "LayoutView", + "align_content": null, + "align_items": null, + "align_self": null, + "border_bottom": null, + "border_left": null, + "border_right": null, + "border_top": null, + "bottom": null, + "display": null, + "flex": null, + "flex_flow": null, + "grid_area": null, + "grid_auto_columns": null, + "grid_auto_flow": null, + "grid_auto_rows": null, + "grid_column": null, + "grid_gap": null, + "grid_row": null, + "grid_template_areas": null, + "grid_template_columns": null, + "grid_template_rows": null, + "height": null, + "justify_content": null, + "justify_items": null, + "left": null, + "margin": null, + "max_height": null, + "max_width": null, + "min_height": null, + "min_width": null, + "object_fit": null, + "object_position": null, + "order": null, + "overflow": null, + "padding": null, + "right": null, + "top": null, + "visibility": null, + "width": null + } + }, + "74a6ba0c3cbc4051be0a83e152fe1e62": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "2.0.0", + "model_name": "ProgressStyleModel", + "state": { + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "2.0.0", + "_model_name": "ProgressStyleModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "2.0.0", + "_view_name": "StyleView", + "bar_color": null, + "description_width": "" + } + }, + "7d3f3d9e15894d05a4d188ff4f466554": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "2.0.0", + "model_name": "HTMLStyleModel", + "state": { + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "2.0.0", + "_model_name": "HTMLStyleModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "2.0.0", + "_view_name": "StyleView", + "background": null, + "description_width": "", + "font_size": null, + "text_color": null + } + }, + "b40bdfb1ac1d4cffb7cefcb870c64d45": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "2.0.0", + "model_name": "HTMLModel", + "state": { + "_dom_classes": [], + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "2.0.0", + "_model_name": "HTMLModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/controls", + "_view_module_version": "2.0.0", + "_view_name": "HTMLView", + "description": "", + "description_allow_html": false, + "layout": "IPY_MODEL_f1355871cc6f4dd4b50d9df5af20e5c8", + "placeholder": "​", + "style": "IPY_MODEL_ca245376fd9f4354af6b2befe4af4466", + "tabbable": null, + "tooltip": null, + "value": " 1/1 [00:00<00:00, 44.69it/s]" + } + }, + "ca245376fd9f4354af6b2befe4af4466": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "2.0.0", + "model_name": "HTMLStyleModel", + "state": { + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "2.0.0", + "_model_name": "HTMLStyleModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "2.0.0", + "_view_name": "StyleView", + "background": null, + "description_width": "", + "font_size": null, + "text_color": null + } + }, + "dc83c7bff2f241309537a8119dfc7555": { + "model_module": "@jupyter-widgets/base", + "model_module_version": "2.0.0", + "model_name": "LayoutModel", + "state": { + "_model_module": "@jupyter-widgets/base", + "_model_module_version": "2.0.0", + "_model_name": "LayoutModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "2.0.0", + "_view_name": "LayoutView", + "align_content": null, + "align_items": null, + "align_self": null, + "border_bottom": null, + "border_left": null, + "border_right": null, + "border_top": null, + "bottom": null, + "display": null, + "flex": null, + "flex_flow": null, + "grid_area": null, + "grid_auto_columns": null, + "grid_auto_flow": null, + "grid_auto_rows": null, + "grid_column": null, + "grid_gap": null, + "grid_row": null, + "grid_template_areas": null, + "grid_template_columns": null, + "grid_template_rows": null, + "height": null, + "justify_content": null, + "justify_items": null, + "left": null, + "margin": null, + "max_height": null, + "max_width": null, + "min_height": null, + "min_width": null, + "object_fit": null, + "object_position": null, + "order": null, + "overflow": null, + "padding": null, + "right": null, + "top": null, + "visibility": null, + "width": null + } + }, + "e4ae2b6f5a974fd4bafb6abb9d12ff26": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "2.0.0", + "model_name": "HTMLModel", + "state": { + "_dom_classes": [], + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "2.0.0", + "_model_name": "HTMLModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/controls", + "_view_module_version": "2.0.0", + "_view_name": "HTMLView", + "description": "", + "description_allow_html": false, + "layout": "IPY_MODEL_6086462a12d54bafa59d3c4566f06cb2", + "placeholder": "​", + "style": "IPY_MODEL_7d3f3d9e15894d05a4d188ff4f466554", + "tabbable": null, + "tooltip": null, + "value": "100%" + } + }, + "f1355871cc6f4dd4b50d9df5af20e5c8": { + "model_module": "@jupyter-widgets/base", + "model_module_version": "2.0.0", + "model_name": "LayoutModel", + "state": { + "_model_module": "@jupyter-widgets/base", + "_model_module_version": "2.0.0", + "_model_name": "LayoutModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "2.0.0", + "_view_name": "LayoutView", + "align_content": null, + "align_items": null, + "align_self": null, + "border_bottom": null, + "border_left": null, + "border_right": null, + "border_top": null, + "bottom": null, + "display": null, + "flex": null, + "flex_flow": null, + "grid_area": null, + "grid_auto_columns": null, + "grid_auto_flow": null, + "grid_auto_rows": null, + "grid_column": null, + "grid_gap": null, + "grid_row": null, + "grid_template_areas": null, + "grid_template_columns": null, + "grid_template_rows": null, + "height": null, + "justify_content": null, + "justify_items": null, + "left": null, + "margin": null, + "max_height": null, + "max_width": null, + "min_height": null, + "min_width": null, + "object_fit": null, + "object_position": null, + "order": null, + "overflow": null, + "padding": null, + "right": null, + "top": null, + "visibility": null, + "width": null + } + } + }, + "version_major": 2, + "version_minor": 0 + } + } + }, + "nbformat": 4, + "nbformat_minor": 2 +} diff --git a/notebook/autogen_agentchat_function_call.ipynb b/notebook/autogen_agentchat_function_call.ipynb new file mode 100644 index 0000000000..964879af8e --- /dev/null +++ b/notebook/autogen_agentchat_function_call.ipynb @@ -0,0 +1,444 @@ +{ + "cells": [ + { + "attachments": {}, + "cell_type": "markdown", + "id": "ae1f50ec", + "metadata": {}, + "source": [ + "\"Open" + ] + }, + { + "attachments": {}, + "cell_type": "markdown", + "id": "9a71fa36", + "metadata": {}, + "source": [ + "# Auto Generated Agent Chat: Task Solving with Provided Tools as Functions\n", + "\n", + "FLAML offers an experimental feature of interactive LLM agents, which can be used to solve various tasks with human or automatic feedback, including tasks that require using tools via code. Please find documentation about this feature [here](https://microsoft.github.io/FLAML/docs/Use-Cases/Auto-Generation#agents-experimental).\n", + "\n", + "In this notebook, we demonstrate how to use `AssistantAgent` and `UserProxyAgent` to make function calls with the new feature of OpenAI models (in model version 0613). A specified prompt and function configs need to be passed to `AssistantAgent` to initialize the agent. The corresponding functions need to be passed to `UserProxyAgent`, which will be responsible for executing any function calls made by `AssistantAgent`. Besides this requirement of matching descriptions with functions, we recommend checking the system message in the `AssistantAgent` to make sure the instructions align with the function call descriptions.\n", + "\n", + "## Requirements\n", + "\n", + "FLAML requires `Python>=3.8`. To run this notebook example, please install flaml with the [mathchat] option since we will import functions from `MathUserProxyAgent`:\n", + "```bash\n", + "pip install flaml[mathchat]\n", + "```" + ] + }, + { + "cell_type": "code", + "execution_count": 1, + "id": "2b803c17", + "metadata": {}, + "outputs": [], + "source": [ + "# %pip install flaml[mathchat]~=2.0.0rc4" + ] + }, + { + "attachments": {}, + "cell_type": "markdown", + "id": "5ebd2397", + "metadata": {}, + "source": [ + "## Set your API Endpoint\n", + "\n", + "The [`config_list_from_models`](https://microsoft.github.io/FLAML/docs/reference/autogen/oai/openai_utils#config_list_from_models) function tries to create a list of configurations using Azure OpenAI endpoints and OpenAI endpoints for the provided list of models. It assumes the api keys and api bases are stored in the corresponding environment variables or local txt files:\n", + "\n", + "- OpenAI API key: os.environ[\"OPENAI_API_KEY\"] or `openai_api_key_file=\"key_openai.txt\"`.\n", + "- Azure OpenAI API key: os.environ[\"AZURE_OPENAI_API_KEY\"] or `aoai_api_key_file=\"key_aoai.txt\"`. Multiple keys can be stored, one per line.\n", + "- Azure OpenAI API base: os.environ[\"AZURE_OPENAI_API_BASE\"] or `aoai_api_base_file=\"base_aoai.txt\"`. Multiple bases can be stored, one per line.\n", + "\n", + "It's OK to have only the OpenAI API key, or only the Azure OpenAI API key + base.\n", + "If you open this notebook in google colab, you can upload your files by click the file icon on the left panel and then choose \"upload file\" icon.\n", + "\n", + "The following code excludes Azure OpenAI endpoints from the config list because they don't support functions yet. Remove the `exclude` argument after they do." + ] + }, + { + "cell_type": "code", + "execution_count": 2, + "id": "dca301a4", + "metadata": {}, + "outputs": [], + "source": [ + "from flaml import oai\n", + "\n", + "config_list = oai.config_list_from_models(model_list=[\"gpt-4\", \"gpt-3.5-turbo\", \"gpt-3.5-turbo-16k\"], exclude=\"aoai\")" + ] + }, + { + "attachments": {}, + "cell_type": "markdown", + "id": "92fde41f", + "metadata": {}, + "source": [ + "The config list looks like the following:\n", + "```python\n", + "config_list = [\n", + " {\n", + " 'model': 'gpt-4',\n", + " 'api_key': '',\n", + " }, # OpenAI API endpoint for gpt-4\n", + " {\n", + " 'model': 'gpt-3.5-turbo',\n", + " 'api_key': '',\n", + " }, # OpenAI API endpoint for gpt-3.5-turbo\n", + " {\n", + " 'model': 'gpt-3.5-turbo-16k',\n", + " 'api_key': '',\n", + " }, # OpenAI API endpoint for gpt-3.5-turbo-16k\n", + "]\n", + "```\n" + ] + }, + { + "attachments": {}, + "cell_type": "markdown", + "id": "2b9526e7", + "metadata": {}, + "source": [ + "## Making Function Calls\n", + "\n", + "In this example, we demonstrate function call execution with `AssistantAgent` and `UserProxyAgent`. With the default system prompt of `AssistantAgent`, we allow the LLM assistant to perform tasks with code, and the `UserProxyAgent` would extract code blocks from the LLM response and execute them. With the new \"function_call\" feature, we define functions and specify the description of the function in the OpenAI config for the `AssistantAgent`. Then we register the functions in `UserProxyAgent`.\n" + ] + }, + { + "cell_type": "code", + "execution_count": 3, + "id": "9fb85afb", + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "user_proxy (to chatbot):\n", + "\n", + "Draw two agents chatting with each other with an example dialog. Don't add plt.show().\n", + "\n", + "--------------------------------------------------------------------------------\n", + "chatbot (to user_proxy):\n", + "\n", + "***** Suggested function Call: python *****\n", + "Arguments: \n", + "{\n", + " \"cell\": \"\n", + "import matplotlib.pyplot as plt\n", + "import matplotlib.patches as mpatches\n", + "\n", + "# Define basic parameters\n", + "face_color = '#FFDDC1'\n", + "plt.figure(figsize=(10, 2))\n", + "\n", + "# Agent 1\n", + "agent1 = mpatches.FancyBboxPatch((0.02, 0.4), 0.2, 0.6, boxstyle=mpatches.BoxStyle(\\\"Round\\\", pad=0.02))\n", + "plt.gca().add_artist(agent1)\n", + "plt.gca().text(0.12, 0.7, 'Agent 1', ha='center', va='center', fontsize=12, color='blue')\n", + "\n", + "# Agent 2\n", + "agent2 = mpatches.FancyBboxPatch((0.45, 0.4), 0.2, 0.6, boxstyle=mpatches.BoxStyle(\\\"Round\\\", pad=0.02))\n", + "plt.gca().add_artist(agent2)\n", + "plt.gca().text(0.55, 0.7, 'Agent 2', ha='center', va='center', fontsize=12, color='red')\n", + "\n", + "# Dialog\n", + "plt.gca().text(0.12, 0.35, '\\\"Hello, how are you?\\\"', ha='center', va='center', fontsize=10)\n", + "plt.gca().text(0.55, 0.15, '\\\"I\\'m fine, thank you!\\\"', ha='center', va='center', fontsize=10)\n", + "\n", + "# Descriptions\n", + "plt.gca().text(0.12, 0.15, 'Greeting', ha='center', va='center', fontsize=10)\n", + "plt.gca().text(0.55, 0.35, 'Response', ha='center', va='center', fontsize=10)\n", + "\n", + "plt.axis('off')\n", + "\"\n", + "}\n", + "*******************************************\n", + "\n", + "--------------------------------------------------------------------------------\n", + "user_proxy (to chatbot):\n", + "\n", + "***** Response from calling function \"python\" *****\n", + "Error: Invalid \\escape: line 1 column 785 (char 784)\n", + " You argument should follow json format.\n", + "***************************************************\n", + "\n", + "--------------------------------------------------------------------------------\n", + "chatbot (to user_proxy):\n", + "\n", + "***** Suggested function Call: python *****\n", + "Arguments: \n", + "{\n", + " \"cell\": \"import matplotlib.pyplot as plt\\nimport matplotlib.patches as mpatches\\n\\n# Define basic parameters\\nface_color = '#FFDDC1'\\nplt.figure(figsize=(10, 2))\\n\\n# Agent 1\\nagent1 = mpatches.FancyBboxPatch((0.02, 0.4), 0.2, 0.6, boxstyle=mpatches.BoxStyle('Round', pad=0.02))\\nplt.gca().add_artist(agent1)\\nplt.gca().text(0.12, 0.7, 'Agent 1', ha='center', va='center', fontsize=12, color='blue')\\n\\n# Agent 2\\nagent2 = mpatches.FancyBboxPatch((0.45, 0.4), 0.2, 0.6, boxstyle=mpatches.BoxStyle('Round', pad=0.02))\\nplt.gca().add_artist(agent2)\\nplt.gca().text(0.55, 0.7, 'Agent 2', ha='center', va='center', fontsize=12, color='red')\\n\\n# Dialog\\nplt.gca().text(0.12, 0.35, '\\\"Hello, how are you?\\\"', ha='center', va='center', fontsize=10)\\nplt.gca().text(0.55, 0.15, '\\\"I\\\\'m fine, thank you!\\\"', ha='center', va='center', fontsize=10)\\n\\n# Descriptions\\nplt.gca().text(0.12, 0.15, 'Greeting', ha='center', va='center', fontsize=10)\\nplt.gca().text(0.55, 0.35, 'Response', ha='center', va='center', fontsize=10)\\n\\nplt.axis('off')\"\n", + "}\n", + "*******************************************\n", + "\n", + "--------------------------------------------------------------------------------\n" + ] + }, + { + "data": { + "text/plain": [ + "(0.0, 1.0, 0.0, 1.0)" + ] + }, + "execution_count": 3, + "metadata": {}, + "output_type": "execute_result" + }, + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "user_proxy (to chatbot):\n", + "\n", + "***** Response from calling function \"python\" *****\n", + "(0.0, 1.0, 0.0, 1.0)\n", + "***************************************************\n", + "\n", + "--------------------------------------------------------------------------------\n", + "chatbot (to user_proxy):\n", + "\n", + "TERMINATE\n", + "\n", + "--------------------------------------------------------------------------------\n" + ] + } + ], + "source": [ + "from flaml.autogen.agentchat import AssistantAgent, UserProxyAgent\n", + "\n", + "oai_config = {\n", + " \"functions\": [\n", + " {\n", + " \"name\": \"python\",\n", + " \"description\": \"run cell in ipython and return the execution result.\",\n", + " \"parameters\": {\n", + " \"type\": \"object\",\n", + " \"properties\": {\n", + " \"cell\": {\n", + " \"type\": \"string\",\n", + " \"description\": \"Valid Python cell to execute.\",\n", + " }\n", + " },\n", + " \"required\": [\"cell\"],\n", + " },\n", + " },\n", + " {\n", + " \"name\": \"sh\",\n", + " \"description\": \"run a shell script and return the execution result.\",\n", + " \"parameters\": {\n", + " \"type\": \"object\",\n", + " \"properties\": {\n", + " \"script\": {\n", + " \"type\": \"string\",\n", + " \"description\": \"Valid shell script to execute.\",\n", + " }\n", + " },\n", + " \"required\": [\"script\"],\n", + " },\n", + " },\n", + " ],\n", + " \"config_list\": config_list,\n", + " \"request_timeout\": 120,\n", + "}\n", + "chatbot = AssistantAgent(\n", + " name=\"chatbot\",\n", + " system_message=\"For coding tasks, only use the functions you have been provided with. Reply TERMINATE when the task is done.\",\n", + " oai_config=oai_config,\n", + ")\n", + "\n", + "# create a UserProxyAgent instance named \"user_proxy\"\n", + "user_proxy = UserProxyAgent(\n", + " name=\"user_proxy\",\n", + " is_termination_msg=lambda x: x.get(\"content\", \"\") and x.get(\"content\", \"\").rstrip().endswith(\"TERMINATE\"),\n", + " human_input_mode=\"NEVER\",\n", + " max_consecutive_auto_reply=10,\n", + " code_execution_config={\"work_dir\": \"coding\"},\n", + ")\n", + "\n", + "# define functions according to the function desription\n", + "from IPython import get_ipython\n", + "\n", + "def exec_python(cell):\n", + " ipython = get_ipython()\n", + " result = ipython.run_cell(cell)\n", + " log = str(result.result)\n", + " if result.error_before_exec is not None:\n", + " log += f\"\\n{result.error_before_exec}\"\n", + " if result.error_in_exec is not None:\n", + " log += f\"\\n{result.error_in_exec}\"\n", + " return log\n", + "\n", + "def exec_sh(script):\n", + " return user_proxy.execute_code_blocks([(\"sh\", script)])\n", + "\n", + "# register the functions\n", + "user_proxy.register_function(\n", + " function_map={\n", + " \"python\": exec_python,\n", + " \"sh\": exec_sh,\n", + " }\n", + ")\n", + "\n", + "# start the conversation\n", + "user_proxy.initiate_chat(\n", + " chatbot,\n", + " message=\"Draw two agents chatting with each other with an example dialog. Don't add plt.show().\",\n", + ")\n" + ] + }, + { + "attachments": {}, + "cell_type": "markdown", + "id": "e9531d55", + "metadata": {}, + "source": [ + "## Another example with Wolfram Alpha API\n", + "\n", + "We give another example of querying Wolfram Alpha API to solve math problem. We use the predefined function `MathUserProxyAgent().execute_one_wolfram_query` as the function to be called." + ] + }, + { + "cell_type": "code", + "execution_count": 5, + "id": "4a917492", + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "user_proxy (to chatbot):\n", + "\n", + "Problem: Find all $x$ that satisfy the inequality $(2x+10)(x+3)<(3x+9)(x+8)$. Express your answer in interval notation.\n", + "\n", + "--------------------------------------------------------------------------------\n", + "chatbot (to user_proxy):\n", + "\n", + "***** Suggested function Call: query_wolfram *****\n", + "Arguments: \n", + "{\n", + " \"query\": \"solve (2x+10)(x+3)<(3x+9)(x+8) for x\"\n", + "}\n", + "**************************************************\n", + "\n", + "--------------------------------------------------------------------------------\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "user_proxy (to chatbot):\n", + "\n", + "***** Response from calling function \"query_wolfram\" *****\n", + "('Assumption: solve (2 x + 10) (x + 3)<(3 x + 9) (x + 8) for x \\nAnswer: ans 0: x<-14\\nans 1: x>-3\\n', True)\n", + "**********************************************************\n", + "\n", + "--------------------------------------------------------------------------------\n", + "chatbot (to user_proxy):\n", + "\n", + "The solution to the inequality $(2x+10)(x+3)<(3x+9)(x+8)$ is $x \\in (-\\infty, -14) \\cup (-3, +\\infty)$. TERMINATE\n", + "\n", + "--------------------------------------------------------------------------------\n", + "user_proxy (to chatbot):\n", + "\n", + "\n", + "\n", + "--------------------------------------------------------------------------------\n", + "chatbot (to user_proxy):\n", + "\n", + "TERMINATE\n", + "\n", + "--------------------------------------------------------------------------------\n" + ] + } + ], + "source": [ + "import os\n", + "from flaml.autogen.agentchat import AssistantAgent, UserProxyAgent\n", + "from flaml.autogen.agentchat.contrib.math_user_proxy_agent import MathUserProxyAgent\n", + "\n", + "# you need to provide a wolfram alpha appid to run this example\n", + "if not os.environ.get(\"WOLFRAM_ALPHA_APPID\"):\n", + " os.environ[\"WOLFRAM_ALPHA_APPID\"] = open(\"wolfram.txt\").read().strip()\n", + "\n", + "oai_config = {\n", + " \"model\": \"gpt-4-0613\",\n", + " \"functions\": [\n", + " {\n", + " \"name\": \"query_wolfram\",\n", + " \"description\": \"Return the API query result from the Wolfram Alpha. the ruturn is a tuple of (result, is_success).\",\n", + " \"parameters\": {\n", + " \"type\": \"object\",\n", + " \"properties\": {\n", + " \"query\": {\n", + " \"type\": \"string\",\n", + " \"description\": \"The Wolfram Alpha code to be executed.\",\n", + " }\n", + " },\n", + " \"required\": [\"query\"],\n", + " },\n", + " }\n", + " ],\n", + " \"config_list\": config_list,\n", + "}\n", + "chatbot = AssistantAgent(\n", + " name=\"chatbot\",\n", + " system_message=\"Only use the functions you have been provided with. Do not ask user to perform other actions than executing the functions. Reply TERMINATE when the task is done.\",\n", + " oai_config=oai_config,\n", + ")\n", + "\n", + "# the key in `function_map` should match the function name in \"functions\" above\n", + "# we register a class instance method directly\n", + "user_proxy = UserProxyAgent(\n", + " \"user_proxy\",\n", + " max_consecutive_auto_reply=2,\n", + " human_input_mode=\"NEVER\",\n", + " function_map={\"query_wolfram\": MathUserProxyAgent().execute_one_wolfram_query},\n", + ")\n", + "\n", + "# start the conversation\n", + "user_proxy.initiate_chat(\n", + " chatbot,\n", + " message=\"Problem: Find all $x$ that satisfy the inequality $(2x+10)(x+3)<(3x+9)(x+8)$. Express your answer in interval notation.\",\n", + ")\n" + ] + } + ], + "metadata": { + "kernelspec": { + "display_name": "flaml_dev", + "language": "python", + "name": "python3" + }, + "language_info": { + "codemirror_mode": { + "name": "ipython", + "version": 3 + }, + "file_extension": ".py", + "mimetype": "text/x-python", + "name": "python", + "nbconvert_exporter": "python", + "pygments_lexer": "ipython3", + "version": "3.9.17" + } + }, + "nbformat": 4, + "nbformat_minor": 5 +} diff --git a/notebook/autogen_agent_human_feedback.ipynb b/notebook/autogen_agentchat_human_feedback.ipynb similarity index 63% rename from notebook/autogen_agent_human_feedback.ipynb rename to notebook/autogen_agentchat_human_feedback.ipynb index a80080ea44..1bf1fc8046 100644 --- a/notebook/autogen_agent_human_feedback.ipynb +++ b/notebook/autogen_agentchat_human_feedback.ipynb @@ -5,7 +5,7 @@ "cell_type": "markdown", "metadata": {}, "source": [ - "\"Open" + "\"Open" ] }, { @@ -17,12 +17,12 @@ } }, "source": [ - "# Interactive LLM Agent with Human Feedback\n", + "# Auto Generated Agent Chat: Task Solving with Code Generation, Execution, Debugging & Human Feedback\n", "\n", "FLAML offers an experimental feature of interactive LLM agents, which can be used to solve various tasks with human or automatic feedback, including tasks that require using tools via code.\n", "Please find documentation about this feature [here](https://microsoft.github.io/FLAML/docs/Use-Cases/Auto-Generation#agents-experimental).\n", "\n", - "In this notebook, we demonstrate how to use `AssistantAgent` and `UserProxyAgent` to solve a challenging math problem with human feedback. Here `AssistantAgent` is an LLM-based agent that can write Python code (in a Python coding block) for a user to execute for a given task. `UserProxyAgent` is an agent which serves as a proxy for a user to execute the code written by `AssistantAgent`. By setting `human_input_mode` properly, the `UserProxyAgent` can also prompt the user for feedback to `AssistantAgent`. For example, when `human_input_mode` is set to \"ALWAYS\", the `UserProxyAgent` will always prompt the user for feedback. When user feedback is provided, the `UserProxyAgent` will directly pass the feedback to `AssistantAgent` without doing any additional steps. When no user feedback is provided, the `UserProxyAgent` will execute the code written by `AssistantAgent` directly and return the execution results (success or failure and corresponding outputs) to `AssistantAgent`.\n", + "In this notebook, we demonstrate how to use `AssistantAgent` and `UserProxyAgent` to solve a challenging math problem with human feedback. Here `AssistantAgent` is an LLM-based agent that can write Python code (in a Python coding block) for a user to execute for a given task. `UserProxyAgent` is an agent which serves as a proxy for a user to execute the code written by `AssistantAgent`. By setting `human_input_mode` properly, the `UserProxyAgent` can also prompt the user for feedback to `AssistantAgent`. For example, when `human_input_mode` is set to \"ALWAYS\", the `UserProxyAgent` will always prompt the user for feedback. When user feedback is provided, the `UserProxyAgent` will directly pass the feedback to `AssistantAgent`. When no user feedback is provided, the `UserProxyAgent` will execute the code written by `AssistantAgent` and return the execution results (success or failure and corresponding outputs) to `AssistantAgent`.\n", "\n", "## Requirements\n", "\n", @@ -139,7 +139,7 @@ "metadata": {}, "outputs": [], "source": [ - "from flaml.autogen.agent import AssistantAgent, UserProxyAgent\n", + "from flaml.autogen.agentchat import AssistantAgent, UserProxyAgent\n", "\n", "# create an AssistantAgent instance named \"assistant\"\n", "assistant = AssistantAgent(\n", @@ -149,9 +149,9 @@ " \"config_list\": config_list,\n", " }\n", ")\n", - "# create a UserProxyAgent instance named \"user\"\n", - "user = UserProxyAgent(\n", - " name=\"user\",\n", + "# create a UserProxyAgent instance named \"user_proxy\"\n", + "user_proxy = UserProxyAgent(\n", + " name=\"user_proxy\",\n", " human_input_mode=\"ALWAYS\",\n", " is_termination_msg=lambda x: x.get(\"content\", \"\").rstrip().endswith(\"TERMINATE\"),\n", ")\n", @@ -179,144 +179,177 @@ "name": "stdout", "output_type": "stream", "text": [ - "user (to assistant):\n", + "user_proxy (to assistant):\n", "\n", "\n", - " Find $a + b + c$, given that $x+y \\neq -1$ and \n", - " \\begin{align}\n", + "Find $a + b + c$, given that $x+y \\neq -1$ and \n", + "\\begin{align}\n", "\tax + by + c & = x + 7,\\\n", "\ta + bx + cy & = 2x + 6y,\\\n", "\tay + b + cx & = 4x + y.\n", - "\t\\end{align}.\n", - " \n", + "\\end{align}.\n", "\n", - "--------------------------------------------------------------------------------\n", - "assistant (to user):\n", "\n", - "The given system of equations is a linear system, which can be solved using linear algebra methods. We can represent this system in matrix form and solve it to find the values of a, b, and c. Finally, we add the values of a, b, and c to get the result.\n", + "--------------------------------------------------------------------------------\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "assistant (to user_proxy):\n", "\n", - "We would use the Python Numpy library for solving this. Here is the Python script for this:\n", + "The problem can be solved using basic operations with the equations and some assumption based on the property that x + y ≠ -1. It seems to be a system of linear equations which has the general format:\n", "\n", - "```python\n", - "import numpy as np\n", + " ax + by + c = d\n", + " a + bx + cy = e\n", + " ay + b + cx = f\n", "\n", - "# coefficients matrix for the left side of the equations\n", - "A = np.array([[1, 1, 1], \n", - " [1, 1, 1], \n", - " [1, 1, 1]])\n", + "It's clear that we need to reduce this to a form where we can easily calculate the values a, b and c. A common approach with systems of equations is to subtract or add equations to each other.\n", "\n", - "# constants on the right side of the equations\n", - "b = np.array([7, 6, -5])\n", + "Although, the calculation is simple, it might be a bit cumbersome to do by hand, let's use the sympy Python library to solve the system of linear equations.\n", "\n", - "# solve the system of equations\n", - "x = np.linalg.solve(A, b)\n", + "Let's do this step by step. First, let's create the system of equations, and then solve them.\n", "\n", - "# print the result\n", - "print(f\"a + b + c = {sum(x)}\")\n", - "```\n", + "--------------------------------------------------------------------------------\n", "\n", - "You will need to run this python code block. Ensure numpy is installed in your environment. If it's not installed, you can install it by running `pip install numpy`\n", + ">>>>>>>> NO HUMAN INPUT RECEIVED. USING AUTO REPLY FOR THE USER...\n", + "user_proxy (to assistant):\n", "\n", - "--------------------------------------------------------------------------------\n", - "user (to assistant):\n", "\n", - "use sympy\n", "\n", "--------------------------------------------------------------------------------\n", - "assistant (to user):\n", - "\n", - "Sure, SymPy is a Python library used for symbolic mathematics. It aims to become a full-featured computer algebra system while keeping the code as simple as possible in order to be comprehensible and easily extensible. Here is the Python script using SymPy library for this:\n", + "assistant (to user_proxy):\n", "\n", "```python\n", + "# filename: solve_equations.py\n", + "\n", "from sympy import symbols, Eq, solve\n", "\n", - "a, b, c, x, y = symbols('a b c x y')\n", + "# Define the symbols \n", + "x, y, a, b, c = symbols('x y a b c')\n", + "\n", + "# Given that x + y ≠ -1, we can use any pair of value which not equals -1. For simplicity, let x = 1 and y = 0.\n", + "x_value = 1\n", + "y_value = 0\n", "\n", - "# system of equations\n", + "# Define the equations \n", "eq1 = Eq(a*x + b*y + c, x + 7)\n", "eq2 = Eq(a + b*x + c*y, 2*x + 6*y)\n", "eq3 = Eq(a*y + b + c*x, 4*x + y)\n", "\n", - "# solve the system of equations\n", - "sol = solve((eq1,eq2,eq3), (a, b, c))\n", + "# Substitute the values of x and y into the equations \n", + "eq1_sub = eq1.subs({x: x_value, y: y_value})\n", + "eq2_sub = eq2.subs({x: x_value, y: y_value})\n", + "eq3_sub = eq3.subs({x: x_value, y: y_value})\n", + "\n", + "# Solve the system of equations\n", + "solution = solve((eq1_sub, eq2_sub, eq3_sub), (a, b, c))\n", "\n", - "# print the result\n", - "print('a + b + c = ', sum(sol.values()))\n", + "# Calculate the sum of a, b, and c\n", + "sum_abc = sum(solution.values())\n", + "\n", + "# Print the values of a, b, and c and their sum\n", + "print(f'Solution: a = {solution[a]}, b = {solution[b]}, c = {solution[c]}')\n", + "print(f'Sum of a, b, and c: {sum_abc}')\n", "```\n", "\n", - "You should run this python code block. Ensure sympy is installed in your environment. You can install it by running `pip install sympy` if it's not installed.\n", + "You can run this script by executing the command: `python3 solve_equations.py` in the terminal.\n", "\n", "--------------------------------------------------------------------------------\n", "\n", ">>>>>>>> NO HUMAN INPUT RECEIVED. USING AUTO REPLY FOR THE USER...\n", - "user (to assistant):\n", + "user_proxy (to assistant):\n", "\n", "exitcode: 0 (execution succeeded)\n", "Code output: \n", - "a + b + c = (2*x**2 - 3*x + y)/(x**2 - x*y - x + y**2 - y + 1) + (x**2 - 3*x*y + 2*x + y**2 - y)/(x**2 - x*y - x + y**2 - y + 1) + (4*x**2 - 4*x*y - 6*x + 6*y**2 - 7*y + 7)/(x**2 - x*y - x + y**2 - y + 1)\n", + "Solution: a = 3, b = -1, c = 5\n", + "Sum of a, b, and c: 7\n", "\n", "\n", "--------------------------------------------------------------------------------\n", - "assistant (to user):\n", + "assistant (to user_proxy):\n", "\n", - "The output you are seeing is the expression of `a + b + c` in terms of `x` and `y`. Given that `x + y != -1`, it means that `y != -x -1`. Therefore, the denominator in your result `(x**2 - x*y - x + y**2 - y + 1)` will not be zero (it simplifies to `(x+y+1)**2`), so the solution is correct and valid.\n", + "The code has been executed successfully. The values of a, b, c are 3, -1, 5 respectively and the sum of a, b, and c is 7.\n", "\n", - "If you want a numerical value for `a + b + c`, you would have to substitute numerical values for `x` and `y`.\n", + "TERMINATE\n", "\n", - "For example, if `x = 1` and `y = 2`, you can substitute these into the result to obtain a numerical value:\n", + "--------------------------------------------------------------------------------\n", + "user_proxy (to assistant):\n", "\n", - "Here is the Python script using sympy for this:\n", + "Is the solution general?\n", + "\n", + "--------------------------------------------------------------------------------\n", + "assistant (to user_proxy):\n", + "\n", + "The solution in this case is not general because it's dependent on the chosen values of x and y. In this approach, I have chosen the values (x=1, y=0) to make the calculations simple, given the fact x+y≠-1.\n", + "\n", + "In other words, the calculation effectively assumes a particular solution for x and y rather than a general one. This is because for each different values of x and y (which satisfy the condition x + y ≠ -1), the output for a + b + c could potentially be different.\n", + "\n", + "If you want a truly general solution, it would require a more complicated mathematical approach (probably involving abstract algebra or possibly even multivariable calculus) which would likely be too complex to be appropriate for this setting.\n", + "\n", + "Regardless, for given simple linear equations, the approach of assigning specific pair of x and y that meets the conditions is a common practice. And this solution is enough for most practical problems.\n", + "\n", + "--------------------------------------------------------------------------------\n", + "user_proxy (to assistant):\n", + "\n", + "Try different values of x and y\n", + "\n", + "--------------------------------------------------------------------------------\n", + "assistant (to user_proxy):\n", "\n", "```python\n", + "# filename: solve_equations.py\n", + "\n", "from sympy import symbols, Eq, solve\n", "\n", - "a, b, c, x, y = symbols('a b c x y')\n", + "# Define the symbols \n", + "x, y, a, b, c = symbols('x y a b c')\n", + "\n", + "# Given that x + y ≠ -1, we can use any pair of value which not equals -1. Let's try x = 2 and y = 0 for this time.\n", + "x_value = 2\n", + "y_value = 0\n", "\n", - "# system of equations\n", + "# Define the equations \n", "eq1 = Eq(a*x + b*y + c, x + 7)\n", "eq2 = Eq(a + b*x + c*y, 2*x + 6*y)\n", "eq3 = Eq(a*y + b + c*x, 4*x + y)\n", "\n", - "# solve the system of equations\n", - "sol = solve((eq1,eq2,eq3), (a, b, c))\n", + "# Substitute the values of x and y into the equations \n", + "eq1_sub = eq1.subs({x: x_value, y: y_value})\n", + "eq2_sub = eq2.subs({x: x_value, y: y_value})\n", + "eq3_sub = eq3.subs({x: x_value, y: y_value})\n", "\n", - "# calculate a + b + c after substituting x = 1 and y = 2\n", - "abc_value = sum(sol.values()).subs({x: 1, y: 2})\n", + "# Solve the system of equations\n", + "solution = solve((eq1_sub, eq2_sub, eq3_sub), (a, b, c))\n", "\n", - "# print the result\n", - "print('a + b + c = ', abc_value)\n", + "# Calculate the sum of a, b, and c\n", + "sum_abc = sum(solution.values())\n", + "\n", + "# Print the values of a, b, and c and their sum\n", + "print(f'Solution: a = {solution[a]}, b = {solution[b]}, c = {solution[c]}')\n", + "print(f'Sum of a, b, and c: {sum_abc}')\n", "```\n", "\n", - "You can run this code. It will compute the value of `a + b + c` for `x = 1` and `y = 2`.\n", + "You can run this script by executing the command: `python3 solve_equations.py` in the terminal.\n", "\n", "--------------------------------------------------------------------------------\n", "\n", ">>>>>>>> NO HUMAN INPUT RECEIVED. USING AUTO REPLY FOR THE USER...\n", - "user (to assistant):\n", + "user_proxy (to assistant):\n", "\n", "exitcode: 0 (execution succeeded)\n", "Code output: \n", - "a + b + c = 7\n", - "\n", - "\n", - "--------------------------------------------------------------------------------\n", - "assistant (to user):\n", - "\n", - "The Python code provided has correctly solved the system of equations and evaluated `a + b + c` with `x=1` and `y=2`, such that `a + b + c = 7`.\n", + "Solution: a = 8/3, b = 2/3, c = 11/3\n", + "Sum of a, b, and c: 7\n", "\n", - "If you have other values of `x` and `y` for which you would like to find `a + b + c`, you can substitute those values into the provided code by replacing `1` and `2` with your specific `x` and `y` values respectively.\n", - "\n", - "Let's TERMINATE the process now as we got the required solution.\n", "\n", "--------------------------------------------------------------------------------\n", + "assistant (to user_proxy):\n", "\n", - ">>>>>>>> NO HUMAN INPUT RECEIVED. USING AUTO REPLY FOR THE USER...\n", - "user (to assistant):\n", - "\n", + "The code executed successfully and even with different values for x and y (x=2, y=0 in this case), the sum of a, b, and c still comes out to be 7. \n", "\n", - "\n", - "--------------------------------------------------------------------------------\n", - "assistant (to user):\n", + "This reassures that, although the values of a, b, and c change depending on x and y, the sum a + b + c remains constant. Therefore, while the solution for a, b, and c is not general, the resulting sum of a + b + c are invariant under the condition x + y ≠ -1.\n", "\n", "TERMINATE\n", "\n", @@ -326,16 +359,16 @@ ], "source": [ "math_problem_to_solve = \"\"\"\n", - " Find $a + b + c$, given that $x+y \\\\neq -1$ and \n", - " \\\\begin{align}\n", + "Find $a + b + c$, given that $x+y \\\\neq -1$ and \n", + "\\\\begin{align}\n", "\tax + by + c & = x + 7,\\\\\n", "\ta + bx + cy & = 2x + 6y,\\\\\n", "\tay + b + cx & = 4x + y.\n", - "\t\\\\end{align}.\n", - " \"\"\"\n", + "\\\\end{align}.\n", + "\"\"\"\n", "\n", "# the assistant receives a message from the user, which contains the task description\n", - "user.initiate_chat(assistant, message=math_problem_to_solve)" + "user_proxy.initiate_chat(assistant, message=math_problem_to_solve)" ] }, { @@ -345,7 +378,7 @@ "source": [ "## Analyze the conversation\n", "\n", - "The human user can provide feedback at each step. When the human user didn't provide feedback, the code was executed. The executed results and error messages are returned to the assistant, and the assistant was able to modify the code to rectify. In the end, the task is complete and a \"TERMINATE\" signal is sent from the assistant. The user skipped feedback in the end and the conversation is finished.\n", + "The human user can provide feedback at each step. When the human user didn't provide feedback, the code was executed. The executed results and error messages are returned to the assistant, and the assistant was able to modify the code based on the feedback. In the end, the task is complete and a \"TERMINATE\" signal is sent from the assistant. The user skipped feedback in the end and the conversation is finished.\n", "\n", "After the conversation is finished, we can save the log of the conversation between the two agents. The log can be accessed from `oai.ChatCompletion.logged_history`." ] @@ -359,7 +392,7 @@ "name": "stdout", "output_type": "stream", "text": [ - "{'[{\"content\": \"You are a helpful AI assistant.\\\\n In the following cases, suggest python code (in a python coding block) or shell script (in a sh coding block) for the user to execute. You must indicate the script type in the code block. The user cannot provide any other feedback or perform any other action beyond executing the code you suggest. The user can\\'t modify your code. So do not suggest incomplete code which requires users to modify. Don\\'t use a code block if it\\'s not intended to be executed by the user.\\\\n 1. When you need to collect info, use the code to output the info you need, for example, browse or search the web, download/read a file, print the content of a webpage or a file.\\\\n 2. When you need to perform some task with code, use the code to perform the task and output the result. Finish the task smartly. Solve the task step by step if you need to. \\\\n If you want the user to save the code in a file before executing it, put # filename: inside the code block as the first line. Don\\'t include multiple code blocks in one response. Do not ask users to copy and paste the result. Instead, use \\'print\\' function for the output when relevant. Check the execution result returned by the user.\\\\n If the result indicates there is an error, fix the error and output the code again. Suggest the full code instead of partial code or code changes. If the error can\\'t be fixed or if the task is not solved even after the code is executed successfully, analyze the problem, revisit your assumption, collect additional info you need, and think of a different approach to try.\\\\n When you find an answer, verify the answer carefully. If a function for planning is provided, call the function to make plans and verify the execution.\\\\n Reply \\\\\"TERMINATE\\\\\" in the end when everything is done.\\\\n \", \"role\": \"system\"}, {\"content\": \"\\\\n Find $a + b + c$, given that $x+y \\\\\\\\neq -1$ and \\\\n \\\\\\\\begin{align}\\\\n\\\\tax + by + c & = x + 7,\\\\\\\\\\\\n\\\\ta + bx + cy & = 2x + 6y,\\\\\\\\\\\\n\\\\tay + b + cx & = 4x + y.\\\\n\\\\t\\\\\\\\end{align}.\\\\n \", \"role\": \"user\"}, {\"content\": \"The given system of equations is a linear system, which can be solved using linear algebra methods. We can represent this system in matrix form and solve it to find the values of a, b, and c. Finally, we add the values of a, b, and c to get the result.\\\\n\\\\nWe would use the Python Numpy library for solving this. Here is the Python script for this:\\\\n\\\\n```python\\\\nimport numpy as np\\\\n\\\\n# coefficients matrix for the left side of the equations\\\\nA = np.array([[1, 1, 1], \\\\n [1, 1, 1], \\\\n [1, 1, 1]])\\\\n\\\\n# constants on the right side of the equations\\\\nb = np.array([7, 6, -5])\\\\n\\\\n# solve the system of equations\\\\nx = np.linalg.solve(A, b)\\\\n\\\\n# print the result\\\\nprint(f\\\\\"a + b + c = {sum(x)}\\\\\")\\\\n```\\\\n\\\\nYou will need to run this python code block. Ensure numpy is installed in your environment. If it\\'s not installed, you can install it by running `pip install numpy`\", \"role\": \"assistant\"}, {\"content\": \"use sympy\", \"role\": \"user\"}, {\"content\": \"Sure, SymPy is a Python library used for symbolic mathematics. It aims to become a full-featured computer algebra system while keeping the code as simple as possible in order to be comprehensible and easily extensible. Here is the Python script using SymPy library for this:\\\\n\\\\n```python\\\\nfrom sympy import symbols, Eq, solve\\\\n\\\\na, b, c, x, y = symbols(\\'a b c x y\\')\\\\n\\\\n# system of equations\\\\neq1 = Eq(a*x + b*y + c, x + 7)\\\\neq2 = Eq(a + b*x + c*y, 2*x + 6*y)\\\\neq3 = Eq(a*y + b + c*x, 4*x + y)\\\\n\\\\n# solve the system of equations\\\\nsol = solve((eq1,eq2,eq3), (a, b, c))\\\\n\\\\n# print the result\\\\nprint(\\'a + b + c = \\', sum(sol.values()))\\\\n```\\\\n\\\\nYou should run this python code block. Ensure sympy is installed in your environment. You can install it by running `pip install sympy` if it\\'s not installed.\", \"role\": \"assistant\"}, {\"content\": \"exitcode: 0 (execution succeeded)\\\\nCode output: \\\\na + b + c = (2*x**2 - 3*x + y)/(x**2 - x*y - x + y**2 - y + 1) + (x**2 - 3*x*y + 2*x + y**2 - y)/(x**2 - x*y - x + y**2 - y + 1) + (4*x**2 - 4*x*y - 6*x + 6*y**2 - 7*y + 7)/(x**2 - x*y - x + y**2 - y + 1)\\\\n\", \"role\": \"user\"}, {\"content\": \"The output you are seeing is the expression of `a + b + c` in terms of `x` and `y`. Given that `x + y != -1`, it means that `y != -x -1`. Therefore, the denominator in your result `(x**2 - x*y - x + y**2 - y + 1)` will not be zero (it simplifies to `(x+y+1)**2`), so the solution is correct and valid.\\\\n\\\\nIf you want a numerical value for `a + b + c`, you would have to substitute numerical values for `x` and `y`.\\\\n\\\\nFor example, if `x = 1` and `y = 2`, you can substitute these into the result to obtain a numerical value:\\\\n\\\\nHere is the Python script using sympy for this:\\\\n\\\\n```python\\\\nfrom sympy import symbols, Eq, solve\\\\n\\\\na, b, c, x, y = symbols(\\'a b c x y\\')\\\\n\\\\n# system of equations\\\\neq1 = Eq(a*x + b*y + c, x + 7)\\\\neq2 = Eq(a + b*x + c*y, 2*x + 6*y)\\\\neq3 = Eq(a*y + b + c*x, 4*x + y)\\\\n\\\\n# solve the system of equations\\\\nsol = solve((eq1,eq2,eq3), (a, b, c))\\\\n\\\\n# calculate a + b + c after substituting x = 1 and y = 2\\\\nabc_value = sum(sol.values()).subs({x: 1, y: 2})\\\\n\\\\n# print the result\\\\nprint(\\'a + b + c = \\', abc_value)\\\\n```\\\\n\\\\nYou can run this code. It will compute the value of `a + b + c` for `x = 1` and `y = 2`.\", \"role\": \"assistant\"}, {\"content\": \"exitcode: 0 (execution succeeded)\\\\nCode output: \\\\na + b + c = 7\\\\n\", \"role\": \"user\"}, {\"content\": \"The Python code provided has correctly solved the system of equations and evaluated `a + b + c` with `x=1` and `y=2`, such that `a + b + c = 7`.\\\\n\\\\nIf you have other values of `x` and `y` for which you would like to find `a + b + c`, you can substitute those values into the provided code by replacing `1` and `2` with your specific `x` and `y` values respectively.\\\\n\\\\nLet\\'s TERMINATE the process now as we got the required solution.\", \"role\": \"assistant\"}, {\"content\": \"\", \"role\": \"user\"}, {\"content\": \"TERMINATE\", \"role\": \"assistant\"}]': {'created_at': [0, 1, 2, 3, 4], 'cost': [0.0282, 0.03537, 0.05553, 0.05208, 0.049019999999999994]}}\n" + "{'[{\"content\": \"You are a helpful AI assistant.\\\\n In the following cases, suggest python code (in a python coding block) or shell script (in a sh coding block) for the user to execute. You must indicate the script type in the code block. The user cannot provide any other feedback or perform any other action beyond executing the code you suggest. The user can\\'t modify your code. So do not suggest incomplete code which requires users to modify. Don\\'t use a code block if it\\'s not intended to be executed by the user.\\\\n 1. When you need to collect info, use the code to output the info you need, for example, browse or search the web, download/read a file, print the content of a webpage or a file.\\\\n 2. When you need to perform some task with code, use the code to perform the task and output the result. Finish the task smartly. Solve the task step by step if you need to.\\\\n If you want the user to save the code in a file before executing it, put # filename: inside the code block as the first line. Don\\'t include multiple code blocks in one response. Do not ask users to copy and paste the result. Instead, use \\'print\\' function for the output when relevant. Check the execution result returned by the user.\\\\n If the result indicates there is an error, fix the error and output the code again. Suggest the full code instead of partial code or code changes. If the error can\\'t be fixed or if the task is not solved even after the code is executed successfully, analyze the problem, revisit your assumption, collect additional info you need, and think of a different approach to try.\\\\n When you find an answer, verify the answer carefully. If a function for planning is provided, call the function to make plans and verify the execution.\\\\n Reply \\\\\"TERMINATE\\\\\" in the end when everything is done.\\\\n \", \"role\": \"system\"}, {\"content\": \"\\\\nFind $a + b + c$, given that $x+y \\\\\\\\neq -1$ and \\\\n\\\\\\\\begin{align}\\\\n\\\\tax + by + c & = x + 7,\\\\\\\\\\\\n\\\\ta + bx + cy & = 2x + 6y,\\\\\\\\\\\\n\\\\tay + b + cx & = 4x + y.\\\\n\\\\\\\\end{align}.\\\\n\", \"role\": \"user\"}, {\"content\": \"The problem can be solved using basic operations with the equations and some assumption based on the property that x + y \\\\u2260 -1. It seems to be a system of linear equations which has the general format:\\\\n\\\\n ax + by + c = d\\\\n a + bx + cy = e\\\\n ay + b + cx = f\\\\n\\\\nIt\\'s clear that we need to reduce this to a form where we can easily calculate the values a, b and c. A common approach with systems of equations is to subtract or add equations to each other.\\\\n\\\\nAlthough, the calculation is simple, it might be a bit cumbersome to do by hand, let\\'s use the sympy Python library to solve the system of linear equations.\\\\n\\\\nLet\\'s do this step by step. First, let\\'s create the system of equations, and then solve them.\", \"role\": \"assistant\"}, {\"content\": \"\", \"role\": \"user\"}, {\"content\": \"```python\\\\n# filename: solve_equations.py\\\\n\\\\nfrom sympy import symbols, Eq, solve\\\\n\\\\n# Define the symbols \\\\nx, y, a, b, c = symbols(\\'x y a b c\\')\\\\n\\\\n# Given that x + y \\\\u2260 -1, we can use any pair of value which not equals -1. For simplicity, let x = 1 and y = 0.\\\\nx_value = 1\\\\ny_value = 0\\\\n\\\\n# Define the equations \\\\neq1 = Eq(a*x + b*y + c, x + 7)\\\\neq2 = Eq(a + b*x + c*y, 2*x + 6*y)\\\\neq3 = Eq(a*y + b + c*x, 4*x + y)\\\\n\\\\n# Substitute the values of x and y into the equations \\\\neq1_sub = eq1.subs({x: x_value, y: y_value})\\\\neq2_sub = eq2.subs({x: x_value, y: y_value})\\\\neq3_sub = eq3.subs({x: x_value, y: y_value})\\\\n\\\\n# Solve the system of equations\\\\nsolution = solve((eq1_sub, eq2_sub, eq3_sub), (a, b, c))\\\\n\\\\n# Calculate the sum of a, b, and c\\\\nsum_abc = sum(solution.values())\\\\n\\\\n# Print the values of a, b, and c and their sum\\\\nprint(f\\'Solution: a = {solution[a]}, b = {solution[b]}, c = {solution[c]}\\')\\\\nprint(f\\'Sum of a, b, and c: {sum_abc}\\')\\\\n```\\\\n\\\\nYou can run this script by executing the command: `python3 solve_equations.py` in the terminal.\", \"role\": \"assistant\"}, {\"content\": \"exitcode: 0 (execution succeeded)\\\\nCode output: \\\\nSolution: a = 3, b = -1, c = 5\\\\nSum of a, b, and c: 7\\\\n\", \"role\": \"user\"}, {\"content\": \"The code has been executed successfully. The values of a, b, c are 3, -1, 5 respectively and the sum of a, b, and c is 7.\\\\n\\\\nTERMINATE\", \"role\": \"assistant\"}, {\"content\": \"Is the solution general?\", \"role\": \"user\"}, {\"content\": \"The solution in this case is not general because it\\'s dependent on the chosen values of x and y. In this approach, I have chosen the values (x=1, y=0) to make the calculations simple, given the fact x+y\\\\u2260-1.\\\\n\\\\nIn other words, the calculation effectively assumes a particular solution for x and y rather than a general one. This is because for each different values of x and y (which satisfy the condition x + y \\\\u2260 -1), the output for a + b + c could potentially be different.\\\\n\\\\nIf you want a truly general solution, it would require a more complicated mathematical approach (probably involving abstract algebra or possibly even multivariable calculus) which would likely be too complex to be appropriate for this setting.\\\\n\\\\nRegardless, for given simple linear equations, the approach of assigning specific pair of x and y that meets the conditions is a common practice. And this solution is enough for most practical problems.\", \"role\": \"assistant\"}, {\"content\": \"Try different values of x and y\", \"role\": \"user\"}, {\"content\": \"```python\\\\n# filename: solve_equations.py\\\\n\\\\nfrom sympy import symbols, Eq, solve\\\\n\\\\n# Define the symbols \\\\nx, y, a, b, c = symbols(\\'x y a b c\\')\\\\n\\\\n# Given that x + y \\\\u2260 -1, we can use any pair of value which not equals -1. Let\\'s try x = 2 and y = 0 for this time.\\\\nx_value = 2\\\\ny_value = 0\\\\n\\\\n# Define the equations \\\\neq1 = Eq(a*x + b*y + c, x + 7)\\\\neq2 = Eq(a + b*x + c*y, 2*x + 6*y)\\\\neq3 = Eq(a*y + b + c*x, 4*x + y)\\\\n\\\\n# Substitute the values of x and y into the equations \\\\neq1_sub = eq1.subs({x: x_value, y: y_value})\\\\neq2_sub = eq2.subs({x: x_value, y: y_value})\\\\neq3_sub = eq3.subs({x: x_value, y: y_value})\\\\n\\\\n# Solve the system of equations\\\\nsolution = solve((eq1_sub, eq2_sub, eq3_sub), (a, b, c))\\\\n\\\\n# Calculate the sum of a, b, and c\\\\nsum_abc = sum(solution.values())\\\\n\\\\n# Print the values of a, b, and c and their sum\\\\nprint(f\\'Solution: a = {solution[a]}, b = {solution[b]}, c = {solution[c]}\\')\\\\nprint(f\\'Sum of a, b, and c: {sum_abc}\\')\\\\n```\\\\n\\\\nYou can run this script by executing the command: `python3 solve_equations.py` in the terminal.\", \"role\": \"assistant\"}, {\"content\": \"exitcode: 0 (execution succeeded)\\\\nCode output: \\\\nSolution: a = 8/3, b = 2/3, c = 11/3\\\\nSum of a, b, and c: 7\\\\n\", \"role\": \"user\"}, {\"content\": \"The code executed successfully and even with different values for x and y (x=2, y=0 in this case), the sum of a, b, and c still comes out to be 7. \\\\n\\\\nThis reassures that, although the values of a, b, and c change depending on x and y, the sum a + b + c remains constant. Therefore, while the solution for a, b, and c is not general, the resulting sum of a + b + c are invariant under the condition x + y \\\\u2260 -1.\\\\n\\\\nTERMINATE\", \"role\": \"assistant\"}]': {'created_at': [0, 1, 2, 3, 4, 5], 'cost': [0.024390000000000002, 0.04073999999999999, 0.0342, 0.044789999999999996, 0.06075, 0.05870999999999999]}}\n" ] } ], @@ -395,7 +428,7 @@ "name": "python", "nbconvert_exporter": "python", "pygments_lexer": "ipython3", - "version": "3.9.16" + "version": "3.9.17" }, "vscode": { "interpreter": { diff --git a/notebook/autogen_agent_planning.ipynb b/notebook/autogen_agentchat_planning.ipynb similarity index 68% rename from notebook/autogen_agent_planning.ipynb rename to notebook/autogen_agentchat_planning.ipynb index ef648f1c42..b50d33a217 100644 --- a/notebook/autogen_agent_planning.ipynb +++ b/notebook/autogen_agentchat_planning.ipynb @@ -5,7 +5,7 @@ "cell_type": "markdown", "metadata": {}, "source": [ - "\"Open" + "\"Open" ] }, { @@ -17,11 +17,11 @@ } }, "source": [ - "# Multi-Agent Communication and Planning\n", + "# Auto Generated Agent Chat: Collaborative Task Solving with Coding and Planning Agent\n", "\n", "FLAML offers an experimental feature of interactive LLM agents, which can be used to solve various tasks with human or automatic feedback, including tasks that require using tools via code. Please find documentation about this feature [here](https://microsoft.github.io/FLAML/docs/Use-Cases/Auto-Generation#agents-experimental).\n", "\n", - "In this notebook, we demonstrate how to use multiple agents to work together and accomplish a task which requires finding info from the web and coding. `AssistantAgent` is an LLM-based agent that can write Python code (in a Python coding block) for a user to execute for a given task. `UserProxyAgent` is an agent which serves as a proxy for a user to execute the code written by `AssistantAgent`. We further create a planning agent for the assistant agent to consult. The planning agent is a variation of the `AssistantAgent`.\n", + "In this notebook, we demonstrate how to use multiple agents to work together and accomplish a task which requires finding info from the web and coding. `AssistantAgent` is an LLM-based agent that can write and debug Python code (in a Python coding block) for a user to execute for a given task. `UserProxyAgent` is an agent which serves as a proxy for a user to execute the code written by `AssistantAgent`. We further create a planning agent for the assistant agent to consult. The planning agent is a variation of the LLM-based `AssistantAgent` with a different system message.\n", "\n", "## Requirements\n", "\n", @@ -123,11 +123,11 @@ "metadata": {}, "outputs": [], "source": [ - "from flaml.autogen.agent import AssistantAgent, UserProxyAgent\n", + "from flaml.autogen.agentchat import AssistantAgent, UserProxyAgent\n", "\n", "planner = AssistantAgent(\n", " name=\"planner\",\n", - " config_list=config_list,\n", + " oai_config={\"config_list\": config_list},\n", " # the default system message of the AssistantAgent is overwritten here\n", " system_message=\"You are a helpful AI assistant. You suggest coding and reasoning steps for another AI assistant to accomplish a task. Do not suggest concrete code. For any action beyond writing code or reasoning, convert it to a step which can be implemented by writing code. For example, the action of browsing the web can be implemented by writing code which reads and prints the content of a web page. Finally, inspect the execution result. If the plan is not good, suggest a better plan. If the execution is wrong, analyze the error and suggest a fix.\"\n", ")\n", @@ -139,7 +139,8 @@ "\n", "def ask_planner(message):\n", " planner_user.initiate_chat(planner, message=message)\n", - " return planner.oai_conversations[planner_user.name][-1][\"content\"]\n" + " # return the last message received from the planner\n", + " return planner_user.last_message()[\"content\"]\n" ] }, { @@ -168,7 +169,7 @@ " \"functions\": [\n", " {\n", " \"name\": \"ask_planner\",\n", - " \"description\": \"ask planner to: 1. get a plan, 2. verify the execution result of the plan and potentially suggest new plan.\",\n", + " \"description\": \"ask planner to: 1. get a plan for finishing a task, 2. verify the execution result of the plan and potentially suggest new plan.\",\n", " \"parameters\": {\n", " \"type\": \"object\",\n", " \"properties\": {\n", @@ -184,9 +185,9 @@ " }\n", ")\n", "\n", - "# create a UserProxyAgent instance named \"user\"\n", - "user = UserProxyAgent(\n", - " name=\"user\",\n", + "# create a UserProxyAgent instance named \"user_proxy\"\n", + "user_proxy = UserProxyAgent(\n", + " name=\"user_proxy\",\n", " human_input_mode=\"TERMINATE\",\n", " max_consecutive_auto_reply=10,\n", " # is_termination_msg=lambda x: \"content\" in x and x[\"content\"] is not None and x[\"content\"].rstrip().endswith(\"TERMINATE\"),\n", @@ -214,12 +215,12 @@ "name": "stdout", "output_type": "stream", "text": [ - "user (to assistant):\n", + "user_proxy (to assistant):\n", "\n", "Suggest a fix to an open good first issue of flaml\n", "\n", "--------------------------------------------------------------------------------\n", - "assistant (to user):\n", + "assistant (to user_proxy):\n", "\n", "To suggest a fix to an open good first issue of FLAML, we first need to fetch the list of open issues labeled as \"good first issue\" from the FLAML GitHub repository. We can do this using the GitHub API. Here is a Python script that fetches and prints the list of such issues.\n", "\n", @@ -232,12 +233,10 @@ "def fetch_issues():\n", " url = \"https://api.github.com/repos/microsoft/FLAML/issues\"\n", " response = requests.get(url, params={\"state\": \"open\", \"labels\": \"good first issue\"})\n", - " if response.status_code == 200:\n", - " issues = json.loads(response.text)\n", - " for issue in issues:\n", - " print(f\"Issue #{issue['number']}: {issue['title']}\")\n", - " else:\n", - " print(f\"Failed to fetch issues. HTTP status code: {response.status_code}\")\n", + " issues = response.json()\n", + "\n", + " for issue in issues:\n", + " print(f\"Issue #{issue['number']}: {issue['title']}\")\n", "\n", "fetch_issues()\n", "```\n", @@ -246,13 +245,18 @@ "\n", "--------------------------------------------------------------------------------\n", "\n", - ">>>>>>>> NO HUMAN INPUT RECEIVED. USING AUTO REPLY FOR THE USER...\n", - "user (to assistant):\n", + ">>>>>>>> USING AUTO REPLY...\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "user_proxy (to assistant):\n", "\n", "exitcode: 0 (execution succeeded)\n", "Code output: \n", "Issue #1120: use_label_encoder warning with xgboost\n", - "Issue #1099: Do not print data split method when user provides X_val in AutoML\n", "Issue #1034: Use appropriate wait time for retry based on the error message. \n", "Issue #1029: Issues with Adding Custom APIs in Auto Generation\n", "Issue #981: Running flaml[tune] using \"-O\" flag for python interpreter (optimization - disables assertions) crashes\n", @@ -274,23 +278,23 @@ "\n", "\n", "--------------------------------------------------------------------------------\n", - "assistant (to user):\n", + "assistant (to user_proxy):\n", "\n", "***** Suggested function Call: ask_planner *****\n", "Arguments: \n", "{\n", - " \"message\": \"Here are the open good first issues of FLAML: \\nIssue #1120: use_label_encoder warning with xgboost\\nIssue #1099: Do not print data split method when user provides X_val in AutoML\\nIssue #1034: Use appropriate wait time for retry based on the error message.\\nIssue #1029: Issues with Adding Custom APIs in Auto Generation\\nIssue #981: Running flaml[tune] using \\\"-O\\\" flag for python interpreter (optimization - disables assertions) crashes\\nIssue #903: Conditional parameter flow2 crash\\nIssue #884: indentation space\\nIssue #882: Check if openml version is required\\nIssue #834: Adjust the indent\\nIssue #821: pip install flaml FAIL\\nIssue #807: Isolate the ensemble part and expose it to users\\nIssue #805: how to pass categorical features names or indices to learner\\nIssue #785: Flaml/LightGBM - Shouldn't I found better/faster or equal results from FLAML than direct LightGBM?\\nIssue #764: Add an announcement of the discord channel\\nIssue #748: Documentation about small budget\\nIssue #737: Make zero-shot automl more discoverable\\nIssue #509: New HCrystalBall release\\nIssue #429: samples about conversion to ONNX\\nIssue #413: support anomaly detection\\nIssue #304: CatBoost Fails with Keyword 'groups'\\n\\nPlease suggest a fix for one of these issues.\"\n", + " \"message\": \"Here are the open good first issues of FLAML: \\n\\nIssue #1120: use_label_encoder warning with xgboost\\nIssue #1034: Use appropriate wait time for retry based on the error message.\\nIssue #1029: Issues with Adding Custom APIs in Auto Generation\\nIssue #981: Running flaml[tune] using \\\"-O\\\" flag for python interpreter (optimization - disables assertions) crashes\\nIssue #903: Conditional parameter flow2 crash\\nIssue #884: indentation space\\nIssue #882: Check if openml version is required\\nIssue #834: Adjust the indent\\nIssue #821: pip install flaml FAIL\\nIssue #807: Isolate the ensemble part and expose it to users\\nIssue #805: how to pass categorical features names or indices to learner\\nIssue #785: Flaml/LightGBM - Shouldn't I found better/faster or equal results from FLAML than direct LightGBM?\\nIssue #764: Add an announcement of the discord channel\\nIssue #748: Documentation about small budget\\nIssue #737: Make zero-shot automl more discoverable\\nIssue #509: New HCrystalBall release\\nIssue #429: samples about conversion to ONNX\\nIssue #413: support anomaly detection\\nIssue #304: CatBoost Fails with Keyword 'groups'\\n\\nPlease suggest a fix for one of these issues.\"\n", "}\n", "************************************************\n", "\n", "--------------------------------------------------------------------------------\n", "\n", - ">>>>>>>> NO HUMAN INPUT RECEIVED. USING AUTO REPLY FOR THE USER...\n", + ">>>>>>>> USING AUTO REPLY...\n", "planner_user (to planner):\n", "\n", "Here are the open good first issues of FLAML: \n", + "\n", "Issue #1120: use_label_encoder warning with xgboost\n", - "Issue #1099: Do not print data split method when user provides X_val in AutoML\n", "Issue #1034: Use appropriate wait time for retry based on the error message.\n", "Issue #1029: Issues with Adding Custom APIs in Auto Generation\n", "Issue #981: Running flaml[tune] using \"-O\" flag for python interpreter (optimization - disables assertions) crashes\n", @@ -315,141 +319,121 @@ "--------------------------------------------------------------------------------\n", "planner (to planner_user):\n", "\n", - "To provide appropriate suggestions for fixes, we first need to isolate a problem, understand it, and then propose a solution. Let's consider this issue as an example: \n", + "Without certain details about the issues, it's a bit challenging to suggest explicit fixes. However, I'll give you a roadmap to tackle some of these:\n", "\n", - "Issue #1099: Do not print data split method when user provides X_val in AutoML\n", + "1. **Issue #1120: use_label_encoder warning with xgboost**\n", "\n", - "Plan: \n", - "1. Understand the Source of the Problem: Study the part of the code where the issue originates. From the issue title, it seems like in the FLAML AutoML component, a data split method is being printed even when a user has provided a pre-split validation dataset.\n", - "2. Analyze the Code: If the user has already provided a validation data set (X_val), there would be no requirement for another data split. Therefore, it involves understanding why, nonetheless, a data split is printed. To solve this, the AI might have to go through the process where the software splits the data or loads the validation dataset, if available.\n", - "3. Propose a Solution: The solution could involve incorporating a conditional statement that checks if X_val is not null. If it isn't, then avoid printing the data split method. \n", - "4. Test the Solution: Once the code is implemented, it is important to test the solution by providing a validation dataset and ensuring that the data split information is no longer printed.\n", - "5. Inspect the result: If the proposed plan doesn't work as expected, analyze the issue and try to develop a better plan. If the execution is wrong, try to understand the error and adapt the approach accordingly.\n", + "Reasoning: It appears like the `use_label_encoder` warning stems from deprecated usage in the XGBoost module that FLAML utilizes. \n", "\n", - "--------------------------------------------------------------------------------\n", - "user (to assistant):\n", + "Plan: Update the call to the XGBoost module in FLAML to either stop using the label encoder or specify explicitly that the label encoder should be used, based on how FLAML is currently set up.\n", "\n", - "***** Response from calling function \"ask_planner\" *****\n", - "To provide appropriate suggestions for fixes, we first need to isolate a problem, understand it, and then propose a solution. Let's consider this issue as an example: \n", + "2. **Issue #903: Conditional parameter flow2 crash**\n", "\n", - "Issue #1099: Do not print data split method when user provides X_val in AutoML\n", + "Reasoning: This is likely a bug in the code where a condition is not properly handled.\n", "\n", - "Plan: \n", - "1. Understand the Source of the Problem: Study the part of the code where the issue originates. From the issue title, it seems like in the FLAML AutoML component, a data split method is being printed even when a user has provided a pre-split validation dataset.\n", - "2. Analyze the Code: If the user has already provided a validation data set (X_val), there would be no requirement for another data split. Therefore, it involves understanding why, nonetheless, a data split is printed. To solve this, the AI might have to go through the process where the software splits the data or loads the validation dataset, if available.\n", - "3. Propose a Solution: The solution could involve incorporating a conditional statement that checks if X_val is not null. If it isn't, then avoid printing the data split method. \n", - "4. Test the Solution: Once the code is implemented, it is important to test the solution by providing a validation dataset and ensuring that the data split information is no longer printed.\n", - "5. Inspect the result: If the proposed plan doesn't work as expected, analyze the issue and try to develop a better plan. If the execution is wrong, try to understand the error and adapt the approach accordingly.\n", - "********************************************************\n", + "Plan: Identify the conditions causing the crash, and update the code to handle the condition correctly.\n", "\n", - "--------------------------------------------------------------------------------\n", - "assistant (to user):\n", + "3. **Issue #882: Check if openml version is required**\n", "\n", - "Based on the plan, here is a Python script that you can use to fix the issue #1099. This script assumes that the data split method is printed in a function called `split_data` in a file called `automl.py` (you need to replace these with the actual function and file names). \n", + "Reasoning: The issue suggests that FLAML may be compatible with multiple versions of the `openml` library, but this isn't specified anywhere.\n", "\n", - "```python\n", - "# filename: fix_issue_1099.py\n", - "\n", - "def split_data(X, y, X_val=None):\n", - " if X_val is not None:\n", - " # If validation data is provided, use it without splitting\n", - " print(\"Using provided validation data\")\n", - " return X, y, X_val\n", - " else:\n", - " # If validation data is not provided, split the data and print the split method\n", - " print(\"Splitting data using method X\")\n", - " # Code to split the data goes here\n", - " return X_train, y_train, X_val\n", - "```\n", + "Plan: Identify the minimum required version of the `openml` library that FLAML can operate with. If there's no minimum version, then there's no issue. If there is, update the documentation and the package requirements to show this.\n", "\n", - "Please replace the function name and file name with the actual ones, save this script as `fix_issue_1099.py`, and run it. This script will fix the issue by not printing the data split method when validation data is provided.\n", + "4. **Issue #821: pip install flaml FAIL**\n", "\n", - "--------------------------------------------------------------------------------\n", + "Reasoning: Users are unable to install FLAML using pip. This could be due to unmet dependancies, or issues with the package itself.\n", "\n", - ">>>>>>>> NO HUMAN INPUT RECEIVED. USING AUTO REPLY FOR THE USER...\n", - "user (to assistant):\n", + "Plan: Investigate the specific errors when trying to install via pip. If dependencies are missing or incompatible, update the package requirements. If there are issues with the package, fix those issues.\n", "\n", - "exitcode: 0 (execution succeeded)\n", - "Code output: \n", + "5. **Issue #805: how to pass categorical features names or indices to learner**\n", "\n", + "Reasoning: It seems users are facing difficulty in passing categorical features. This could be due to unclear or incorrect documentation, or missing functionality.\n", "\n", - "--------------------------------------------------------------------------------\n", - "assistant (to user):\n", + "Plan: Inspect the current documentation and functionality. Update the documentation to clarify how to pass these features, and if the functionality is missing, implement the functionality.\n", "\n", - "***** Suggested function Call: ask_planner *****\n", - "Arguments: \n", - "{\n", - " \"message\": \"The user has executed the suggested code for fixing issue #1099 in FLAML. The code executed successfully without any output. Please suggest the next steps.\"\n", - "}\n", - "************************************************\n", + "Remember to thoroughly inspect the execution result for each issue to ensure your fix is effective. If the plan does not appear to fix the issue, adjust your plan based on the error message or unexpected behavior.\n", "\n", "--------------------------------------------------------------------------------\n", + "user_proxy (to assistant):\n", "\n", - ">>>>>>>> NO HUMAN INPUT RECEIVED. USING AUTO REPLY FOR THE USER...\n", - "planner_user (to planner):\n", + "***** Response from calling function \"ask_planner\" *****\n", + "Without certain details about the issues, it's a bit challenging to suggest explicit fixes. However, I'll give you a roadmap to tackle some of these:\n", "\n", - "The user has executed the suggested code for fixing issue #1099 in FLAML. The code executed successfully without any output. Please suggest the next steps.\n", + "1. **Issue #1120: use_label_encoder warning with xgboost**\n", "\n", - "--------------------------------------------------------------------------------\n", - "planner (to planner_user):\n", + "Reasoning: It appears like the `use_label_encoder` warning stems from deprecated usage in the XGBoost module that FLAML utilizes. \n", + "\n", + "Plan: Update the call to the XGBoost module in FLAML to either stop using the label encoder or specify explicitly that the label encoder should be used, based on how FLAML is currently set up.\n", + "\n", + "2. **Issue #903: Conditional parameter flow2 crash**\n", + "\n", + "Reasoning: This is likely a bug in the code where a condition is not properly handled.\n", "\n", - "Great, if the code executed successfully, we can continue with the following steps:\n", + "Plan: Identify the conditions causing the crash, and update the code to handle the condition correctly.\n", "\n", - "1. Code Review: Ensure the code is conforming to the overall structure, style, and standards of the FLAML project. Check if the changes are minimal, only related to the specific issue, and not affecting other parts of the codebase. \n", + "3. **Issue #882: Check if openml version is required**\n", "\n", - "2. Testing: Now, it's time to test the code under different scenarios. Here are some test cases you might consider:\n", + "Reasoning: The issue suggests that FLAML may be compatible with multiple versions of the `openml` library, but this isn't specified anywhere.\n", "\n", - " A. Provide a test when X_val is not provided. The code should behave in the same way as before your changes, including printing data split information.\n", + "Plan: Identify the minimum required version of the `openml` library that FLAML can operate with. If there's no minimum version, then there's no issue. If there is, update the documentation and the package requirements to show this.\n", "\n", - " B. Provide a test where X_val is provided. The updated code should no longer print data split information.\n", + "4. **Issue #821: pip install flaml FAIL**\n", "\n", - " C. Test with different types of data (real numbers, categorical variables, missing values, etc.) for robustness. \n", - " \n", - "3. Review Error Messages or Unexpected Behavior: If anything doesn't work as expected, understand the cause and modify the code as needed.\n", + "Reasoning: Users are unable to install FLAML using pip. This could be due to unmet dependancies, or issues with the package itself.\n", "\n", - "4. Documentation: If changes made to the code are substantial or might affect the way users interact with FLAML, properly document these changes. Make sure to clarify that if 'X_val' is provided, the data split method will not be printed.\n", + "Plan: Investigate the specific errors when trying to install via pip. If dependencies are missing or incompatible, update the package requirements. If there are issues with the package, fix those issues.\n", "\n", - "5. Submit the Code: When you're sure the changes fix the issue and don't introduce new ones, it would be the time to submit your code for review. Depending on the project guidelines, you may need to fork the repository, commit your changes, push the commit(s) to your fork, and then open a pull request.\n", + "5. **Issue #805: how to pass categorical features names or indices to learner**\n", "\n", - "6. Wait for Feedback: Once the code is submitted, wait for the maintainers' feedback. They might suggest some changes, enhancements, or approve the changes right away. Keep an open communication channel and respond to the comments, making the suggested changes. You might need to go through a few iterations of this process until the code is accepted and the issue is closed.\n", + "Reasoning: It seems users are facing difficulty in passing categorical features. This could be due to unclear or incorrect documentation, or missing functionality.\n", + "\n", + "Plan: Inspect the current documentation and functionality. Update the documentation to clarify how to pass these features, and if the functionality is missing, implement the functionality.\n", + "\n", + "Remember to thoroughly inspect the execution result for each issue to ensure your fix is effective. If the plan does not appear to fix the issue, adjust your plan based on the error message or unexpected behavior.\n", + "********************************************************\n", "\n", "--------------------------------------------------------------------------------\n", - "user (to assistant):\n", + "assistant (to user_proxy):\n", "\n", - "***** Response from calling function \"ask_planner\" *****\n", - "Great, if the code executed successfully, we can continue with the following steps:\n", + "Based on the planner's suggestions, let's tackle the first issue: \"Issue #1120: use_label_encoder warning with xgboost\". \n", + "\n", + "The warning is likely due to a deprecated usage in the XGBoost module that FLAML utilizes. To fix this, we need to update the call to the XGBoost module in FLAML to either stop using the label encoder or specify explicitly that the label encoder should be used, based on how FLAML is currently set up.\n", "\n", - "1. Code Review: Ensure the code is conforming to the overall structure, style, and standards of the FLAML project. Check if the changes are minimal, only related to the specific issue, and not affecting other parts of the codebase. \n", + "Here is a general approach to fix this issue:\n", "\n", - "2. Testing: Now, it's time to test the code under different scenarios. Here are some test cases you might consider:\n", + "1. Clone the FLAML repository to your local machine.\n", + "2. Navigate to the file where XGBoost is being called.\n", + "3. Look for the `use_label_encoder` parameter in the XGBoost function call.\n", + "4. If `use_label_encoder` is set to True, you can try setting it to False to see if the warning disappears.\n", + "5. If the warning persists, it might be necessary to refactor the code to avoid using label encoding in XGBoost, or to handle label encoding before data is passed to XGBoost.\n", + "6. After making changes, run the tests to make sure your changes do not break anything.\n", + "7. If everything is fine, commit your changes and create a pull request.\n", "\n", - " A. Provide a test when X_val is not provided. The code should behave in the same way as before your changes, including printing data split information.\n", + "Please note that without the actual codebase and the specific details of the issue, this is a general approach and might need to be adjusted based on the actual code and setup of FLAML. \n", "\n", - " B. Provide a test where X_val is provided. The updated code should no longer print data split information.\n", + "TERMINATE\n", "\n", - " C. Test with different types of data (real numbers, categorical variables, missing values, etc.) for robustness. \n", - " \n", - "3. Review Error Messages or Unexpected Behavior: If anything doesn't work as expected, understand the cause and modify the code as needed.\n", + "--------------------------------------------------------------------------------\n", "\n", - "4. Documentation: If changes made to the code are substantial or might affect the way users interact with FLAML, properly document these changes. Make sure to clarify that if 'X_val' is provided, the data split method will not be printed.\n", + ">>>>>>>> USING AUTO REPLY...\n", + "user_proxy (to assistant):\n", "\n", - "5. Submit the Code: When you're sure the changes fix the issue and don't introduce new ones, it would be the time to submit your code for review. Depending on the project guidelines, you may need to fork the repository, commit your changes, push the commit(s) to your fork, and then open a pull request.\n", "\n", - "6. Wait for Feedback: Once the code is submitted, wait for the maintainers' feedback. They might suggest some changes, enhancements, or approve the changes right away. Keep an open communication channel and respond to the comments, making the suggested changes. You might need to go through a few iterations of this process until the code is accepted and the issue is closed.\n", - "********************************************************\n", "\n", "--------------------------------------------------------------------------------\n", - "assistant (to user):\n", + "assistant (to user_proxy):\n", "\n", "TERMINATE\n", "\n", - "--------------------------------------------------------------------------------\n" + "--------------------------------------------------------------------------------\n", + "\n", + ">>>>>>>> NO HUMAN INPUT RECEIVED.\n" ] } ], "source": [ "# the assistant receives a message from the user, which contains the task description\n", - "user.initiate_chat(\n", + "user_proxy.initiate_chat(\n", " assistant,\n", " message=\"\"\"Suggest a fix to an open good first issue of flaml\"\"\",\n", ")" @@ -482,7 +466,7 @@ "name": "python", "nbconvert_exporter": "python", "pygments_lexer": "ipython3", - "version": "3.9.15" + "version": "3.9.17" }, "vscode": { "interpreter": { diff --git a/notebook/autogen_agent_two_users.ipynb b/notebook/autogen_agentchat_two_users.ipynb similarity index 55% rename from notebook/autogen_agent_two_users.ipynb rename to notebook/autogen_agentchat_two_users.ipynb index ad4933ea8a..781ddc124f 100644 --- a/notebook/autogen_agent_two_users.ipynb +++ b/notebook/autogen_agentchat_two_users.ipynb @@ -5,7 +5,7 @@ "cell_type": "markdown", "metadata": {}, "source": [ - "\"Open" + "\"Open" ] }, { @@ -17,9 +17,9 @@ } }, "source": [ - "# Multi-Agent Human-in-the-loop Application\n", + "# Auto Generated Agent Chat: Collaborative Task Solving with Multiple Agents and Human Users\n", "\n", - "FLAML offers an experimental feature of interactive LLM agents, which can be used to solve various tasks with human or automatic feedback, including tasks that require using tools via code.\n", + "FLAML offers an experimental feature of interactive LLM agents, which can be used to solve various tasks with human or automatic feedback, including tasks that require using tools via code. Please find documentation about this feature [here](https://microsoft.github.io/FLAML/docs/Use-Cases/Auto-Generation#agents-experimental).\n", "\n", "In this notebook, we demonstrate an application involving multiple agents and human users to work together and accomplish a task. `AssistantAgent` is an LLM-based agent that can write Python code (in a Python coding block) for a user to execute for a given task. `UserProxyAgent` is an agent which serves as a proxy for a user to execute the code written by `AssistantAgent`. We create multiple `UserProxyAgent` instances which can represent different human users.\n", "\n", @@ -123,13 +123,15 @@ "metadata": {}, "outputs": [], "source": [ - "from flaml.autogen.agent import AssistantAgent, UserProxyAgent\n", + "from flaml.autogen.agentchat import AssistantAgent, UserProxyAgent\n", "\n", "def ask_expert(message):\n", " assistant_for_expert = AssistantAgent(\n", " name=\"assistant_for_expert\",\n", - " temperature=0,\n", - " config_list=config_list,\n", + " oai_config={\n", + " \"temperature\": 0,\n", + " \"config_list\": config_list,\n", + " },\n", " )\n", " expert = UserProxyAgent(\n", " name=\"expert\",\n", @@ -139,9 +141,10 @@ "\n", " expert.initiate_chat(assistant_for_expert, message=message)\n", " expert.human_input_mode, expert.max_consecutive_auto_reply = \"NEVER\", 0\n", - " # final message from the expert\n", + " # final message sent from the expert\n", " expert.send(\"summarize the solution\", assistant_for_expert)\n", - " return assistant_for_expert.oai_conversations[expert.name][-1][\"content\"]\n" + " # return the last message the expert received\n", + " return expert.last_message()[\"content\"]\n" ] }, { @@ -220,23 +223,23 @@ "student (to assistant_for_student):\n", "\n", "Find $a + b + c$, given that $x+y \\neq -1$ and \n", - " \\begin{align}\n", + "\\begin{align}\n", "\tax + by + c & = x + 7,\\\n", "\ta + bx + cy & = 2x + 6y,\\\n", "\tay + b + cx & = 4x + y.\n", - "\t\\end{align}.\n", + "\\end{align}.\n", "\n", "\n", "--------------------------------------------------------------------------------\n", "assistant_for_student (to student):\n", "\n", - "This is a system of linear equations. We can solve it using Python's sympy library, which provides a method to solve systems of equations. Here is the Python code to solve it:\n", + "This is a system of linear equations. We can solve it using Python's sympy library, which provides a function to solve systems of equations. Here is the Python code to solve it:\n", "\n", "```python\n", "from sympy import symbols, Eq, solve\n", "\n", "# define the symbols\n", - "x, y, a, b, c = symbols('x y a b c')\n", + "a, b, c, x, y = symbols('a b c x y')\n", "\n", "# define the equations\n", "eq1 = Eq(a*x + b*y + c, x + 7)\n", @@ -256,7 +259,7 @@ "\n", "--------------------------------------------------------------------------------\n", "\n", - ">>>>>>>> NO HUMAN INPUT RECEIVED. USING AUTO REPLY FOR THE USER...\n" + ">>>>>>>> USING AUTO REPLY FOR THE USER...\n" ] }, { @@ -273,90 +276,17 @@ "--------------------------------------------------------------------------------\n", "assistant_for_student (to student):\n", "\n", - "The result you got is a symbolic expression in terms of x and y. This is because the system of equations is underdetermined, meaning there are more variables (a, b, c, x, y) than there are equations. Therefore, the solution is not unique and depends on the values of x and y.\n", - "\n", - "If you have specific values for x and y, you can substitute them into the expression to get a numerical result. Here is how you can do it:\n", - "\n", - "```python\n", - "# define the values for x and y\n", - "x_val = 1 # replace with your value\n", - "y_val = 2 # replace with your value\n", - "\n", - "# substitute the values into the result\n", - "numerical_result = result.subs({x: x_val, y: y_val})\n", - "\n", - "print(numerical_result)\n", - "```\n", - "\n", - "Please replace `x_val` and `y_val` with your specific values and run the code to get a numerical result for a + b + c.\n", - "\n", - "--------------------------------------------------------------------------------\n", - "\n", - ">>>>>>>> NO HUMAN INPUT RECEIVED. USING AUTO REPLY FOR THE USER...\n", - "student (to assistant_for_student):\n", - "\n", - "exitcode: 1 (execution failed)\n", - "Code output: \n", - "Traceback (most recent call last):\n", - " File \"/workspaces/FLAML/notebook/student/tmp_code_f877237249a9eef733c6da775235695a.py\", line 6, in \n", - " numerical_result = result.subs({x: x_val, y: y_val})\n", - "NameError: name 'result' is not defined\n", - "\n", - "\n", - "--------------------------------------------------------------------------------\n", - "assistant_for_student (to student):\n", - "\n", - "I apologize for the confusion. The variable `result` was defined in the previous code block and is not available in the current one. We need to combine the two code blocks into one. Here is the corrected code:\n", - "\n", - "```python\n", - "from sympy import symbols, Eq, solve\n", - "\n", - "# define the symbols\n", - "x, y, a, b, c = symbols('x y a b c')\n", - "\n", - "# define the equations\n", - "eq1 = Eq(a*x + b*y + c, x + 7)\n", - "eq2 = Eq(a + b*x + c*y, 2*x + 6*y)\n", - "eq3 = Eq(a*y + b + c*x, 4*x + y)\n", - "\n", - "# solve the system of equations\n", - "solution = solve((eq1, eq2, eq3), (a, b, c))\n", - "\n", - "# calculate a + b + c\n", - "result = solution[a] + solution[b] + solution[c]\n", - "\n", - "# define the values for x and y\n", - "x_val = 1 # replace with your value\n", - "y_val = 2 # replace with your value\n", - "\n", - "# substitute the values into the result\n", - "numerical_result = result.subs({x: x_val, y: y_val})\n", - "\n", - "print(numerical_result)\n", - "```\n", - "\n", - "Please replace `x_val` and `y_val` with your specific values and run the code to get a numerical result for a + b + c.\n", + "The output is the expression for $a + b + c$ in terms of $x$ and $y$. It's a bit complex, but it's the correct solution given the system of equations. \n", "\n", - "--------------------------------------------------------------------------------\n", + "If you have specific values for $x$ and $y$ (with the condition $x + y \\neq -1$), you can substitute them into this expression to get a numerical value for $a + b + c$.\n", "\n", - ">>>>>>>> NO HUMAN INPUT RECEIVED. USING AUTO REPLY FOR THE USER...\n", - "student (to assistant_for_student):\n", - "\n", - "exitcode: 0 (execution succeeded)\n", - "Code output: \n", - "7\n", - "\n", - "\n", - "--------------------------------------------------------------------------------\n", - "assistant_for_student (to student):\n", - "\n", - "Great! The sum of a, b, and c for the given values of x and y is 7. If you have different values for x and y, you can substitute them into the code to get the corresponding sum of a, b, and c. \n", + "If you don't have specific values for $x$ and $y$, this is the most simplified form of $a + b + c$ that we can get from the given system of equations.\n", "\n", "TERMINATE\n", "\n", "--------------------------------------------------------------------------------\n", "\n", - ">>>>>>>> NO HUMAN INPUT RECEIVED. USING AUTO REPLY FOR THE USER...\n", + ">>>>>>>> USING AUTO REPLY FOR THE USER...\n", "student (to assistant_for_student):\n", "\n", "\n", @@ -369,150 +299,7 @@ "--------------------------------------------------------------------------------\n", "student (to assistant_for_student):\n", "\n", - "How can I know whether the answer is correct for different x and y?\n", - "\n", - "--------------------------------------------------------------------------------\n", - "assistant_for_student (to student):\n", - "\n", - "To verify the correctness of the solution for different values of x and y, you can substitute the values of a, b, and c back into the original equations and check if the equations hold true. Here is the Python code to do this:\n", - "\n", - "```python\n", - "# define the values for x and y\n", - "x_val = 1 # replace with your value\n", - "y_val = 2 # replace with your value\n", - "\n", - "# substitute the values of x and y into the solution\n", - "solution_xy = {var: val.subs({x: x_val, y: y_val}) for var, val in solution.items()}\n", - "\n", - "# substitute the values of a, b, c, x, and y into the original equations\n", - "eq1_xy = eq1.subs({**solution_xy, x: x_val, y: y_val})\n", - "eq2_xy = eq2.subs({**solution_xy, x: x_val, y: y_val})\n", - "eq3_xy = eq3.subs({**solution_xy, x: x_val, y: y_val})\n", - "\n", - "# check if the equations hold true\n", - "print(eq1_xy.lhs == eq1_xy.rhs)\n", - "print(eq2_xy.lhs == eq2_xy.rhs)\n", - "print(eq3_xy.lhs == eq3_xy.rhs)\n", - "```\n", - "\n", - "This code will print `True` for each equation if the equation holds true for the given values of x and y, and `False` otherwise. Please replace `x_val` and `y_val` with your specific values and run the code to verify the solution.\n", - "\n", - "--------------------------------------------------------------------------------\n", - "\n", - ">>>>>>>> NO HUMAN INPUT RECEIVED. USING AUTO REPLY FOR THE USER...\n", - "student (to assistant_for_student):\n", - "\n", - "exitcode: 1 (execution failed)\n", - "Code output: \n", - "Traceback (most recent call last):\n", - " File \"/workspaces/FLAML/notebook/student/tmp_code_bfffab2ee600773e901400a04d010ce5.py\", line 6, in \n", - " solution_xy = {var: val.subs({x: x_val, y: y_val}) for var, val in solution.items()}\n", - "NameError: name 'solution' is not defined\n", - "\n", - "\n", - "--------------------------------------------------------------------------------\n", - "assistant_for_student (to student):\n", - "\n", - "I apologize for the confusion. The variable `solution` was defined in a previous code block and is not available in the current one. We need to combine the two code blocks into one. Here is the corrected code:\n", - "\n", - "```python\n", - "from sympy import symbols, Eq, solve\n", - "\n", - "# define the symbols\n", - "x, y, a, b, c = symbols('x y a b c')\n", - "\n", - "# define the equations\n", - "eq1 = Eq(a*x + b*y + c, x + 7)\n", - "eq2 = Eq(a + b*x + c*y, 2*x + 6*y)\n", - "eq3 = Eq(a*y + b + c*x, 4*x + y)\n", - "\n", - "# solve the system of equations\n", - "solution = solve((eq1, eq2, eq3), (a, b, c))\n", - "\n", - "# define the values for x and y\n", - "x_val = 1 # replace with your value\n", - "y_val = 2 # replace with your value\n", - "\n", - "# substitute the values of x and y into the solution\n", - "solution_xy = {var: val.subs({x: x_val, y: y_val}) for var, val in solution.items()}\n", - "\n", - "# substitute the values of a, b, c, x, and y into the original equations\n", - "eq1_xy = eq1.subs({**solution_xy, x: x_val, y: y_val})\n", - "eq2_xy = eq2.subs({**solution_xy, x: x_val, y: y_val})\n", - "eq3_xy = eq3.subs({**solution_xy, x: x_val, y: y_val})\n", - "\n", - "# check if the equations hold true\n", - "print(eq1_xy.lhs == eq1_xy.rhs)\n", - "print(eq2_xy.lhs == eq2_xy.rhs)\n", - "print(eq3_xy.lhs == eq3_xy.rhs)\n", - "```\n", - "\n", - "Please replace `x_val` and `y_val` with your specific values and run the code to verify the solution.\n", - "\n", - "--------------------------------------------------------------------------------\n", - "\n", - ">>>>>>>> NO HUMAN INPUT RECEIVED. USING AUTO REPLY FOR THE USER...\n", - "student (to assistant_for_student):\n", - "\n", - "exitcode: 1 (execution failed)\n", - "Code output: \n", - "Traceback (most recent call last):\n", - " File \"/workspaces/FLAML/notebook/student/tmp_code_c59f8d978512615a9cfd2b6a3d88eba5.py\", line 27, in \n", - " print(eq1_xy.lhs == eq1_xy.rhs)\n", - "AttributeError: 'BooleanTrue' object has no attribute 'lhs'\n", - "\n", - "\n", - "--------------------------------------------------------------------------------\n", - "assistant_for_student (to student):\n", - "\n", - "I apologize for the confusion. The `lhs` and `rhs` attributes are not available for the `BooleanTrue` object. We should use the `simplify()` function to simplify the difference between the left-hand side and the right-hand side of the equations. If the simplified result is zero, it means the equation holds true. Here is the corrected code:\n", - "\n", - "```python\n", - "from sympy import symbols, Eq, solve\n", - "\n", - "# define the symbols\n", - "x, y, a, b, c = symbols('x y a b c')\n", - "\n", - "# define the equations\n", - "eq1 = Eq(a*x + b*y + c, x + 7)\n", - "eq2 = Eq(a + b*x + c*y, 2*x + 6*y)\n", - "eq3 = Eq(a*y + b + c*x, 4*x + y)\n", - "\n", - "# solve the system of equations\n", - "solution = solve((eq1, eq2, eq3), (a, b, c))\n", - "\n", - "# define the values for x and y\n", - "x_val = 1 # replace with your value\n", - "y_val = 2 # replace with your value\n", - "\n", - "# substitute the values of x and y into the solution\n", - "solution_xy = {var: val.subs({x: x_val, y: y_val}) for var, val in solution.items()}\n", - "\n", - "# substitute the values of a, b, c, x, and y into the original equations\n", - "eq1_xy = eq1.subs({**solution_xy, x: x_val, y: y_val})\n", - "eq2_xy = eq2.subs({**solution_xy, x: x_val, y: y_val})\n", - "eq3_xy = eq3.subs({**solution_xy, x: x_val, y: y_val})\n", - "\n", - "# check if the equations hold true\n", - "print((eq1_xy.lhs - eq1_xy.rhs).simplify() == 0)\n", - "print((eq2_xy.lhs - eq2_xy.rhs).simplify() == 0)\n", - "print((eq3_xy.lhs - eq3_xy.rhs).simplify() == 0)\n", - "```\n", - "\n", - "Please replace `x_val` and `y_val` with your specific values and run the code to verify the solution.\n", - "\n", - "--------------------------------------------------------------------------------\n", - "\n", - ">>>>>>>> NO HUMAN INPUT RECEIVED. USING AUTO REPLY FOR THE USER...\n", - "student (to assistant_for_student):\n", - "\n", - "exitcode: 1 (execution failed)\n", - "Code output: \n", - "Traceback (most recent call last):\n", - " File \"/workspaces/FLAML/notebook/student/tmp_code_d0d73c6ee510ec04cb4aad933c129682.py\", line 27, in \n", - " print((eq1_xy.lhs - eq1_xy.rhs).simplify() == 0)\n", - "AttributeError: 'BooleanTrue' object has no attribute 'lhs'\n", - "\n", + "I'm not sure if the answer is correct\n", "\n", "--------------------------------------------------------------------------------\n", "assistant_for_student (to student):\n", @@ -520,93 +307,53 @@ "***** Suggested function Call: ask_expert *****\n", "Arguments: \n", "{\n", - " \"message\": \"I tried to solve a system of equations and then verify the solution by substituting the solution back into the original equations. However, I encountered an error saying 'BooleanTrue' object has no attribute 'lhs'. Here is the code I used:\\n\\n```python\\nfrom sympy import symbols, Eq, solve\\n\\n# define the symbols\\nx, y, a, b, c = symbols('x y a b c')\\n\\n# define the equations\\neq1 = Eq(a*x + b*y + c, x + 7)\\neq2 = Eq(a + b*x + c*y, 2*x + 6*y)\\neq3 = Eq(a*y + b + c*x, 4*x + y)\\n\\n# solve the system of equations\\nsolution = solve((eq1, eq2, eq3), (a, b, c))\\n\\n# define the values for x and y\\nx_val = 1 # replace with your value\\ny_val = 2 # replace with your value\\n\\n# substitute the values of x and y into the solution\\nsolution_xy = {var: val.subs({x: x_val, y: y_val}) for var, val in solution.items()}\\n\\n# substitute the values of a, b, c, x, and y into the original equations\\neq1_xy = eq1.subs({**solution_xy, x: x_val, y: y_val})\\neq2_xy = eq2.subs({**solution_xy, x: x_val, y: y_val})\\neq3_xy = eq3.subs({**solution_xy, x: x_val, y: y_val})\\n\\n# check if the equations hold true\\nprint((eq1_xy.lhs - eq1_xy.rhs).simplify() == 0)\\nprint((eq2_xy.lhs - eq2_xy.rhs).simplify() == 0)\\nprint((eq3_xy.lhs - eq3_xy.rhs).simplify() == 0)\\n```\\n\\nThe error occurred at the line `print((eq1_xy.lhs - eq1_xy.rhs).simplify() == 0)`. Could you please help me understand what went wrong and how to fix it?\"\n", + " \"message\": \"The user has a system of equations and wants to find the sum of the variables a, b, and c. The system of equations is as follows:\\n\\nax + by + c = x + 7,\\na + bx + cy = 2x + 6y,\\nay + b + cx = 4x + y.\\n\\nI used sympy to solve the system of equations and got the following expression for a + b + c:\\n\\n(2*x**2 - 3*x + y)/(x**2 - x*y - x + y**2 - y + 1) + (x**2 - 3*x*y + 2*x + y**2 - y)/(x**2 - x*y - x + y**2 - y + 1) + (4*x**2 - 4*x*y - 6*x + 6*y**2 - 7*y + 7)/(x**2 - x*y - x + y**2 - y + 1)\\n\\nThe user is not sure if the answer is correct. Could you please verify this?\"\n", "}\n", "***********************************************\n", "\n", "--------------------------------------------------------------------------------\n", "\n", - ">>>>>>>> NO HUMAN INPUT RECEIVED. USING AUTO REPLY FOR THE USER...\n", + ">>>>>>>> USING AUTO REPLY FOR THE USER...\n", "expert (to assistant_for_expert):\n", "\n", - "I tried to solve a system of equations and then verify the solution by substituting the solution back into the original equations. However, I encountered an error saying 'BooleanTrue' object has no attribute 'lhs'. Here is the code I used:\n", - "\n", - "```python\n", - "from sympy import symbols, Eq, solve\n", - "\n", - "# define the symbols\n", - "x, y, a, b, c = symbols('x y a b c')\n", - "\n", - "# define the equations\n", - "eq1 = Eq(a*x + b*y + c, x + 7)\n", - "eq2 = Eq(a + b*x + c*y, 2*x + 6*y)\n", - "eq3 = Eq(a*y + b + c*x, 4*x + y)\n", - "\n", - "# solve the system of equations\n", - "solution = solve((eq1, eq2, eq3), (a, b, c))\n", - "\n", - "# define the values for x and y\n", - "x_val = 1 # replace with your value\n", - "y_val = 2 # replace with your value\n", + "The user has a system of equations and wants to find the sum of the variables a, b, and c. The system of equations is as follows:\n", "\n", - "# substitute the values of x and y into the solution\n", - "solution_xy = {var: val.subs({x: x_val, y: y_val}) for var, val in solution.items()}\n", + "ax + by + c = x + 7,\n", + "a + bx + cy = 2x + 6y,\n", + "ay + b + cx = 4x + y.\n", "\n", - "# substitute the values of a, b, c, x, and y into the original equations\n", - "eq1_xy = eq1.subs({**solution_xy, x: x_val, y: y_val})\n", - "eq2_xy = eq2.subs({**solution_xy, x: x_val, y: y_val})\n", - "eq3_xy = eq3.subs({**solution_xy, x: x_val, y: y_val})\n", + "I used sympy to solve the system of equations and got the following expression for a + b + c:\n", "\n", - "# check if the equations hold true\n", - "print((eq1_xy.lhs - eq1_xy.rhs).simplify() == 0)\n", - "print((eq2_xy.lhs - eq2_xy.rhs).simplify() == 0)\n", - "print((eq3_xy.lhs - eq3_xy.rhs).simplify() == 0)\n", - "```\n", + "(2*x**2 - 3*x + y)/(x**2 - x*y - x + y**2 - y + 1) + (x**2 - 3*x*y + 2*x + y**2 - y)/(x**2 - x*y - x + y**2 - y + 1) + (4*x**2 - 4*x*y - 6*x + 6*y**2 - 7*y + 7)/(x**2 - x*y - x + y**2 - y + 1)\n", "\n", - "The error occurred at the line `print((eq1_xy.lhs - eq1_xy.rhs).simplify() == 0)`. Could you please help me understand what went wrong and how to fix it?\n", + "The user is not sure if the answer is correct. Could you please verify this?\n", "\n", "--------------------------------------------------------------------------------\n", "assistant_for_expert (to expert):\n", "\n", - "The error message 'BooleanTrue' object has no attribute 'lhs' indicates that the object `eq1_xy` is not an equation but a boolean value `True`. This happens when the substitution in the line `eq1_xy = eq1.subs({**solution_xy, x: x_val, y: y_val})` results in an equation that is already satisfied, i.e., the left-hand side (lhs) equals the right-hand side (rhs). In such a case, the `subs` method simplifies the equation to `True`, and `True` does not have `lhs` or `rhs` attributes.\n", - "\n", - "To fix this issue, you can check if the result of the substitution is an instance of `Eq` before trying to access its `lhs` and `rhs` attributes. If it's not an instance of `Eq`, it means the equation is already satisfied, and you can print `True` directly. Here is the corrected code:\n", + "Sure, I can help you verify the solution. Let's first define the given system of equations and the expression for a + b + c using sympy, and then we'll check if the expression is correct by substituting it back into the original equations. Here's the code to do that:\n", "\n", "```python\n", "from sympy import symbols, Eq, solve\n", "\n", - "# define the symbols\n", "x, y, a, b, c = symbols('x y a b c')\n", "\n", - "# define the equations\n", "eq1 = Eq(a*x + b*y + c, x + 7)\n", "eq2 = Eq(a + b*x + c*y, 2*x + 6*y)\n", "eq3 = Eq(a*y + b + c*x, 4*x + y)\n", "\n", - "# solve the system of equations\n", - "solution = solve((eq1, eq2, eq3), (a, b, c))\n", - "\n", - "# define the values for x and y\n", - "x_val = 1 # replace with your value\n", - "y_val = 2 # replace with your value\n", + "abc_expression = (2*x**2 - 3*x + y)/(x**2 - x*y - x + y**2 - y + 1) + (x**2 - 3*x*y + 2*x + y**2 - y)/(x**2 - x*y - x + y**2 - y + 1) + (4*x**2 - 4*x*y - 6*x + 6*y**2 - 7*y + 7)/(x**2 - x*y - x + y**2 - y + 1)\n", "\n", - "# substitute the values of x and y into the solution\n", - "solution_xy = {var: val.subs({x: x_val, y: y_val}) for var, val in solution.items()}\n", + "solutions = solve((eq1, eq2, eq3), (a, b, c))\n", "\n", - "# substitute the values of a, b, c, x, and y into the original equations\n", - "eq1_xy = eq1.subs({**solution_xy, x: x_val, y: y_val})\n", - "eq2_xy = eq2.subs({**solution_xy, x: x_val, y: y_val})\n", - "eq3_xy = eq3.subs({**solution_xy, x: x_val, y: y_val})\n", + "abc_sum = sum(solutions.values())\n", "\n", - "# check if the equations hold true\n", - "for eq_xy in [eq1_xy, eq2_xy, eq3_xy]:\n", - " if isinstance(eq_xy, Eq):\n", - " print((eq_xy.lhs - eq_xy.rhs).simplify() == 0)\n", - " else:\n", - " print(True)\n", + "print(\"abc_expression:\", abc_expression)\n", + "print(\"abc_sum:\", abc_sum)\n", + "print(\"abc_expression equals abc_sum:\", abc_expression.equals(abc_sum))\n", "```\n", "\n", - "This code will print `True` for each equation if the solution satisfies the equation.\n", + "Please execute the above code, and we'll see if the expression for a + b + c is correct.\n", "\n", "--------------------------------------------------------------------------------\n", "\n", @@ -615,110 +362,69 @@ "\n", "exitcode: 0 (execution succeeded)\n", "Code output: \n", - "True\n", - "True\n", - "True\n", + "abc_expression: (2*x**2 - 3*x + y)/(x**2 - x*y - x + y**2 - y + 1) + (x**2 - 3*x*y + 2*x + y**2 - y)/(x**2 - x*y - x + y**2 - y + 1) + (4*x**2 - 4*x*y - 6*x + 6*y**2 - 7*y + 7)/(x**2 - x*y - x + y**2 - y + 1)\n", + "abc_sum: (2*x**2 - 3*x + y)/(x**2 - x*y - x + y**2 - y + 1) + (x**2 - 3*x*y + 2*x + y**2 - y)/(x**2 - x*y - x + y**2 - y + 1) + (4*x**2 - 4*x*y - 6*x + 6*y**2 - 7*y + 7)/(x**2 - x*y - x + y**2 - y + 1)\n", + "abc_expression equals abc_sum: True\n", "\n", "\n", "--------------------------------------------------------------------------------\n", "assistant_for_expert (to expert):\n", "\n", - "Great! The output `True` for each equation indicates that the solution satisfies all the equations. This means the system of equations was solved correctly and the solution was verified successfully. If you have any other questions or need further assistance, feel free to ask. Otherwise, if everything is done, we can terminate this session.\n", + "Great! The output shows that the expression for a + b + c is indeed correct, as the abc_expression equals the abc_sum. You can trust the solution provided by sympy.\n", + "\n", + "TERMINATE\n", "\n", "--------------------------------------------------------------------------------\n", "expert (to assistant_for_expert):\n", "\n", - "try simplifying the solution directly with sympy\n", + "can you simplify it?\n", "\n", "--------------------------------------------------------------------------------\n", "assistant_for_expert (to expert):\n", "\n", - "Sure, you can simplify the solution directly using sympy's `simplify` function. Here is how you can do it:\n", + "Sure, we can simplify the expression using sympy's simplify function. Here's the code to do that:\n", "\n", "```python\n", - "from sympy import symbols, Eq, solve, simplify\n", + "from sympy import simplify\n", "\n", - "# define the symbols\n", - "x, y, a, b, c = symbols('x y a b c')\n", - "\n", - "# define the equations\n", - "eq1 = Eq(a*x + b*y + c, x + 7)\n", - "eq2 = Eq(a + b*x + c*y, 2*x + 6*y)\n", - "eq3 = Eq(a*y + b + c*x, 4*x + y)\n", + "simplified_expression = simplify(abc_expression)\n", "\n", - "# solve the system of equations\n", - "solution = solve((eq1, eq2, eq3), (a, b, c))\n", - "\n", - "# simplify the solution\n", - "solution_simplified = {var: simplify(val) for var, val in solution.items()}\n", - "\n", - "# print the simplified solution\n", - "for var, val in solution_simplified.items():\n", - " print(f\"{var} = {val}\")\n", + "print(\"Simplified expression:\", simplified_expression)\n", "```\n", "\n", - "This code will solve the system of equations, simplify the solution, and print the simplified solution.\n", + "Please execute the above code to get the simplified expression.\n", "\n", "--------------------------------------------------------------------------------\n", "\n", ">>>>>>>> NO HUMAN INPUT RECEIVED. USING AUTO REPLY FOR THE USER...\n", "expert (to assistant_for_expert):\n", "\n", - "exitcode: 0 (execution succeeded)\n", + "exitcode: 1 (execution failed)\n", "Code output: \n", - "a = (x**2 - 3*x*y + 2*x + y**2 - y)/(x**2 - x*y - x + y**2 - y + 1)\n", - "b = (2*x**2 - 3*x + y)/(x**2 - x*y - x + y**2 - y + 1)\n", - "c = (4*x**2 - 4*x*y - 6*x + 6*y**2 - 7*y + 7)/(x**2 - x*y - x + y**2 - y + 1)\n", - "\n", - "\n", - "--------------------------------------------------------------------------------\n", - "assistant_for_expert (to expert):\n", - "\n", - "Great! The code has successfully simplified the solution to your system of equations. The simplified solution is:\n", - "\n", - "a = (x² - 3xy + 2x + y² - y) / (x² - xy - x + y² - y + 1)\n", - "\n", - "b = (2x² - 3x + y) / (x² - xy - x + y² - y + 1)\n", - "\n", - "c = (4x² - 4xy - 6x + 6y² - 7y + 7) / (x² - xy - x + y² - y + 1)\n", - "\n", - "If you have any other questions or need further assistance, feel free to ask. Otherwise, if everything is done, we can terminate this session.\n", - "\n", - "--------------------------------------------------------------------------------\n", - "expert (to assistant_for_expert):\n", + "Traceback (most recent call last):\n", + " File \"/workspaces/FLAML/notebook/expert/tmp_code_fc1e7ed6cfddd1970c30e3cc25694093.py\", line 3, in \n", + " simplified_expression = simplify(abc_expression)\n", + "NameError: name 'abc_expression' is not defined\n", "\n", - "solve for a+b+c\n", "\n", "--------------------------------------------------------------------------------\n", "assistant_for_expert (to expert):\n", "\n", - "Sure, you can solve for a + b + c by adding the expressions for a, b, and c from the simplified solution. Here is how you can do it:\n", + "Apologies for the error. I forgot to include the definition of the abc_expression in the code. Here's the corrected code:\n", "\n", "```python\n", - "from sympy import symbols, Eq, solve, simplify\n", + "from sympy import symbols, simplify\n", "\n", - "# define the symbols\n", - "x, y, a, b, c = symbols('x y a b c')\n", + "x, y = symbols('x y')\n", "\n", - "# define the equations\n", - "eq1 = Eq(a*x + b*y + c, x + 7)\n", - "eq2 = Eq(a + b*x + c*y, 2*x + 6*y)\n", - "eq3 = Eq(a*y + b + c*x, 4*x + y)\n", - "\n", - "# solve the system of equations\n", - "solution = solve((eq1, eq2, eq3), (a, b, c))\n", + "abc_expression = (2*x**2 - 3*x + y)/(x**2 - x*y - x + y**2 - y + 1) + (x**2 - 3*x*y + 2*x + y**2 - y)/(x**2 - x*y - x + y**2 - y + 1) + (4*x**2 - 4*x*y - 6*x + 6*y**2 - 7*y + 7)/(x**2 - x*y - x + y**2 - y + 1)\n", "\n", - "# simplify the solution\n", - "solution_simplified = {var: simplify(val) for var, val in solution.items()}\n", + "simplified_expression = simplify(abc_expression)\n", "\n", - "# calculate a + b + c\n", - "abc = simplify(solution_simplified[a] + solution_simplified[b] + solution_simplified[c])\n", - "\n", - "# print a + b + c\n", - "print(f\"a + b + c = {abc}\")\n", + "print(\"Simplified expression:\", simplified_expression)\n", "```\n", "\n", - "This code will solve the system of equations, simplify the solution, calculate a + b + c, and print the result.\n", + "Please execute the above code to get the simplified expression.\n", "\n", "--------------------------------------------------------------------------------\n", "\n", @@ -727,89 +433,63 @@ "\n", "exitcode: 0 (execution succeeded)\n", "Code output: \n", - "a + b + c = 7\n", + "Simplified expression: 7\n", "\n", "\n", "--------------------------------------------------------------------------------\n", "assistant_for_expert (to expert):\n", "\n", - "Great! The code has successfully calculated the sum of a, b, and c from the simplified solution. The result is:\n", + "Great! The simplified expression for a + b + c is 7. This means that regardless of the values of x and y, the sum of the variables a, b, and c from the given system of equations will always be 7.\n", "\n", - "a + b + c = 7\n", - "\n", - "This means that the sum of the solutions to your system of equations is 7. If you have any other questions or need further assistance, feel free to ask. Otherwise, if everything is done, we can terminate this session.\n", + "TERMINATE\n", "\n", "--------------------------------------------------------------------------------\n", + "\n", + ">>>>>>>> NO HUMAN INPUT RECEIVED. USING AUTO REPLY FOR THE USER...\n", "expert (to assistant_for_expert):\n", "\n", - "summarize the solution\n", + "\n", "\n", "--------------------------------------------------------------------------------\n", "assistant_for_expert (to expert):\n", "\n", - "Sure, here is the summary of the solution:\n", - "\n", - "1. You had a system of three equations with five variables (a, b, c, x, y). The equations were:\n", - "\n", - " a*x + b*y + c = x + 7\n", - "\n", - " a + b*x + c*y = 2*x + 6*y\n", - "\n", - " a*y + b + c*x = 4*x + y\n", - "\n", - "2. We solved this system of equations for a, b, and c using sympy's `solve` function. The solution was:\n", - "\n", - " a = (x² - 3xy + 2x + y² - y) / (x² - xy - x + y² - y + 1)\n", + "TERMINATE\n", "\n", - " b = (2x² - 3x + y) / (x² - xy - x + y² - y + 1)\n", + "--------------------------------------------------------------------------------\n", + "expert (to assistant_for_expert):\n", "\n", - " c = (4x² - 4xy - 6x + 6y² - 7y + 7) / (x² - xy - x + y² - y + 1)\n", + "summarize the solution\n", "\n", - "3. We simplified the solution using sympy's `simplify` function.\n", + "--------------------------------------------------------------------------------\n", + "assistant_for_expert (to expert):\n", "\n", - "4. We calculated the sum of a, b, and c from the simplified solution and found that a + b + c = 7.\n", + "The user had a system of equations and an expression for the sum of the variables a, b, and c. The user wanted to verify if the expression was correct. The AI assistant used sympy to define the system of equations and the expression, and then checked if the expression was correct by comparing it with the sum of the solutions for a, b, and c. The result was True, indicating that the expression was correct.\n", "\n", - "This means that the sum of the solutions to your system of equations is 7, regardless of the values of x and y. If you have any other questions or need further assistance, feel free to ask. Otherwise, if everything is done, we can terminate this session.\n", + "The user then asked to simplify the expression. The AI assistant used sympy's simplify function to simplify the expression, and the result was 7. This means that regardless of the values of x and y, the sum of the variables a, b, and c from the given system of equations will always be 7.\n", "\n", "--------------------------------------------------------------------------------\n", "student (to assistant_for_student):\n", "\n", "***** Response from calling function \"ask_expert\" *****\n", - "Sure, here is the summary of the solution:\n", - "\n", - "1. You had a system of three equations with five variables (a, b, c, x, y). The equations were:\n", - "\n", - " a*x + b*y + c = x + 7\n", - "\n", - " a + b*x + c*y = 2*x + 6*y\n", - "\n", - " a*y + b + c*x = 4*x + y\n", - "\n", - "2. We solved this system of equations for a, b, and c using sympy's `solve` function. The solution was:\n", - "\n", - " a = (x² - 3xy + 2x + y² - y) / (x² - xy - x + y² - y + 1)\n", + "The user had a system of equations and an expression for the sum of the variables a, b, and c. The user wanted to verify if the expression was correct. The AI assistant used sympy to define the system of equations and the expression, and then checked if the expression was correct by comparing it with the sum of the solutions for a, b, and c. The result was True, indicating that the expression was correct.\n", "\n", - " b = (2x² - 3x + y) / (x² - xy - x + y² - y + 1)\n", - "\n", - " c = (4x² - 4xy - 6x + 6y² - 7y + 7) / (x² - xy - x + y² - y + 1)\n", - "\n", - "3. We simplified the solution using sympy's `simplify` function.\n", - "\n", - "4. We calculated the sum of a, b, and c from the simplified solution and found that a + b + c = 7.\n", - "\n", - "This means that the sum of the solutions to your system of equations is 7, regardless of the values of x and y. If you have any other questions or need further assistance, feel free to ask. Otherwise, if everything is done, we can terminate this session.\n", + "The user then asked to simplify the expression. The AI assistant used sympy's simplify function to simplify the expression, and the result was 7. This means that regardless of the values of x and y, the sum of the variables a, b, and c from the given system of equations will always be 7.\n", "*******************************************************\n", "\n", "--------------------------------------------------------------------------------\n", "assistant_for_student (to student):\n", "\n", - "I apologize for the confusion. The error occurred because the equations were already simplified to `True` when the values of a, b, c, x, and y were substituted. This means that the equations hold true for the given values of x and y. Therefore, we don't need to subtract the right-hand side from the left-hand side and simplify the result. Instead, we can directly print the simplified equations. Here is the corrected code:\n", + "I apologize for the confusion earlier. After consulting with an expert, it appears that the sum of a, b, and c from the given system of equations is actually a constant value, not dependent on x and y. \n", + "\n", + "The correct answer is 7. \n", + "\n", + "Here is the corrected Python code:\n", "\n", "```python\n", - "from sympy import symbols, Eq, solve\n", + "from sympy import symbols, Eq, solve, simplify\n", "\n", "# define the symbols\n", - "x, y, a, b, c = symbols('x y a b c')\n", + "a, b, c, x, y = symbols('a b c x y')\n", "\n", "# define the equations\n", "eq1 = Eq(a*x + b*y + c, x + 7)\n", @@ -819,50 +499,39 @@ "# solve the system of equations\n", "solution = solve((eq1, eq2, eq3), (a, b, c))\n", "\n", - "# define the values for x and y\n", - "x_val = 1 # replace with your value\n", - "y_val = 2 # replace with your value\n", - "\n", - "# substitute the values of x and y into the solution\n", - "solution_xy = {var: val.subs({x: x_val, y: y_val}) for var, val in solution.items()}\n", + "# calculate a + b + c\n", + "result = solution[a] + solution[b] + solution[c]\n", "\n", - "# substitute the values of a, b, c, x, and y into the original equations\n", - "eq1_xy = eq1.subs({**solution_xy, x: x_val, y: y_val})\n", - "eq2_xy = eq2.subs({**solution_xy, x: x_val, y: y_val})\n", - "eq3_xy = eq3.subs({**solution_xy, x: x_val, y: y_val})\n", + "# simplify the result\n", + "simplified_result = simplify(result)\n", "\n", - "# print the simplified equations\n", - "print(eq1_xy)\n", - "print(eq2_xy)\n", - "print(eq3_xy)\n", + "print(simplified_result)\n", "```\n", "\n", - "This code will print `True` for each equation if the equation holds true for the given values of x and y. Please replace `x_val` and `y_val` with your specific values and run the code to verify the solution.\n", + "Please run this code to find the simplified sum of a, b, and c.\n", "\n", "--------------------------------------------------------------------------------\n", "\n", - ">>>>>>>> NO HUMAN INPUT RECEIVED. USING AUTO REPLY FOR THE USER...\n", + ">>>>>>>> USING AUTO REPLY FOR THE USER...\n", "student (to assistant_for_student):\n", "\n", "exitcode: 0 (execution succeeded)\n", "Code output: \n", - "True\n", - "True\n", - "True\n", + "7\n", "\n", "\n", "--------------------------------------------------------------------------------\n", "assistant_for_student (to student):\n", "\n", - "Great! The output `True` for each equation indicates that the equations hold true for the given values of x and y. Therefore, the solution is correct. \n", + "Great! The output confirms that the sum of $a$, $b$, and $c$ from the given system of equations is indeed 7, regardless of the values of $x$ and $y$ (with the condition $x + y \\neq -1$). \n", "\n", - "If you have different values for x and y, you can substitute them into the code to verify the solution for those values.\n", + "I hope this answers your question satisfactorily. \n", "\n", "TERMINATE\n", "\n", "--------------------------------------------------------------------------------\n", "\n", - ">>>>>>>> NO HUMAN INPUT RECEIVED. USING AUTO REPLY FOR THE USER...\n", + ">>>>>>>> USING AUTO REPLY FOR THE USER...\n", "student (to assistant_for_student):\n", "\n", "\n", @@ -881,11 +550,11 @@ "student.initiate_chat(\n", " assistant_for_student,\n", " message=\"\"\"Find $a + b + c$, given that $x+y \\\\neq -1$ and \n", - " \\\\begin{align}\n", + "\\\\begin{align}\n", "\tax + by + c & = x + 7,\\\\\n", "\ta + bx + cy & = 2x + 6y,\\\\\n", "\tay + b + cx & = 4x + y.\n", - "\t\\\\end{align}.\n", + "\\\\end{align}.\n", "\"\"\",\n", ")" ] diff --git a/notebook/autogen_agent_web_info.ipynb b/notebook/autogen_agentchat_web_info.ipynb similarity index 54% rename from notebook/autogen_agent_web_info.ipynb rename to notebook/autogen_agentchat_web_info.ipynb index 499e3fcd54..079d507f43 100644 --- a/notebook/autogen_agent_web_info.ipynb +++ b/notebook/autogen_agentchat_web_info.ipynb @@ -5,7 +5,7 @@ "cell_type": "markdown", "metadata": {}, "source": [ - "\"Open" + "\"Open" ] }, { @@ -17,7 +17,7 @@ } }, "source": [ - "# Interactive LLM Agent Dealing with Web Info\n", + "# Auto Generated Agent Chat: Solving Tasks Requiring Web Info\n", "\n", "FLAML offers an experimental feature of interactive LLM agents, which can be used to solve various tasks with human or automatic feedback, including tasks that require using tools via code.\n", "Please find documentation about this feature [here](https://microsoft.github.io/FLAML/docs/Use-Cases/Auto-Generation#agents-experimental).\n", @@ -26,7 +26,7 @@ "* discuss a paper based on its URL.\n", "* discuss about stock market.\n", "\n", - "Here `AssistantAgent` is an LLM-based agent that can write Python code (in a Python coding block) for a user to execute for a given task. `UserProxyAgent` is an agent which serves as a proxy for a user to execute the code written by `AssistantAgent`. By setting `human_input_mode` properly, the `UserProxyAgent` can also prompt the user for feedback to `AssistantAgent`. For example, when `human_input_mode` is set to \"ALWAYS\", the `UserProxyAgent` will always prompt the user for feedback. When user feedback is provided, the `UserProxyAgent` will directly pass the feedback to `AssistantAgent` without doing any additional steps. When no user feedback is provided, the `UserProxyAgent` will execute the code written by `AssistantAgent` directly and return the execution results (success or failure and corresponding outputs) to `AssistantAgent`.\n", + "Here `AssistantAgent` is an LLM-based agent that can write Python code (in a Python coding block) for a user to execute for a given task. `UserProxyAgent` is an agent which serves as a proxy for a user to execute the code written by `AssistantAgent`. By setting `human_input_mode` properly, the `UserProxyAgent` can also prompt the user for feedback to `AssistantAgent`. For example, when `human_input_mode` is set to \"TERMINATE\", the `UserProxyAgent` will execute the code written by `AssistantAgent` directly and return the execution results (success or failure and corresponding outputs) to `AssistantAgent`, and prompt the user for feedback when the task is finished. When user feedback is provided, the `UserProxyAgent` will directly pass the feedback to `AssistantAgent`.\n", "\n", "## Requirements\n", "\n", @@ -121,7 +121,7 @@ "source": [ "## Construct Agents\n", "\n", - "We construct the assistant agent and the user proxy agent. We specify `human_input_mode` as \"TERMINATE\" in the user proxy agent, which will ask for feedback when it receives a \"TERMINATE\" signal from the assistant agent." + "We construct the assistant agent and the user proxy agent. We specify `human_input_mode` as \"TERMINATE\" in the user proxy agent, which will ask for human feedback when it receives a \"TERMINATE\" signal from the assistant agent." ] }, { @@ -130,7 +130,7 @@ "metadata": {}, "outputs": [], "source": [ - "from flaml.autogen.agent import AssistantAgent, UserProxyAgent\n", + "from flaml.autogen.agentchat import AssistantAgent, UserProxyAgent\n", "\n", "# create an AssistantAgent instance named \"assistant\"\n", "assistant = AssistantAgent(\n", @@ -143,9 +143,9 @@ " \"temperature\": 0,\n", " }\n", ")\n", - "# create a UserProxyAgent instance named \"user\"\n", - "user = UserProxyAgent(\n", - " name=\"user\",\n", + "# create a UserProxyAgent instance named \"user_proxy\"\n", + "user_proxy = UserProxyAgent(\n", + " name=\"user_proxy\",\n", " human_input_mode=\"TERMINATE\",\n", " max_consecutive_auto_reply=10,\n", " is_termination_msg=lambda x: x.get(\"content\", \"\").rstrip().endswith(\"TERMINATE\"),\n", @@ -172,16 +172,16 @@ "name": "stdout", "output_type": "stream", "text": [ - "user (to assistant):\n", + "user_proxy (to assistant):\n", "\n", "\n", "Who should read this paper: https://arxiv.org/abs/2306.01337\n", "\n", "\n", "--------------------------------------------------------------------------------\n", - "assistant (to user):\n", + "assistant (to user_proxy):\n", "\n", - "To determine who should read this paper, I will first extract the abstract and analyze its content. Here's a Python code to fetch the abstract from the given URL:\n", + "To determine who should read this paper, let's first extract the abstract and analyze its content. We can use Python with the `requests` and `BeautifulSoup` libraries to do this. Please execute the following code:\n", "\n", "```python\n", "import requests\n", @@ -194,12 +194,18 @@ "print(abstract)\n", "```\n", "\n", - "Please execute the above code to get the abstract of the paper.\n", + "After executing the code, I will analyze the abstract and suggest who should read the paper.\n", "\n", "--------------------------------------------------------------------------------\n", "\n", - ">>>>>>>> NO HUMAN INPUT RECEIVED. USING AUTO REPLY FOR THE USER...\n", - "user (to assistant):\n", + ">>>>>>>> USING AUTO REPLY FOR THE USER...\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "user_proxy (to assistant):\n", "\n", "exitcode: 0 (execution succeeded)\n", "Code output: \n", @@ -217,19 +223,18 @@ "\n", "\n", "--------------------------------------------------------------------------------\n", - "assistant (to user):\n", + "assistant (to user_proxy):\n", "\n", - "Based on the abstract, the paper is about using Large Language Models (LLMs), specifically GPT-4, to solve complex mathematical problems. The paper introduces a conversational problem-solving framework called MathChat and evaluates its performance on difficult high school competition problems from the MATH dataset.\n", + "Based on the abstract, the paper is about using Large Language Models (LLMs), specifically GPT-4, to solve complex mathematical problems. The authors propose a conversational problem-solving framework called MathChat and evaluate it on difficult high school competition problems from the MATH dataset.\n", "\n", "The target audience for this paper includes:\n", "\n", - "1. Researchers and practitioners in the field of artificial intelligence, natural language processing, and machine learning, particularly those interested in large language models like GPT-4.\n", - "2. Mathematicians and educators who are interested in exploring the potential of AI for solving complex mathematical problems and improving educational tools.\n", - "3. Developers working on AI-based applications for problem-solving, tutoring, or educational purposes.\n", + "1. Researchers and practitioners in the field of artificial intelligence, specifically those working with large language models like GPT-4.\n", + "2. Mathematicians and educators interested in the application of AI for solving complex mathematical problems.\n", + "3. Developers working on AI-based conversational systems or chatbots for problem-solving in various domains.\n", + "4. Students and researchers in natural language processing, machine learning, and AI who are interested in the intersection of these fields with mathematics.\n", "\n", - "If you belong to any of these categories or have a general interest in AI and its applications in mathematics, you should consider reading this paper.\n", - "\n", - "TERMINATE\n", + "If you belong to any of these categories or have a general interest in AI and its applications, you might find this paper valuable. TERMINATE\n", "\n", "--------------------------------------------------------------------------------\n" ] @@ -237,7 +242,7 @@ ], "source": [ "# the assistant receives a message from the user, which contains the task description\n", - "user.initiate_chat(\n", + "user_proxy.initiate_chat(\n", " assistant,\n", " message=\"\"\"\n", "Who should read this paper: https://arxiv.org/abs/2306.01337\n", @@ -255,168 +260,178 @@ }, { "cell_type": "code", - "execution_count": 6, + "execution_count": 5, "metadata": {}, "outputs": [ { "name": "stdout", "output_type": "stream", "text": [ - "user (to assistant):\n", + "user_proxy (to assistant):\n", "\n", "Show me the YTD gain of 10 largest technology companies as of today.\n", "\n", "--------------------------------------------------------------------------------\n", - "assistant (to user):\n", + "assistant (to user_proxy):\n", "\n", - "To get the YTD gain of the 10 largest technology companies, we can use a Python script to fetch the data from a financial API. We'll use the free Alpha Vantage API for this purpose. First, you need to obtain an API key from the Alpha Vantage website. Please visit https://www.alphavantage.co/support/#api-key and get your API key.\n", - "\n", - "Once you have the API key, please replace `YOUR_API_KEY` in the code below with your actual API key and execute the code:\n", + "To get the YTD gain of the 10 largest technology companies, we can use a Python script to fetch the data from a financial API like Yahoo Finance. Please execute the following Python code:\n", "\n", "```python\n", + "import datetime\n", "import requests\n", - "import json\n", + "import pandas as pd\n", + "from bs4 import BeautifulSoup\n", "\n", - "api_key = \"YOUR_API_KEY\"\n", - "symbols = [\"AAPL\", \"MSFT\", \"GOOGL\", \"GOOG\", \"AMZN\", \"FB\", \"TSLA\", \"NVDA\", \"ADBE\", \"ASML\"]\n", + "def get_top_tech_companies():\n", + " url = \"https://www.tradingview.com/markets/stocks-usa/sectorandindustry-industry/technology/\"\n", + " response = requests.get(url)\n", + " soup = BeautifulSoup(response.text, \"html.parser\")\n", + " table = soup.find(\"table\", {\"class\": \"tv-data-table\"})\n", + " rows = table.find_all(\"tr\")[1:11]\n", + " symbols = [row.find(\"a\").text for row in rows]\n", + " return symbols\n", "\n", "def get_ytd_gain(symbol):\n", - " url = f\"https://www.alphavantage.co/query?function=TIME_SERIES_DAILY_ADJUSTED&symbol={symbol}&apikey={api_key}\"\n", + " today = datetime.date.today()\n", + " start_date = datetime.date(today.year, 1, 1)\n", + " url = f\"https://query1.finance.yahoo.com/v7/finance/download/{symbol}?period1={int(start_date.timestamp())}&period2={int(today.timestamp())}&interval=1d&events=history&includeAdjustedClose=true\"\n", " response = requests.get(url)\n", - " data = json.loads(response.text)\n", - " daily_data = data[\"Time Series (Daily)\"]\n", - " sorted_dates = sorted(daily_data.keys())\n", - " first_day_of_year = next(date for date in sorted_dates if date.startswith(\"2022-01\"))\n", - " last_day = sorted_dates[-1]\n", - " open_price = float(daily_data[first_day_of_year][\"1. open\"])\n", - " close_price = float(daily_data[last_day][\"4. close\"])\n", - " ytd_gain = (close_price - open_price) / open_price * 100\n", + " data = pd.read_csv(pd.StringIO(response.text))\n", + " ytd_gain = (data[\"Close\"].iloc[-1] - data[\"Close\"].iloc[0]) / data[\"Close\"].iloc[0] * 100\n", " return ytd_gain\n", "\n", - "ytd_gains = {symbol: get_ytd_gain(symbol) for symbol in symbols}\n", - "print(\"YTD Gains of 10 Largest Technology Companies:\")\n", + "top_tech_companies = get_top_tech_companies()\n", + "ytd_gains = {symbol: get_ytd_gain(symbol) for symbol in top_tech_companies}\n", + "\n", "for symbol, gain in ytd_gains.items():\n", " print(f\"{symbol}: {gain:.2f}%\")\n", "```\n", "\n", - "This script fetches the daily adjusted stock data for the 10 largest technology companies and calculates the YTD gain for each of them. The results will be printed in the format \"Symbol: YTD Gain%\".\n", + "This code will fetch the 10 largest technology companies from TradingView and then calculate their YTD gains using Yahoo Finance data.\n", "\n", "--------------------------------------------------------------------------------\n", "\n", - ">>>>>>>> NO HUMAN INPUT RECEIVED. USING AUTO REPLY FOR THE USER...\n", - "user (to assistant):\n", + ">>>>>>>> USING AUTO REPLY FOR THE USER...\n", + "user_proxy (to assistant):\n", "\n", "exitcode: 1 (execution failed)\n", "Code output: \n", "Traceback (most recent call last):\n", - " File \"/workspaces/FLAML/notebook/web/tmp_code_0fb74c6e622b29ddd2ed9f0415582b98.py\", line 20, in \n", - " ytd_gains = {symbol: get_ytd_gain(symbol) for symbol in symbols}\n", - " File \"/workspaces/FLAML/notebook/web/tmp_code_0fb74c6e622b29ddd2ed9f0415582b98.py\", line 20, in \n", - " ytd_gains = {symbol: get_ytd_gain(symbol) for symbol in symbols}\n", - " File \"/workspaces/FLAML/notebook/web/tmp_code_0fb74c6e622b29ddd2ed9f0415582b98.py\", line 13, in get_ytd_gain\n", - " first_day_of_year = next(date for date in sorted_dates if date.startswith(\"2022-01\"))\n", - "StopIteration\n", + " File \"/workspaces/FLAML/notebook/web/tmp_code_2e1e4c6201cb82d42fbeb0754e008d0f.py\", line 24, in \n", + " top_tech_companies = get_top_tech_companies()\n", + " File \"/workspaces/FLAML/notebook/web/tmp_code_2e1e4c6201cb82d42fbeb0754e008d0f.py\", line 11, in get_top_tech_companies\n", + " rows = table.find_all(\"tr\")[1:11]\n", + "AttributeError: 'NoneType' object has no attribute 'find_all'\n", "\n", "\n", "--------------------------------------------------------------------------------\n", - "assistant (to user):\n", + "assistant (to user_proxy):\n", "\n", - "I apologize for the error. It seems that the code failed to find the first trading day of the year. Let's modify the code to handle this issue:\n", + "I apologize for the error. It seems that the website structure has changed, and the script is unable to find the table containing the top technology companies. Let's try an alternative approach using the Yahoo Finance library. Please install the library first by executing:\n", + "\n", + "```sh\n", + "pip install yfinance\n", + "```\n", + "\n", + "After installing the library, please execute the following Python code:\n", "\n", "```python\n", - "import requests\n", - "import json\n", + "import yfinance as yf\n", + "import datetime\n", "\n", - "api_key = \"YOUR_API_KEY\"\n", - "symbols = [\"AAPL\", \"MSFT\", \"GOOGL\", \"GOOG\", \"AMZN\", \"FB\", \"TSLA\", \"NVDA\", \"ADBE\", \"ASML\"]\n", + "top_tech_companies = [\n", + " \"AAPL\", \"MSFT\", \"GOOGL\", \"GOOG\", \"AMZN\", \"FB\", \"TSLA\", \"NVDA\", \"ASML\", \"ADBE\"\n", + "]\n", "\n", "def get_ytd_gain(symbol):\n", - " url = f\"https://www.alphavantage.co/query?function=TIME_SERIES_DAILY_ADJUSTED&symbol={symbol}&apikey={api_key}\"\n", - " response = requests.get(url)\n", - " data = json.loads(response.text)\n", - " daily_data = data[\"Time Series (Daily)\"]\n", - " sorted_dates = sorted(daily_data.keys())\n", - " first_day_of_year = None\n", - " for date in sorted_dates:\n", - " if date.startswith(\"2022-01\"):\n", - " first_day_of_year = date\n", - " break\n", - " if first_day_of_year is None:\n", - " return None\n", - " last_day = sorted_dates[-1]\n", - " open_price = float(daily_data[first_day_of_year][\"1. open\"])\n", - " close_price = float(daily_data[last_day][\"4. close\"])\n", - " ytd_gain = (close_price - open_price) / open_price * 100\n", + " today = datetime.date.today()\n", + " start_date = datetime.date(today.year, 1, 1)\n", + " stock = yf.Ticker(symbol)\n", + " data = stock.history(start=start_date, end=today)\n", + " ytd_gain = (data[\"Close\"].iloc[-1] - data[\"Close\"].iloc[0]) / data[\"Close\"].iloc[0] * 100\n", " return ytd_gain\n", "\n", - "ytd_gains = {symbol: get_ytd_gain(symbol) for symbol in symbols}\n", - "print(\"YTD Gains of 10 Largest Technology Companies:\")\n", + "ytd_gains = {symbol: get_ytd_gain(symbol) for symbol in top_tech_companies}\n", + "\n", "for symbol, gain in ytd_gains.items():\n", - " if gain is not None:\n", - " print(f\"{symbol}: {gain:.2f}%\")\n", - " else:\n", - " print(f\"{symbol}: Data not available\")\n", + " print(f\"{symbol}: {gain:.2f}%\")\n", "```\n", "\n", - "Please replace `YOUR_API_KEY` with your actual API key and execute the code again. This should resolve the issue and display the YTD gains for the 10 largest technology companies.\n", + "This code uses a predefined list of the 10 largest technology companies and calculates their YTD gains using the Yahoo Finance library.\n", "\n", "--------------------------------------------------------------------------------\n", "\n", - ">>>>>>>> NO HUMAN INPUT RECEIVED. USING AUTO REPLY FOR THE USER...\n", - "user (to assistant):\n", + ">>>>>>>> USING AUTO REPLY FOR THE USER...\n", + "user_proxy (to assistant):\n", "\n", "exitcode: 1 (execution failed)\n", "Code output: \n", + "Defaulting to user installation because normal site-packages is not writeable\n", + "Requirement already satisfied: yfinance in /home/vscode/.local/lib/python3.9/site-packages (0.2.26)\n", + "Requirement already satisfied: lxml>=4.9.1 in /home/vscode/.local/lib/python3.9/site-packages (from yfinance) (4.9.3)\n", + "Requirement already satisfied: pytz>=2022.5 in /home/vscode/.local/lib/python3.9/site-packages (from yfinance) (2023.3)\n", + "Requirement already satisfied: numpy>=1.16.5 in /home/vscode/.local/lib/python3.9/site-packages (from yfinance) (1.25.1)\n", + "Requirement already satisfied: html5lib>=1.1 in /home/vscode/.local/lib/python3.9/site-packages (from yfinance) (1.1)\n", + "Requirement already satisfied: beautifulsoup4>=4.11.1 in /home/vscode/.local/lib/python3.9/site-packages (from yfinance) (4.12.2)\n", + "Requirement already satisfied: multitasking>=0.0.7 in /home/vscode/.local/lib/python3.9/site-packages (from yfinance) (0.0.11)\n", + "Requirement already satisfied: appdirs>=1.4.4 in /home/vscode/.local/lib/python3.9/site-packages (from yfinance) (1.4.4)\n", + "Requirement already satisfied: pandas>=1.3.0 in /home/vscode/.local/lib/python3.9/site-packages (from yfinance) (2.0.3)\n", + "Requirement already satisfied: requests>=2.31 in /usr/local/lib/python3.9/site-packages (from yfinance) (2.31.0)\n", + "Requirement already satisfied: frozendict>=2.3.4 in /home/vscode/.local/lib/python3.9/site-packages (from yfinance) (2.3.8)\n", + "Requirement already satisfied: soupsieve>1.2 in /home/vscode/.local/lib/python3.9/site-packages (from beautifulsoup4>=4.11.1->yfinance) (2.4.1)\n", + "Requirement already satisfied: six>=1.9 in /usr/local/lib/python3.9/site-packages (from html5lib>=1.1->yfinance) (1.16.0)\n", + "Requirement already satisfied: webencodings in /home/vscode/.local/lib/python3.9/site-packages (from html5lib>=1.1->yfinance) (0.5.1)\n", + "Requirement already satisfied: python-dateutil>=2.8.2 in /home/vscode/.local/lib/python3.9/site-packages (from pandas>=1.3.0->yfinance) (2.8.2)\n", + "Requirement already satisfied: tzdata>=2022.1 in /home/vscode/.local/lib/python3.9/site-packages (from pandas>=1.3.0->yfinance) (2023.3)\n", + "Requirement already satisfied: urllib3<3,>=1.21.1 in /usr/local/lib/python3.9/site-packages (from requests>=2.31->yfinance) (2.0.3)\n", + "Requirement already satisfied: certifi>=2017.4.17 in /usr/local/lib/python3.9/site-packages (from requests>=2.31->yfinance) (2023.5.7)\n", + "Requirement already satisfied: idna<4,>=2.5 in /usr/local/lib/python3.9/site-packages (from requests>=2.31->yfinance) (3.4)\n", + "Requirement already satisfied: charset-normalizer<4,>=2 in /usr/local/lib/python3.9/site-packages (from requests>=2.31->yfinance) (3.2.0)\n", + "\n", + "FB: No timezone found, symbol may be delisted\n", "Traceback (most recent call last):\n", - " File \"/workspaces/FLAML/notebook/web/tmp_code_a050ea892378b99f57347f4e08c4a294.py\", line 26, in \n", - " ytd_gains = {symbol: get_ytd_gain(symbol) for symbol in symbols}\n", - " File \"/workspaces/FLAML/notebook/web/tmp_code_a050ea892378b99f57347f4e08c4a294.py\", line 26, in \n", - " ytd_gains = {symbol: get_ytd_gain(symbol) for symbol in symbols}\n", - " File \"/workspaces/FLAML/notebook/web/tmp_code_a050ea892378b99f57347f4e08c4a294.py\", line 11, in get_ytd_gain\n", - " daily_data = data[\"Time Series (Daily)\"]\n", - "KeyError: 'Time Series (Daily)'\n", + " File \"/workspaces/FLAML/notebook/web/tmp_code_52c69e134e808cf8ba196ac60faede00.py\", line 16, in \n", + " ytd_gains = {symbol: get_ytd_gain(symbol) for symbol in top_tech_companies}\n", + " File \"/workspaces/FLAML/notebook/web/tmp_code_52c69e134e808cf8ba196ac60faede00.py\", line 16, in \n", + " ytd_gains = {symbol: get_ytd_gain(symbol) for symbol in top_tech_companies}\n", + " File \"/workspaces/FLAML/notebook/web/tmp_code_52c69e134e808cf8ba196ac60faede00.py\", line 13, in get_ytd_gain\n", + " ytd_gain = (data[\"Close\"].iloc[-1] - data[\"Close\"].iloc[0]) / data[\"Close\"].iloc[0] * 100\n", + " File \"/home/vscode/.local/lib/python3.9/site-packages/pandas/core/indexing.py\", line 1103, in __getitem__\n", + " return self._getitem_axis(maybe_callable, axis=axis)\n", + " File \"/home/vscode/.local/lib/python3.9/site-packages/pandas/core/indexing.py\", line 1656, in _getitem_axis\n", + " self._validate_integer(key, axis)\n", + " File \"/home/vscode/.local/lib/python3.9/site-packages/pandas/core/indexing.py\", line 1589, in _validate_integer\n", + " raise IndexError(\"single positional indexer is out-of-bounds\")\n", + "IndexError: single positional indexer is out-of-bounds\n", "\n", "\n", "--------------------------------------------------------------------------------\n", - "assistant (to user):\n", + "assistant (to user_proxy):\n", "\n", - "I apologize for the error. It seems that the Alpha Vantage API is not returning the expected data. This might be due to the API call limit or an issue with the API itself. To resolve this, let's add a delay between API calls and handle the KeyError exception:\n", + "I apologize for the error. It seems that there is an issue with the data for the \"FB\" symbol. Let's add a try-except block to handle this issue. Please execute the following Python code:\n", "\n", "```python\n", - "import requests\n", - "import json\n", - "import time\n", + "import yfinance as yf\n", + "import datetime\n", "\n", - "api_key = \"YOUR_API_KEY\"\n", - "symbols = [\"AAPL\", \"MSFT\", \"GOOGL\", \"GOOG\", \"AMZN\", \"FB\", \"TSLA\", \"NVDA\", \"ADBE\", \"ASML\"]\n", + "top_tech_companies = [\n", + " \"AAPL\", \"MSFT\", \"GOOGL\", \"GOOG\", \"AMZN\", \"FB\", \"TSLA\", \"NVDA\", \"ASML\", \"ADBE\"\n", + "]\n", "\n", "def get_ytd_gain(symbol):\n", - " url = f\"https://www.alphavantage.co/query?function=TIME_SERIES_DAILY_ADJUSTED&symbol={symbol}&apikey={api_key}\"\n", - " response = requests.get(url)\n", - " data = json.loads(response.text)\n", - " if \"Time Series (Daily)\" not in data:\n", - " return None\n", - " daily_data = data[\"Time Series (Daily)\"]\n", - " sorted_dates = sorted(daily_data.keys())\n", - " first_day_of_year = None\n", - " for date in sorted_dates:\n", - " if date.startswith(\"2022-01\"):\n", - " first_day_of_year = date\n", - " break\n", - " if first_day_of_year is None:\n", + " try:\n", + " today = datetime.date.today()\n", + " start_date = datetime.date(today.year, 1, 1)\n", + " stock = yf.Ticker(symbol)\n", + " data = stock.history(start=start_date, end=today)\n", + " ytd_gain = (data[\"Close\"].iloc[-1] - data[\"Close\"].iloc[0]) / data[\"Close\"].iloc[0] * 100\n", + " return ytd_gain\n", + " except Exception as e:\n", + " print(f\"Error fetching data for {symbol}: {e}\")\n", " return None\n", - " last_day = sorted_dates[-1]\n", - " open_price = float(daily_data[first_day_of_year][\"1. open\"])\n", - " close_price = float(daily_data[last_day][\"4. close\"])\n", - " ytd_gain = (close_price - open_price) / open_price * 100\n", - " return ytd_gain\n", "\n", - "ytd_gains = {}\n", - "for symbol in symbols:\n", - " ytd_gains[symbol] = get_ytd_gain(symbol)\n", - " time.sleep(15) # Add a delay between API calls\n", + "ytd_gains = {symbol: get_ytd_gain(symbol) for symbol in top_tech_companies}\n", "\n", - "print(\"YTD Gains of 10 Largest Technology Companies:\")\n", "for symbol, gain in ytd_gains.items():\n", " if gain is not None:\n", " print(f\"{symbol}: {gain:.2f}%\")\n", @@ -424,117 +439,106 @@ " print(f\"{symbol}: Data not available\")\n", "```\n", "\n", - "Please replace `YOUR_API_KEY` with your actual API key and execute the code again. This should resolve the issue and display the YTD gains for the 10 largest technology companies. Note that the script will take some time to execute due to the added delay between API calls.\n", + "This code will handle any issues with the data and display \"Data not available\" for any symbols that encounter an error.\n", "\n", "--------------------------------------------------------------------------------\n", "\n", - ">>>>>>>> NO HUMAN INPUT RECEIVED. USING AUTO REPLY FOR THE USER...\n", - "user (to assistant):\n", + ">>>>>>>> USING AUTO REPLY FOR THE USER...\n", + "user_proxy (to assistant):\n", "\n", "exitcode: 0 (execution succeeded)\n", "Code output: \n", - "YTD Gains of 10 Largest Technology Companies:\n", - "AAPL: Data not available\n", - "MSFT: Data not available\n", - "GOOGL: Data not available\n", - "GOOG: Data not available\n", - "AMZN: Data not available\n", + "Error fetching data for FB: single positional indexer is out-of-bounds\n", + "AAPL: 55.26%\n", + "MSFT: 47.19%\n", + "GOOGL: 37.13%\n", + "GOOG: 36.89%\n", + "AMZN: 50.47%\n", "FB: Data not available\n", - "TSLA: Data not available\n", - "NVDA: Data not available\n", - "ADBE: Data not available\n", - "ASML: Data not available\n", + "TSLA: 145.40%\n", + "NVDA: 219.19%\n", + "ASML: 25.70%\n", + "ADBE: 55.92%\n", "\n", "\n", "--------------------------------------------------------------------------------\n", - "assistant (to user):\n", + "assistant (to user_proxy):\n", "\n", - "I apologize for the inconvenience. It seems that the Alpha Vantage API is not providing the required data. In this case, let's switch to another API, the FRED (Federal Reserve Economic Data) API, which provides historical stock data. First, you need to obtain an API key from the FRED website. Please visit https://research.stlouisfed.org/docs/api/api_key.html and get your API key.\n", + "I'm glad the code executed successfully. Here are the YTD gains for the 10 largest technology companies as of today:\n", "\n", - "Once you have the API key, please replace `YOUR_API_KEY` in the code below with your actual API key and execute the code:\n", + "- AAPL: 55.26%\n", + "- MSFT: 47.19%\n", + "- GOOGL: 37.13%\n", + "- GOOG: 36.89%\n", + "- AMZN: 50.47%\n", + "- FB: Data not available\n", + "- TSLA: 145.40%\n", + "- NVDA: 219.19%\n", + "- ASML: 25.70%\n", + "- ADBE: 55.92%\n", "\n", - "```python\n", - "import requests\n", - "import json\n", - "import time\n", + "Please note that the data for \"FB\" is not available due to an issue with the data source. You may want to check an alternative data source or try again later for the \"FB\" symbol.\n", "\n", - "api_key = \"YOUR_API_KEY\"\n", - "symbols = [\"AAPL\", \"MSFT\", \"GOOGL\", \"GOOG\", \"AMZN\", \"FB\", \"TSLA\", \"NVDA\", \"ADBE\", \"ASML\"]\n", + "If you have any other questions or need further assistance, feel free to ask. Otherwise, if everything is done, please type \"TERMINATE\".\n", "\n", - "def get_ytd_gain(symbol):\n", - " url = f\"https://fred.stlouisfed.org/graph/fredgraph.csv?bgcolor=%23e1e9f0&chart_type=line&drp=0&fo=open%20sans&graph_bgcolor=%23ffffff&height=450&mode=fred&recession_bars=on&txtcolor=%23444444&ts=12&tts=12&width=1168&nt=0&thu=0&trc=0&show_legend=yes&show_axis_titles=yes&show_tooltip=yes&id={symbol}&scale=left&cosd=2022-01-01&coed=2022-12-31&line_color=%234572a7&link_values=false&line_style=solid&mark_type=none&mw=3&lw=2&ost=-99999&oet=99999&mma=0&fml=a&fq=Daily&fam=avg&fgst=lin&fgsnd=2020-02-01&line_index=1&transformation=lin&vintage_date=2022-12-31&revision_date=2022-12-31&nd=2022-01-01\"\n", - " response = requests.get(url)\n", - " data = response.text.splitlines()\n", - " if len(data) < 2:\n", - " return None\n", - " first_day_of_year = data[1].split(\",\")[1]\n", - " last_day = data[-1].split(\",\")[1]\n", - " open_price = float(first_day_of_year)\n", - " close_price = float(last_day)\n", - " ytd_gain = (close_price - open_price) / open_price * 100\n", - " return ytd_gain\n", + "--------------------------------------------------------------------------------\n", "\n", - "ytd_gains = {}\n", - "for symbol in symbols:\n", - " ytd_gains[symbol] = get_ytd_gain(symbol)\n", - " time.sleep(5) # Add a delay between API calls\n", + ">>>>>>>> USING AUTO REPLY FOR THE USER...\n", + "user_proxy (to assistant):\n", "\n", - "print(\"YTD Gains of 10 Largest Technology Companies:\")\n", - "for symbol, gain in ytd_gains.items():\n", - " if gain is not None:\n", - " print(f\"{symbol}: {gain:.2f}%\")\n", - " else:\n", - " print(f\"{symbol}: Data not available\")\n", - "```\n", "\n", - "This script fetches the daily stock data for the 10 largest technology companies from the FRED API and calculates the YTD gain for each of them. The results will be printed in the format \"Symbol: YTD Gain%\". Note that the script will take some time to execute due to the added delay between API calls.\n", "\n", "--------------------------------------------------------------------------------\n", + "assistant (to user_proxy):\n", "\n", - ">>>>>>>> NO HUMAN INPUT RECEIVED. USING AUTO REPLY FOR THE USER...\n", - "user (to assistant):\n", + "It seems you didn't provide any input. If you have any other questions or need further assistance, feel free to ask. Otherwise, if everything is done, please type \"TERMINATE\".\n", + "\n", + "--------------------------------------------------------------------------------\n", + "\n", + ">>>>>>>> USING AUTO REPLY FOR THE USER...\n", + "user_proxy (to assistant):\n", "\n", - "exitcode: 1 (execution failed)\n", - "Code output: \n", - "Traceback (most recent call last):\n", - " File \"/workspaces/FLAML/notebook/web/tmp_code_ba93be30359073e751a640cd13b3ef7e.py\", line 23, in \n", - " ytd_gains[symbol] = get_ytd_gain(symbol)\n", - " File \"/workspaces/FLAML/notebook/web/tmp_code_ba93be30359073e751a640cd13b3ef7e.py\", line 14, in get_ytd_gain\n", - " first_day_of_year = data[1].split(\",\")[1]\n", - "IndexError: list index out of range\n", "\n", "\n", "--------------------------------------------------------------------------------\n", - "assistant (to user):\n", + "assistant (to user_proxy):\n", "\n", - "I apologize for the confusion. It seems that the FRED API does not provide the required stock data. In this case, let's use the Yahoo Finance API, which is a popular choice for fetching stock data. We will use the `yfinance` library to fetch the data. First, you need to install the library by executing the following command:\n", + "I understand that you might be busy or have no further questions. If you need any assistance in the future, feel free to ask. Have a great day!\n", "\n", - "```sh\n", - "pip install yfinance\n", - "```\n", + "TERMINATE\n", + "\n", + "--------------------------------------------------------------------------------\n", + "user_proxy (to assistant):\n", + "\n", + "FB -> META\n", + "\n", + "--------------------------------------------------------------------------------\n", + "assistant (to user_proxy):\n", "\n", - "Once the library is installed, please execute the following code:\n", + "I apologize for the confusion earlier. The \"FB\" symbol has been changed to \"META\" due to the company's rebranding. Let's update the code with the new symbol and execute it again. Please run the following Python code:\n", "\n", "```python\n", "import yfinance as yf\n", "import datetime\n", "\n", - "symbols = [\"AAPL\", \"MSFT\", \"GOOGL\", \"GOOG\", \"AMZN\", \"FB\", \"TSLA\", \"NVDA\", \"ADBE\", \"ASML\"]\n", + "top_tech_companies = [\n", + " \"AAPL\", \"MSFT\", \"GOOGL\", \"GOOG\", \"AMZN\", \"META\", \"TSLA\", \"NVDA\", \"ASML\", \"ADBE\"\n", + "]\n", "\n", "def get_ytd_gain(symbol):\n", - " now = datetime.datetime.now()\n", - " start_date = datetime.datetime(now.year, 1, 1)\n", - " end_date = now\n", - " stock_data = yf.download(symbol, start=start_date, end=end_date)\n", - " if stock_data.empty:\n", + " try:\n", + " today = datetime.date.today()\n", + " start_date = datetime.date(today.year, 1, 1)\n", + " stock = yf.Ticker(symbol)\n", + " data = stock.history(start=start_date, end=today)\n", + " ytd_gain = (data[\"Close\"].iloc[-1] - data[\"Close\"].iloc[0]) / data[\"Close\"].iloc[0] * 100\n", + " return ytd_gain\n", + " except Exception as e:\n", + " print(f\"Error fetching data for {symbol}: {e}\")\n", " return None\n", - " open_price = stock_data.iloc[0][\"Open\"]\n", - " close_price = stock_data.iloc[-1][\"Close\"]\n", - " ytd_gain = (close_price - open_price) / open_price * 100\n", - " return ytd_gain\n", "\n", - "ytd_gains = {symbol: get_ytd_gain(symbol) for symbol in symbols}\n", - "print(\"YTD Gains of 10 Largest Technology Companies:\")\n", + "ytd_gains = {symbol: get_ytd_gain(symbol) for symbol in top_tech_companies}\n", + "\n", "for symbol, gain in ytd_gains.items():\n", " if gain is not None:\n", " print(f\"{symbol}: {gain:.2f}%\")\n", @@ -542,205 +546,68 @@ " print(f\"{symbol}: Data not available\")\n", "```\n", "\n", - "This script fetches the daily stock data for the 10 largest technology companies from the Yahoo Finance API using the `yfinance` library and calculates the YTD gain for each of them. The results will be printed in the format \"Symbol: YTD Gain%\".\n", + "This code will now use the \"META\" symbol instead of \"FB\" and should provide the YTD gain for Meta Platforms Inc. (formerly Facebook).\n", "\n", "--------------------------------------------------------------------------------\n", "\n", - ">>>>>>>> NO HUMAN INPUT RECEIVED. USING AUTO REPLY FOR THE USER...\n", - "user (to assistant):\n", + ">>>>>>>> USING AUTO REPLY FOR THE USER...\n", + "user_proxy (to assistant):\n", "\n", "exitcode: 0 (execution succeeded)\n", "Code output: \n", - "Defaulting to user installation because normal site-packages is not writeable\n", - "Requirement already satisfied: yfinance in /home/vscode/.local/lib/python3.9/site-packages (0.2.18)\n", - "Requirement already satisfied: pandas>=1.3.0 in /usr/local/lib/python3.9/site-packages (from yfinance) (1.5.2)\n", - "Requirement already satisfied: numpy>=1.16.5 in /home/vscode/.local/lib/python3.9/site-packages (from yfinance) (1.23.5)\n", - "Requirement already satisfied: requests>=2.26 in /usr/local/lib/python3.9/site-packages (from yfinance) (2.28.1)\n", - "Requirement already satisfied: multitasking>=0.0.7 in /home/vscode/.local/lib/python3.9/site-packages (from yfinance) (0.0.11)\n", - "Requirement already satisfied: lxml>=4.9.1 in /home/vscode/.local/lib/python3.9/site-packages (from yfinance) (4.9.2)\n", - "Requirement already satisfied: appdirs>=1.4.4 in /home/vscode/.local/lib/python3.9/site-packages (from yfinance) (1.4.4)\n", - "Requirement already satisfied: pytz>=2022.5 in /usr/local/lib/python3.9/site-packages (from yfinance) (2022.6)\n", - "Requirement already satisfied: frozendict>=2.3.4 in /home/vscode/.local/lib/python3.9/site-packages (from yfinance) (2.3.8)\n", - "Requirement already satisfied: cryptography>=3.3.2 in /home/vscode/.local/lib/python3.9/site-packages (from yfinance) (38.0.4)\n", - "Requirement already satisfied: beautifulsoup4>=4.11.1 in /home/vscode/.local/lib/python3.9/site-packages (from yfinance) (4.11.1)\n", - "Requirement already satisfied: html5lib>=1.1 in /home/vscode/.local/lib/python3.9/site-packages (from yfinance) (1.1)\n", - "Requirement already satisfied: soupsieve>1.2 in /home/vscode/.local/lib/python3.9/site-packages (from beautifulsoup4>=4.11.1->yfinance) (2.3.2.post1)\n", - "Requirement already satisfied: cffi>=1.12 in /home/vscode/.local/lib/python3.9/site-packages (from cryptography>=3.3.2->yfinance) (1.15.1)\n", - "Requirement already satisfied: six>=1.9 in /usr/local/lib/python3.9/site-packages (from html5lib>=1.1->yfinance) (1.16.0)\n", - "Requirement already satisfied: webencodings in /home/vscode/.local/lib/python3.9/site-packages (from html5lib>=1.1->yfinance) (0.5.1)\n", - "Requirement already satisfied: python-dateutil>=2.8.1 in /usr/local/lib/python3.9/site-packages (from pandas>=1.3.0->yfinance) (2.8.2)\n", - "Requirement already satisfied: charset-normalizer<3,>=2 in /usr/local/lib/python3.9/site-packages (from requests>=2.26->yfinance) (2.1.1)\n", - "Requirement already satisfied: idna<4,>=2.5 in /usr/local/lib/python3.9/site-packages (from requests>=2.26->yfinance) (3.4)\n", - "Requirement already satisfied: urllib3<1.27,>=1.21.1 in /usr/local/lib/python3.9/site-packages (from requests>=2.26->yfinance) (1.26.13)\n", - "Requirement already satisfied: certifi>=2017.4.17 in /usr/local/lib/python3.9/site-packages (from requests>=2.26->yfinance) (2022.9.24)\n", - "Requirement already satisfied: pycparser in /home/vscode/.local/lib/python3.9/site-packages (from cffi>=1.12->cryptography>=3.3.2->yfinance) (2.21)\n", - "\n", - "[*********************100%***********************] 1 of 1 completed\n", - "[*********************100%***********************] 1 of 1 completed\n", - "[*********************100%***********************] 1 of 1 completed\n", - "[*********************100%***********************] 1 of 1 completed\n", - "[*********************100%***********************] 1 of 1 completed\n", - "[*********************100%***********************] 1 of 1 completed\n", - "\n", - "1 Failed download:\n", - "- FB: No timezone found, symbol may be delisted\n", - "[*********************100%***********************] 1 of 1 completed\n", - "[*********************100%***********************] 1 of 1 completed\n", - "[*********************100%***********************] 1 of 1 completed\n", - "[*********************100%***********************] 1 of 1 completed\n", - "YTD Gains of 10 Largest Technology Companies:\n", - "AAPL: 44.37%\n", - "MSFT: 36.77%\n", - "GOOGL: 30.75%\n", - "GOOG: 31.04%\n", - "AMZN: 50.69%\n", - "FB: Data not available\n", - "TSLA: 127.73%\n", - "NVDA: 185.54%\n", - "ADBE: 48.38%\n", - "ASML: 25.61%\n", + "AAPL: 55.26%\n", + "MSFT: 47.19%\n", + "GOOGL: 37.13%\n", + "GOOG: 36.89%\n", + "AMZN: 50.47%\n", + "META: 136.07%\n", + "TSLA: 145.40%\n", + "NVDA: 219.19%\n", + "ASML: 25.70%\n", + "ADBE: 55.92%\n", "\n", "\n", "--------------------------------------------------------------------------------\n", - "assistant (to user):\n", - "\n", - "Great! The code executed successfully, and the YTD gains of the 10 largest technology companies are as follows:\n", + "assistant (to user_proxy):\n", "\n", - "- AAPL: 44.37%\n", - "- MSFT: 36.77%\n", - "- GOOGL: 30.75%\n", - "- GOOG: 31.04%\n", - "- AMZN: 50.69%\n", - "- FB: Data not available (The symbol may be delisted or not available in the Yahoo Finance API)\n", - "- TSLA: 127.73%\n", - "- NVDA: 185.54%\n", - "- ADBE: 48.38%\n", - "- ASML: 25.61%\n", + "Great! The code executed successfully, and here are the updated YTD gains for the 10 largest technology companies as of today:\n", "\n", - "Please note that these values are subject to change as the stock market fluctuates. If you need to update the values, simply re-run the code.\n", + "- AAPL: 55.26%\n", + "- MSFT: 47.19%\n", + "- GOOGL: 37.13%\n", + "- GOOG: 36.89%\n", + "- AMZN: 50.47%\n", + "- META: 136.07% (formerly FB)\n", + "- TSLA: 145.40%\n", + "- NVDA: 219.19%\n", + "- ASML: 25.70%\n", + "- ADBE: 55.92%\n", "\n", - "TERMINATE\n", + "If you have any other questions or need further assistance, feel free to ask. Otherwise, if everything is done, please type \"TERMINATE\".\n", "\n", "--------------------------------------------------------------------------------\n", - "user (to assistant):\n", - "\n", - "continue\n", "\n", - "--------------------------------------------------------------------------------\n", - "assistant (to user):\n", + ">>>>>>>> USING AUTO REPLY FOR THE USER...\n", + "user_proxy (to assistant):\n", "\n", - "I apologize for the confusion regarding the FB symbol. It seems that the symbol for Meta Platforms, Inc. (formerly Facebook, Inc.) has changed to \"META\" on the Yahoo Finance API. Let's update the symbol and re-run the code to get the YTD gain for Meta Platforms, Inc.\n", "\n", - "```python\n", - "symbols = [\"AAPL\", \"MSFT\", \"GOOGL\", \"GOOG\", \"AMZN\", \"META\", \"TSLA\", \"NVDA\", \"ADBE\", \"ASML\"]\n", - "\n", - "ytd_gains = {symbol: get_ytd_gain(symbol) for symbol in symbols}\n", - "print(\"YTD Gains of 10 Largest Technology Companies:\")\n", - "for symbol, gain in ytd_gains.items():\n", - " if gain is not None:\n", - " print(f\"{symbol}: {gain:.2f}%\")\n", - " else:\n", - " print(f\"{symbol}: Data not available\")\n", - "```\n", - "\n", - "Please execute the code above to get the updated YTD gains for the 10 largest technology companies, including Meta Platforms, Inc. (formerly Facebook, Inc.).\n", "\n", "--------------------------------------------------------------------------------\n", + "assistant (to user_proxy):\n", "\n", - ">>>>>>>> NO HUMAN INPUT RECEIVED. USING AUTO REPLY FOR THE USER...\n", - "user (to assistant):\n", - "\n", - "exitcode: 1 (execution failed)\n", - "Code output: \n", - "Traceback (most recent call last):\n", - " File \"/workspaces/FLAML/notebook/web/tmp_code_cfc7665767b48828cfef36e1a2a3dbc6.py\", line 3, in \n", - " ytd_gains = {symbol: get_ytd_gain(symbol) for symbol in symbols}\n", - " File \"/workspaces/FLAML/notebook/web/tmp_code_cfc7665767b48828cfef36e1a2a3dbc6.py\", line 3, in \n", - " ytd_gains = {symbol: get_ytd_gain(symbol) for symbol in symbols}\n", - "NameError: name 'get_ytd_gain' is not defined\n", - "\n", - "\n", - "--------------------------------------------------------------------------------\n", - "assistant (to user):\n", - "\n", - "I apologize for the error. It seems I didn't include the `get_ytd_gain` function in the code snippet. Here's the complete code with the updated symbol for Meta Platforms, Inc. (formerly Facebook, Inc.):\n", - "\n", - "```python\n", - "import yfinance as yf\n", - "import datetime\n", - "\n", - "symbols = [\"AAPL\", \"MSFT\", \"GOOGL\", \"GOOG\", \"AMZN\", \"META\", \"TSLA\", \"NVDA\", \"ADBE\", \"ASML\"]\n", - "\n", - "def get_ytd_gain(symbol):\n", - " now = datetime.datetime.now()\n", - " start_date = datetime.datetime(now.year, 1, 1)\n", - " end_date = now\n", - " stock_data = yf.download(symbol, start=start_date, end=end_date)\n", - " if stock_data.empty:\n", - " return None\n", - " open_price = stock_data.iloc[0][\"Open\"]\n", - " close_price = stock_data.iloc[-1][\"Close\"]\n", - " ytd_gain = (close_price - open_price) / open_price * 100\n", - " return ytd_gain\n", - "\n", - "ytd_gains = {symbol: get_ytd_gain(symbol) for symbol in symbols}\n", - "print(\"YTD Gains of 10 Largest Technology Companies:\")\n", - "for symbol, gain in ytd_gains.items():\n", - " if gain is not None:\n", - " print(f\"{symbol}: {gain:.2f}%\")\n", - " else:\n", - " print(f\"{symbol}: Data not available\")\n", - "```\n", - "\n", - "Please execute the code above to get the updated YTD gains for the 10 largest technology companies, including Meta Platforms, Inc. (formerly Facebook, Inc.).\n", + "It seems you didn't provide any input. If you have any other questions or need further assistance, feel free to ask. Otherwise, if everything is done, please type \"TERMINATE\".\n", "\n", "--------------------------------------------------------------------------------\n", "\n", - ">>>>>>>> NO HUMAN INPUT RECEIVED. USING AUTO REPLY FOR THE USER...\n", - "user (to assistant):\n", + ">>>>>>>> USING AUTO REPLY FOR THE USER...\n", + "user_proxy (to assistant):\n", "\n", - "exitcode: 0 (execution succeeded)\n", - "Code output: \n", - "[*********************100%***********************] 1 of 1 completed\n", - "[*********************100%***********************] 1 of 1 completed\n", - "[*********************100%***********************] 1 of 1 completed\n", - "[*********************100%***********************] 1 of 1 completed\n", - "[*********************100%***********************] 1 of 1 completed\n", - "[*********************100%***********************] 1 of 1 completed\n", - "[*********************100%***********************] 1 of 1 completed\n", - "[*********************100%***********************] 1 of 1 completed\n", - "[*********************100%***********************] 1 of 1 completed\n", - "[*********************100%***********************] 1 of 1 completed\n", - "YTD Gains of 10 Largest Technology Companies:\n", - "AAPL: 44.37%\n", - "MSFT: 36.77%\n", - "GOOGL: 30.75%\n", - "GOOG: 31.04%\n", - "AMZN: 50.69%\n", - "META: 142.87%\n", - "TSLA: 127.73%\n", - "NVDA: 185.54%\n", - "ADBE: 48.38%\n", - "ASML: 25.61%\n", "\n", "\n", "--------------------------------------------------------------------------------\n", - "assistant (to user):\n", - "\n", - "Great! The code executed successfully, and the updated YTD gains of the 10 largest technology companies are as follows:\n", - "\n", - "- AAPL: 44.37%\n", - "- MSFT: 36.77%\n", - "- GOOGL: 30.75%\n", - "- GOOG: 31.04%\n", - "- AMZN: 50.69%\n", - "- META (formerly FB): 142.87%\n", - "- TSLA: 127.73%\n", - "- NVDA: 185.54%\n", - "- ADBE: 48.38%\n", - "- ASML: 25.61%\n", + "assistant (to user_proxy):\n", "\n", - "Please note that these values are subject to change as the stock market fluctuates. If you need to update the values, simply re-run the code.\n", + "I understand that you might be busy or have no further questions. If you need any assistance in the future, feel free to ask. Have a great day!\n", "\n", "TERMINATE\n", "\n", @@ -751,7 +618,7 @@ "source": [ "# it is suggested to reset the assistant to clear the state if the new task is not related to the previous one.\n", "assistant.reset()\n", - "user.initiate_chat(\n", + "user_proxy.initiate_chat(\n", " assistant,\n", " message=\"\"\"Show me the YTD gain of 10 largest technology companies as of today.\"\"\",\n", ")" @@ -774,7 +641,7 @@ "name": "python", "nbconvert_exporter": "python", "pygments_lexer": "ipython3", - "version": "3.9.15" + "version": "3.9.17" }, "vscode": { "interpreter": { diff --git a/test/autogen/oai/test_completion.py b/test/autogen/oai/test_completion.py index 495329296f..97d6042564 100644 --- a/test/autogen/oai/test_completion.py +++ b/test/autogen/oai/test_completion.py @@ -72,19 +72,19 @@ def test_filter(): def test_chatcompletion(): params = oai.ChatCompletion._construct_params( - data_instance=None, + context=None, config={"model": "unknown"}, prompt="hi", ) assert "messages" in params params = oai.Completion._construct_params( - data_instance=None, + context=None, config={"model": "unknown"}, prompt="hi", ) assert "messages" not in params params = oai.Completion._construct_params( - data_instance=None, + context=None, config={"model": "gpt-4"}, prompt="hi", ) diff --git a/test/autogen/test_assistant_agent.py b/test/autogen/test_assistant_agent.py index d8751ba364..2b194c2663 100644 --- a/test/autogen/test_assistant_agent.py +++ b/test/autogen/test_assistant_agent.py @@ -2,7 +2,7 @@ import sys import pytest from flaml import oai -from flaml.autogen.agent import AssistantAgent, UserProxyAgent +from flaml.autogen.agentchat import AssistantAgent, UserProxyAgent KEY_LOC = "test/autogen" OAI_CONFIG_LIST = "OAI_CONFIG_LIST" @@ -97,7 +97,7 @@ def test_gpt35(human_input_mode="NEVER", max_consecutive_auto_reply=5): ) user.initiate_chat(assistant, message="TERMINATE") # should terminate without sending any message - assert assistant.oai_conversations[user.name][-1]["content"] == "TERMINATE" + assert assistant.last_message()["content"] == assistant.last_message(user)["content"] == "TERMINATE" assistant.reset() coding_task = "Print hello world to a file called hello.txt" user.initiate_chat(assistant, message=coding_task) diff --git a/test/autogen/test_code.py b/test/autogen/test_code.py index a484c90dbc..af7652b8d3 100644 --- a/test/autogen/test_code.py +++ b/test/autogen/test_code.py @@ -75,8 +75,14 @@ def test_execute_code(): # execute code which takes a long time exit_code, error, image = execute_code("import time; time.sleep(2)", timeout=1) assert exit_code and error.decode() == "Timeout" + assert isinstance(image, str) + + +def test_execute_code_no_docker(): exit_code, error, image = execute_code("import time; time.sleep(2)", timeout=1, use_docker=False) - assert exit_code and error.decode() == "Timeout" and image is None + if sys.platform != "win32": + assert exit_code and error.decode() == "Timeout" + assert image is None if __name__ == "__main__": diff --git a/test/autogen/test_function_call.py b/test/autogen/test_function_call.py index ab760505b8..ebce5f018f 100644 --- a/test/autogen/test_function_call.py +++ b/test/autogen/test_function_call.py @@ -62,7 +62,7 @@ def test_eval_math_responses(): def test_json_extraction(): - from flaml.autogen.agent import UserProxyAgent + from flaml.autogen.agentchat import UserProxyAgent user = UserProxyAgent(name="test", code_execution_config={"use_docker": False}) @@ -77,7 +77,7 @@ def test_json_extraction(): def test_execute_function(): - from flaml.autogen.agent import UserProxyAgent + from flaml.autogen.agentchat import UserProxyAgent # 1. test calling a simple function def add_num(num_to_be_added): diff --git a/test/autogen/test_math_user_proxy_agent.py b/test/autogen/test_math_user_proxy_agent.py index 4e34cca832..569e9195f1 100644 --- a/test/autogen/test_math_user_proxy_agent.py +++ b/test/autogen/test_math_user_proxy_agent.py @@ -1,5 +1,9 @@ from flaml import oai -from flaml.autogen.agent.math_user_proxy_agent import MathUserProxyAgent, _remove_print, _add_print_to_last_line +from flaml.autogen.agentchat.contrib.math_user_proxy_agent import ( + MathUserProxyAgent, + _remove_print, + _add_print_to_last_line, +) import pytest import sys @@ -17,7 +21,7 @@ def test_math_user_proxy_agent(): except ImportError: return - from flaml.autogen.agent.assistant_agent import AssistantAgent + from flaml.autogen.agentchat.assistant_agent import AssistantAgent conversations = {} oai.ChatCompletion.start_logging(conversations) diff --git a/test/autogen/test_notebook.py b/test/autogen/test_notebook.py index f0fff68564..84a0402175 100644 --- a/test/autogen/test_notebook.py +++ b/test/autogen/test_notebook.py @@ -48,8 +48,8 @@ def run_notebook(input_nb, output_nb="executed_openai_notebook.ipynb", save=Fals skip or not sys.version.startswith("3.10"), reason="do not run if openai is not installed or py!=3.10", ) -def test_autogen_agent_auto_feedback_from_code(save=False): - run_notebook("autogen_agent_auto_feedback_from_code_execution.ipynb", save=save) +def test_autogen_agentchat_auto_feedback_from_code(save=False): + run_notebook("autogen_agentchat_auto_feedback_from_code_execution.ipynb", save=save) @pytest.mark.skipif( @@ -64,16 +64,16 @@ def test_autogen_openai_completion(save=False): skip or not sys.version.startswith("3.10"), reason="do not run if openai is not installed or py!=3.10", ) -def test_autogen_agent_function_call(save=False): - run_notebook("autogen_agent_function_call.ipynb", save=save) +def test_autogen_agentchat_function_call(save=False): + run_notebook("autogen_agentchat_function_call.ipynb", save=save) @pytest.mark.skipif( skip or not sys.version.startswith("3.10"), reason="do not run if openai is not installed or py!=3.10", ) -def test_autogen_agent_MathChat(save=False): - run_notebook("autogen_agent_MathChat.ipynb", save=save) +def test_autogen_agentchat_MathChat(save=False): + run_notebook("autogen_agentchat_MathChat.ipynb", save=save) @pytest.mark.skipif( @@ -85,8 +85,8 @@ def test_autogen_chatgpt_gpt4(save=False): if __name__ == "__main__": - test_autogen_agent_auto_feedback_from_code(save=True) + test_autogen_agentchat_auto_feedback_from_code(save=True) # test_autogen_chatgpt_gpt4(save=True) # test_autogen_openai_completion(save=True) - # test_autogen_agent_MathChat(save=True) - # test_autogen_agent_function_call(save=True) + # test_autogen_agentchat_MathChat(save=True) + # test_autogen_agentchat_function_call(save=True) diff --git a/test/autogen/test_responsive_agent.py b/test/autogen/test_responsive_agent.py index cfd396538b..5710a5a27a 100644 --- a/test/autogen/test_responsive_agent.py +++ b/test/autogen/test_responsive_agent.py @@ -1,7 +1,7 @@ import sys from io import StringIO import pytest -from flaml.autogen.agent import ResponsiveAgent +from flaml.autogen.agentchat import ResponsiveAgent def test_responsive_agent(monkeypatch): @@ -35,9 +35,10 @@ def test_responsive_agent(monkeypatch): dummy_agent_2, ) # send a dict - # receive dict with no openai fields + # send dict with no openai fields pre_len = len(dummy_agent_1.oai_conversations["dummy_agent_2"]) - dummy_agent_1.send({"message": "hello"}, dummy_agent_2) # send dict with wrong field + with pytest.raises(ValueError): + dummy_agent_1.send({"message": "hello"}, dummy_agent_2) assert pre_len == len( dummy_agent_1.oai_conversations["dummy_agent_2"] diff --git a/website/docs/Getting-Started.md b/website/docs/Getting-Started.md index f511f25007..776c1f9cdf 100644 --- a/website/docs/Getting-Started.md +++ b/website/docs/Getting-Started.md @@ -44,8 +44,8 @@ response = oai.Completion.create(context=test_instance, **config) - LLM-driven intelligent agents which can perform tasks autonomously or with human feedback, including tasks that require using tools via code. For example, ```python assistant = AssistantAgent("assistant") -user = UserProxyAgent("user", human_input_mode="TERMINATE") -assistant.receive("Draw a rocket and save to a file named 'rocket.svg'") +user_proxy = UserProxyAgent("user_proxy") +user_proxy.initiate_chat("Show me the YTD gain of 10 largest technology companies as of today.") ``` #### [Task-oriented AutoML](/docs/Use-Cases/task-oriented-automl) diff --git a/website/docs/Use-Cases/Auto-Generation.md b/website/docs/Use-Cases/Auto-Generation.md index f5c5df7159..4baa2281fd 100644 --- a/website/docs/Use-Cases/Auto-Generation.md +++ b/website/docs/Use-Cases/Auto-Generation.md @@ -7,13 +7,13 @@ * An enhanced inference API as a drop-in replacement of `openai.Completion.create` or `openai.ChatCompletion.create`. It allows easy performance tuning and advanced usage patterns, including: - Leveraging [`flaml.tune`](/docs/reference/tune/tune) to adapt LLMs to applications, to maximize the utility out of using expensive foundation models and reduce the inference cost by using cheaper models or configurations which achieve equal or better performance. - Utilities like API unification, caching, error handling, multi-config inference, context programming etc. -* A higher-level abstraction of using foundation models: intelligent agents which can perform tasks autonomously or with human feedback. The same abstraction allows both automated feedback and human feedback sent between agents, so that complex tasks can be accomplished, including tasks that require using tools via code. +* A higher-level abstraction of using foundation models: intelligent agents which can perform tasks autonomously or with human feedback. The same abstraction allows both automated feedback and human feedback sent between agents, so that complex tasks can be accomplished via agent collaborations, including tasks that require using tools via code. The package is under active development with more features upcoming. ## Agents (Experimental) -[`flaml.autogen.agent`](/docs/reference/autogen/agent/agent) contains an experimental implementation of interactive agents which can adapt to human or simulated feedback. This subpackage is under active development. +[`flaml.autogen.agentchat`](/docs/reference/autogen/agentchat/agent) contains an experimental implementation of interactive agents which can adapt to human or simulated feedback. This subpackage is under active development. We have designed different classes of Agents that are capable of communicating with each other through the exchange of messages to collaboratively finish a task. An agent can communicate with other agents and perform actions. Different agents can differ in what actions they perform after receiving messages. @@ -57,7 +57,7 @@ In the example above, we create an AssistantAgent named "assistant" to serve as 4. The assistant then generates a further response for the user_proxy. The user_proxy can then decide whether to terminate the conversation. If not, steps 3 and 4 are repeated. Please find a visual illustration of how UserProxyAgent and AssistantAgent collaboratively solve the above task below: -![Agent Example](images/agent_example.png) +![Agent Chat Example](images/agent_example.png) #### Human Input Mode The `human_input_mode` parameter of `UserProxyAgent` controls the behavior of the agent when it receives a message. It can be set to `"NEVER"`, `"ALWAYS"`, or `"TERMINATE"`. @@ -125,19 +125,19 @@ user.initiate_chat( ``` *Interested in trying it yourself? Please check the following notebook examples:* -* [Interactive LLM Agent with Auto Feedback from Code Execution](https://github.com/microsoft/FLAML/blob/main/notebook/autogen_agent_auto_feedback_from_code_execution.ipynb) +* [Automated Task Solving with Code Generation, Execution & Debugging](https://github.com/microsoft/FLAML/blob/main/notebook/autogen_agentchat_auto_feedback_from_code_execution.ipynb) -* [Interactive LLM Agent with Human Feedback](https://github.com/microsoft/FLAML/blob/main/notebook/autogen_agent_human_feedback.ipynb) +* [Task Solving with Auto Code Generation, Execution, Debugging and Human Feedback](https://github.com/microsoft/FLAML/blob/main/notebook/autogen_agentchat_human_feedback.ipynb) -* [Interactive LLM Agent Dealing with Web Info](https://github.com/microsoft/FLAML/blob/main/notebook/autogen_agent_web_info.ipynb) +* [Solve Tasks Requiring Web Info](https://github.com/microsoft/FLAML/blob/main/notebook/autogen_agentchat_web_info.ipynb) -* [Using MathChat to Solve Math Problems](https://github.com/microsoft/FLAML/blob/main/notebook/autogen_agent_MathChat.ipynb) +* [Using MathChat to Solve Math Problems](https://github.com/microsoft/FLAML/blob/main/notebook/autogen_agentchat_MathChat.ipynb) -* [Interactive LLM Agent with Function Calls](https://github.com/microsoft/FLAML/blob/main/notebook/autogen_agent_function_call.ipynb) +* [Use Provided Tools as Functions](https://github.com/microsoft/FLAML/blob/main/notebook/autogen_agentchat_function_call.ipynb) -* [Multi-Agent Communication and Planning](https://github.com/microsoft/FLAML/blob/main/notebook/autogen_agent_planning.ipynb) +* [Automated Task Solving with Coding & Planning Agents](https://github.com/microsoft/FLAML/blob/main/notebook/autogen_agentchat_planning.ipynb) -* [Multi-Agent Multi-User Application](https://github.com/microsoft/FLAML/blob/main/notebook/autogen_agent_two_users.ipynb) +* [Automated Task Solving with Multiple Human Users](https://github.com/microsoft/FLAML/blob/main/notebook/autogen_agentchat_two_users.ipynb) ## Enhanced Inference