A programming framework for agentic AI
Json config list, agent refactoring and new notebooks (#1133)
Chi Wang2406e694963c
diff --git a/.devcontainer/devcontainer.json b/.devcontainer/devcontainer.jsonindex cdef85c9d..82cd6153f 100644--- a/.devcontainer/devcontainer.json+++ b/.devcontainer/devcontainer.json@@ -9,5 +9,5 @@},"terminal.integrated.defaultProfile.linux": "bash"},- "updateContentCommand": "pip install -e .[test,notebook,openai] && pre-commit install"+ "updateContentCommand": "pip install -e .[notebook,openai] pre-commit && pre-commit install"}diff --git a/.github/workflows/openai.yml b/.github/workflows/openai.ymlindex 1963b25bb..11b9dcd98 100644--- a/.github/workflows/openai.yml+++ b/.github/workflows/openai.yml@@ -44,6 +44,7 @@ jobs:OPENAI_API_KEY: ${{ secrets.OPENAI_API_KEY }}AZURE_OPENAI_API_KEY: ${{ secrets.AZURE_OPENAI_API_KEY }}AZURE_OPENAI_API_BASE: ${{ secrets.AZURE_OPENAI_API_BASE }}+ OAI_CONFIG_LIST: ${{ secrets.OAI_CONFIG_LIST }}run: |coverage run -a -m pytest test/autogencoverage xml@@ -54,6 +55,7 @@ jobs:AZURE_OPENAI_API_KEY: ${{ secrets.AZURE_OPENAI_API_KEY }}AZURE_OPENAI_API_BASE: ${{ secrets.AZURE_OPENAI_API_BASE }}WOLFRAM_ALPHA_APPID: ${{ secrets.WOLFRAM_ALPHA_APPID }}+ OAI_CONFIG_LIST: ${{ secrets.OAI_CONFIG_LIST }}run: |pip install nbconvert nbformat ipykernelcoverage run -a -m pytest test/autogen/test_notebook.pydiff --git a/flaml/autogen/agent/__init__.py b/flaml/autogen/agent/__init__.pyindex d9cd8933e..470b1c356 100644--- a/flaml/autogen/agent/__init__.py+++ b/flaml/autogen/agent/__init__.py@@ -1,6 +1,5 @@from .agent import Agentfrom .assistant_agent import AssistantAgent-from .user_proxy_agent import UserProxyAgent-from .math_user_proxy_agent import MathUserProxyAgent+from .user_proxy_agent import UserProxyAgent, AIUserProxyAgent-__all__ = ["Agent", "AssistantAgent", "UserProxyAgent", "MathUserProxyAgent"]+__all__ = ["Agent", "AssistantAgent", "UserProxyAgent", "AIUserProxyAgent"]diff --git a/flaml/autogen/agent/agent.py b/flaml/autogen/agent/agent.pyindex 4e6e55415..3c213a680 100644--- a/flaml/autogen/agent/agent.py+++ b/flaml/autogen/agent/agent.py@@ -1,5 +1,7 @@from collections import defaultdict-from typing import Dict, Union+from typing import Callable, Dict, List, Optional, Union+from flaml import oai+from flaml.autogen.code_utils import DEFAULT_MODELclass Agent:@@ -9,27 +11,45 @@ class Agent:"""- def __init__(self, name, system_message=""):+ DEFAULT_CONFIG = {+ "model": DEFAULT_MODEL,+ }++ def __init__(+ self,+ name: str,+ system_message: Optional[str] = "",+ is_termination_msg: Optional[Callable[[Dict], bool]] = None,+ **config,+ ):"""Args:name (str): name of the agent- system_message (str): system message to be sent to the agent+ system_message (str): system message to be sent to the agent.+ is_termination_msg (function): a function that takes a message in the form of a dictionary+ and returns a boolean value indicating if this received message is a termination message.+ The dict can contain the following keys: "content", "role", "name", "function_call"."""- # empty memory- self._memory = []# a dictionary of conversations, default value is listself._oai_conversations = defaultdict(list)self._name = nameself._system_message = system_message+ self._is_termination_msg = (+ is_termination_msg if is_termination_msg is not None else (lambda x: x.get("content") == "TERMINATE")+ )+ self.config = self.DEFAULT_CONFIG.copy()+ self.config.update(config)+ self._sender_dict = {}@propertydef name(self):"""Get the name of the agent."""return self._name- def _remember(self, memory):- """Remember something."""- self._memory.append(memory)+ @property+ def oai_conversations(self) -> Dict[str, List[Dict]]:+ """a dictionary of conversations from name to list of oai messages"""+ return self._oai_conversations@staticmethoddef _message_to_dict(message: Union[Dict, str]):@@ -69,8 +89,10 @@ class Agent:self._append_oai_message(message, "assistant", recipient.name)recipient.receive(message, self)- def _receive(self, message: Union[Dict, str], sender: "Agent"):+ def receive(self, message: Union[Dict, str], sender: "Agent"):"""Receive a message from another agent.+ This method is called by the sender.+ It needs to be overriden by the subclass to perform followup actions.Args:message (dict or str): message from the sender. If the type is dict, it may contain the following reserved fields (All fields are optional).@@ -81,6 +103,9 @@ class Agent:4. "name": In most cases, this field is not needed. When the role is "function", this field is needed to indicate the function name.sender: sender of an Agent instance."""+ if sender.name not in self._sender_dict:+ self._sender_dict[sender.name] = sender+ self._oai_conversations[sender.name] = [{"content": self._system_message, "role": "system"}]message = self._message_to_dict(message)# print the message receivedprint(sender.name, "(to", f"{self.name}):\n", flush=True)@@ -107,19 +132,13 @@ class Agent:# When the agent receives a message, the role of the message is "user". (If 'role' exists and is 'function', it will remain unchanged.)self._append_oai_message(message, "user", sender.name)- def receive(self, message: Union[Dict, str], sender):- """Receive a message from another agent.- This method is called by the sender.- It needs to be overriden by the subclass to perform followup actions.+ # After the above, perform actions based on the message in a subclass.- Args:- message (dict or str): message from the sender. If the type is dict, it may contain the following reserved fields (All fields are optional).- 1. "content": content of the message, can be None.- 2. "function_call": a dictionary containing the function name and arguments.- 3. "role": role of the message, can be "assistant", "user", "function".- This field is only needed to distinguish between "function" or "assistant"/"user".- 4. "name": In most cases, this field is not needed. When the role is "function", this field is needed to indicate the function name.- sender: sender of an Agent instance.- """- self._receive(message, sender)- # perform actions based on the message+ def reset(self):+ """Reset the agent."""+ self._sender_dict.clear()+ self._oai_conversations.clear()++ def _ai_reply(self, sender):+ response = oai.ChatCompletion.create(messages=self._oai_conversations[sender.name], **self.config)+ return oai.ChatCompletion.extract_text_or_function_call(response)[0]diff --git a/flaml/autogen/agent/assistant_agent.py b/flaml/autogen/agent/assistant_agent.pyindex 80d2c2a93..d61016447 100644--- a/flaml/autogen/agent/assistant_agent.py+++ b/flaml/autogen/agent/assistant_agent.py@@ -1,7 +1,5 @@from .agent import Agent-from flaml.autogen.code_utils import DEFAULT_MODEL-from flaml import oai-from typing import Dict, Union+from typing import Dict, Optional, Unionclass AssistantAgent(Agent):@@ -17,33 +15,19 @@ class AssistantAgent(Agent):Reply "TERMINATE" in the end when everything is done."""- DEFAULT_CONFIG = {- "model": DEFAULT_MODEL,- }-- def __init__(self, name, system_message=DEFAULT_SYSTEM_MESSAGE, **config):+ def __init__(self, name: str, system_message: Optional[str] = DEFAULT_SYSTEM_MESSAGE, **kwargs):"""Args:name (str): agent name.system_message (str): system message to be sent to the agent.- **config (dict): other configurations allowed in- [oai.Completion.create](../oai/Completion#create).- These configurations will be used when invoking LLM.+ **kwargs (dict): other kwargs allowed in+ [Agent](agent#__init__)."""- super().__init__(name, system_message)- self._config = self.DEFAULT_CONFIG.copy()- self._config.update(config)- self._sender_dict = {}+ super().__init__(name, system_message, **kwargs)def receive(self, message: Union[Dict, str], sender):- if sender.name not in self._sender_dict:- self._sender_dict[sender.name] = sender- self._oai_conversations[sender.name] = [{"content": self._system_message, "role": "system"}]-+ message = self._message_to_dict(message)super().receive(message, sender)- responses = oai.ChatCompletion.create(messages=self._oai_conversations[sender.name], **self._config)- self.send(oai.ChatCompletion.extract_text_or_function_call(responses)[0], sender)-- def reset(self):- self._sender_dict.clear()- self._oai_conversations.clear()+ if self._is_termination_msg(message):+ return+ self.send(self._ai_reply(sender), sender)diff --git a/flaml/autogen/agent/math_user_proxy_agent.py b/flaml/autogen/agent/math_user_proxy_agent.pyindex b5d2d989a..11219d264 100644--- a/flaml/autogen/agent/math_user_proxy_agent.py+++ b/flaml/autogen/agent/math_user_proxy_agent.py@@ -1,12 +1,11 @@-from .user_proxy_agent import UserProxyAgent-from flaml.autogen.code_utils import UNKNOWN, extract_code, execute_code, infer_lang-from flaml.autogen.math_utils import get_answer-from collections import defaultdictimport reimport osfrom pydantic import BaseModel, Extra, root_validator-from typing import Any, Dict, Optional+from typing import Any, Callable, Dict, Optional, Unionfrom time import sleep+from flaml.autogen.agent import UserProxyAgent, Agent+from flaml.autogen.code_utils import UNKNOWN, extract_code, execute_code, infer_lang+from flaml.autogen.math_utils import get_answerPROMPTS = {@@ -82,19 +81,19 @@ Problem: """,}-def is_termination_msg(x):+def is_termination_msg_mathchat(message):"""Check if a message is a termination message."""- if isinstance(x, dict):- x = x.get("content")- if x is None:+ if isinstance(message, dict):+ message = message.get("content")+ if message is None:return False- cb = extract_code(x)+ cb = extract_code(message)contain_code = Falsefor c in cb:if c[0] == "python" or c[0] == "wolfram":contain_code = Truebreak- return not contain_code and get_answer(x) is not None and get_answer(x) != ""+ return not contain_code and get_answer(message) is not None and get_answer(message) != ""def add_print_to_last_line(s):@@ -130,14 +129,13 @@ class MathUserProxyAgent(UserProxyAgent):def __init__(self,- name="MathChatAgent", # default set to MathChatAgent- system_message="",- work_dir=None,- function_map=defaultdict(callable),- human_input_mode="NEVER", # Fully automated- max_consecutive_auto_reply=None,- is_termination_msg=is_termination_msg,- use_docker=True,+ name: Optional[str] = "MathChatAgent", # default set to MathChatAgent+ system_message: Optional[str] = "",+ is_termination_msg: Optional[Callable[[Dict], bool]] = None,+ human_input_mode: Optional[str] = "NEVER", # Fully automated+ function_map: Optional[Dict[str, Callable]] = None,+ max_consecutive_auto_reply: Optional[int] = None,+ code_execution_config: Optional[Dict] = None,max_invalid_q_per_step=3, # a parameter needed in MathChat**config,):@@ -145,7 +143,8 @@ class MathUserProxyAgent(UserProxyAgent):Args:name (str): name of the agentsystem_message (str): system message to be sent to the agent- work_dir (str): working directory for the agent+ is_termination_msg (function): a function that takes a message in the form of a dictionary and returns a boolean value indicating if this received message is a termination message.+ The dict can contain the following keys: "content", "role", "name", "function_call".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.@@ -159,21 +158,30 @@ class MathUserProxyAgent(UserProxyAgent):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".- is_termination_msg (function): a function that takes a message in the form of a dictionary and returns a boolean value indicating if this received message is a termination message.- The dict can contain the following keys: "content", "role", "name", "function_call".- use_docker (bool): whether to use docker to execute the code.+ code_execution_config (dict or False): config for the code execution.+ To disable code execution, set to False. Otherwise, set to a dictionary with the following keys:+ - work_dir (Optional, str): The working directory for the code execution.+ If None, a default working directory will be used.+ The default working directory is the "extensions" directory under+ "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.+ 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,+ the code must be trusted.max_invalid_q_per_step (int): (ADDED) the maximum number of invalid queries per step.**config (dict): other configurations."""super().__init__(name=name,system_message=system_message,- work_dir=work_dir,+ is_termination_msg=is_termination_msg,function_map=function_map,human_input_mode=human_input_mode,max_consecutive_auto_reply=max_consecutive_auto_reply,- is_termination_msg=is_termination_msg,- use_docker=use_docker,+ code_execution_config=code_execution_config,**config,)@@ -187,7 +195,7 @@ class MathUserProxyAgent(UserProxyAgent):self._previous_code = ""self.last_reply = None- def generate_init_prompt(self, problem, prompt_type="default", customized_prompt=None):+ def generate_init_message(self, problem, prompt_type="default", customized_prompt=None):"""Generate a prompt for the assitant agent with the given problem and prompt.Args:@@ -211,8 +219,7 @@ class MathUserProxyAgent(UserProxyAgent):self._reset()if customized_prompt is not None:return customized_prompt + problem- else:- return PROMPTS[prompt_type] + problem+ return PROMPTS[prompt_type] + problemdef _reset(self):self._oai_conversations.clear()@@ -232,21 +239,21 @@ class MathUserProxyAgent(UserProxyAgent):pycode = pycode.replace("; ", "\n").replace(";", "\n")pycode = self._previous_code + add_print_to_last_line(pycode)- return_code, output, _ = execute_code(pycode, use_docker=self._use_docker, timeout=5)+ return_code, output, _ = execute_code(pycode, **self._code_execution_config, timeout=5)is_success = return_code == 0# Decode the outputif isinstance(output, bytes):try:output = output.decode("utf-8")- except Exception:+ except UnicodeDecodeError:is_success = Falseoutput = "The return cannot be decoded."if not is_success:# Remove the file information from the error stringpattern = r'File "/[^"]+\.py", line \d+, in .+\n'- if type(output) == str:+ if isinstance(output, str):output = re.sub(pattern, "", output)output = "Error: " + outputelif output == "":@@ -265,14 +272,14 @@ class MathUserProxyAgent(UserProxyAgent):if is_success:# remove print and check if it still workstmp = self._previous_code + "\n" + remove_print(pycode) + "\n"- rcode, _, _ = execute_code(tmp, use_docker=self._use_docker)+ rcode, _, _ = execute_code(tmp, **self._code_execution_config)else:# only add imports and check if it workstmp = self._previous_code + "\n"for line in pycode.split("\n"):if "import" in line:tmp += line + "\n"- rcode, _, _ = execute_code(tmp, use_docker=self._use_docker)+ rcode, _, _ = execute_code(tmp, **self._code_execution_config)if rcode == 0:self._previous_code = tmp@@ -293,8 +300,9 @@ class MathUserProxyAgent(UserProxyAgent):is_success = Falsereturn output, is_success- def auto_reply(self, message, sender, default_reply=""):+ def auto_reply(self, sender: "Agent", default_reply: Union[str, Dict] = ""):"""Generate an auto reply."""+ message = self.oai_conversations[sender.name][-1]message = message.get("content", "")code_blocks = extract_code(message)@@ -302,43 +310,39 @@ class MathUserProxyAgent(UserProxyAgent):# 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{}.)"- self.send(default_reply, sender)- else:- is_success, all_success = True, True- reply = ""- for code_block in code_blocks:- lang, code = code_block- if not lang:- lang = infer_lang(code)- if lang == "python":- output, is_success = self.execute_one_python_code(code)- elif lang == "wolfram":- output, is_success = self.execute_one_wolfram_query(code)- else:- output = "Error: Unknown language."- is_success = False-- reply += output + "\n"- if not is_success:- all_success = False- self._valid_q_count -= 1 # count invalid queries-- reply = reply.strip()-- if self.last_reply == reply:- return (- reply + "\nYour query or result is same from the last, please try a new approach.",- False,- )- self.last_reply = reply+ return default_reply+ is_success, all_success = True, True+ reply = ""+ for code_block in code_blocks:+ lang, code = code_block+ if not lang:+ lang = infer_lang(code)+ if lang == "python":+ output, is_success = self.execute_one_python_code(code)+ elif lang == "wolfram":+ output, is_success = self.execute_one_wolfram_query(code)+ else:+ output = "Error: Unknown language."+ is_success = False++ reply += output + "\n"+ if not is_success:+ all_success = False+ self._valid_q_count -= 1 # count invalid queries++ reply = reply.strip()++ if self.last_reply == reply:+ return reply + "\nYour query or result is same from the last, please try a new approach."+ self.last_reply = reply- if not all_success:- self._accum_invalid_q_per_step += 1- if self._accum_invalid_q_per_step > self._max_invalid_q_per_step:- self._accum_invalid_q_per_step = 0- reply = "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."+ if not all_success:+ self._accum_invalid_q_per_step += 1+ if self._accum_invalid_q_per_step > self._max_invalid_q_per_step:+ self._accum_invalid_q_per_step = 0+ reply = "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."- self.send(reply, sender)+ return reply# Imported from langchain. Langchain is licensed under MIT License:diff --git a/flaml/autogen/agent/user_proxy_agent.py b/flaml/autogen/agent/user_proxy_agent.pyindex 4523c38b3..6a9437a86 100644--- a/flaml/autogen/agent/user_proxy_agent.py+++ b/flaml/autogen/agent/user_proxy_agent.py@@ -2,7 +2,7 @@ from .agent import Agentfrom flaml.autogen.code_utils import UNKNOWN, extract_code, execute_code, infer_langfrom collections import defaultdictimport json-from typing import Callable, Dict, List, Optional, Union+from typing import Callable, Dict, Optional, Unionclass UserProxyAgent(Agent):@@ -14,23 +14,20 @@ class UserProxyAgent(Agent):self,name: str,system_message: Optional[str] = "",- work_dir: Optional[str] = None,+ is_termination_msg: Optional[Callable[[Dict], bool]] = None,human_input_mode: Optional[str] = "ALWAYS",- function_map: Optional[Dict[str, Callable]] = {},+ function_map: Optional[Dict[str, Callable]] = None,max_consecutive_auto_reply: Optional[int] = None,- is_termination_msg: Optional[Callable[[Dict], bool]] = None,- use_docker: Optional[Union[List[str], str, bool]] = True,- timeout: Optional[int] = 600,+ code_execution_config: Optional[Dict] = None,**config,):"""Args:name (str): name of the agent.system_message (str): system message for the agent.- work_dir (Optional, str): The working directory for the code execution.- If None, a default working directory will be used.- The default working directory is the "extensions" directory under- "path_to_flaml/autogen".+ is_termination_msg (function): a function that takes a message in the form of a dictionary+ and returns a boolean value indicating if this received message is a termination message.+ The dict can contain the following keys: "content", "role", "name", "function_call".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.@@ -44,69 +41,78 @@ class UserProxyAgent(Agent):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".- is_termination_msg (function): a function that takes a message in the form of a dictionary and returns a boolean value indicating if this received message is a termination message.- The dict can contain the following keys: "content", "role", "name", "function_call".- 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.- 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,- the code must be trusted.- timeout (Optional, int): The maximum execution time in seconds.+ code_execution_config (dict or False): config for the code execution.+ To disable code execution, set to False. Otherwise, set to a dictionary with the following keys:+ - work_dir (Optional, str): The working directory for the code execution.+ If None, a default working directory will be used.+ The default working directory is the "extensions" directory under+ "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.+ 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,+ the code must be trusted.+ - timeout (Optional, int): The maximum execution time in seconds.**config (dict): other configurations."""- super().__init__(name, system_message)- self._work_dir = work_dir- self._human_input_mode = human_input_mode- self._is_termination_msg = (- is_termination_msg if is_termination_msg is not None else (lambda x: x.get("content") == "TERMINATE")- )- self._config = config- self._max_consecutive_auto_reply = (+ super().__init__(name, system_message, is_termination_msg)+ self._code_execution_config = {} if code_execution_config is None else code_execution_config+ self.human_input_mode = human_input_mode+ self.max_consecutive_auto_reply = (max_consecutive_auto_reply if max_consecutive_auto_reply is not None else self.MAX_CONSECUTIVE_AUTO_REPLY)self._consecutive_auto_reply_counter = defaultdict(int)- self._use_docker = use_docker- self._time_out = timeout- self._function_map = function_map+ self._function_map = {} if function_map is None else function_map@property- def use_docker(self) -> Union[bool, str]:+ def use_docker(self) -> Union[bool, str, None]:"""bool value of whether to use docker to execute the code,- or str value of the docker image name to use."""- return self._use_docker+ or str value of the docker image name to use, or None when code execution is disabled."""+ return None if self._code_execution_config is False else self._code_execution_config.get("use_docker")++ def _run_code(self, code, **kwargs):+ """Run the code and return the result.++ Args:+ code (str): the code to be executed.+ **kwargs: other keyword arguments.++ Returns:+ A tuple of (exitcode, logs, image).+ exitcode (int): the exit code of the code execution.+ logs (bytes): the logs of the code execution.+ image (str or None): the docker image used for the code execution.+ """+ return execute_code(code, **kwargs)- def execute_code(self, code_blocks):- """Execute the code and return the result."""+ def execute_code_blocks(self, code_blocks):+ """Execute the code blocks and return the result."""logs_all = ""for code_block in code_blocks:lang, code = code_blockif not lang:lang = infer_lang(code)if lang in ["bash", "shell", "sh"]:- exitcode, logs, image = execute_code(- code, work_dir=self._work_dir, use_docker=self._use_docker, lang=lang, timeout=self._time_out- )+ exitcode, logs, image = self._run_code(code, lang=lang, **self._code_execution_config)logs = logs.decode("utf-8")elif lang in ["python", "Python"]:if code.startswith("# filename: "):filename = code[11 : code.find("\n")].strip()else:filename = None- exitcode, logs, image = execute_code(+ exitcode, logs, image = self._run_code(code,- work_dir=self._work_dir,filename=filename,- use_docker=self._use_docker,- timeout=self._time_out,+ **self._code_execution_config,)logs = logs.decode("utf-8")else:# In case the language is not supported, we return an error message.- exitcode, logs, image = 1, f"unknown language {lang}", self._use_docker+ exitcode, logs, image = 1, f"unknown language {lang}", self._code_execution_config["use_docker"]# raise NotImplementedError- self._use_docker = image+ self._code_execution_config["use_docker"] = imagelogs_all += "\n" + logsif exitcode != 0:return exitcode, logs_all@@ -114,7 +120,7 @@ class UserProxyAgent(Agent):@staticmethoddef _format_json_str(jstr):- """Remove newlines outside of quotes, and hanlde JSON escape sequences.+ """Remove newlines outside of quotes, and handle JSON escape sequences.1. this function removes the newline in the query outside of quotes otherwise json.loads(s) will fail.Ex 1:@@ -182,22 +188,22 @@ class UserProxyAgent(Agent):"content": str(content),}- def auto_reply(self, message: dict, sender, default_reply=""):+ def auto_reply(self, sender: "Agent", default_reply: Union[str, Dict] = ""):"""Generate an auto reply."""+ message = self.oai_conversations[sender.name][-1]if "function_call" in message:_, func_return = self._execute_function(message["function_call"])- self.send(func_return, sender)- return-+ return func_return+ if self._code_execution_config is False:+ return default_replycode_blocks = extract_code(message["content"])if len(code_blocks) == 1 and code_blocks[0][0] == UNKNOWN:# no code block is found, lang should be `UNKNOWN`- self.send(default_reply, sender)- else:- # try to execute the code- exitcode, logs = self.execute_code(code_blocks)- exitcode2str = "execution succeeded" if exitcode == 0 else "execution failed"- self.send(f"exitcode: {exitcode} ({exitcode2str})\nCode output: {logs}", sender)+ return default_reply+ # try to execute the code+ exitcode, logs = self.execute_code_blocks(code_blocks)+ exitcode2str = "execution succeeded" if exitcode == 0 else "execution failed"+ return f"exitcode: {exitcode} ({exitcode2str})\nCode output: {logs}"def receive(self, message: Union[Dict, str], sender):"""Receive a message from the sender agent.@@ -208,14 +214,14 @@ class UserProxyAgent(Agent):super().receive(message, sender)# default reply is empty (i.e., no reply, in this case we will try to generate auto reply)reply = ""- if self._human_input_mode == "ALWAYS":+ if self.human_input_mode == "ALWAYS":reply = input("Provide feedback to the sender. 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":+ ] >= self.max_consecutive_auto_reply or self._is_termination_msg(message):+ if self.human_input_mode == "TERMINATE":reply = input("Please give feedback to the sender. (Press enter or type 'exit' to stop the conversation): ")@@ -234,27 +240,33 @@ class UserProxyAgent(Agent):returnself._consecutive_auto_reply_counter[sender.name] += 1- print("\n>>>>>>>> NO HUMAN INPUT RECEIVED. USING AUTO REPLY FOR THE USER...", flush=True)- self.auto_reply(message, sender, default_reply=reply)+ no_human_input = "NO HUMAN INPUT RECEIVED. " if self.human_input_mode != "NEVER" else ""+ print(f"\n>>>>>>>> {no_human_input}USING AUTO REPLY FOR THE USER...", flush=True)+ self.send(self.auto_reply(sender, default_reply=reply), sender)- def generate_init_prompt(self, *args, **kwargs) -> Union[str, Dict]:- """Generate the initial prompt for the agent.+ def reset(self):+ """Reset the agent."""+ super().reset()+ self._consecutive_auto_reply_counter.clear()- Override this function to customize the initial prompt based on user's request.+ def generate_init_message(self, **context) -> Union[str, Dict]:+ """Generate the initial message for the agent.++ Override this function to customize the initial message based on user's request."""- return args[0]+ return context["message"]- def initiate_chat(self, recipient, *args, **kwargs):- """Initiate a chat with the receiver agent.+ def initiate_chat(self, recipient, **context):+ """Initiate a chat with the recipient agent.- `generate_init_prompt` is called to generate the initial prompt for the agent.+ `generate_init_message` is called to generate the initial message for the agent.Args:- receiver: the receiver agent.- *args: any additional arguments.- **kwargs: any additional keyword arguments.+ recipient: the recipient agent.+ **context: any context information.+ "message" needs to be provided if the `generate_init_message` method is not overridden."""- self.send(self.generate_init_prompt(*args, **kwargs), recipient)+ self.send(self.generate_init_message(**context), recipient)def register_function(self, function_map: Dict[str, Callable]):"""Register functions to the agent.@@ -263,3 +275,19 @@ class UserProxyAgent(Agent):function_map: a dictionary mapping function names to functions."""self._function_map.update(function_map)+++class AIUserProxyAgent(UserProxyAgent):+ """(Experimental) A proxy agent for the user, that can execute code and provide feedback to the other agents.++ Compared to UserProxyAgent, this agent can also generate AI replies.+ Code execution is enabled by default. AI replies are generated only when no code execution is performed.+ To disable code execution, set code_execution_config to False.+ """++ def auto_reply(self, sender: "Agent", default_reply: Union[str, Dict] = ""):+ reply = super().auto_reply(sender, default_reply)+ if reply == default_reply:+ # try to generate AI reply+ reply = self._ai_reply(sender)+ return replydiff --git a/flaml/autogen/oai/__init__.py b/flaml/autogen/oai/__init__.pyindex 819d408cc..3c5a5b619 100644--- a/flaml/autogen/oai/__init__.py+++ b/flaml/autogen/oai/__init__.py@@ -4,6 +4,7 @@ from flaml.autogen.oai.openai_utils import (config_list_gpt4_gpt35,config_list_openai_aoai,config_list_from_models,+ config_list_from_json,)__all__ = [@@ -13,4 +14,5 @@ __all__ = ["config_list_gpt4_gpt35","config_list_openai_aoai","config_list_from_models",+ "config_list_from_json",]diff --git a/flaml/autogen/oai/completion.py b/flaml/autogen/oai/completion.pyindex e56a6630c..409ab3fa6 100644--- a/flaml/autogen/oai/completion.py+++ b/flaml/autogen/oai/completion.py@@ -176,7 +176,7 @@ class Completion(openai_Completion):cls._count_create += 1@classmethod- def _get_response(cls, config: Dict, raise_error=False, use_cache=True):+ def _get_response(cls, config: Dict, raise_on_ratelimit_or_timeout=False, use_cache=True):"""Get the response from the openai api call.Try cache first. If not found, call the openai api. If the api call fails, retry after retry_time.@@ -186,7 +186,7 @@ class Completion(openai_Completion):key = get_key(config)if use_cache:response = cls._cache.get(key, None)- if response is not None and (response != -1 or not raise_error):+ if response is not None and (response != -1 or not raise_on_ratelimit_or_timeout):# print("using cached response")cls._book_keeping(config, response)return response@@ -197,6 +197,7 @@ class Completion(openai_Completion):)start_time = time.time()request_timeout = cls.request_timeout+ retry_timeout = config.pop("retry_timeout", cls.retry_timeout)while True:try:if "request_timeout" in config:@@ -219,30 +220,29 @@ class Completion(openai_Completion):logger.info(f"retrying in {cls.retry_time} seconds...", exc_info=1)sleep(cls.retry_time)except (RateLimitError, Timeout) as err:- time_left = cls.retry_timeout - (time.time() - start_time + cls.retry_time)+ time_left = retry_timeout - (time.time() - start_time + cls.retry_time)if (time_left > 0and isinstance(err, RateLimitError)or time_left > request_timeoutand isinstance(err, Timeout)+ and "request_timeout" not in config):+ if isinstance(err, Timeout):+ request_timeout <<= 1+ request_timeout = min(request_timeout, time_left)logger.info(f"retrying in {cls.retry_time} seconds...", exc_info=1)- elif raise_error:+ sleep(cls.retry_time)+ elif raise_on_ratelimit_or_timeout:raiseelse:response = -1if use_cache and isinstance(err, Timeout):cls._cache.set(key, response)logger.warning(- f"Failed to get response from openai api due to getting RateLimitError or Timeout for {cls.retry_timeout} seconds."+ f"Failed to get response from openai api due to getting RateLimitError or Timeout for {retry_timeout} seconds.")return response- if isinstance(err, Timeout):- if "request_timeout" in config:- raise- request_timeout <<= 1- request_timeout = min(request_timeout, time_left)- sleep(cls.retry_time)except InvalidRequestError:if "azure" in config.get("api_type", openai.api_type) and "model" in config:# azure api uses "engine" instead of "model"@@ -386,8 +386,7 @@ class Completion(openai_Completion):for i in range(prev_data_limit, data_limit):logger.debug(f"num_completions={num_completions}, data instance={i}")data_i = data[i]- # params = cls._construct_params(data_i, params, prompt, messages)- response = cls.create(data_i, raise_error=eval_only, **params)+ response = cls.create(data_i, raise_on_ratelimit_or_timeout=eval_only, **params)if response == -1: # rate limit/timeout error, treat as invalidcls._update_invalid_n(prune, region_key, max_tokens, num_completions)result[metric] = 0@@ -684,7 +683,7 @@ class Completion(openai_Completion):use_cache: Optional[bool] = True,config_list: Optional[List[Dict]] = None,filter_func: Optional[Callable[[Dict, Dict, Dict], bool]] = None,- raise_error: Optional[bool] = True,+ raise_on_ratelimit_or_timeout: Optional[bool] = True,**config,):"""Make a completion for a given context.@@ -737,7 +736,7 @@ class Completion(openai_Completion):)```- raise_error (bool, Optional): Whether to raise error when all configs fail.+ raise_on_ratelimit_or_timeout (bool, Optional): Whether to raise RateLimitError or Timeout when all configs fail.When set to False, -1 will be returned when all configs fail.**config: Configuration for the openai API call. This is used as parameters for calling openai API.Besides the parameters for the openai API call, it can also contain a seed (int) for the cache.@@ -750,16 +749,23 @@ class Completion(openai_Completion):if ERROR:raise ERRORif config_list:- retry_timeout = cls.retry_timeoutlast = len(config_list) - 1cost = 0for i, each_config in enumerate(config_list):base_config = config.copy()base_config.update(each_config)- try:- cls.retry_timeout = 0 if i < last and filter_func is None else retry_timeout+ if i < last and filter_func is None and "retry_timeout" not in base_config:# retry_timeout = 0 to avoid retrying when no filter is given- response = cls.create(context, use_cache, **base_config)+ base_config["retry_timeout"] = 0+ try:+ response = cls.create(+ context,+ use_cache,+ raise_on_ratelimit_or_timeout=i < last or raise_on_ratelimit_or_timeout,+ **base_config,+ )+ if response == -1:+ return responsepass_filter = filter_func is None or filter_func(context=context, base_config=config, response=response)@@ -773,17 +779,17 @@ class Completion(openai_Completion):logger.debug(f"failed with config {i}", exc_info=1)if i == last:raise- finally:- cls.retry_timeout = retry_timeoutparams = cls._construct_params(context, config)if not use_cache:- return cls._get_response(params, raise_error=raise_error, use_cache=False)+ return cls._get_response(+ params, raise_on_ratelimit_or_timeout=raise_on_ratelimit_or_timeout, use_cache=False+ )seed = cls.seedif "seed" in params:cls.set_cache(params.pop("seed"))with diskcache.Cache(cls.cache_path) as cls._cache:cls.set_cache(seed)- return cls._get_response(params, raise_error=raise_error)+ return cls._get_response(params, raise_on_ratelimit_or_timeout=raise_on_ratelimit_or_timeout)@classmethoddef _instantiate(cls, template: str, context: Optional[Dict] = None):diff --git a/flaml/autogen/oai/openai_utils.py b/flaml/autogen/oai/openai_utils.pyindex fb8e2a0a0..0215eeeea 100644--- a/flaml/autogen/oai/openai_utils.py+++ b/flaml/autogen/oai/openai_utils.py@@ -1,6 +1,6 @@import osimport json-from typing import List, Optional, Dict+from typing import List, Optional, Dict, Set, Unionimport loggingNON_CACHE_KEY = ["api_key", "api_base", "api_type", "api_version"]@@ -155,7 +155,7 @@ def config_list_from_models(exclude,)if model_list:- config_list = [{**config, "model": model} for config in config_list for model in model_list]+ config_list = [{**config, "model": model} for model in model_list for config in config_list]return config_list@@ -186,3 +186,56 @@ def config_list_gpt4_gpt35(exclude,model_list=["gpt-4", "gpt-3.5-turbo"],)+++def filter_config(config_list, filter_dict):+ """Filter the config list by provider and model.++ Args:+ config_list (list): The config list.+ filter_dict (dict, optional): The filter dict with keys corresponding to a field in each config,+ and values corresponding to lists of acceptable values for each key.++ Returns:+ list: The filtered config list.+ """+ if filter_dict:+ config_list = [+ config for config in config_list if all(config.get(key) in value for key, value in filter_dict.items())+ ]+ return config_list+++def config_list_from_json(+ env_or_file: str,+ file_location: Optional[str] = "",+ filter_dict: Optional[Dict[str, Union[List[Union[str, None]], Set[Union[str, None]]]]] = None,+) -> List[Dict]:+ """Get a list of configs from a json parsed from an env variable or a file.++ Args:+ env_or_file (str): The env variable name or file name.+ file_location (str, optional): The file location.+ filter_dict (dict, optional): The filter dict with keys corresponding to a field in each config,+ and values corresponding to lists of acceptable values for each key.+ e.g.,+ ```python+ filter_dict = {+ "api_type": ["open_ai", None], # None means a missing key is acceptable+ "model": ["gpt-3.5-turbo", "gpt-4"],+ }+ ```++ Returns:+ list: A list of configs for openai api calls.+ """+ json_str = os.environ.get(env_or_file)+ if json_str:+ config_list = json.loads(json_str)+ else:+ try:+ with open(os.path.join(file_location, env_or_file)) as json_file:+ config_list = json.load(json_file)+ except FileNotFoundError:+ return []+ return filter_config(config_list, filter_dict)diff --git a/notebook/autogen_agent_MathChat.ipynb b/notebook/autogen_agent_MathChat.ipynbindex 5e075d3f5..35ac98623 100644--- a/notebook/autogen_agent_MathChat.ipynb+++ b/notebook/autogen_agent_MathChat.ipynb@@ -19,7 +19,7 @@"\n","## Requirements\n","\n",- "FLAML requires `Python>=3.7`. To run this notebook example, please install flaml with the [mathchat] option.\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","```"@@ -27,7 +27,7 @@},{"cell_type": "code",- "execution_count": null,+ "execution_count": 1,"metadata": {},"outputs": [],"source": [@@ -41,26 +41,33 @@"source": ["## Set your API Endpoint\n","\n",- "The [`config_list_gpt4_gpt35`](https://microsoft.github.io/FLAML/docs/reference/autogen/oai/openai_utils#config_list_gpt4_gpt35) function tries to create a list of gpt-4 and gpt-3.5 configurations using Azure OpenAI endpoints and OpenAI endpoints. 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",- "\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"+ "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": 1,+ "execution_count": 2,"metadata": {},"outputs": [],"source": ["from flaml import oai\n","\n",- "config_list = oai.config_list_gpt4_gpt35()"+ "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",+ ")"]},{@@ -68,31 +75,35 @@"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': '<your OpenAI API key here>',\n",- " }, # only if OpenAI API key is found\n",+ " },\n"," {\n"," 'model': 'gpt-4',\n",- " 'api_key': '<your first Azure OpenAI API key here>',\n",- " 'api_base': '<your first Azure OpenAI API base here>',\n",+ " 'api_key': '<your Azure OpenAI API key here>',\n",+ " 'api_base': '<your Azure OpenAI API base here>',\n"," 'api_type': 'azure',\n",- " 'api_version': '2023-03-15-preview',\n",- " }, # only if the at least one Azure OpenAI API key is found\n",+ " 'api_version': '2023-06-01-preview',\n",+ " },\n"," {\n",- " 'model': 'gpt-4',\n",- " 'api_key': '<your second Azure OpenAI API key here>',\n",- " 'api_base': '<your second Azure OpenAI API base here>',\n",+ " 'model': 'gpt-3.5-turbo',\n",+ " 'api_key': '<your Azure OpenAI API key here>',\n",+ " 'api_base': '<your Azure OpenAI API base here>',\n"," 'api_type': 'azure',\n",- " 'api_version': '2023-03-15-preview',\n",- " }, # only if the second Azure OpenAI API key is found\n",+ " 'api_version': '2023-06-01-preview',\n",+ " },\n","]\n","```\n","\n",- "You can directly override it if the above function returns an empty list, i.e., it doesn't find the keys in the specified locations."+ "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."]},{@@ -102,12 +113,12 @@"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_prompt` to combine the instructions and a math problem for an initial prompt to be sent to the LLM assistant."+ "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": 11,+ "execution_count": 3,"metadata": {},"outputs": [],"source": [@@ -130,7 +141,7 @@"mathproxyagent = MathUserProxyAgent(\n"," name=\"MathChatAgent\", \n"," human_input_mode=\"NEVER\",\n",- " use_docker=False,\n",+ " code_execution_config={\"use_docker\": False},\n",")"]},@@ -155,17 +166,15 @@},{"cell_type": "code",- "execution_count": 9,+ "execution_count": 5,"metadata": {},"outputs": [{"name": "stdout","output_type": "stream","text": [- "\n",- " -------------------------------------------------------------------------------- \n",- "\n","MathChatAgent (to assistant):\n",+ "\n","Let's use Python to solve a math problem.\n","\n","Query requirements:\n",@@ -187,94 +196,305 @@"\n","After all the queries are run and you get the answer, put the answer in \\boxed{}.\n","\n",- "Find all $x$ that satisfy the inequality $(2x+10)(x+3)<(3x+9)(x+8)$. Express your answer in interval notation.\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",- " -------------------------------------------------------------------------------- \n",+ "--------------------------------------------------------------------------------\n",+ "assistant (to MathChatAgent):\n",+ "\n",+ "To solve this problem using a trigonometric substitution, we will follow these steps:\n",+ "\n",+ "1. Choose an appropriate trigonometric substitution for the given integral.\n",+ "2. Convert the given integral in terms of the chosen trigonometric function.\n",+ "3. Evaluate the new integral.\n",+ "4. Transform the result back to the original variable x.\n",+ "5. Carefully evaluate the limits.\n",+ "\n",+ "Let's begin with step 1:\n",+ "\n",+ "Since we have an expression of the form $(a^2 + x^2)^n$, we can use the substitution $x = a\\tan{\\theta}$. In our case, $a^2 = 4$, so $a = 2$. Thus, we have:\n",+ "\n",+ "$$ x = 2\\tan{\\theta} $$\n",+ "\n",+ "Now, let's find $dx$ in terms of $d\\theta$:\n",+ "\n",+ "```python\n",+ "from sympy import symbols, tan, diff\n",+ "\n",+ "x, theta = symbols('x theta')\n",+ "a = 2\n",+ "x_substitution = a * tan(theta)\n",+ "dx = diff(x_substitution, theta)\n",+ "dx\n",+ "```\n",+ "\n",+ "Then we will proceed to step 2 and rewrite the integral in terms of $\\theta$.\n",+ "\n",+ "--------------------------------------------------------------------------------\n",+ "\n",+ ">>>>>>>> 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",- "The key idea to solve this problem is to find the critical points, which are the points where the inequality is equal. Then, test the intervals between the critical points to find the interval for which the inequality holds true.\n","\n",- "We start by finding the critical points:\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",- "1. Set the given inequality to be equal: $(2x+10)(x+3)=(3x+9)(x+8)$\n",- "2. Expand both sides and simplify\n",- "3. Bring all terms to one side of the equation\n",- "4. Solve for `x`\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",- "Then we'll test the intervals between the critical points.\n",- " 1. Test a point less than the smallest critical point\n",- " 2. Test a point between the critical points\n",- " 3. Test a point greater than the largest critical point\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",- "Now we will find the critical points using Python:\n",+ "For $x = 1$:\n","```python\n",- "from sympy import symbols, Eq, solve\n",+ "from sympy import solve, Eq\n",+ "\n",+ "theta_upper = solve(Eq(x_substitution, 1), theta)[0]\n",+ "theta_upper\n",+ "```\n","\n",- "x = symbols(\"x\")\n",- "lhs = (2*x + 10)*(x + 3)\n",- "rhs = (3*x + 9)*(x + 8)\n",- "equation = Eq(lhs, rhs)\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",- "critical_points = solve(equation, x)\n",- "critical_points\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",- " -------------------------------------------------------------------------------- \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",- "[-14, -3]\n","\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",- "We found the critical points to be $x=-14$ and $x=-3$. Now we'll test the intervals between these critical points as well as points before and after the critical points.\n","\n",- "The intervals are:\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",- "1. $x < -14$\n",- "2. $-14 < x < -3$\n",- "3. $x > -3$\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",- "Next, we will test a point in each interval using Python and the original inequality:\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",- "from sympy import symbols\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",- "x = symbols(\"x\")\n",- "inequality = (2*x + 10)*(x + 3) < (3*x + 9)*(x + 8)\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",- "test_points = [-15, -5, 0]\n",- "intervals = []\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",- "for point in test_points:\n",- " if inequality.subs(x, point):\n",- " intervals.append(point)\n",+ "Now let's simplify the integrand:\n","\n",- "intervals\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",- " -------------------------------------------------------------------------------- \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",- "[-15, 0]\n","\n",- " -------------------------------------------------------------------------------- \n",+ "0.13002860242931885\n","\n",+ "--------------------------------------------------------------------------------\n","assistant (to MathChatAgent):\n",- "We have tested the intervals and found that the inequality holds true for:\n","\n",- "1. $x < -14$ (test point: $-15$)\n",- "3. $x > -3$ (test point: $0$)\n",+ "Yes! The value of the integral is:\n","\n",- "Therefore, the solution to the inequality $(2x+10)(x+3)<(3x+9)(x+8)$ is:\n",+ "$$\\int_{0}^{1} \\frac{d x}{\\left(4+x^{2}\\right)^{3 / 2}} = \\boxed{0.13002860242931885}$$\n","\n",- "$x \\in \\boxed{(-\\infty, -14) \\cup (-3, \\infty)}$\n"+ "--------------------------------------------------------------------------------\n"]}],@@ -286,7 +506,7 @@"# 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, math_problem)"+ "mathproxyagent.initiate_chat(assistant, problem=math_problem)"]},{@@ -429,7 +649,7 @@"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, math_problem)"+ "mathproxyagent.initiate_chat(assistant, problem=math_problem)"]},{@@ -558,7 +778,7 @@"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, math_problem)"+ "mathproxyagent.initiate_chat(assistant, problem=math_problem)"]},{@@ -571,12 +791,12 @@"\n","MathChat allows different prompts that instruct assistant to solve the problem.\n","\n",- "Check out `MathUserProxyAgent.generate_init_prompt(problem, prompt_type='default', customized_prompt=None)`:\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_prompt(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",+ "- 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",@@ -754,7 +974,7 @@"\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, math_problem, prompt_type=\"python\")"+ "mathproxyagent.initiate_chat(assistant, problem=math_problem, prompt_type=\"python\")"]},{@@ -895,7 +1115,7 @@"\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, math_problem, prompt_type=\"two_tools\")"+ "mathproxyagent.initiate_chat(assistant, problem=math_problem, prompt_type=\"two_tools\")"]}],@@ -915,7 +1135,7 @@"name": "python","nbconvert_exporter": "python","pygments_lexer": "ipython3",- "version": "3.9.16"+ "version": "3.9.15"},"orig_nbformat": 4},diff --git a/notebook/autogen_agent_auto_feedback_from_code_execution.ipynb b/notebook/autogen_agent_auto_feedback_from_code_execution.ipynbindex ea35e85c4..3897076fa 100644--- a/notebook/autogen_agent_auto_feedback_from_code_execution.ipynb+++ b/notebook/autogen_agent_auto_feedback_from_code_execution.ipynb@@ -20,6 +20,7 @@"# 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",@@ -54,13 +55,7 @@"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"+ "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"]},{@@ -71,7 +66,12 @@"source": ["from flaml import oai\n","\n",- "config_list = oai.config_list_from_models(model_list=[\"gpt-4\"])"+ "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",+ ")"]},{@@ -79,31 +79,35 @@"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': '<your OpenAI API key here>',\n",- " }, # only if OpenAI API key is found\n",+ " },\n"," {\n"," 'model': 'gpt-4',\n",- " 'api_key': '<your first Azure OpenAI API key here>',\n",- " 'api_base': '<your first Azure OpenAI API base here>',\n",+ " 'api_key': '<your Azure OpenAI API key here>',\n",+ " 'api_base': '<your Azure OpenAI API base here>',\n"," 'api_type': 'azure',\n",- " 'api_version': '2023-03-15-preview',\n",- " }, # only if the at least one Azure OpenAI API key is found\n",+ " 'api_version': '2023-06-01-preview',\n",+ " },\n"," {\n",- " 'model': 'gpt-4',\n",- " 'api_key': '<your second Azure OpenAI API key here>',\n",- " 'api_base': '<your second Azure OpenAI API base here>',\n",+ " 'model': 'gpt-4-32k',\n",+ " 'api_key': '<your Azure OpenAI API key here>',\n",+ " 'api_base': '<your Azure OpenAI API base here>',\n"," 'api_type': 'azure',\n",- " 'api_version': '2023-03-15-preview',\n",- " }, # only if the second Azure OpenAI API key is found\n",+ " 'api_version': '2023-06-01-preview',\n",+ " },\n","]\n","```\n","\n",- "You can directly override it if the above function returns an empty list, i.e., it doesn't find the keys in the specified locations."+ "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."]},{@@ -129,16 +133,17 @@"\n","What date is today? Compare the year-to-date gain for META and TESLA.\n","\n",- "--------------------------------------------------------------------------------\n",+ "--------------------------------------------------------------------------------\n"+ ]+ },+ {+ "name": "stdout",+ "output_type": "stream",+ "text": ["assistant (to user):\n","\n",- "To get the current date and compare the year-to-date gain for META and TESLA, we can use the `datetime` and `yfinance` libraries in Python. The `yfinance` library allows us to download stock market data from Yahoo Finance.\n",- "\n",- "Here is the Python code to do this:\n",- "\n",- "```python\n","# filename: stock_comparison.py\n",- "\n",+ "```python\n","import datetime\n","import yfinance as yf\n","\n",@@ -146,42 +151,43 @@"today = datetime.date.today()\n","print(\"Today's date:\", today)\n","\n",- "# Get the data for the stock META and TESLA\n",- "meta = yf.Ticker(\"META\")\n",- "tesla = yf.Ticker(\"TSLA\")\n",+ "# Get the start of the year\n",+ "start_of_year = datetime.date(today.year, 1, 1)\n","\n",- "# Get the historical data for this year\n",- "meta_data = meta.history(start=f'{today.year}-01-01', end=str(today))\n",- "tesla_data = tesla.history(start=f'{today.year}-01-01', end=str(today))\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 each stock\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(f\"Year-to-date gain for META: {meta_gain * 100}%\")\n",- "print(f\"Year-to-date gain for TESLA: {tesla_gain * 100}%\")\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",- "\n",- "You can save this code in a file named `stock_comparison.py` and run it using Python.\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",- ">>>>>>>> NO HUMAN INPUT RECEIVED. USING AUTO REPLY FOR THE USER...\n",+ ">>>>>>>> USING AUTO REPLY FOR THE USER...\n","user (to assistant):\n","\n","exitcode: 0 (execution succeeded)\n","Code output: \n",- "Today's date: 2023-07-12\n",- "Year-to-date gain for META: 139.12940007477712%\n",- "Year-to-date gain for TESLA: 149.5744795126052%\n",+ "Today's date: 2023-07-23\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 code executed successfully. Today's date is July 12, 2023. The year-to-date gain for META is approximately 139.13%, and the year-to-date gain for TESLA is approximately 149.57%. \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 23, 2023), the year-to-date gain for META is 135.9%, and for TESLA, it's 140.54%. This means that both stocks have increased significantly since the start of the year, with TESLA slightly outperforming META. \n","\n",- "If you have any other questions or need further assistance, feel free to ask.\n",+ "If you have any other questions or need further assistance, feel free to ask. Otherwise, if everything is clear, we can conclude here. \n","\n","TERMINATE\n","\n",@@ -205,13 +211,15 @@" 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",- " work_dir=\"coding\",\n",- " use_docker=False, # set to True if you are using docker\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",- " \"\"\"What date is today? Compare the year-to-date gain for META and TESLA.\"\"\",\n",+ " message=\"\"\"What date is today? Compare the year-to-date gain for META and TESLA.\"\"\",\n",")"]},@@ -255,56 +263,111 @@"--------------------------------------------------------------------------------\n","assistant (to user):\n","\n",- "To plot a chart of the stock price change year-to-date (YTD) for META and TESLA and save it to a file, we can use the `matplotlib` library in Python. Here is the Python code to do this:\n",- "\n",+ "# filename: stock_plot.py\n","```python\n",- "# filename: stock_price_plot.py\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('META vs TESLA Stock Price YTD')\n",+ "plt.xlabel('Date')\n",+ "plt.ylabel('Close Price')\n",+ "\n",+ "# Show the legend\n",+ "plt.legend()\n",+ "\n",+ "# Save the figure\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 close price for META and TESLA and save the plot as `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_21e31c0db5c0c051b1fe02f6b8b62812.py\", line 5, in <module>\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 previous script was intended to be run in the same session as the first script where `meta_data` and `tesla_data` were defined. Since they were run separately, the variables are not defined in the second script. \n",+ "\n",+ "Let's combine the two scripts into one so that the data is available when we plot the graph.\n",+ "\n",+ "# filename: stock_comparison_and_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",+ "print(\"Today's date:\", today)\n","\n",- "# Get the data for the stock META and TESLA\n",- "meta = yf.Ticker(\"META\")\n",- "tesla = yf.Ticker(\"TSLA\")\n",+ "# Get the start of the year\n",+ "start_of_year = datetime.date(today.year, 1, 1)\n","\n",- "# Get the historical data for this year\n",- "meta_data = meta.history(start=f'{today.year}-01-01', end=str(today))\n",- "tesla_data = tesla.history(start=f'{today.year}-01-01', end=str(today))\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 closing price of META and TESLA\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",+ "# 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('META vs TESLA Stock Price YTD')\n","plt.xlabel('Date')\n",- "plt.ylabel('Closing Price')\n",+ "plt.ylabel('Close Price')\n",+ "\n",+ "# Show the legend\n","plt.legend()\n","\n",- "# Save the plot to a file\n",+ "# Save the figure\n","plt.savefig('stock_price_ytd.png')\n","```\n",- "\n",- "You can save this code in a file named `stock_price_plot.py` and run it using Python. This will create a file named `stock_price_ytd.png` in the same directory.\n",+ "Please save this code in a file named `stock_comparison_and_plot.py` and run it. This script will print today's date, compare the year-to-date gain for META and TESLA, plot the year-to-date close price for META and TESLA, and save the plot as `stock_price_ytd.png`.\n","\n","--------------------------------------------------------------------------------\n","\n",- ">>>>>>>> NO HUMAN INPUT RECEIVED. USING AUTO REPLY FOR THE USER...\n",+ ">>>>>>>> USING AUTO REPLY FOR THE USER...\n","user (to assistant):\n","\n","exitcode: 0 (execution succeeded)\n","Code output: \n",+ "Today's date: 2023-07-23\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 code executed successfully and should have created a file named `stock_price_ytd.png` in the same directory. This file contains a chart of the stock price change year-to-date (YTD) for META and TESLA.\n",+ "Great! The script has successfully executed. It has printed today's date, calculated the year-to-date gain for META and TESLA, and created a plot of the year-to-date close price for META and TESLA. The plot has been saved as `stock_price_ytd.png` in your current directory. You can open this file to view the plot.\n","\n",- "If you have any other questions or need further assistance, feel free to ask.\n",+ "If you have any other questions or need further assistance, feel free to ask. Otherwise, if everything is clear, we can conclude here.\n","\n","TERMINATE\n","\n",@@ -335,7 +398,7 @@"outputs": [{"data": {- "image/png": "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",+ "image/png": "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","text/plain": ["<IPython.core.display.Image object>"]@@ -350,6 +413,264 @@"\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": 12,+ "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_prompt`. \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": 13,+ "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: appdirs>=1.4.4 in /home/vscode/.local/lib/python3.9/site-packages (from yfinance) (1.4.4)\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: numpy>=1.16.5 in /home/vscode/.local/lib/python3.9/site-packages (from yfinance) (1.25.1)\n",+ "Requirement already satisfied: requests>=2.31 in /usr/local/lib/python3.9/site-packages (from yfinance) (2.31.0)\n",+ "Requirement already satisfied: pytz>=2022.5 in /home/vscode/.local/lib/python3.9/site-packages (from yfinance) (2023.3)\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: html5lib>=1.1 in /home/vscode/.local/lib/python3.9/site-packages (from yfinance) (1.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: 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: 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: idna<4,>=2.5 in /usr/local/lib/python3.9/site-packages (from requests>=2.31->yfinance) (3.4)\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: 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\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": [+ "<Figure size 1400x700 with 1 Axes>"+ ]+ },+ "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": [+ "<Axes: title={'center': 'YTD Stock Price Change for META and TESLA'}, xlabel='Date'>"+ ]+ },+ "execution_count": 13,+ "metadata": {},+ "output_type": "execute_result"+ },+ {+ "data": {+ "image/png": "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",+ "text/plain": [+ "<Figure size 1400x700 with 1 Axes>"+ ]+ },+ "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": {@@ -368,7 +689,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_function_call.ipynb b/notebook/autogen_agent_function_call.ipynbindex 7c6098f96..d1f9e89e4 100644--- a/notebook/autogen_agent_function_call.ipynb+++ b/notebook/autogen_agent_function_call.ipynb@@ -17,9 +17,9 @@"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. We now support the new feature of OpenAI models to make function calls to pre-defined functions. \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 (For details of the two agents please check out [autogen_agent_auto_feedback_from_code_execution.ipynb](https://github.com/microsoft/FLAML/blob/main/notebook/autogen_agent_auto_feedback_from_code_execution.ipynb)). 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",+ "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",@@ -71,6 +71,31 @@"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': '<your OpenAI API key here>',\n",+ " }, # OpenAI API endpoint for gpt-4\n",+ " {\n",+ " 'model': 'gpt-3.5-turbo',\n",+ " 'api_key': '<your OpenAI API key here>',\n",+ " }, # OpenAI API endpoint for gpt-3.5-turbo\n",+ " {\n",+ " 'model': 'gpt-3.5-turbo-16k',\n",+ " 'api_key': '<your OpenAI API key here>',\n",+ " }, # OpenAI API endpoint for gpt-3.5-turbo-16k\n",+ "]\n",+ "```\n"+ ]+ },{"attachments": {},"cell_type": "markdown",@@ -238,14 +263,14 @@"user = UserProxyAgent(\n"," \"user\",\n"," human_input_mode=\"NEVER\",\n",- " work_dir=\"coding\",\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([(code_type, code)])\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",@@ -253,7 +278,7 @@"# start the conversation\n","user.initiate_chat(\n"," chatbot,\n",- " \"Draw a rocket and save to a file named 'rocket.svg'\",\n",+ " message=\"Draw a rocket and save to a file named 'rocket.svg'\",\n",")\n"]},@@ -354,7 +379,8 @@],"source": ["import os\n",- "from flaml.autogen.agent import AssistantAgent, UserProxyAgent, MathUserProxyAgent\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",@@ -402,7 +428,7 @@"# start the conversation\n","user.initiate_chat(\n"," chatbot,\n",- " \"Problem: Find all $x$ that satisfy the inequality $(2x+10)(x+3)<(3x+9)(x+8)$. Express your answer in interval notation.\",\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"]}diff --git a/notebook/autogen_agent_human_feedback.ipynb b/notebook/autogen_agent_human_feedback.ipynbindex fc046d7d6..4ef0ef0ab 100644--- a/notebook/autogen_agent_human_feedback.ipynb+++ b/notebook/autogen_agent_human_feedback.ipynb@@ -20,6 +20,7 @@"# Interactive LLM Agent with 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","\n",@@ -54,13 +55,7 @@"source": ["## Set your API Endpoint\n","\n",- "The [`config_list_gpt4_gpt35`](https://microsoft.github.io/FLAML/docs/reference/autogen/oai/openai_utils#config_list_gpt4_gpt35) function tries to create a list of gpt-4 and gpt-3.5 configurations using Azure OpenAI endpoints and OpenAI endpoints. 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"+ "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."]},{@@ -71,7 +66,7 @@"source": ["from flaml import oai\n","\n",- "config_list = oai.config_list_gpt4_gpt35()"+ "config_list = oai.config_list_from_json(\"OAI_CONFIG_LIST\")"]},{@@ -79,49 +74,53 @@"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\".\n",+ "\n","The config list looks like the following:\n","```python\n","config_list = [\n"," {\n"," 'model': 'gpt-4',\n"," 'api_key': '<your OpenAI API key here>',\n",- " }, # only if OpenAI API key is found\n",+ " }, # OpenAI API endpoint for gpt-4\n"," {\n"," 'model': 'gpt-4',\n"," 'api_key': '<your first Azure OpenAI API key here>',\n"," 'api_base': '<your first Azure OpenAI API base here>',\n"," 'api_type': 'azure',\n",- " 'api_version': '2023-03-15-preview',\n",- " }, # only if the at least one Azure OpenAI API key is found\n",+ " 'api_version': '2023-06-01-preview',\n",+ " }, # Azure OpenAI API endpoint for gpt-4\n"," {\n"," 'model': 'gpt-4',\n"," 'api_key': '<your second Azure OpenAI API key here>',\n"," 'api_base': '<your second Azure OpenAI API base here>',\n"," 'api_type': 'azure',\n",- " 'api_version': '2023-03-15-preview',\n",- " }, # only if the second Azure OpenAI API key is found\n",+ " 'api_version': '2023-06-01-preview',\n",+ " }, # another Azure OpenAI API endpoint for gpt-4\n"," {\n"," 'model': 'gpt-3.5-turbo',\n"," 'api_key': '<your OpenAI API key here>',\n",- " }, # only if OpenAI API key is found\n",+ " }, # OpenAI API endpoint for gpt-3.5-turbo\n"," {\n"," 'model': 'gpt-3.5-turbo',\n"," 'api_key': '<your first Azure OpenAI API key here>',\n"," 'api_base': '<your first Azure OpenAI API base here>',\n"," 'api_type': 'azure',\n",- " 'api_version': '2023-03-15-preview',\n",- " }, # only if the at least one Azure OpenAI API key is found\n",+ " 'api_version': '2023-06-01-preview',\n",+ " }, # Azure OpenAI API endpoint for gpt-3.5-turbo\n"," {\n"," 'model': 'gpt-3.5-turbo',\n"," 'api_key': '<your second Azure OpenAI API key here>',\n"," 'api_base': '<your second Azure OpenAI API base here>',\n"," 'api_type': 'azure',\n",- " 'api_version': '2023-03-15-preview',\n",- " }, # only if the second Azure OpenAI API key is found\n",+ " 'api_version': '2023-06-01-preview',\n",+ " }, # another Azure OpenAI API endpoint for gpt-3.5-turbo\n","]\n","```\n","\n",- "You can directly override it if the above function returns an empty list, i.e., it doesn't find the keys in the specified locations."+ "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."]},{@@ -166,7 +165,7 @@"source": ["## Perform a task\n","\n",- "We invoke the `receive()` method of the assistant agent to start the conversation. When you run the cell below, you will be prompted to provide feedback after receving a message from the assistant agent. If you don't provide any feedback (by pressing Enter directly), the user proxy agent will try to execute the code suggested by the assistant agent on behalf of you, or terminate if the assistant agent sends a \"TERMINATE\" signal in the end of the message."+ "We invoke the `initiate_chat()` method of the user proxy agent to start the conversation. When you run the cell below, you will be prompted to provide feedback after receving a message from the assistant agent. If you don't provide any feedback (by pressing Enter directly), the user proxy agent will try to execute the code suggested by the assistant agent on behalf of you, or terminate if the assistant agent sends a \"TERMINATE\" signal in the end of the message."]},{@@ -334,7 +333,7 @@" \"\"\"\n","\n","# the assistant receives a message from the user, which contains the task description\n",- "assistant.receive(math_problem_to_solve, user)"+ "user.initiate_chat(assistant, message=math_problem_to_solve)"]},{@@ -394,7 +393,7 @@"name": "python","nbconvert_exporter": "python","pygments_lexer": "ipython3",- "version": "3.9.15"+ "version": "3.9.16"},"vscode": {"interpreter": {diff --git a/notebook/autogen_agent_planning.ipynb b/notebook/autogen_agent_planning.ipynbindex 0deb280af..a243f138b 100644--- a/notebook/autogen_agent_planning.ipynb+++ b/notebook/autogen_agent_planning.ipynb@@ -19,7 +19,7 @@"source": ["# Multi-Agent Communication and Planning\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 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","\n",@@ -54,13 +54,11 @@"source": ["## Set your API Endpoint\n","\n",- "* The [`config_list_openai_aoai`](https://microsoft.github.io/FLAML/docs/reference/autogen/oai/openai_utils#config_list_openai_aoai) function tries to create a list of configurations using Azure OpenAI endpoints and OpenAI endpoints. \n",- "\n",- "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",+ "* The [`config_list_openai_aoai`](https://microsoft.github.io/FLAML/docs/reference/autogen/oai/openai_utils#config_list_openai_aoai) function tries to create a list of configurations using Azure OpenAI endpoints and OpenAI endpoints. It assumes the api keys and api bases are stored in the corresponding environment variables or local txt files:\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",+ "* 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. It first looks for environment variable `env_or_file` which needs to be a valid json string. If that variable is not found, it then looks for a json file with the same name. It filters the configs by filter_dict.\n","\n","It's OK to have only the OpenAI API key, or only the Azure OpenAI API key + base. 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"]@@ -73,7 +71,12 @@"source": ["from flaml import oai\n","\n",- "config_list = oai.config_list_openai_aoai()"+ "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",+ ")"]},{@@ -81,9 +84,37 @@"cell_type": "markdown","metadata": {},"source": [+ "The config list looks like the following:\n",+ "```python\n",+ "config_list = [\n",+ " {\n",+ " 'model': 'gpt-4',\n",+ " 'api_key': '<your OpenAI API key here>',\n",+ " }, # OpenAI API endpoint for gpt-4\n",+ " {\n",+ " 'model': 'gpt-4',\n",+ " 'api_key': '<your Azure OpenAI API key here>',\n",+ " 'api_base': '<your Azure OpenAI API base here>',\n",+ " 'api_type': 'azure',\n",+ " 'api_version': '2023-06-01-preview',\n",+ " }, # Azure OpenAI API endpoint for gpt-4\n",+ " {\n",+ " 'model': 'gpt-4-32k',\n",+ " 'api_key': '<your Azure OpenAI API key here>',\n",+ " 'api_base': '<your Azure OpenAI API base here>',\n",+ " 'api_type': 'azure',\n",+ " 'api_version': '2023-06-01-preview',\n",+ " }, # Azure OpenAI API endpoint for gpt-4-32k\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.\n",+ "\n","## Construct Agents\n","\n",- "We construct the planning agent named \"planner\" and a user proxy agent for the planner named \"planner_user\". We specify `human_input_mode` as \"TERMINATE\" in the user proxy agent, which will never ask for human feedback. We define `ask_planner` function to send a message to planner and return the suggestion from the planner."+ "We construct the planning agent named \"planner\" and a user proxy agent for the planner named \"planner_user\". We specify `human_input_mode` as \"NEVER\" in the user proxy agent, which will never ask for human feedback. We define `ask_planner` function to send a message to planner and return the suggestion from the planner."]},{@@ -97,7 +128,6 @@"planner = AssistantAgent(\n"," name=\"planner\",\n"," config_list=config_list,\n",- " model=\"gpt-4\",\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",@@ -108,8 +138,8 @@")\n","\n","def ask_planner(message):\n",- " planner.receive(message, planner_user)\n",- " return planner._oai_conversations[planner_user.name][-1][\"content\"]\n"+ " planner_user.initiate_chat(planner, message=message)\n",+ " return planner.oai_conversations[planner_user.name][-1][\"content\"]\n"]},{@@ -117,7 +147,7 @@"cell_type": "markdown","metadata": {},"source": [- "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 set the `functions` in `AssistantAgent` and `function_map` in UserProxyAgent to use the created `ask_planner` function."+ "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 set the `functions` in `AssistantAgent` and `function_map` in `UserProxyAgent` to use the created `ask_planner` function."]},{@@ -160,7 +190,7 @@" 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",- " work_dir=\"planning\",\n",+ " code_execution_config={\"work_dir\": \"planning\"},\n"," function_map={\"ask_planner\": ask_planner},\n",")"]@@ -172,7 +202,7 @@"source": ["## Perform a task\n","\n",- "We invoke the `receive()` method of the coding agent to start the conversation. When you run the cell below, you will be prompted to provide feedback after the coding agent sends a \"TERMINATE\" signal in the end of the message. If you don't provide any feedback (by pressing Enter directly), the conversation will finish. Before the \"TERMINATE\" signal, the user proxy agent will try to execute the code suggested by the coding agent on behalf of the user."+ "We invoke the `initiate_chat()` method of the user proxy agent to start the conversation. When you run the cell below, you will be prompted to provide feedback after the assistant agent sends a \"TERMINATE\" signal in the end of the message. If you don't provide any feedback (by pressing Enter directly), the conversation will finish. Before the \"TERMINATE\" signal, the user proxy agent will try to execute the code suggested by the assistant agent on behalf of the user."]},{@@ -421,7 +451,7 @@"# the assistant receives a message from the user, which contains the task description\n","user.initiate_chat(\n"," assistant,\n",- " \"\"\"Suggest a fix to an open good first issue of flaml\"\"\",\n",+ " message=\"\"\"Suggest a fix to an open good first issue of flaml\"\"\",\n",")"]},diff --git a/notebook/autogen_agent_two_users.ipynb b/notebook/autogen_agent_two_users.ipynbnew file mode 100644index 000000000..1b3269d10--- /dev/null+++ b/notebook/autogen_agent_two_users.ipynb@@ -0,0 +1,1297 @@+{+ "cells": [+ {+ "attachments": {},+ "cell_type": "markdown",+ "metadata": {},+ "source": [+ "<a href=\"https://colab.research.google.com/github/microsoft/FLAML/blob/main/notebook/autogen_agent_two_users.ipynb\" target=\"_parent\"><img src=\"https://colab.research.google.com/assets/colab-badge.svg\" alt=\"Open In Colab\"/></a>"+ ]+ },+ {+ "attachments": {},+ "cell_type": "markdown",+ "metadata": {+ "slideshow": {+ "slide_type": "slide"+ }+ },+ "source": [+ "# Multi-Agent Human-in-the-loop Application\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",+ "\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",+ "## 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_openai_aoai`](https://microsoft.github.io/FLAML/docs/reference/autogen/oai/openai_utils#config_list_openai_aoai) function tries to create a list of configurations using Azure OpenAI endpoints and OpenAI endpoints. It assumes the api keys and api bases are stored in the corresponding environment variables or local txt files:\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",+ "* 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. It first looks for environment variable `env_or_file` which needs to be a valid json string. If that variable is not found, it then looks for a json file with the same name. It filters the configs by filter_dict.\n",+ "\n",+ "It's OK to have only the OpenAI API key, or only the Azure OpenAI API key + base. 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"+ ]+ },+ {+ "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": [+ "The config list looks like the following:\n",+ "```python\n",+ "config_list = [\n",+ " {\n",+ " 'model': 'gpt-4',\n",+ " 'api_key': '<your OpenAI API key here>',\n",+ " }, # OpenAI API endpoint for gpt-4\n",+ " {\n",+ " 'model': 'gpt-4',\n",+ " 'api_key': '<your Azure OpenAI API key here>',\n",+ " 'api_base': '<your Azure OpenAI API base here>',\n",+ " 'api_type': 'azure',\n",+ " 'api_version': '2023-06-01-preview',\n",+ " }, # Azure OpenAI API endpoint for gpt-4\n",+ " {\n",+ " 'model': 'gpt-4-32k',\n",+ " 'api_key': '<your Azure OpenAI API key here>',\n",+ " 'api_base': '<your Azure OpenAI API base here>',\n",+ " 'api_type': 'azure',\n",+ " 'api_version': '2023-06-01-preview',\n",+ " }, # Azure OpenAI API endpoint for gpt-4-32k\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.\n",+ "\n",+ "## Construct Agents\n",+ "\n",+ "We define `ask_expert` function to start a conversation between two agents and return a summary of the result. We construct an assistant agent named \"assistant_for_expert\" and a user proxy agent named \"expert\". We specify `human_input_mode` as \"ALWAYS\" in the user proxy agent, which will always ask for feedback from the expert user."+ ]+ },+ {+ "cell_type": "code",+ "execution_count": 3,+ "metadata": {},+ "outputs": [],+ "source": [+ "from flaml.autogen.agent 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",+ " )\n",+ " expert = UserProxyAgent(\n",+ " name=\"expert\",\n",+ " human_input_mode=\"ALWAYS\",\n",+ " code_execution_config={\"work_dir\": \"expert\"},\n",+ " )\n",+ "\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",+ " expert.send(\"summarize the solution\", assistant_for_expert)\n",+ " return assistant_for_expert.oai_conversations[expert.name][-1][\"content\"]\n"+ ]+ },+ {+ "attachments": {},+ "cell_type": "markdown",+ "metadata": {},+ "source": [+ "We construct another assistant agent named \"assistant_for_student\" and a user proxy agent named \"student\". 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 set the `functions` in `AssistantAgent` and `function_map` in `UserProxyAgent` to use the created `ask_expert` function.\n",+ "\n",+ "For simplicity, the `ask_expert` function is defined to run locally. For real applications, the function should run remotely to interact with an expert user."+ ]+ },+ {+ "cell_type": "code",+ "execution_count": 4,+ "metadata": {},+ "outputs": [],+ "source": [+ "assistant_for_student = AssistantAgent(\n",+ " name=\"assistant_for_student\",\n",+ " request_timeout=600,\n",+ " seed=42,\n",+ " # Excluding azure openai endpoints from the config list.\n",+ " # Change to `exclude=\"openai\"` to exclude openai endpoints, or remove the `exclude` argument to include both.\n",+ " config_list=oai.config_list_openai_aoai(exclude=\"aoai\"),\n",+ " model=\"gpt-4-0613\", # make sure the endpoint you use supports the model\n",+ " temperature=0,\n",+ " functions=[\n",+ " {\n",+ " \"name\": \"ask_expert\",\n",+ " \"description\": \"ask expert when you can't solve the problem satisfactorily.\",\n",+ " \"parameters\": {\n",+ " \"type\": \"object\",\n",+ " \"properties\": {\n",+ " \"message\": {\n",+ " \"type\": \"string\",\n",+ " \"description\": \"question to ask expert. Make sure the question include enough context, such as the code and the execution result. The expert does not know the conversation between you and the user, unless you share the conversation with the expert.\",\n",+ " },\n",+ " },\n",+ " \"required\": [\"message\"],\n",+ " },\n",+ " }\n",+ " ],\n",+ ")\n",+ "\n",+ "student = UserProxyAgent(\n",+ " name=\"student\",\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",+ " code_execution_config={\"work_dir\": \"student\"},\n",+ " function_map={\"ask_expert\": ask_expert},\n",+ ")"+ ]+ },+ {+ "attachments": {},+ "cell_type": "markdown",+ "metadata": {},+ "source": [+ "## Perform a task\n",+ "\n",+ "We invoke the `initiate_chat()` method of the student proxy agent to start the conversation. When you run the cell below, you will be prompted to provide feedback after the assistant agent sends a \"TERMINATE\" signal in the end of the message. If you don't provide any feedback (by pressing Enter directly), the conversation will finish. Before the \"TERMINATE\" signal, the student proxy agent will try to execute the code suggested by the assistant agent on behalf of the user."+ ]+ },+ {+ "cell_type": "code",+ "execution_count": 5,+ "metadata": {},+ "outputs": [+ {+ "name": "stdout",+ "output_type": "stream",+ "text": [+ "student (to assistant_for_student):\n",+ "\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",+ "\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",+ "\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",+ "print(result)\n",+ "```\n",+ "\n",+ "Please run this code to find the values of a, b, and c, and their sum.\n",+ "\n",+ "--------------------------------------------------------------------------------\n",+ "\n",+ ">>>>>>>> NO HUMAN INPUT RECEIVED. USING AUTO REPLY FOR THE USER...\n"+ ]+ },+ {+ "name": "stdout",+ "output_type": "stream",+ "text": [+ "student (to assistant_for_student):\n",+ "\n",+ "exitcode: 0 (execution succeeded)\n",+ "Code output: \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",+ "\n",+ "--------------------------------------------------------------------------------\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 <module>\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",+ "\n",+ "--------------------------------------------------------------------------------\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",+ "\n",+ "TERMINATE\n",+ "\n",+ "--------------------------------------------------------------------------------\n",+ "\n",+ ">>>>>>>> NO HUMAN INPUT RECEIVED. USING AUTO REPLY FOR THE USER...\n",+ "student (to assistant_for_student):\n",+ "\n",+ "\n",+ "\n",+ "--------------------------------------------------------------------------------\n",+ "assistant_for_student (to student):\n",+ "\n",+ "TERMINATE\n",+ "\n",+ "--------------------------------------------------------------------------------\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 <module>\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 <module>\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 <module>\n",+ " print((eq1_xy.lhs - eq1_xy.rhs).simplify() == 0)\n",+ "AttributeError: 'BooleanTrue' object has no attribute 'lhs'\n",+ "\n",+ "\n",+ "--------------------------------------------------------------------------------\n",+ "assistant_for_student (to student):\n",+ "\n",+ "***** 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",+ "}\n",+ "***********************************************\n",+ "\n",+ "--------------------------------------------------------------------------------\n",+ "\n",+ ">>>>>>>> NO HUMAN INPUT RECEIVED. 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",+ "\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",+ "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",+ "\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",+ "\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",+ "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",+ "```\n",+ "\n",+ "This code will print `True` for each equation if the solution satisfies the equation.\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",+ "Code output: \n",+ "True\n",+ "True\n",+ "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",+ "\n",+ "--------------------------------------------------------------------------------\n",+ "expert (to assistant_for_expert):\n",+ "\n",+ "try simplifying the solution directly with sympy\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",+ "\n",+ "```python\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",+ "\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",+ "# 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",+ "```\n",+ "\n",+ "This code will solve the system of equations, simplify the solution, and print the simplified solution.\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",+ "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",+ "\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",+ "\n",+ "```python\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",+ "\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",+ "# simplify the solution\n",+ "solution_simplified = {var: simplify(val) for var, val in solution.items()}\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",+ "```\n",+ "\n",+ "This code will solve the system of equations, simplify the solution, calculate a + b + c, and print the result.\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",+ "Code output: \n",+ "a + b + c = 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",+ "\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",+ "\n",+ "--------------------------------------------------------------------------------\n",+ "expert (to assistant_for_expert):\n",+ "\n",+ "summarize the solution\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",+ "\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",+ "\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",+ "\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",+ "*******************************************************\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",+ "\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",+ "# print the simplified equations\n",+ "print(eq1_xy)\n",+ "print(eq2_xy)\n",+ "print(eq3_xy)\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",+ "\n",+ "--------------------------------------------------------------------------------\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",+ "True\n",+ "True\n",+ "True\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",+ "\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",+ "\n",+ "TERMINATE\n",+ "\n",+ "--------------------------------------------------------------------------------\n",+ "\n",+ ">>>>>>>> NO HUMAN INPUT RECEIVED. USING AUTO REPLY FOR THE USER...\n",+ "student (to assistant_for_student):\n",+ "\n",+ "\n",+ "\n",+ "--------------------------------------------------------------------------------\n",+ "assistant_for_student (to student):\n",+ "\n",+ "TERMINATE\n",+ "\n",+ "--------------------------------------------------------------------------------\n"+ ]+ }+ ],+ "source": [+ "# the assistant receives a message from the student, which contains the task description\n",+ "student.initiate_chat(\n",+ " assistant_for_student,\n",+ " message=\"\"\"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",+ ")"+ ]+ },+ {+ "attachments": {},+ "cell_type": "markdown",+ "metadata": {},+ "source": [+ "When the assistant needs to consult the expert, it suggests a function call to `ask_expert`. When this happens, a line like the following will be displayed:\n",+ "\n",+ "***** Suggested function Call: ask_expert *****\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_web_info.ipynb b/notebook/autogen_agent_web_info.ipynbindex 8899bdf8d..47771f800 100644--- a/notebook/autogen_agent_web_info.ipynb+++ b/notebook/autogen_agent_web_info.ipynb@@ -20,6 +20,7 @@"# Interactive LLM Agent Dealing with 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","\n","In this notebook, we demonstrate how to use `AssistantAgent` and `UserProxyAgent` to perform tasks which require acquiring info from the web:\n","* discuss a paper based on its URL.\n",@@ -58,16 +59,7 @@"source": ["## Set your API Endpoint\n","\n",- "The [`config_list_openai_aoai`](https://microsoft.github.io/FLAML/docs/reference/autogen/oai/openai_utils#config_list_openai_aoai) function tries to create a list of configurations using Azure OpenAI endpoints and OpenAI endpoints. 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. 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",- "The following code excludes openai endpoints from the config list.\n",- "Change to `exclude=\"aoai\"` to exclude Azure OpenAI, or remove the `exclude` argument to include both.\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"]},{@@ -78,7 +70,48 @@"source": ["from flaml import oai\n","\n",- "config_list = oai.config_list_openai_aoai(exclude=\"openai\")"+ "config_list = oai.config_list_from_json(\n",+ " \"OAI_CONFIG_LIST\",\n",+ " filter_dict={\n",+ " \"model\": [\"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 models with matching names 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-32k',\n",+ " 'api_key': '<your OpenAI API key here>',\n",+ " },\n",+ " {\n",+ " 'model': 'gpt4',\n",+ " 'api_key': '<your Azure OpenAI API key here>',\n",+ " 'api_base': '<your Azure OpenAI API base here>',\n",+ " 'api_type': 'azure',\n",+ " 'api_version': '2023-06-01-preview',\n",+ " },\n",+ " {\n",+ " 'model': 'gpt-4-32k-0314',\n",+ " 'api_key': '<your Azure OpenAI API key here>',\n",+ " 'api_base': '<your Azure OpenAI API base here>',\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."]},{@@ -114,7 +147,7 @@" human_input_mode=\"TERMINATE\",\n"," max_consecutive_auto_reply=10,\n"," is_termination_msg=lambda x: x.get(\"content\", \"\").rstrip().endswith(\"TERMINATE\"),\n",- " work_dir='web',\n",+ " code_execution_config={\"work_dir\": \"web\"},\n",")"]},@@ -125,7 +158,7 @@"source": ["## Example Task: Paper Talk from URL\n","\n",- "We invoke the `receive()` method of the coding agent to start the conversation. When you run the cell below, you will be prompted to provide feedback after the coding agent sends a \"TERMINATE\" signal in the end of the message. If you don't provide any feedback (by pressing Enter directly), the conversation will finish. Before the \"TERMINATE\" signal, the user proxy agent will try to execute the code suggested by the coding agent on behalf of the user."+ "We invoke the `initiate_chat()` method of the user proxy agent to start the conversation. When you run the cell below, you will be prompted to provide feedback after the assistant agent sends a \"TERMINATE\" signal in the end of the message. If you don't provide any feedback (by pressing Enter directly), the conversation will finish. Before the \"TERMINATE\" signal, the user proxy agent will try to execute the code suggested by the assistant agent on behalf of the user."]},{@@ -202,11 +235,11 @@],"source": ["# the assistant receives a message from the user, which contains the task description\n",- "assistant.receive(\n",- " \"\"\"\n",+ "user.initiate_chat(\n",+ " assistant,\n",+ " message=\"\"\"\n","Who should read this paper: https://arxiv.org/abs/2306.01337\n","\"\"\",\n",- " user\n",")"]},@@ -716,9 +749,9 @@"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",- "assistant.receive(\n",- " \"\"\"Show me the YTD gain of 10 largest technology companies as of today.\"\"\",\n",- " user,\n",+ "user.initiate_chat(\n",+ " assistant,\n",+ " message=\"\"\"Show me the YTD gain of 10 largest technology companies as of today.\"\"\",\n",")"]}diff --git a/notebook/autogen_chatgpt_gpt4.ipynb b/notebook/autogen_chatgpt_gpt4.ipynbindex 3d30ca889..1417d795d 100644--- a/notebook/autogen_chatgpt_gpt4.ipynb+++ b/notebook/autogen_chatgpt_gpt4.ipynb@@ -127,13 +127,13 @@" 'api_key': '<your first Azure OpenAI API key here>',\n"," 'api_base': '<your first Azure OpenAI API base here>',\n"," 'api_type': 'azure',\n",- " 'api_version': '2023-03-15-preview',\n",+ " 'api_version': '2023-06-01-preview',\n"," }, # only if the at least one Azure OpenAI API key is found\n"," {\n"," 'api_key': '<your second Azure OpenAI API key here>',\n"," 'api_base': '<your second Azure OpenAI API base here>',\n"," 'api_type': 'azure',\n",- " 'api_version': '2023-03-15-preview',\n",+ " 'api_version': '2023-06-01-preview',\n"," }, # only if the second Azure OpenAI API key is found\n","]\n","```\n",diff --git a/notebook/autogen_openai_completion.ipynb b/notebook/autogen_openai_completion.ipynbindex 13fbbd954..a418db4e8 100644--- a/notebook/autogen_openai_completion.ipynb+++ b/notebook/autogen_openai_completion.ipynb@@ -37,7 +37,7 @@},{"cell_type": "code",- "execution_count": 1,+ "execution_count": 11,"metadata": {"execution": {"iopub.execute_input": "2023-02-24T23:25:36.910966Z",@@ -58,18 +58,18 @@"source": ["## Set your API Endpoint\n","\n",- "The [`config_list_openai_aoai`](https://microsoft.github.io/FLAML/docs/reference/autogen/oai/openai_utils#config_list_openai_aoai) function tries to create a list of configurations using Azure OpenAI endpoints and OpenAI endpoints. It assumes the api keys and api bases are stored in the corresponding environment variables or local txt files:\n",+ "* The [`config_list_openai_aoai`](https://microsoft.github.io/FLAML/docs/reference/autogen/oai/openai_utils#config_list_openai_aoai) function tries to create a list of configurations using Azure OpenAI endpoints and OpenAI endpoints. It assumes the api keys and api bases are stored in the corresponding environment variables or local txt files:\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",+ "* 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. It first looks for environment variable `env_or_file` which needs to be a valid json string. If that variable is not found, it then looks for a json file with the same name. It filters the configs by filter_dict.\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"+ "It's OK to have only the OpenAI API key, or only the Azure OpenAI API key + base. 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"]},{"cell_type": "code",- "execution_count": 2,+ "execution_count": 12,"metadata": {"execution": {"iopub.execute_input": "2023-02-24T23:25:36.917301Z",@@ -82,7 +82,59 @@"source": ["from flaml import oai\n","\n",- "config_list = oai.config_list_openai_aoai()"+ "endpoint_list = oai.config_list_openai_aoai()\n",+ "# the endpoint_list looks like this:\n",+ "# endpoint_list = [\n",+ "# {\n",+ "# 'api_key': '<your OpenAI API key here>',\n",+ "# }, # OpenAI API endpoint for gpt-4\n",+ "# {\n",+ "# 'api_key': '<your first Azure OpenAI API key here>',\n",+ "# 'api_base': '<your first Azure OpenAI API base here>',\n",+ "# 'api_type': 'azure',\n",+ "# 'api_version': '2023-03-15-preview',\n",+ "# }, # Azure OpenAI API endpoint for gpt-4\n",+ "# {\n",+ "# 'api_key': '<your second Azure OpenAI API key here>',\n",+ "# 'api_base': '<your second Azure OpenAI API base here>',\n",+ "# 'api_type': 'azure',\n",+ "# 'api_version': '2023-03-15-preview',\n",+ "# }, # another Azure OpenAI API endpoint for gpt-4\n",+ "# ]\n",+ "\n",+ "config_list = oai.config_list_from_json(\n",+ " env_or_file=\"OAI_CONFIG_LIST\",\n",+ " filter_dict={\n",+ " \"model\": {\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",+ ")\n",+ "# the config_list looks like this:\n",+ "# config_list = [\n",+ "# {\n",+ "# 'model': 'gpt-3.5-turbo',\n",+ "# 'api_key': '<your OpenAI API key here>',\n",+ "# }, # OpenAI API endpoint for gpt-3.5-turbo\n",+ "# {\n",+ "# 'model': 'gpt-3.5-turbo',\n",+ "# 'api_key': '<your first Azure OpenAI API key here>',\n",+ "# 'api_base': '<your first Azure OpenAI API base here>',\n",+ "# 'api_type': 'azure',\n",+ "# 'api_version': '2023-06-01-preview',\n",+ "# }, # Azure OpenAI API endpoint for gpt-3.5-turbo\n",+ "# {\n",+ "# 'model': 'gpt-35-turbo-v0301',\n",+ "# 'api_key': '<your second Azure OpenAI API key here>',\n",+ "# 'api_base': '<your second Azure OpenAI API base here>',\n",+ "# 'api_type': 'azure',\n",+ "# 'api_version': '2023-06-01-preview',\n",+ "# }, # another Azure OpenAI API endpoint for gpt-3.5-turbo with deployment name gpt-35-turbo-v0301\n",+ "# ]\n"]},{@@ -90,6 +142,8 @@"cell_type": "markdown","metadata": {},"source": [+ "If you don't use the two provided utility functions above, you can define the lists in other ways you prefer.\n",+ "\n","## Load dataset\n","\n","First, we load the humaneval dataset. The dataset contains 164 examples. We use the first 20 for tuning the generation hyperparameters and the remaining for evaluation. In each example, the \"prompt\" is the prompt string for eliciting the code generation (renamed into \"definition\"), \"test\" is the Python code for unit test for the example, and \"entry_point\" is the function name to be tested."@@ -97,7 +151,7 @@},{"cell_type": "code",- "execution_count": 4,+ "execution_count": 13,"metadata": {"execution": {"iopub.execute_input": "2023-02-24T23:25:36.931255Z",@@ -117,7 +171,7 @@{"data": {"application/vnd.jupyter.widget-view+json": {- "model_id": "0be40d7ad7f049f1946bd69b0c570f33",+ "model_id": "95bea2ebf248403aac1ee64e8bebd5e3","version_major": 2,"version_minor": 0},@@ -174,7 +228,7 @@},{"cell_type": "code",- "execution_count": 5,+ "execution_count": 14,"metadata": {"execution": {"iopub.execute_input": "2023-02-24T23:25:39.152156Z",@@ -226,7 +280,7 @@},{"cell_type": "code",- "execution_count": 6,+ "execution_count": 15,"metadata": {"execution": {"iopub.execute_input": "2023-02-24T23:25:39.158398Z",@@ -271,7 +325,7 @@},{"cell_type": "code",- "execution_count": 7,+ "execution_count": 16,"metadata": {"execution": {"iopub.execute_input": "2023-02-24T23:25:39.164187Z",@@ -287,7 +341,7 @@"\n","eval_with_generated_assertions = partial(\n"," eval_function_completions,\n",- " assertions=generate_assertions,\n",+ " assertions=partial(generate_assertions, config_list=config_list),\n"," use_docker=False,\n"," # Please set use_docker=True if you have docker available to run the generated code.\n"," # Using docker is safer than running the generated code directly.\n",@@ -316,7 +370,7 @@},{"cell_type": "code",- "execution_count": 9,+ "execution_count": 17,"metadata": {"execution": {"iopub.execute_input": "2023-02-24T23:25:40.587815Z",@@ -377,7 +431,7 @@},{"cell_type": "code",- "execution_count": 14,+ "execution_count": 18,"metadata": {"execution": {"iopub.execute_input": "2023-02-24T23:25:40.593603Z",@@ -391,25 +445,25 @@"name": "stderr","output_type": "stream","text": [- "\u001b[32m[I 2023-04-07 17:47:31,801]\u001b[0m A new study created in memory with name: optuna\u001b[0m\n",- "\u001b[32m[I 2023-04-07 17:47:31,804]\u001b[0m A new study created in memory with name: optuna\u001b[0m\n"+ "\u001b[32m[I 2023-07-18 17:50:33,625]\u001b[0m A new study created in memory with name: optuna\u001b[0m\n",+ "\u001b[32m[I 2023-07-18 17:50:33,628]\u001b[0m A new study created in memory with name: optuna\u001b[0m\n"]},{"name": "stdout","output_type": "stream","text": [- "[flaml.tune.tune: 04-07 17:47:31] {832} INFO - trial 1 config: {'prompt': 1, 'stop': 0, 'subspace': {'model': 'text-ada-001', 'max_tokens': 148, 'temperature_or_top_p': {'top_p': 0.755486898036596}, 'n': 27}}\n",- "[flaml.tune.tune: 04-07 17:47:48] {215} INFO - result: {'index_selected': 26.0, 'succeed_assertions': 0.0, 'success': 0.0, 'gen_cost': 0.00046369999999999994, 'assertions': 'assert vowels_count(\"abcde\") == 2\\nassert vowels_count(\"ACEDY\") == 3', 'total_cost': 0.010323600000000004, 'cost': 0.010323600000000004, 'inference_cost': 0.00022578, 'training_iteration': 0, 'config': {'prompt': 1, 'stop': 0, 'subspace': {'model': 'text-ada-001', 'max_tokens': 148, 'temperature_or_top_p': {'top_p': 0.755486898036596}, 'n': 27}}, 'config/prompt': 1, 'config/stop': 0, 'config/subspace': {'model': 'text-ada-001', 'max_tokens': 148, 'temperature_or_top_p': {'top_p': 0.755486898036596}, 'n': 27}, 'experiment_tag': 'exp', 'time_total_s': 16.660529136657715}\n",- "[flaml.tune.tune: 04-07 17:47:48] {832} INFO - trial 2 config: {'prompt': 1, 'stop': 0, 'subspace': {'model': 'text-babbage-001', 'max_tokens': 148, 'temperature_or_top_p': {'top_p': 0.755486898036596}, 'n': 27}}\n",- "[flaml.tune.tune: 04-07 17:48:05] {215} INFO - result: {'index_selected': 26.0, 'succeed_assertions': 0.0, 'success': 0.0, 'gen_cost': 0.00046369999999999994, 'assertions': 'assert vowels_count(\"abcde\") == 2\\nassert vowels_count(\"ACEDY\") == 3', 'total_cost': 0.03038410000000001, 'cost': 0.020060500000000002, 'inference_cost': 0.001003025, 'training_iteration': 0, 'config': {'prompt': 1, 'stop': 0, 'subspace': {'model': 'text-babbage-001', 'max_tokens': 148, 'temperature_or_top_p': {'top_p': 0.755486898036596}, 'n': 27}}, 'config/prompt': 1, 'config/stop': 0, 'config/subspace': {'model': 'text-babbage-001', 'max_tokens': 148, 'temperature_or_top_p': {'top_p': 0.755486898036596}, 'n': 27}, 'experiment_tag': 'exp', 'time_total_s': 16.726527452468872}\n",- "[flaml.tune.tune: 04-07 17:48:05] {832} INFO - trial 3 config: {'prompt': 1, 'stop': 0, 'subspace': {'model': 'text-davinci-003', 'max_tokens': 148, 'temperature_or_top_p': {'top_p': 0.755486898036596}, 'n': 27}}\n",- "[flaml.tune.tune: 04-07 17:48:08] {215} INFO - result: {'index_selected': 3.95, 'succeed_assertions': 0.9, 'success': 0.75, 'gen_cost': 0.00046369999999999994, 'assertions': 'assert vowels_count(\"abcde\") == 2\\nassert vowels_count(\"ACEDY\") == 3', 'total_cost': 0.8871640999999999, 'cost': 0.8567799999999999, 'inference_cost': 0.042096, 'training_iteration': 0, 'config': {'prompt': 1, 'stop': 0, 'subspace': {'model': 'text-davinci-003', 'max_tokens': 148, 'temperature_or_top_p': {'top_p': 0.755486898036596}, 'n': 27}}, 'config/prompt': 1, 'config/stop': 0, 'config/subspace': {'model': 'text-davinci-003', 'max_tokens': 148, 'temperature_or_top_p': {'top_p': 0.755486898036596}, 'n': 27}, 'experiment_tag': 'exp', 'time_total_s': 3.7132015228271484}\n",- "[flaml.tune.tune: 04-07 17:48:08] {832} INFO - trial 4 config: {'prompt': 1, 'stop': 0, 'subspace': {'model': 'gpt-3.5-turbo', 'max_tokens': 148, 'temperature_or_top_p': {'top_p': 0.755486898036596}, 'n': 27}}\n",- "[flaml.tune.tune: 04-07 17:48:18] {215} INFO - result: {'index_selected': 13.85, 'succeed_assertions': 0.55, 'success': 0.5, 'gen_cost': 0.00046369999999999994, 'assertions': 'assert vowels_count(\"abcde\") == 2\\nassert vowels_count(\"ACEDY\") == 3', 'total_cost': 0.9526220999999998, 'cost': 0.065458, 'inference_cost': 0.0033335, 'training_iteration': 0, 'config': {'prompt': 1, 'stop': 0, 'subspace': {'model': 'gpt-3.5-turbo', 'max_tokens': 148, 'temperature_or_top_p': {'top_p': 0.755486898036596}, 'n': 27}}, 'config/prompt': 1, 'config/stop': 0, 'config/subspace': {'model': 'gpt-3.5-turbo', 'max_tokens': 148, 'temperature_or_top_p': {'top_p': 0.755486898036596}, 'n': 27}, 'experiment_tag': 'exp', 'time_total_s': 9.689077615737915}\n",- "[flaml.tune.tune: 04-07 17:48:18] {832} INFO - trial 5 config: {'prompt': 1, 'stop': 0, 'subspace': {'model': 'gpt-4', 'max_tokens': 148, 'temperature_or_top_p': {'top_p': 0.755486898036596}, 'n': 27}}\n",- "[flaml.tune.tune: 04-07 17:48:18] {215} INFO - result: {'success': 0, 'total_cost': 1.0297820999999998, 'cost': 0.07715999999999999, 'training_iteration': 0, 'config': {'prompt': 1, 'stop': 0, 'subspace': {'model': 'gpt-4', 'max_tokens': 148, 'temperature_or_top_p': {'top_p': 0.755486898036596}, 'n': 27}}, 'config/prompt': 1, 'config/stop': 0, 'config/subspace': {'model': 'gpt-4', 'max_tokens': 148, 'temperature_or_top_p': {'top_p': 0.755486898036596}, 'n': 27}, 'experiment_tag': 'exp', 'time_total_s': 0.002007722854614258}\n",- "[flaml.tune.tune: 04-07 17:48:18] {855} WARNING - fail to sample a trial for 100 times in a row, stopping.\n"+ "[flaml.tune.tune: 07-18 17:50:34] {805} INFO - trial 1 config: {'prompt': 1, 'stop': 0, 'subspace': {'model': 'text-ada-001', 'max_tokens': 148, 'temperature_or_top_p': {'top_p': 0.755486898036596}, 'n': 27}}\n",+ "[flaml.tune.tune: 07-18 17:51:28] {197} INFO - result: {'index_selected': 26.0, 'succeed_assertions': 0.0, 'success': 0.0, 'gen_cost': 0.0004240249999999999, 'assertions': 'assert vowels_count(\"abcde\") == 2\\nassert vowels_count(\"ACEDY\") == 3', 'total_cost': 0.0104828, 'cost': 0.0104828, 'inference_cost': 0.00023374, 'training_iteration': 0, 'config': {'prompt': 1, 'stop': 0, 'subspace': {'model': 'text-ada-001', 'max_tokens': 148, 'temperature_or_top_p': {'top_p': 0.755486898036596}, 'n': 27}}, 'config/prompt': 1, 'config/stop': 0, 'config/subspace': {'model': 'text-ada-001', 'max_tokens': 148, 'temperature_or_top_p': {'top_p': 0.755486898036596}, 'n': 27}, 'experiment_tag': 'exp', 'time_total_s': 54.489821434020996}\n",+ "[flaml.tune.tune: 07-18 17:51:28] {805} INFO - trial 2 config: {'prompt': 1, 'stop': 0, 'subspace': {'model': 'text-babbage-001', 'max_tokens': 148, 'temperature_or_top_p': {'top_p': 0.755486898036596}, 'n': 27}}\n",+ "[flaml.tune.tune: 07-18 17:52:11] {197} INFO - result: {'index_selected': 26.0, 'succeed_assertions': 0.0, 'success': 0.0, 'gen_cost': 0.0004240249999999999, 'assertions': 'assert vowels_count(\"abcde\") == 2\\nassert vowels_count(\"ACEDY\") == 3', 'total_cost': 0.030993300000000005, 'cost': 0.020510499999999997, 'inference_cost': 0.001025525, 'training_iteration': 0, 'config': {'prompt': 1, 'stop': 0, 'subspace': {'model': 'text-babbage-001', 'max_tokens': 148, 'temperature_or_top_p': {'top_p': 0.755486898036596}, 'n': 27}}, 'config/prompt': 1, 'config/stop': 0, 'config/subspace': {'model': 'text-babbage-001', 'max_tokens': 148, 'temperature_or_top_p': {'top_p': 0.755486898036596}, 'n': 27}, 'experiment_tag': 'exp', 'time_total_s': 42.71049189567566}\n",+ "[flaml.tune.tune: 07-18 17:52:11] {805} INFO - trial 3 config: {'prompt': 1, 'stop': 0, 'subspace': {'model': 'text-davinci-003', 'max_tokens': 148, 'temperature_or_top_p': {'top_p': 0.755486898036596}, 'n': 27}}\n",+ "[flaml.tune.tune: 07-18 17:54:24] {197} INFO - result: {'index_selected': 3.65, 'succeed_assertions': 0.9, 'success': 0.7, 'gen_cost': 0.0004240249999999999, 'assertions': 'assert vowels_count(\"abcde\") == 2\\nassert vowels_count(\"ACEDY\") == 3', 'total_cost': 0.8669533, 'cost': 0.83596, 'inference_cost': 0.041073000000000005, 'training_iteration': 0, 'config': {'prompt': 1, 'stop': 0, 'subspace': {'model': 'text-davinci-003', 'max_tokens': 148, 'temperature_or_top_p': {'top_p': 0.755486898036596}, 'n': 27}}, 'config/prompt': 1, 'config/stop': 0, 'config/subspace': {'model': 'text-davinci-003', 'max_tokens': 148, 'temperature_or_top_p': {'top_p': 0.755486898036596}, 'n': 27}, 'experiment_tag': 'exp', 'time_total_s': 133.33429384231567}\n",+ "[flaml.tune.tune: 07-18 17:54:24] {805} INFO - trial 4 config: {'prompt': 1, 'stop': 0, 'subspace': {'model': 'gpt-3.5-turbo', 'max_tokens': 148, 'temperature_or_top_p': {'top_p': 0.755486898036596}, 'n': 27}}\n",+ "[flaml.tune.tune: 07-18 17:55:48] {197} INFO - result: {'index_selected': 16.65, 'succeed_assertions': 0.4, 'success': 0.35, 'gen_cost': 0.0004240249999999999, 'assertions': 'assert vowels_count(\"abcde\") == 2\\nassert vowels_count(\"ACEDY\") == 3', 'total_cost': 0.9311253000000002, 'cost': 0.064172, 'inference_cost': 0.0031784499999999998, 'training_iteration': 0, 'config': {'prompt': 1, 'stop': 0, 'subspace': {'model': 'gpt-3.5-turbo', 'max_tokens': 148, 'temperature_or_top_p': {'top_p': 0.755486898036596}, 'n': 27}}, 'config/prompt': 1, 'config/stop': 0, 'config/subspace': {'model': 'gpt-3.5-turbo', 'max_tokens': 148, 'temperature_or_top_p': {'top_p': 0.755486898036596}, 'n': 27}, 'experiment_tag': 'exp', 'time_total_s': 83.27373838424683}\n",+ "[flaml.tune.tune: 07-18 17:55:48] {805} INFO - trial 5 config: {'prompt': 1, 'stop': 0, 'subspace': {'model': 'gpt-4', 'max_tokens': 148, 'temperature_or_top_p': {'top_p': 0.755486898036596}, 'n': 27}}\n",+ "[flaml.tune.tune: 07-18 17:56:06] {197} INFO - result: {'success': 0, 'total_cost': 1.0261653000000002, 'cost': 0.09504, 'training_iteration': 0, 'config': {'prompt': 1, 'stop': 0, 'subspace': {'model': 'gpt-4', 'max_tokens': 148, 'temperature_or_top_p': {'top_p': 0.755486898036596}, 'n': 27}}, 'config/prompt': 1, 'config/stop': 0, 'config/subspace': {'model': 'gpt-4', 'max_tokens': 148, 'temperature_or_top_p': {'top_p': 0.755486898036596}, 'n': 27}, 'experiment_tag': 'exp', 'time_total_s': 18.89783787727356}\n",+ "[flaml.tune.tune: 07-18 17:56:06] {828} WARNING - fail to sample a trial for 100 times in a row, stopping.\n"]}],@@ -431,6 +485,7 @@" \"Complete the following Python function:{definition}\",\n"," ], # the prompt templates to choose from\n"," stop=[[\"\\nclass\", \"\\ndef\", \"\\nif\", \"\\nprint\"], None], # the stop sequences\n",+ " config_list=endpoint_list, # optional: a list of endpoints to use\n",")\n"]},@@ -446,7 +501,7 @@},{"cell_type": "code",- "execution_count": 15,+ "execution_count": 19,"metadata": {"execution": {"iopub.execute_input": "2023-02-24T23:26:38.352710Z",@@ -461,7 +516,7 @@"output_type": "stream","text": ["optimized config {'prompt': '# Python 3{definition}', 'stop': ['\\nclass', '\\ndef', '\\nif', '\\nprint'], 'model': 'text-davinci-003', 'max_tokens': 148, 'n': 27, 'top_p': 0.755486898036596}\n",- "best result on tuning data {'index_selected': 3.95, 'succeed_assertions': 0.9, 'success': 0.75, 'gen_cost': 0.00046369999999999994, 'assertions': 'assert vowels_count(\"abcde\") == 2\\nassert vowels_count(\"ACEDY\") == 3', 'total_cost': 0.8871640999999999, 'cost': 0.8567799999999999, 'inference_cost': 0.042096, 'training_iteration': 0, 'config': {'prompt': 1, 'stop': 0, 'subspace': {'model': 'text-davinci-003', 'max_tokens': 148, 'temperature_or_top_p': {'top_p': 0.755486898036596}, 'n': 27}}, 'config/prompt': 1, 'config/stop': 0, 'config/subspace': {'model': 'text-davinci-003', 'max_tokens': 148, 'temperature_or_top_p': {'top_p': 0.755486898036596}, 'n': 27}, 'experiment_tag': 'exp', 'time_total_s': 3.7132015228271484}\n"+ "best result on tuning data {'index_selected': 3.65, 'succeed_assertions': 0.9, 'success': 0.7, 'gen_cost': 0.0004240249999999999, 'assertions': 'assert vowels_count(\"abcde\") == 2\\nassert vowels_count(\"ACEDY\") == 3', 'total_cost': 0.8669533, 'cost': 0.83596, 'inference_cost': 0.041073000000000005, 'training_iteration': 0, 'config': {'prompt': 1, 'stop': 0, 'subspace': {'model': 'text-davinci-003', 'max_tokens': 148, 'temperature_or_top_p': {'top_p': 0.755486898036596}, 'n': 27}}, 'config/prompt': 1, 'config/stop': 0, 'config/subspace': {'model': 'text-davinci-003', 'max_tokens': 148, 'temperature_or_top_p': {'top_p': 0.755486898036596}, 'n': 27}, 'experiment_tag': 'exp', 'time_total_s': 133.33429384231567}\n"]}],@@ -486,7 +541,7 @@},{"cell_type": "code",- "execution_count": 16,+ "execution_count": 20,"metadata": {"execution": {"iopub.execute_input": "2023-02-24T23:26:38.359902Z",@@ -505,186 +560,189 @@"output_type": "stream","text": ["{\n",+ " \"id\": \"cmpl-7djA2WbYCudgjWodOG8aAHyEZ2lex\",\n",+ " \"object\": \"text_completion\",\n",+ " \"created\": 1689702746,\n",+ " \"model\": \"text-davinci-003\",\n"," \"choices\": [\n"," {\n",- " \"finish_reason\": \"stop\",\n",+ " \"text\": \" result = []\\n for i in range(len(game)):\\n result.append(abs(game[i]-guess[i]))\\n return result\",\n"," \"index\": 0,\n"," \"logprobs\": null,\n",- " \"text\": \" result = []\\n for i in range(len(game)):\\n result.append(abs(game[i]-guess[i]))\\n return result\"\n",+ " \"finish_reason\": \"stop\"\n"," },\n"," {\n",- " \"finish_reason\": \"stop\",\n",+ " \"text\": \" result = []\\n for i in range(len(game)):\\n if game[i] == guess[i]:\\n result.append(0)\\n else:\\n result.append(abs(game[i] - guess[i]))\\n return result\",\n"," \"index\": 1,\n"," \"logprobs\": null,\n",- " \"text\": \" result = []\\n for i in range(len(game)):\\n result.append(abs(game[i] - guess[i]))\\n return result\"\n",+ " \"finish_reason\": \"stop\"\n"," },\n"," {\n",- " \"finish_reason\": \"stop\",\n",+ " \"text\": \" result = []\\n for i in range(len(game)):\\n if game[i] == guess[i]:\\n result.append(0)\\n else:\\n result.append(abs(game[i] - guess[i]))\\n return result\",\n"," \"index\": 2,\n"," \"logprobs\": null,\n",- " \"text\": \" result = []\\n for i in range(len(game)):\\n diff = abs(game[i] - guess[i])\\n result.append(diff)\\n return result\"\n",+ " \"finish_reason\": \"stop\"\n"," },\n"," {\n",- " \"finish_reason\": \"stop\",\n",+ " \"text\": \" result = []\\n for i in range(len(game)):\\n result.append(abs(game[i] - guess[i]))\\n return result\",\n"," \"index\": 3,\n"," \"logprobs\": null,\n",- " \"text\": \" result = []\\n for i in range(len(game)):\\n result.append(abs(game[i] - guess[i]))\\n return result\"\n",+ " \"finish_reason\": \"stop\"\n"," },\n"," {\n",- " \"finish_reason\": \"stop\",\n",+ " \"text\": \" results = []\\n for i in range(len(game)):\\n diff = abs(game[i] - guess[i])\\n results.append(diff)\\n return results\",\n"," \"index\": 4,\n"," \"logprobs\": null,\n",- " \"text\": \" result = []\\n for i in range(len(game)):\\n diff = abs(game[i] - guess[i])\\n result.append(diff)\\n return result\"\n",+ " \"finish_reason\": \"stop\"\n"," },\n"," {\n",- " \"finish_reason\": \"stop\",\n",+ " \"text\": \" result = []\\n for i in range(len(game)):\\n diff = abs(game[i] - guess[i])\\n result.append(diff)\\n return result\",\n"," \"index\": 5,\n"," \"logprobs\": null,\n",- " \"text\": \" result = []\\n for i in range(len(game)):\\n result.append(abs(game[i] - guess[i]))\\n return result\"\n",+ " \"finish_reason\": \"stop\"\n"," },\n"," {\n",- " \"finish_reason\": \"stop\",\n",+ " \"text\": \" # write your code here\\n result = []\\n for i in range(len(game)):\\n diff = abs(game[i] - guess[i])\\n result.append(diff)\\n return result\",\n"," \"index\": 6,\n"," \"logprobs\": null,\n",- " \"text\": \" results = []\\n for i in range(len(game)):\\n if game[i] == guess[i]:\\n results.append(0)\\n else:\\n results.append(abs(game[i] - guess[i]))\\n return results\"\n",+ " \"finish_reason\": \"stop\"\n"," },\n"," {\n",- " \"finish_reason\": \"stop\",\n",+ " \"text\": \" result = []\\n for i in range(len(game)):\\n if game[i] == guess[i]:\\n result.append(0)\\n else:\\n result.append(abs(game[i] - guess[i]))\\n return result\",\n"," \"index\": 7,\n"," \"logprobs\": null,\n",- " \"text\": \" res = []\\n for i in range(len(game)):\\n res.append(abs(game[i] - guess[i]))\\n return res\"\n",+ " \"finish_reason\": \"stop\"\n"," },\n"," {\n",- " \"finish_reason\": \"stop\",\n",+ " \"text\": \" result = []\\n for i in range(len(game)):\\n diff = abs(game[i] - guess[i])\\n result.append(diff)\\n return result\",\n"," \"index\": 8,\n"," \"logprobs\": null,\n",- " \"text\": \" result = []\\n for i in range(len(game)):\\n result.append(abs(game[i] - guess[i]))\\n return result\"\n",+ " \"finish_reason\": \"stop\"\n"," },\n"," {\n",- " \"finish_reason\": \"stop\",\n",+ " \"text\": \" result = []\\n for i in range(len(game)):\\n diff = abs(game[i] - guess[i])\\n result.append(diff)\\n return result\",\n"," \"index\": 9,\n"," \"logprobs\": null,\n",- " \"text\": \" result = []\\n for i in range(len(game)):\\n result.append(abs(game[i]-guess[i]))\\n return result\"\n",+ " \"finish_reason\": \"stop\"\n"," },\n"," {\n",- " \"finish_reason\": \"stop\",\n",+ " \"text\": \" result = []\\n for i in range(len(game)):\\n if game[i] == guess[i]:\\n result.append(0)\\n else:\\n result.append(abs(game[i]-guess[i]))\\n return result\",\n"," \"index\": 10,\n"," \"logprobs\": null,\n",- " \"text\": \" result = []\\n for i in range(len(game)):\\n result.append(abs(game[i] - guess[i]))\\n return result\"\n",+ " \"finish_reason\": \"stop\"\n"," },\n"," {\n",- " \"finish_reason\": \"stop\",\n",+ " \"text\": \" result = []\\n for i in range(len(game)):\\n diff = abs(game[i] - guess[i])\\n result.append(diff)\\n return result\",\n"," \"index\": 11,\n"," \"logprobs\": null,\n",- " \"text\": \" result = []\\n for i in range(len(game)):\\n diff = abs(game[i] - guess[i])\\n result.append(diff)\\n return result\"\n",+ " \"finish_reason\": \"stop\"\n"," },\n"," {\n",- " \"finish_reason\": \"stop\",\n",+ " \"text\": \" result = []\\n for i in range(len(game)):\\n result.append(abs(game[i] - guess[i]))\\n return result\",\n"," \"index\": 12,\n"," \"logprobs\": null,\n",- " \"text\": \" result = []\\n for i in range(len(game)):\\n if game[i] == guess[i]:\\n result.append(0)\\n else:\\n result.append(abs(game[i] - guess[i]))\\n return result\"\n",+ " \"finish_reason\": \"stop\"\n"," },\n"," {\n",- " \"finish_reason\": \"stop\",\n",+ " \"text\": \" result = []\\n for i in range(len(game)):\\n diff = abs(game[i] - guess[i])\\n result.append(diff)\\n return result\",\n"," \"index\": 13,\n"," \"logprobs\": null,\n",- " \"text\": \" #your code here\\n result = []\\n for i in range(len(game)):\\n if game[i] == guess[i]:\\n result.append(0)\\n else:\\n result.append(abs(game[i] - guess[i]))\\n return result\"\n",+ " \"finish_reason\": \"stop\"\n"," },\n"," {\n",- " \"finish_reason\": \"stop\",\n",+ " \"text\": \" #initialize empty list\\n result = []\\n #iterate over the two lists\\n for i in range(len(game)):\\n #append the absolute difference between the guess and the score to the result list\\n result.append(abs(game[i]-guess[i]))\\n #return the result list\\n return result\",\n"," \"index\": 14,\n"," \"logprobs\": null,\n",- " \"text\": \" result = []\\n for i in range(len(game)):\\n result.append(abs(game[i] - guess[i]))\\n return result\"\n",+ " \"finish_reason\": \"stop\"\n"," },\n"," {\n",- " \"finish_reason\": \"stop\",\n",+ " \"text\": \" result = []\\n for i in range(len(game)):\\n diff = abs(game[i] - guess[i])\\n result.append(diff)\\n return result\",\n"," \"index\": 15,\n"," \"logprobs\": null,\n",- " \"text\": \" result = []\\n for i in range(len(game)):\\n diff = abs(game[i] - guess[i])\\n result.append(diff)\\n return result\"\n",+ " \"finish_reason\": \"stop\"\n"," },\n"," {\n",- " \"finish_reason\": \"stop\",\n",+ " \"text\": \" result = []\\n for i in range(len(game)):\\n result.append(abs(game[i] - guess[i]))\\n return result\",\n"," \"index\": 16,\n"," \"logprobs\": null,\n",- " \"text\": \" result = []\\n for i in range(len(game)):\\n result.append(abs(game[i]-guess[i]))\\n return result\"\n",+ " \"finish_reason\": \"stop\"\n"," },\n"," {\n",- " \"finish_reason\": \"stop\",\n",+ " \"text\": \" result = []\\n for i in range(len(game)):\\n result.append(abs(game[i] - guess[i]))\\n return result\",\n"," \"index\": 17,\n"," \"logprobs\": null,\n",- " \"text\": \" result = []\\n for i in range(len(game)):\\n result.append(abs(game[i] - guess[i]))\\n return result\"\n",+ " \"finish_reason\": \"stop\"\n"," },\n"," {\n",- " \"finish_reason\": \"stop\",\n",+ " \"text\": \" result = []\\n for i in range(len(game)):\\n result.append(abs(game[i] - guess[i]))\\n return result\",\n"," \"index\": 18,\n"," \"logprobs\": null,\n",- " \"text\": \" # Your code here\\n result = []\\n for i in range(len(game)):\\n result.append(abs(game[i] - guess[i]))\\n return result\"\n",+ " \"finish_reason\": \"stop\"\n"," },\n"," {\n",- " \"finish_reason\": \"stop\",\n",+ " \"text\": \" result = []\\n for i in range(len(game)):\\n diff = abs(game[i] - guess[i])\\n result.append(diff)\\n return result\",\n"," \"index\": 19,\n"," \"logprobs\": null,\n",- " \"text\": \" result = []\\n for i in range(len(game)):\\n result.append(abs(game[i] - guess[i]))\\n return result\"\n",+ " \"finish_reason\": \"stop\"\n"," },\n"," {\n",- " \"finish_reason\": \"stop\",\n",+ " \"text\": \" result = []\\n for i in range(len(game)):\\n diff = abs(game[i] - guess[i])\\n result.append(diff)\\n return result\",\n"," \"index\": 20,\n"," \"logprobs\": null,\n",- " \"text\": \" #create an empty list\\n result = []\\n #iterate over the two lists and compare the values\\n for i in range(len(game)):\\n diff = abs(game[i] - guess[i])\\n result.append(diff)\\n return result\"\n",+ " \"finish_reason\": \"stop\"\n"," },\n"," {\n",- " \"finish_reason\": \"stop\",\n",+ " \"text\": \" res = []\\n for i in range(len(game)):\\n diff = abs(game[i] - guess[i])\\n res.append(diff)\\n return res\",\n"," \"index\": 21,\n"," \"logprobs\": null,\n",- " \"text\": \" result = []\\n for i in range(len(game)):\\n result.append(abs(game[i] - guess[i]))\\n return result\"\n",+ " \"finish_reason\": \"stop\"\n"," },\n"," {\n",- " \"finish_reason\": \"stop\",\n",+ " \"text\": \" result = []\\n for i in range(len(game)):\\n diff = abs(game[i] - guess[i])\\n result.append(diff)\\n return result\",\n"," \"index\": 22,\n"," \"logprobs\": null,\n",- " \"text\": \" # initialize the result array\\n result = []\\n \\n # loop over the arrays and calculate the difference\\n for i in range(len(game)):\\n diff = abs(game[i] - guess[i])\\n result.append(diff)\\n \\n return result\"\n",+ " \"finish_reason\": \"stop\"\n"," },\n"," {\n",- " \"finish_reason\": \"stop\",\n",+ " \"text\": \" result = []\\n for i in range(len(game)):\\n diff = abs(game[i] - guess[i])\\n result.append(diff)\\n return result\",\n"," \"index\": 23,\n"," \"logprobs\": null,\n",- " \"text\": \" result = []\\n for i in range(len(game)):\\n result.append(abs(game[i]-guess[i]))\\n return result\"\n",+ " \"finish_reason\": \"stop\"\n"," },\n"," {\n",- " \"finish_reason\": \"stop\",\n",+ " \"text\": \" result = []\\n for i in range(len(game)):\\n diff = abs(game[i] - guess[i])\\n result.append(diff)\\n return result\",\n"," \"index\": 24,\n"," \"logprobs\": null,\n",- " \"text\": \" result = []\\n for i in range(len(game)):\\n diff = abs(game[i] - guess[i])\\n result.append(diff)\\n return result\"\n",+ " \"finish_reason\": \"stop\"\n"," },\n"," {\n",- " \"finish_reason\": \"stop\",\n",+ " \"text\": \" result = []\\n for i in range(len(game)):\\n diff = abs(game[i] - guess[i])\\n result.append(diff)\\n return result\",\n"," \"index\": 25,\n"," \"logprobs\": null,\n",- " \"text\": \" # Your code here\\n result = []\\n for i in range(len(game)):\\n diff = abs(game[i] - guess[i])\\n result.append(diff)\\n return result\"\n",+ " \"finish_reason\": \"stop\"\n"," },\n"," {\n",- " \"finish_reason\": \"stop\",\n",+ " \"text\": \" result = []\\n for i in range(len(game)):\\n result.append(abs(game[i]-guess[i]))\\n return result\",\n"," \"index\": 26,\n"," \"logprobs\": null,\n",- " \"text\": \" result = []\\n for i in range(len(game)):\\n result.append(abs(game[i]-guess[i]))\\n return result\"\n",+ " \"finish_reason\": \"stop\"\n"," }\n"," ],\n",- " \"created\": 1680456621,\n",- " \"id\": \"cmpl-70vozowIIN2Dcy5lOGYaIiYWvFFmh\",\n",- " \"model\": \"text-davinci-003\",\n",- " \"object\": \"text_completion\",\n"," \"usage\": {\n",- " \"completion_tokens\": 1198,\n"," \"prompt_tokens\": 243,\n",- " \"total_tokens\": 1441\n",- " }\n",+ " \"completion_tokens\": 1244,\n",+ " \"total_tokens\": 1487\n",+ " },\n",+ " \"cost\": 0.029740000000000003,\n",+ " \"config_id\": 0,\n",+ " \"pass_filter\": true\n","}\n",- "{'index_selected': 0, 'succeed_assertions': 1, 'success': 1, 'gen_cost': 0.000702, 'assertions': 'assert compare([1,2,3,4,5,1],[1,2,3,4,2,-2]) == [0,0,0,0,3,3]\\nassert compare([0,5,0,0,0,4],[4,1,1,0,0,-2]) == [4,4,1,0,0,6]'}\n"+ "{'index_selected': 0, 'succeed_assertions': True, 'success': True, 'gen_cost': 0.0005660000000000001, 'assertions': 'assert compare([1,2,3,4,5,1],[1,2,3,4,2,-2]) == [0,0,0,0,3,3]\\nassert compare([0,5,0,0,0,4],[4,1,1,0,0,-2]) == [4,4,1,0,0,6]'}\n"]}],"source": [- "response = oai.Completion.create(context=tune_data[1], **config)\n",+ "response = oai.Completion.create(context=tune_data[1], config_list=endpoint_list, **config)\n","print(response)\n","print(eval_with_generated_assertions(oai.Completion.extract_text(response), **tune_data[1]))\n"]diff --git a/notebook/automl_classification.ipynb b/notebook/automl_classification.ipynbindex 9e367630c..77d6d9482 100644--- a/notebook/automl_classification.ipynb+++ b/notebook/automl_classification.ipynb@@ -27,7 +27,7 @@"\n","In this notebook, we use one real data example (binary classification) to showcase how to use FLAML library.\n","\n",- "FLAML requires `Python>=3.7`. To run this notebook example, please install flaml with the `automl` option (this option is introduced from version 2, for version 1 it is installed by default):\n",+ "FLAML requires `Python>=3.8`. To run this notebook example, please install flaml with the `automl` option (this option is introduced from version 2, for version 1 it is installed by default):\n","```bash\n","pip install flaml[automl]\n","```"@@ -43,6 +43,7 @@]},{+ "attachments": {},"cell_type": "markdown","metadata": {"slideshow": {@@ -78,8 +79,19 @@}],"source": [+ "from minio.error import ServerError\n","from flaml.data import load_openml_dataset\n",- "X_train, X_test, y_train, y_test = load_openml_dataset(dataset_id=1169, data_dir='./')"+ "\n",+ "try:\n",+ " X_train, X_test, y_train, y_test = load_openml_dataset(dataset_id=1169, data_dir='./')\n",+ "except ServerError:\n",+ " from sklearn.datasets import make_classification\n",+ " from sklearn.model_selection import train_test_split\n",+ " from pandas import DataFrame\n",+ "\n",+ " X, y = make_classification(n_samples=539383, n_features=7)\n",+ " X = DataFrame(X)\n",+ " X_train, X_test, y_train, y_test = train_test_split(X, y)\n"]},{@@ -191,6 +203,7 @@]},{+ "attachments": {},"cell_type": "markdown","metadata": {"slideshow": {@@ -1030,6 +1043,7 @@]},{+ "attachments": {},"cell_type": "markdown","metadata": {"slideshow": {@@ -1195,6 +1209,7 @@]},{+ "attachments": {},"cell_type": "markdown","metadata": {"slideshow": {@@ -1277,6 +1292,7 @@]},{+ "attachments": {},"cell_type": "markdown","metadata": {},"source": [@@ -1284,6 +1300,7 @@]},{+ "attachments": {},"cell_type": "markdown","metadata": {},"source": [@@ -1333,6 +1350,7 @@]},{+ "attachments": {},"cell_type": "markdown","metadata": {},"source": [@@ -1440,6 +1458,7 @@]},{+ "attachments": {},"cell_type": "markdown","metadata": {"slideshow": {@@ -1451,6 +1470,7 @@]},{+ "attachments": {},"cell_type": "markdown","metadata": {"slideshow": {@@ -1464,6 +1484,7 @@]},{+ "attachments": {},"cell_type": "markdown","metadata": {"slideshow": {@@ -1592,6 +1613,7 @@]},{+ "attachments": {},"cell_type": "markdown","metadata": {"slideshow": {@@ -1759,6 +1781,7 @@]},{+ "attachments": {},"cell_type": "markdown","metadata": {},"source": [@@ -1796,6 +1819,7 @@]},{+ "attachments": {},"cell_type": "markdown","metadata": {},"source": [diff --git a/notebook/integrate_spark.ipynb b/notebook/integrate_spark.ipynbindex c93430ff0..a7a21e024 100644--- a/notebook/integrate_spark.ipynb+++ b/notebook/integrate_spark.ipynb@@ -1 +1 @@-{"cells":[{"attachments":{},"cell_type":"markdown","metadata":{"slideshow":{"slide_type":"slide"}},"source":["Copyright (c) Microsoft Corporation. All rights reserved. \n","\n","Licensed under the MIT License.\n","\n","# Run FLAML Parallel tuning with Spark\n","\n","\n","## 1. Introduction\n","\n","FLAML is a Python library (https://github.com/microsoft/FLAML) designed to automatically produce accurate machine learning models \n","with low computational cost. It is fast and economical. The simple and lightweight design makes it easy \n","to use and extend, such as adding new learners. FLAML can \n","- serve as an economical AutoML engine,\n","- be used as a fast hyperparameter tuning tool, or \n","- be embedded in self-tuning software that requires low latency & resource in repetitive\n"," tuning tasks.\n","\n","In this notebook, we demonstrate how to run FLAML parallel tuning using Spark as the backend.\n","\n","FLAML requires `Python>=3.7`. To run this notebook example, please install flaml with the following options:\n","```bash\n","pip install flaml[automl,spark,blendsearch]\n","```\n","*Spark support is added in v1.1.0*"]},{"cell_type":"code","execution_count":null,"metadata":{"cellStatus":"{\"Li Jiang\":{\"queued_time\":\"2022-12-07T08:16:51.6335768Z\",\"session_start_time\":null,\"execution_start_time\":\"2022-12-07T08:17:21.9028602Z\",\"execution_finish_time\":\"2022-12-07T08:18:52.3646576Z\",\"state\":\"finished\",\"livy_statement_state\":\"available\"}}"},"outputs":[],"source":["# %pip install flaml[automl,spark,blendsearch] matplotlib openml"]},{"cell_type":"markdown","metadata":{"slideshow":{"slide_type":"slide"}},"source":["## 2. Regression Example\n","### Load data and preprocess\n","\n","Download [houses dataset](https://www.openml.org/d/537) from OpenML. The task is to predict median price of the house in the region based on demographic composition and a state of housing market in the region."]},{"cell_type":"code","execution_count":null,"metadata":{"cellStatus":"{\"Li Jiang\":{\"queued_time\":\"2022-12-07T08:20:53.4783943Z\",\"session_start_time\":null,\"execution_start_time\":\"2022-12-07T08:20:55.7666047Z\",\"execution_finish_time\":\"2022-12-07T08:21:10.9050139Z\",\"state\":\"finished\",\"livy_statement_state\":\"available\"}}","slideshow":{"slide_type":"subslide"},"tags":[]},"outputs":[],"source":["from flaml.data import load_openml_dataset\n","X_train, X_test, y_train, y_test = load_openml_dataset(dataset_id=537, data_dir='./')"]},{"cell_type":"markdown","metadata":{"slideshow":{"slide_type":"slide"}},"source":["### Run FLAML\n","In the FLAML automl run configuration, users can specify the task type, time budget, error metric, learner list, whether to subsample, resampling strategy type, and so on. All these arguments have default values which will be used if users do not provide them. \n","\n","Notice that here `use_spark` is set to `True` in order to use Spark as the parallel training backend."]},{"cell_type":"code","execution_count":null,"metadata":{"cellStatus":"{\"Li Jiang\":{\"queued_time\":\"2022-12-07T08:20:53.7001471Z\",\"session_start_time\":null,\"execution_start_time\":\"2022-12-07T08:21:10.9846131Z\",\"execution_finish_time\":\"2022-12-07T08:21:11.3604062Z\",\"state\":\"finished\",\"livy_statement_state\":\"available\"}}","slideshow":{"slide_type":"slide"},"tags":[]},"outputs":[],"source":["''' import AutoML class from flaml package '''\n","from flaml import AutoML\n","automl = AutoML()"]},{"cell_type":"code","execution_count":null,"metadata":{"cellStatus":"{\"Li Jiang\":{\"queued_time\":\"2022-12-07T08:20:53.8983341Z\",\"session_start_time\":null,\"execution_start_time\":\"2022-12-07T08:21:11.4417491Z\",\"execution_finish_time\":\"2022-12-07T08:21:11.8242955Z\",\"state\":\"finished\",\"livy_statement_state\":\"available\"}}","slideshow":{"slide_type":"slide"}},"outputs":[],"source":["settings = {\n"," \"time_budget\": 30, # total running time in seconds\n"," \"metric\": 'r2', # primary metrics for regression can be chosen from: ['mae','mse','r2','rmse','mape']\n"," \"estimator_list\": ['lgbm'], # list of ML learners; we tune lightgbm in this example\n"," \"task\": 'regression', # task type \n"," \"log_file_name\": 'houses_experiment.log', # flaml log file\n"," \"seed\": 7654321, # random seed\n"," \"use_spark\": True, # whether to use Spark for distributed training\n"," \"n_concurrent_trials\": 2, # the maximum number of concurrent trials\n","}"]},{"cell_type":"code","execution_count":null,"metadata":{"cellStatus":"{\"Li Jiang\":{\"queued_time\":\"2022-12-07T08:20:54.3953298Z\",\"session_start_time\":null,\"execution_start_time\":\"2022-12-07T08:21:11.9003975Z\",\"execution_finish_time\":\"2022-12-07T08:27:58.525709Z\",\"state\":\"finished\",\"livy_statement_state\":\"available\"}}","slideshow":{"slide_type":"slide"},"tags":[]},"outputs":[],"source":["'''The main flaml automl API'''\n","automl.fit(X_train=X_train, y_train=y_train, **settings)"]},{"cell_type":"markdown","metadata":{"slideshow":{"slide_type":"slide"}},"source":["### Best model and metric"]},{"cell_type":"code","execution_count":null,"metadata":{"cellStatus":"{\"Li Jiang\":{\"queued_time\":\"2022-12-07T08:20:54.789647Z\",\"session_start_time\":null,\"execution_start_time\":\"2022-12-07T08:27:58.6014435Z\",\"execution_finish_time\":\"2022-12-07T08:27:58.9745212Z\",\"state\":\"finished\",\"livy_statement_state\":\"available\"}}","slideshow":{"slide_type":"slide"},"tags":[]},"outputs":[],"source":["''' retrieve best config'''\n","print('Best hyperparmeter config:', automl.best_config)\n","print('Best r2 on validation data: {0:.4g}'.format(1-automl.best_loss))\n","print('Training duration of best run: {0:.4g} s'.format(automl.best_config_train_time))"]},{"cell_type":"code","execution_count":null,"metadata":{"cellStatus":"{\"Li Jiang\":{\"queued_time\":\"2022-12-07T08:20:54.9962623Z\",\"session_start_time\":null,\"execution_start_time\":\"2022-12-07T08:27:59.0491242Z\",\"execution_finish_time\":\"2022-12-07T08:27:59.4076477Z\",\"state\":\"finished\",\"livy_statement_state\":\"available\"}}","slideshow":{"slide_type":"slide"}},"outputs":[],"source":["automl.model.estimator"]},{"cell_type":"code","execution_count":null,"metadata":{"cellStatus":"{\"Li Jiang\":{\"queued_time\":\"2022-12-07T08:20:55.2539877Z\",\"session_start_time\":null,\"execution_start_time\":\"2022-12-07T08:27:59.5247209Z\",\"execution_finish_time\":\"2022-12-07T08:28:00.4849272Z\",\"state\":\"finished\",\"livy_statement_state\":\"available\"}}"},"outputs":[],"source":["import matplotlib.pyplot as plt\n","plt.barh(automl.feature_names_in_, automl.feature_importances_)"]},{"cell_type":"code","execution_count":null,"metadata":{"cellStatus":"{\"Li Jiang\":{\"queued_time\":\"2022-12-07T08:20:55.5182783Z\",\"session_start_time\":null,\"execution_start_time\":\"2022-12-07T08:28:00.5644015Z\",\"execution_finish_time\":\"2022-12-07T08:28:01.5531147Z\",\"state\":\"finished\",\"livy_statement_state\":\"available\"}}","slideshow":{"slide_type":"slide"}},"outputs":[],"source":["''' pickle and save the automl object '''\n","import pickle\n","with open('automl.pkl', 'wb') as f:\n"," pickle.dump(automl, f, pickle.HIGHEST_PROTOCOL)"]},{"cell_type":"code","execution_count":null,"metadata":{"cellStatus":"{\"Li Jiang\":{\"queued_time\":\"2022-12-07T08:20:55.803107Z\",\"session_start_time\":null,\"execution_start_time\":\"2022-12-07T08:28:01.6350567Z\",\"execution_finish_time\":\"2022-12-07T08:28:02.5774117Z\",\"state\":\"finished\",\"livy_statement_state\":\"available\"}}","slideshow":{"slide_type":"slide"},"tags":[]},"outputs":[],"source":["''' compute predictions of testing dataset ''' \n","y_pred = automl.predict(X_test)\n","print('Predicted labels', y_pred)\n","print('True labels', y_test)"]},{"cell_type":"code","execution_count":null,"metadata":{"cellStatus":"{\"Li Jiang\":{\"queued_time\":\"2022-12-07T08:20:56.0585537Z\",\"session_start_time\":null,\"execution_start_time\":\"2022-12-07T08:28:02.6537337Z\",\"execution_finish_time\":\"2022-12-07T08:28:03.0177805Z\",\"state\":\"finished\",\"livy_statement_state\":\"available\"}}","slideshow":{"slide_type":"slide"},"tags":[]},"outputs":[],"source":["''' compute different metric values on testing dataset'''\n","from flaml.ml import sklearn_metric_loss_score\n","print('r2', '=', 1 - sklearn_metric_loss_score('r2', y_pred, y_test))\n","print('mse', '=', sklearn_metric_loss_score('mse', y_pred, y_test))\n","print('mae', '=', sklearn_metric_loss_score('mae', y_pred, y_test))"]},{"cell_type":"code","execution_count":null,"metadata":{"cellStatus":"{\"Li Jiang\":{\"queued_time\":\"2022-12-07T08:20:56.2226463Z\",\"session_start_time\":null,\"execution_start_time\":\"2022-12-07T08:28:03.1150781Z\",\"execution_finish_time\":\"2022-12-07T08:28:03.4858362Z\",\"state\":\"finished\",\"livy_statement_state\":\"available\"}}","slideshow":{"slide_type":"subslide"},"tags":[]},"outputs":[],"source":["from flaml.data import get_output_from_log\n","time_history, best_valid_loss_history, valid_loss_history, config_history, metric_history = \\\n"," get_output_from_log(filename=settings['log_file_name'], time_budget=60)\n","\n","for config in config_history:\n"," print(config)"]},{"cell_type":"code","execution_count":null,"metadata":{"cellStatus":"{\"Li Jiang\":{\"queued_time\":\"2022-12-07T08:20:56.4020235Z\",\"session_start_time\":null,\"execution_start_time\":\"2022-12-07T08:28:03.5811012Z\",\"execution_finish_time\":\"2022-12-07T08:28:04.5493292Z\",\"state\":\"finished\",\"livy_statement_state\":\"available\"}}","slideshow":{"slide_type":"slide"}},"outputs":[],"source":["import numpy as np\n","\n","plt.title('Learning Curve')\n","plt.xlabel('Wall Clock Time (s)')\n","plt.ylabel('Validation r2')\n","plt.scatter(time_history, 1 - np.array(valid_loss_history))\n","plt.step(time_history, 1 - np.array(best_valid_loss_history), where='post')\n","plt.show()"]},{"cell_type":"markdown","metadata":{},"source":["## 3. Add a customized LightGBM learner in FLAML\n","The native API of LightGBM allows one to specify a custom objective function in the model constructor. You can easily enable it by adding a customized LightGBM learner in FLAML. In the following example, we show how to add such a customized LightGBM learner with a custom objective function for parallel tuning with Spark.\n","\n","It's a little bit different from adding customized learners for sequential training. In sequential training, we can define the customized learner in a notebook cell. However, in spark training, we have to import it from a file so that Spark can use it in executors. We can easily do it by leveraging `broadcast_code` function in `flaml.tune.spark.utils`."]},{"cell_type":"markdown","metadata":{},"source":["### Create a customized LightGBM learner with a custom objective function"]},{"cell_type":"code","execution_count":null,"metadata":{"cellStatus":"{\"Li Jiang\":{\"queued_time\":\"2022-12-07T09:09:49.540914Z\",\"session_start_time\":null,\"execution_start_time\":\"2022-12-07T09:09:49.6259637Z\",\"execution_finish_time\":\"2022-12-07T09:09:50.5841239Z\",\"state\":\"finished\",\"livy_statement_state\":\"available\"}}"},"outputs":[],"source":["custom_code = \"\"\"\n","import numpy as np \n","from flaml.model import LGBMEstimator\n","from flaml import tune\n","\n","\n","''' define your customized objective function '''\n","def my_loss_obj(y_true, y_pred):\n"," c = 0.5\n"," residual = y_pred - y_true\n"," grad = c * residual /(np.abs(residual) + c)\n"," hess = c ** 2 / (np.abs(residual) + c) ** 2\n"," # rmse grad and hess\n"," grad_rmse = residual\n"," hess_rmse = 1.0\n"," \n"," # mae grad and hess\n"," grad_mae = np.array(residual)\n"," grad_mae[grad_mae > 0] = 1.\n"," grad_mae[grad_mae <= 0] = -1.\n"," hess_mae = 1.0\n","\n"," coef = [0.4, 0.3, 0.3]\n"," return coef[0] * grad + coef[1] * grad_rmse + coef[2] * grad_mae, \\\n"," coef[0] * hess + coef[1] * hess_rmse + coef[2] * hess_mae\n","\n","\n","''' create a customized LightGBM learner class with your objective function '''\n","class MyLGBM(LGBMEstimator):\n"," '''LGBMEstimator with my_loss_obj as the objective function\n"," '''\n","\n"," def __init__(self, **config):\n"," super().__init__(objective=my_loss_obj, **config)\n","\"\"\"\n","\n","from flaml.tune.spark.utils import broadcast_code\n","custom_learner_path = broadcast_code(custom_code=custom_code)\n","print(custom_learner_path)\n","from flaml.tune.spark.mylearner import MyLGBM"]},{"cell_type":"markdown","metadata":{},"source":["### Add the customized learner in FLAML"]},{"cell_type":"code","execution_count":null,"metadata":{"cellStatus":"{\"Li Jiang\":{\"queued_time\":\"2022-12-07T09:14:16.2449566Z\",\"session_start_time\":null,\"execution_start_time\":\"2022-12-07T09:14:16.3227204Z\",\"execution_finish_time\":\"2022-12-07T09:16:49.7573919Z\",\"state\":\"finished\",\"livy_statement_state\":\"available\"}}","tags":[]},"outputs":[],"source":["automl = AutoML()\n","automl.add_learner(learner_name='my_lgbm', learner_class=MyLGBM)\n","settings = {\n"," \"time_budget\": 30, # total running time in seconds\n"," \"metric\": 'r2', # primary metrics for regression can be chosen from: ['mae','mse','r2']\n"," \"estimator_list\": ['my_lgbm',], # list of ML learners; we tune lightgbm in this example\n"," \"task\": 'regression', # task type \n"," \"log_file_name\": 'houses_experiment_my_lgbm.log', # flaml log file\n"," \"n_concurrent_trials\": 2,\n"," \"use_spark\": True,\n","}\n","automl.fit(X_train=X_train, y_train=y_train, **settings)"]},{"cell_type":"code","execution_count":null,"metadata":{"cellStatus":"{\"Li Jiang\":{\"queued_time\":\"2022-12-07T09:17:06.0159529Z\",\"session_start_time\":null,\"execution_start_time\":\"2022-12-07T09:17:06.1042554Z\",\"execution_finish_time\":\"2022-12-07T09:17:06.467989Z\",\"state\":\"finished\",\"livy_statement_state\":\"available\"}}","tags":[]},"outputs":[],"source":["print('Best hyperparmeter config:', automl.best_config)\n","print('Best r2 on validation data: {0:.4g}'.format(1-automl.best_loss))\n","print('Training duration of best run: {0:.4g} s'.format(automl.best_config_train_time))\n","\n","y_pred = automl.predict(X_test)\n","print('Predicted labels', y_pred)\n","print('True labels', y_test)\n","\n","from flaml.ml import sklearn_metric_loss_score\n","print('r2', '=', 1 - sklearn_metric_loss_score('r2', y_pred, y_test))\n","print('mse', '=', sklearn_metric_loss_score('mse', y_pred, y_test))\n","print('mae', '=', sklearn_metric_loss_score('mae', y_pred, y_test))"]},{"cell_type":"code","execution_count":null,"metadata":{"jupyter":{"outputs_hidden":false,"source_hidden":false},"nteract":{"transient":{"deleting":false}}},"outputs":[],"source":[]}],"metadata":{"kernel_info":{"name":"synapse_pyspark"},"kernelspec":{"display_name":"Python 3.8.13 ('syml-py38')","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.8.13 (default, Oct 21 2022, 23:50:54) \n[GCC 11.2.0]"},"notebook_environment":{},"save_output":true,"spark_compute":{"compute_id":"/trident/default","session_options":{"conf":{"spark.livy.synapse.ipythonInterpreter.enabled":"true"},"enableDebugMode":false,"keepAliveTimeout":30}},"synapse_widget":{"state":{},"version":"0.1"},"trident":{"lakehouse":{}},"vscode":{"interpreter":{"hash":"e3d9487e2ef008ade0db1bc293d3206d35cb2b6081faff9f66b40b257b7398f7"}}},"nbformat":4,"nbformat_minor":0}+{"cells":[{"attachments":{},"cell_type":"markdown","metadata":{"slideshow":{"slide_type":"slide"}},"source":["Copyright (c) Microsoft Corporation. All rights reserved. \n","\n","Licensed under the MIT License.\n","\n","# Run FLAML Parallel tuning with Spark\n","\n","\n","## 1. Introduction\n","\n","FLAML is a Python library (https://github.com/microsoft/FLAML) designed to automatically produce accurate machine learning models \n","with low computational cost. It is fast and economical. The simple and lightweight design makes it easy \n","to use and extend, such as adding new learners. FLAML can \n","- serve as an economical AutoML engine,\n","- be used as a fast hyperparameter tuning tool, or \n","- be embedded in self-tuning software that requires low latency & resource in repetitive\n"," tuning tasks.\n","\n","In this notebook, we demonstrate how to run FLAML parallel tuning using Spark as the backend.\n","\n","FLAML requires `Python>=3.7`. To run this notebook example, please install flaml with the following options:\n","```bash\n","pip install flaml[automl,spark,blendsearch]\n","```\n","*Spark support is added in v1.1.0*"]},{"cell_type":"code","execution_count":null,"metadata":{"cellStatus":"{\"Li Jiang\":{\"queued_time\":\"2022-12-07T08:16:51.6335768Z\",\"session_start_time\":null,\"execution_start_time\":\"2022-12-07T08:17:21.9028602Z\",\"execution_finish_time\":\"2022-12-07T08:18:52.3646576Z\",\"state\":\"finished\",\"livy_statement_state\":\"available\"}}"},"outputs":[],"source":["# %pip install flaml[automl,spark,blendsearch] matplotlib openml"]},{"attachments":{},"cell_type":"markdown","metadata":{"slideshow":{"slide_type":"slide"}},"source":["## 2. Regression Example\n","### Load data and preprocess\n","\n","Download [houses dataset](https://www.openml.org/d/537) from OpenML. The task is to predict median price of the house in the region based on demographic composition and a state of housing market in the region."]},{"cell_type":"code","execution_count":null,"metadata":{"cellStatus":"{\"Li Jiang\":{\"queued_time\":\"2022-12-07T08:20:53.4783943Z\",\"session_start_time\":null,\"execution_start_time\":\"2022-12-07T08:20:55.7666047Z\",\"execution_finish_time\":\"2022-12-07T08:21:10.9050139Z\",\"state\":\"finished\",\"livy_statement_state\":\"available\"}}","slideshow":{"slide_type":"subslide"},"tags":[]},"outputs":[],"source":["from minio.error import ServerError\n","from flaml.data import load_openml_dataset\n","\n","try:\n"," X_train, X_test, y_train, y_test = load_openml_dataset(dataset_id=537, data_dir='./')\n","except ServerError:\n"," from sklearn.datasets import fetch_california_housing\n"," from sklearn.model_selection import train_test_split\n","\n"," X, y = fetch_california_housing(return_X_y=True)\n"," X_train, X_test, y_train, y_test = train_test_split(X, y)\n"]},{"attachments":{},"cell_type":"markdown","metadata":{"slideshow":{"slide_type":"slide"}},"source":["### Run FLAML\n","In the FLAML automl run configuration, users can specify the task type, time budget, error metric, learner list, whether to subsample, resampling strategy type, and so on. All these arguments have default values which will be used if users do not provide them. \n","\n","Notice that here `use_spark` is set to `True` in order to use Spark as the parallel training backend."]},{"cell_type":"code","execution_count":null,"metadata":{"cellStatus":"{\"Li Jiang\":{\"queued_time\":\"2022-12-07T08:20:53.7001471Z\",\"session_start_time\":null,\"execution_start_time\":\"2022-12-07T08:21:10.9846131Z\",\"execution_finish_time\":\"2022-12-07T08:21:11.3604062Z\",\"state\":\"finished\",\"livy_statement_state\":\"available\"}}","slideshow":{"slide_type":"slide"},"tags":[]},"outputs":[],"source":["''' import AutoML class from flaml package '''\n","from flaml import AutoML\n","automl = AutoML()"]},{"cell_type":"code","execution_count":null,"metadata":{"cellStatus":"{\"Li Jiang\":{\"queued_time\":\"2022-12-07T08:20:53.8983341Z\",\"session_start_time\":null,\"execution_start_time\":\"2022-12-07T08:21:11.4417491Z\",\"execution_finish_time\":\"2022-12-07T08:21:11.8242955Z\",\"state\":\"finished\",\"livy_statement_state\":\"available\"}}","slideshow":{"slide_type":"slide"}},"outputs":[],"source":["settings = {\n"," \"time_budget\": 30, # total running time in seconds\n"," \"metric\": 'r2', # primary metrics for regression can be chosen from: ['mae','mse','r2','rmse','mape']\n"," \"estimator_list\": ['lgbm'], # list of ML learners; we tune lightgbm in this example\n"," \"task\": 'regression', # task type \n"," \"log_file_name\": 'houses_experiment.log', # flaml log file\n"," \"seed\": 7654321, # random seed\n"," \"use_spark\": True, # whether to use Spark for distributed training\n"," \"n_concurrent_trials\": 2, # the maximum number of concurrent trials\n","}"]},{"cell_type":"code","execution_count":null,"metadata":{"cellStatus":"{\"Li Jiang\":{\"queued_time\":\"2022-12-07T08:20:54.3953298Z\",\"session_start_time\":null,\"execution_start_time\":\"2022-12-07T08:21:11.9003975Z\",\"execution_finish_time\":\"2022-12-07T08:27:58.525709Z\",\"state\":\"finished\",\"livy_statement_state\":\"available\"}}","slideshow":{"slide_type":"slide"},"tags":[]},"outputs":[],"source":["'''The main flaml automl API'''\n","automl.fit(X_train=X_train, y_train=y_train, **settings)"]},{"attachments":{},"cell_type":"markdown","metadata":{"slideshow":{"slide_type":"slide"}},"source":["### Best model and metric"]},{"cell_type":"code","execution_count":null,"metadata":{"cellStatus":"{\"Li Jiang\":{\"queued_time\":\"2022-12-07T08:20:54.789647Z\",\"session_start_time\":null,\"execution_start_time\":\"2022-12-07T08:27:58.6014435Z\",\"execution_finish_time\":\"2022-12-07T08:27:58.9745212Z\",\"state\":\"finished\",\"livy_statement_state\":\"available\"}}","slideshow":{"slide_type":"slide"},"tags":[]},"outputs":[],"source":["''' retrieve best config'''\n","print('Best hyperparmeter config:', automl.best_config)\n","print('Best r2 on validation data: {0:.4g}'.format(1-automl.best_loss))\n","print('Training duration of best run: {0:.4g} s'.format(automl.best_config_train_time))"]},{"cell_type":"code","execution_count":null,"metadata":{"cellStatus":"{\"Li Jiang\":{\"queued_time\":\"2022-12-07T08:20:54.9962623Z\",\"session_start_time\":null,\"execution_start_time\":\"2022-12-07T08:27:59.0491242Z\",\"execution_finish_time\":\"2022-12-07T08:27:59.4076477Z\",\"state\":\"finished\",\"livy_statement_state\":\"available\"}}","slideshow":{"slide_type":"slide"}},"outputs":[],"source":["automl.model.estimator"]},{"cell_type":"code","execution_count":null,"metadata":{"cellStatus":"{\"Li Jiang\":{\"queued_time\":\"2022-12-07T08:20:55.2539877Z\",\"session_start_time\":null,\"execution_start_time\":\"2022-12-07T08:27:59.5247209Z\",\"execution_finish_time\":\"2022-12-07T08:28:00.4849272Z\",\"state\":\"finished\",\"livy_statement_state\":\"available\"}}"},"outputs":[],"source":["import matplotlib.pyplot as plt\n","plt.barh(automl.feature_names_in_, automl.feature_importances_)"]},{"cell_type":"code","execution_count":null,"metadata":{"cellStatus":"{\"Li Jiang\":{\"queued_time\":\"2022-12-07T08:20:55.5182783Z\",\"session_start_time\":null,\"execution_start_time\":\"2022-12-07T08:28:00.5644015Z\",\"execution_finish_time\":\"2022-12-07T08:28:01.5531147Z\",\"state\":\"finished\",\"livy_statement_state\":\"available\"}}","slideshow":{"slide_type":"slide"}},"outputs":[],"source":["''' pickle and save the automl object '''\n","import pickle\n","with open('automl.pkl', 'wb') as f:\n"," pickle.dump(automl, f, pickle.HIGHEST_PROTOCOL)"]},{"cell_type":"code","execution_count":null,"metadata":{"cellStatus":"{\"Li Jiang\":{\"queued_time\":\"2022-12-07T08:20:55.803107Z\",\"session_start_time\":null,\"execution_start_time\":\"2022-12-07T08:28:01.6350567Z\",\"execution_finish_time\":\"2022-12-07T08:28:02.5774117Z\",\"state\":\"finished\",\"livy_statement_state\":\"available\"}}","slideshow":{"slide_type":"slide"},"tags":[]},"outputs":[],"source":["''' compute predictions of testing dataset ''' \n","y_pred = automl.predict(X_test)\n","print('Predicted labels', y_pred)\n","print('True labels', y_test)"]},{"cell_type":"code","execution_count":null,"metadata":{"cellStatus":"{\"Li Jiang\":{\"queued_time\":\"2022-12-07T08:20:56.0585537Z\",\"session_start_time\":null,\"execution_start_time\":\"2022-12-07T08:28:02.6537337Z\",\"execution_finish_time\":\"2022-12-07T08:28:03.0177805Z\",\"state\":\"finished\",\"livy_statement_state\":\"available\"}}","slideshow":{"slide_type":"slide"},"tags":[]},"outputs":[],"source":["''' compute different metric values on testing dataset'''\n","from flaml.ml import sklearn_metric_loss_score\n","print('r2', '=', 1 - sklearn_metric_loss_score('r2', y_pred, y_test))\n","print('mse', '=', sklearn_metric_loss_score('mse', y_pred, y_test))\n","print('mae', '=', sklearn_metric_loss_score('mae', y_pred, y_test))"]},{"cell_type":"code","execution_count":null,"metadata":{"cellStatus":"{\"Li Jiang\":{\"queued_time\":\"2022-12-07T08:20:56.2226463Z\",\"session_start_time\":null,\"execution_start_time\":\"2022-12-07T08:28:03.1150781Z\",\"execution_finish_time\":\"2022-12-07T08:28:03.4858362Z\",\"state\":\"finished\",\"livy_statement_state\":\"available\"}}","slideshow":{"slide_type":"subslide"},"tags":[]},"outputs":[],"source":["from flaml.data import get_output_from_log\n","time_history, best_valid_loss_history, valid_loss_history, config_history, metric_history = \\\n"," get_output_from_log(filename=settings['log_file_name'], time_budget=60)\n","\n","for config in config_history:\n"," print(config)"]},{"cell_type":"code","execution_count":null,"metadata":{"cellStatus":"{\"Li Jiang\":{\"queued_time\":\"2022-12-07T08:20:56.4020235Z\",\"session_start_time\":null,\"execution_start_time\":\"2022-12-07T08:28:03.5811012Z\",\"execution_finish_time\":\"2022-12-07T08:28:04.5493292Z\",\"state\":\"finished\",\"livy_statement_state\":\"available\"}}","slideshow":{"slide_type":"slide"}},"outputs":[],"source":["import numpy as np\n","\n","plt.title('Learning Curve')\n","plt.xlabel('Wall Clock Time (s)')\n","plt.ylabel('Validation r2')\n","plt.scatter(time_history, 1 - np.array(valid_loss_history))\n","plt.step(time_history, 1 - np.array(best_valid_loss_history), where='post')\n","plt.show()"]},{"attachments":{},"cell_type":"markdown","metadata":{},"source":["## 3. Add a customized LightGBM learner in FLAML\n","The native API of LightGBM allows one to specify a custom objective function in the model constructor. You can easily enable it by adding a customized LightGBM learner in FLAML. In the following example, we show how to add such a customized LightGBM learner with a custom objective function for parallel tuning with Spark.\n","\n","It's a little bit different from adding customized learners for sequential training. In sequential training, we can define the customized learner in a notebook cell. However, in spark training, we have to import it from a file so that Spark can use it in executors. We can easily do it by leveraging `broadcast_code` function in `flaml.tune.spark.utils`."]},{"attachments":{},"cell_type":"markdown","metadata":{},"source":["### Create a customized LightGBM learner with a custom objective function"]},{"cell_type":"code","execution_count":null,"metadata":{"cellStatus":"{\"Li Jiang\":{\"queued_time\":\"2022-12-07T09:09:49.540914Z\",\"session_start_time\":null,\"execution_start_time\":\"2022-12-07T09:09:49.6259637Z\",\"execution_finish_time\":\"2022-12-07T09:09:50.5841239Z\",\"state\":\"finished\",\"livy_statement_state\":\"available\"}}"},"outputs":[],"source":["custom_code = \"\"\"\n","import numpy as np \n","from flaml.model import LGBMEstimator\n","from flaml import tune\n","\n","\n","''' define your customized objective function '''\n","def my_loss_obj(y_true, y_pred):\n"," c = 0.5\n"," residual = y_pred - y_true\n"," grad = c * residual /(np.abs(residual) + c)\n"," hess = c ** 2 / (np.abs(residual) + c) ** 2\n"," # rmse grad and hess\n"," grad_rmse = residual\n"," hess_rmse = 1.0\n"," \n"," # mae grad and hess\n"," grad_mae = np.array(residual)\n"," grad_mae[grad_mae > 0] = 1.\n"," grad_mae[grad_mae <= 0] = -1.\n"," hess_mae = 1.0\n","\n"," coef = [0.4, 0.3, 0.3]\n"," return coef[0] * grad + coef[1] * grad_rmse + coef[2] * grad_mae, \\\n"," coef[0] * hess + coef[1] * hess_rmse + coef[2] * hess_mae\n","\n","\n","''' create a customized LightGBM learner class with your objective function '''\n","class MyLGBM(LGBMEstimator):\n"," '''LGBMEstimator with my_loss_obj as the objective function\n"," '''\n","\n"," def __init__(self, **config):\n"," super().__init__(objective=my_loss_obj, **config)\n","\"\"\"\n","\n","from flaml.tune.spark.utils import broadcast_code\n","custom_learner_path = broadcast_code(custom_code=custom_code)\n","print(custom_learner_path)\n","from flaml.tune.spark.mylearner import MyLGBM"]},{"attachments":{},"cell_type":"markdown","metadata":{},"source":["### Add the customized learner in FLAML"]},{"cell_type":"code","execution_count":null,"metadata":{"cellStatus":"{\"Li Jiang\":{\"queued_time\":\"2022-12-07T09:14:16.2449566Z\",\"session_start_time\":null,\"execution_start_time\":\"2022-12-07T09:14:16.3227204Z\",\"execution_finish_time\":\"2022-12-07T09:16:49.7573919Z\",\"state\":\"finished\",\"livy_statement_state\":\"available\"}}","tags":[]},"outputs":[],"source":["automl = AutoML()\n","automl.add_learner(learner_name='my_lgbm', learner_class=MyLGBM)\n","settings = {\n"," \"time_budget\": 30, # total running time in seconds\n"," \"metric\": 'r2', # primary metrics for regression can be chosen from: ['mae','mse','r2']\n"," \"estimator_list\": ['my_lgbm',], # list of ML learners; we tune lightgbm in this example\n"," \"task\": 'regression', # task type \n"," \"log_file_name\": 'houses_experiment_my_lgbm.log', # flaml log file\n"," \"n_concurrent_trials\": 2,\n"," \"use_spark\": True,\n","}\n","automl.fit(X_train=X_train, y_train=y_train, **settings)"]},{"cell_type":"code","execution_count":null,"metadata":{"cellStatus":"{\"Li Jiang\":{\"queued_time\":\"2022-12-07T09:17:06.0159529Z\",\"session_start_time\":null,\"execution_start_time\":\"2022-12-07T09:17:06.1042554Z\",\"execution_finish_time\":\"2022-12-07T09:17:06.467989Z\",\"state\":\"finished\",\"livy_statement_state\":\"available\"}}","tags":[]},"outputs":[],"source":["print('Best hyperparmeter config:', automl.best_config)\n","print('Best r2 on validation data: {0:.4g}'.format(1-automl.best_loss))\n","print('Training duration of best run: {0:.4g} s'.format(automl.best_config_train_time))\n","\n","y_pred = automl.predict(X_test)\n","print('Predicted labels', y_pred)\n","print('True labels', y_test)\n","\n","from flaml.ml import sklearn_metric_loss_score\n","print('r2', '=', 1 - sklearn_metric_loss_score('r2', y_pred, y_test))\n","print('mse', '=', sklearn_metric_loss_score('mse', y_pred, y_test))\n","print('mae', '=', sklearn_metric_loss_score('mae', y_pred, y_test))"]},{"cell_type":"code","execution_count":null,"metadata":{"jupyter":{"outputs_hidden":false,"source_hidden":false},"nteract":{"transient":{"deleting":false}}},"outputs":[],"source":[]}],"metadata":{"kernel_info":{"name":"synapse_pyspark"},"kernelspec":{"display_name":"Python 3.8.13 ('syml-py38')","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.8.13 (default, Oct 21 2022, 23:50:54) \n[GCC 11.2.0]"},"notebook_environment":{},"save_output":true,"spark_compute":{"compute_id":"/trident/default","session_options":{"conf":{"spark.livy.synapse.ipythonInterpreter.enabled":"true"},"enableDebugMode":false,"keepAliveTimeout":30}},"synapse_widget":{"state":{},"version":"0.1"},"trident":{"lakehouse":{}},"vscode":{"interpreter":{"hash":"e3d9487e2ef008ade0db1bc293d3206d35cb2b6081faff9f66b40b257b7398f7"}}},"nbformat":4,"nbformat_minor":0}diff --git a/test/autogen/oai/test_completion.py b/test/autogen/oai/test_completion.pyindex fab13d65f..495329296 100644--- a/test/autogen/oai/test_completion.py+++ b/test/autogen/oai/test_completion.py@@ -17,6 +17,7 @@ from flaml.autogen.code_utils import (from flaml.autogen.math_utils import eval_math_responses, solve_problemKEY_LOC = "test/autogen"+OAI_CONFIG_LIST = "OAI_CONFIG_LIST"here = os.path.abspath(os.path.dirname(__file__))@@ -48,7 +49,11 @@ def test_filter():prompt="Is 37 a prime number? Please answer 'Yes.' or 'No.'",filter_func=yes_or_no_filter,)- assert oai.Completion.extract_text(response)[0] in ["Yes.", "No."]+ assert (+ oai.Completion.extract_text(response)[0] in ["Yes.", "No."]+ or not response["pass_filter"]+ and response["config_id"] == 2+ )response = oai.Completion.create(context={"yes_or_no_choice": False},config_list=[{"model": "text-ada-001"}, {"model": "gpt-3.5-turbo"}, {"model": "text-davinci-003"}],@@ -144,7 +149,19 @@ def test_nocontext():)print(response)code, _ = generate_code(- model="gpt-3.5-turbo",+ config_list=oai.config_list_from_json(+ OAI_CONFIG_LIST,+ file_location=KEY_LOC,+ filter_dict={+ "model": {+ "gpt-3.5-turbo",+ "gpt-3.5-turbo-16k",+ "gpt-3.5-turbo-0301",+ "chatgpt-35-turbo-0301",+ "gpt-35-turbo-v0301",+ },+ },+ ),messages=[{"role": "system",@@ -167,7 +184,23 @@ def test_nocontext():reason="do not run on windows",)def test_humaneval(num_samples=1):- eval_with_generated_assertions = partial(eval_function_completions, assertions=generate_assertions)+ gpt35_config_list = oai.config_list_from_json(+ env_or_file="OAI_CONFIG_LIST",+ filter_dict={+ "model": {+ "gpt-3.5-turbo",+ "gpt-3.5-turbo-16k",+ "gpt-3.5-turbo-0301",+ "chatgpt-35-turbo-0301",+ "gpt-35-turbo-v0301",+ },+ },+ )+ assertions = partial(generate_assertions, config_list=gpt35_config_list)+ eval_with_generated_assertions = partial(+ eval_function_completions,+ assertions=assertions,+ )seed = 41data = datasets.load_dataset("openai_humaneval")["test"].shuffle(seed=seed)@@ -197,6 +230,16 @@ def test_humaneval(num_samples=1):print(exc)returnoai.Completion.clear_cache(400)+ # no error should be raised+ response = oai.Completion.create(+ context=test_data[0],+ config_list=[{"model": "gpt-3.5-turbo"}],+ prompt="",+ max_tokens=1,+ retry_timeout=0,+ raise_on_ratelimit_or_timeout=False,+ )+ # assert response == -1# a minimal tuning exampleconfig, _ = oai.Completion.tune(data=tune_data,@@ -206,7 +249,7 @@ def test_humaneval(num_samples=1):n=1,prompt="{definition}",)- responses = oai.Completion.create(context=test_data[0], **config)+ response = oai.Completion.create(context=test_data[0], **config)# a minimal tuning example for tuning chat completion models using the Completion classconfig, _ = oai.Completion.tune(data=tune_data,@@ -217,7 +260,7 @@ def test_humaneval(num_samples=1):model="text-davinci-003",prompt="{definition}",)- responses = oai.Completion.create(context=test_data[0], **config)+ response = oai.Completion.create(context=test_data[0], **config)# a minimal tuning example for tuning chat completion models using the ChatCompletion classconfig_list = oai.config_list_openai_aoai(KEY_LOC)config, _ = oai.ChatCompletion.tune(@@ -229,9 +272,18 @@ def test_humaneval(num_samples=1):messages=[{"role": "user", "content": "{definition}"}],config_list=config_list,)- responses = oai.ChatCompletion.create(context=test_data[0], config_list=config_list, **config)- print(responses)- code, cost, selected = implement(tune_data[1], [{**config_list[-1], **config}])+ response = oai.ChatCompletion.create(context=test_data[0], config_list=config_list, **config)+ print(response)+ from openai.error import RateLimitError++ try:+ code, cost, selected = implement(tune_data[1], [{**config_list[-1], **config}])+ except RateLimitError:+ code, cost, selected = implement(+ tune_data[1],+ [{**config_list[0], "model": "text-ada-001", "prompt": config["messages"]["content"]}],+ assertions=assertions,+ )print(code)print(cost)assert selected == 0@@ -253,18 +305,31 @@ def test_humaneval(num_samples=1):"Complete the following Python function:{definition}",],stop=[["\nclass", "\ndef", "\nif", "\nprint"], None], # the stop sequences+ config_list=config_list,)print(config2)print(analysis.best_result)print(test_data[0])- responses = oai.Completion.create(context=test_data[0], **config2)- print(responses)+ response = oai.Completion.create(context=test_data[0], **config2)+ print(response)oai.Completion.data = test_data[:num_samples]result = oai.Completion._eval(analysis.best_config, prune=False, eval_only=True)print("result without pruning", result)result = oai.Completion.test(test_data[:num_samples], **config2)print(result)- code, cost, selected = implement(tune_data[1], [config2, config])+ try:+ code, cost, selected = implement(+ tune_data[1], [{**config_list[-2], **config2}, {**config_list[-1], **config}], assertions=assertions+ )+ except RateLimitError:+ code, cost, selected = implement(+ tune_data[1],+ [+ {**config_list[-3], **config2},+ {**config_list[0], "model": "text-ada-001", "prompt": config["messages"]["content"]},+ ],+ assertions=assertions,+ )print(code)print(cost)print(selected)diff --git a/test/autogen/oai/test_utils.py b/test/autogen/oai/test_utils.pynew file mode 100644index 000000000..2789e5cba--- /dev/null+++ b/test/autogen/oai/test_utils.py@@ -0,0 +1,32 @@+import json+import os+from flaml import oai++KEY_LOC = "test/autogen"+++def test_config_list_from_json():+ config_list = oai.config_list_gpt4_gpt35(key_file_path=KEY_LOC)+ json_file = os.path.join(KEY_LOC, "config_list_test.json")+ with open(json_file, "w") as f:+ json.dump(config_list, f, indent=4)+ config_list_1 = oai.config_list_from_json(json_file)+ assert config_list == config_list_1+ os.environ["config_list_test"] = json.dumps(config_list)+ config_list_2 = oai.config_list_from_json("config_list_test")+ assert config_list == config_list_2+ config_list_3 = oai.config_list_from_json(+ "OAI_CONFIG_LIST", file_location=KEY_LOC, filter_dict={"model": ["gpt4", "gpt-4-32k"]}+ )+ assert all(config.get("model") in ["gpt4", "gpt-4-32k"] for config in config_list_3)+ del os.environ["config_list_test"]+ os.remove(json_file)+++def test_config_list_openai_aoai():+ config_list = oai.config_list_openai_aoai(key_file_path=KEY_LOC)+ assert all(config.get("api_type") in [None, "open_ai", "azure"] for config in config_list)+++if __name__ == "__main__":+ test_config_list_from_json()diff --git a/test/autogen/test_agent.py b/test/autogen/test_agent.pyindex ca27c2024..93e85ac80 100644--- a/test/autogen/test_agent.py+++ b/test/autogen/test_agent.py@@ -13,10 +13,10 @@ def test_agent():) # receive a dict# receive dict without openai fields to be printed, such as "content", 'function_call'. There should be no error raised.- pre_len = len(dummy_agent_1._oai_conversations["dummy_agent_2"])+ pre_len = len(dummy_agent_1.oai_conversations["dummy_agent_2"])dummy_agent_1.receive({"message": "hello"}, dummy_agent_2)assert pre_len == len(- dummy_agent_1._oai_conversations["dummy_agent_2"]+ dummy_agent_1.oai_conversations["dummy_agent_2"]), "When the message is not an valid openai message, it should not be appended to the oai conversation."dummy_agent_1.send("hello", dummy_agent_2) # send a str@@ -28,11 +28,11 @@ def test_agent():) # send a dict# receive dict with no openai fields- pre_len = len(dummy_agent_1._oai_conversations["dummy_agent_2"])+ pre_len = len(dummy_agent_1.oai_conversations["dummy_agent_2"])dummy_agent_1.send({"message": "hello"}, dummy_agent_2) # send dict with wrong fieldassert pre_len == len(- dummy_agent_1._oai_conversations["dummy_agent_2"]+ dummy_agent_1.oai_conversations["dummy_agent_2"]), "When the message is not a valid openai message, it should not be appended to the oai conversation."diff --git a/test/autogen/test_assistant_agent.py b/test/autogen/test_assistant_agent.pyindex 64bdf1834..ad3bd8cb3 100644--- a/test/autogen/test_assistant_agent.py+++ b/test/autogen/test_assistant_agent.py@@ -3,6 +3,7 @@ from flaml import oaifrom flaml.autogen.agent import AssistantAgent, UserProxyAgentKEY_LOC = "test/autogen"+OAI_CONFIG_LIST = "OAI_CONFIG_LIST"here = os.path.abspath(os.path.dirname(__file__))@@ -11,7 +12,19 @@ def test_gpt35(human_input_mode="NEVER", max_consecutive_auto_reply=5):import openaiexcept ImportError:return- config_list = oai.config_list_from_models(key_file_path=KEY_LOC, model_list=["gpt-3.5-turbo-0613"], exclude="aoai")+ config_list = oai.config_list_from_json(+ OAI_CONFIG_LIST,+ file_location=KEY_LOC,+ filter_dict={+ "model": {+ "gpt-3.5-turbo",+ "gpt-3.5-turbo-16k",+ "gpt-3.5-turbo-0301",+ "chatgpt-35-turbo-0301",+ "gpt-35-turbo-v0301",+ },+ },+ )assistant = AssistantAgent("coding_agent",# request_timeout=600,@@ -21,20 +34,26 @@ def test_gpt35(human_input_mode="NEVER", max_consecutive_auto_reply=5):)user = UserProxyAgent("user",- work_dir=f"{here}/test_agent_scripts",human_input_mode=human_input_mode,is_termination_msg=lambda x: x.get("content", "").rstrip().endswith("TERMINATE"),max_consecutive_auto_reply=max_consecutive_auto_reply,- use_docker="python:3",- timeout=60,+ code_execution_config={+ "work_dir": f"{here}/test_agent_scripts",+ "use_docker": "python:3",+ "timeout": 60,+ },)+ user.initiate_chat(assistant, message="TERMINATE")+ # should terminate without sending any message+ assert assistant.oai_conversations[user.name][-1]["content"] == "TERMINATE"+ assistant.reset()coding_task = "Print hello world to a file called hello.txt"- user.initiate_chat(assistant, coding_task)+ user.initiate_chat(assistant, message=coding_task)# coding_task = "Create a powerpoint with the text hello world in it."# assistant.receive(coding_task, user)assistant.reset()coding_task = "Save a pandas df with 3 rows and 3 columns to disk."- user.initiate_chat(assistant, coding_task)+ user.initiate_chat(assistant, message=coding_task)assert not isinstance(user.use_docker, bool) # None or str@@ -44,7 +63,7 @@ def test_create_execute_script(human_input_mode="NEVER", max_consecutive_auto_reexcept ImportError:return- config_list = oai.config_list_gpt4_gpt35(key_file_path=KEY_LOC)+ config_list = oai.config_list_from_json(OAI_CONFIG_LIST, file_location=KEY_LOC)conversations = {}oai.ChatCompletion.start_logging(conversations)assistant = AssistantAgent("assistant", request_timeout=600, seed=42, config_list=config_list)@@ -56,12 +75,12 @@ def test_create_execute_script(human_input_mode="NEVER", max_consecutive_auto_re)user.initiate_chat(assistant,- """Create and execute a script to plot a rocket without using matplotlib""",+ message="""Create and execute a script to plot a rocket without using matplotlib""",)assistant.reset()user.initiate_chat(assistant,- """Create a temp.py file with the following content:+ message="""Create a temp.py file with the following content:```print('Hello world!')```""",@@ -79,7 +98,13 @@ def test_tsp(human_input_mode="NEVER", max_consecutive_auto_reply=10):except ImportError:return- config_list = oai.config_list_openai_aoai(key_file_path=KEY_LOC)+ config_list = oai.config_list_from_json(+ OAI_CONFIG_LIST,+ file_location=KEY_LOC,+ filter_dict={+ "model": ["gpt-4", "gpt4", "gpt-4-32k", "gpt-4-32k-0314"],+ },+ )hard_questions = ["What if we must go from node 1 to node 2?","Can we double all distances?",@@ -92,14 +117,14 @@ def test_tsp(human_input_mode="NEVER", max_consecutive_auto_reply=10):with open(f"{here}/tsp_prompt.txt", "r") as f:self._prompt = f.read()- def generate_init_prompt(self, question) -> str:+ def generate_init_message(self, question) -> str:return self._prompt.format(question=question)oai.ChatCompletion.start_logging()assistant = AssistantAgent("assistant", temperature=0, config_list=config_list)user = TSPUserProxyAgent("user",- work_dir=f"{here}",+ code_execution_config={"work_dir": here},human_input_mode=human_input_mode,max_consecutive_auto_reply=max_consecutive_auto_reply,)@@ -111,9 +136,9 @@ def test_tsp(human_input_mode="NEVER", max_consecutive_auto_reply=10):if __name__ == "__main__":- # test_gpt35()+ test_gpt35()# test_create_execute_script(human_input_mode="TERMINATE")# when GPT-4, i.e., the DEFAULT_MODEL, is used, conversation in the following test# should terminate in 2-3 rounds of interactions (because is_termination_msg should be true after 2-3 rounds)# although the max_consecutive_auto_reply is set to 10.- test_tsp(human_input_mode="NEVER", max_consecutive_auto_reply=10)+ # test_tsp(human_input_mode="NEVER", max_consecutive_auto_reply=10)diff --git a/test/autogen/test_function_call.py b/test/autogen/test_function_call.pyindex f0ad30b85..82fa23026 100644--- a/test/autogen/test_function_call.py+++ b/test/autogen/test_function_call.py@@ -12,7 +12,9 @@ KEY_LOC = "test/autogen"@pytest.mark.skipif(openai is None, reason="openai not installed")def test_eval_math_responses():- config_list = oai.config_list_openai_aoai(KEY_LOC, exclude="aoai")+ config_list = oai.config_list_from_models(+ KEY_LOC, exclude="aoai", model_list=["gpt-4-0613", "gpt-3.5-turbo-0613", "gpt-3.5-turbo-16k"]+ )functions = [{"name": "eval_math_responses",@@ -35,7 +37,6 @@ def test_eval_math_responses():},]response = oai.ChatCompletion.create(- model="gpt-3.5-turbo-0613",config_list=config_list,messages=[{diff --git a/test/autogen/test_math_user_proxy_agent.py b/test/autogen/test_math_user_proxy_agent.pyindex 677e30316..440cef1d8 100644--- a/test/autogen/test_math_user_proxy_agent.py+++ b/test/autogen/test_math_user_proxy_agent.py@@ -4,6 +4,7 @@ import pytestimport sysKEY_LOC = "test/autogen"+OAI_CONFIG_LIST = "OAI_CONFIG_LIST"@pytest.mark.skipif(@@ -21,7 +22,13 @@ def test_math_user_proxy_agent():conversations = {}oai.ChatCompletion.start_logging(conversations)- config_list = oai.config_list_openai_aoai(key_file_path=KEY_LOC)+ config_list = oai.config_list_from_json(+ OAI_CONFIG_LIST,+ file_location=KEY_LOC,+ filter_dict={+ "model": ["gpt-4", "gpt4", "gpt-4-32k", "gpt-4-32k-0314"],+ },+ )assistant = AssistantAgent("assistant",system_message="You are a helpful assistant.",@@ -35,7 +42,7 @@ def test_math_user_proxy_agent():math_problem = "$x^3=125$. What is x?"assistant.receive(- message=mathproxyagent.generate_init_prompt(math_problem),+ message=mathproxyagent.generate_init_message(math_problem),sender=mathproxyagent,)print(conversations)@@ -99,7 +106,7 @@ def test_execute_one_wolfram_query():def test_generate_prompt():mathproxyagent = MathUserProxyAgent(name="MathChatAgent", human_input_mode="NEVER")- assert "customized" in mathproxyagent.generate_init_prompt(+ assert "customized" in mathproxyagent.generate_init_message(problem="2x=4", prompt_type="python", customized_prompt="customized")diff --git a/test/autogen/test_user_proxy_agent.py b/test/autogen/test_user_proxy_agent.pynew file mode 100644index 000000000..48731909a--- /dev/null+++ b/test/autogen/test_user_proxy_agent.py@@ -0,0 +1,55 @@+from flaml import oai+from flaml.autogen.agent import AIUserProxyAgent, AssistantAgent+import pytest+import sys++KEY_LOC = "test/autogen"+OAI_CONFIG_LIST = "OAI_CONFIG_LIST"+++ sys.platform in ["darwin", "win32"],+ reason="do not run on MacOS or windows",+)+def test_ai_user_proxy_agent():+ try:+ import openai+ except ImportError:+ return++ conversations = {}+ oai.ChatCompletion.start_logging(conversations)++ config_list = oai.config_list_from_json(+ OAI_CONFIG_LIST,+ file_location=KEY_LOC,+ )+ assistant = AssistantAgent(+ "assistant",+ system_message="You are a helpful assistant.",+ request_timeout=600,+ seed=42,+ config_list=config_list,+ )++ ai_user_proxy = AIUserProxyAgent(+ name="ai_user",+ human_input_mode="NEVER",+ config_list=config_list,+ max_consecutive_auto_reply=2,+ code_execution_config=False,+ # In the system message the "user" always refers to ther other agent.+ system_message="You ask a user for help. You check the answer from the user and provide feedback.",+ )+ assistant.reset()++ math_problem = "$x^3=125$. What is x?"+ ai_user_proxy.initiate_chat(+ assistant,+ message=math_problem,+ )+ print(conversations)+++if __name__ == "__main__":+ test_ai_user_proxy_agent()diff --git a/test/automl/test_notebook_example.py b/test/automl/test_notebook_example.pyindex 0de61ebcc..f53aef062 100644--- a/test/automl/test_notebook_example.py+++ b/test/automl/test_notebook_example.py@@ -1,6 +1,7 @@import sysfrom openml.exceptions import OpenMLServerExceptionfrom requests.exceptions import ChunkedEncodingError, SSLError+from minio.error import ServerErrordef test_automl(budget=5, dataset_format="dataframe", hpo_method=None):@@ -29,6 +30,7 @@ def test_automl(budget=5, dataset_format="dataframe", hpo_method=None):ChunkedEncodingError,urllib3.exceptions.ReadTimeoutError,SSLError,+ ServerError,) as e:print(e)return@@ -119,7 +121,7 @@ def test_mlflow():try:X_train, X_test, y_train, y_test = load_openml_task(task_id=7592, data_dir="test/")- except (OpenMLServerException, ChunkedEncodingError, SSLError) as e:+ except (OpenMLServerException, ChunkedEncodingError, SSLError, ServerError) as e:print(e)return""" import AutoML class from flaml package """diff --git a/test/automl/test_split.py b/test/automl/test_split.pyindex a97dc0fa6..17ba00c75 100644--- a/test/automl/test_split.py+++ b/test/automl/test_split.py@@ -90,9 +90,13 @@ def test_groups():def test_stratified_groupkfold():from sklearn.model_selection import StratifiedGroupKFold+ from minio.error import ServerErrorfrom flaml.data import load_openml_dataset- X_train, _, y_train, _ = load_openml_dataset(dataset_id=1169, data_dir="test/")+ try:+ X_train, _, y_train, _ = load_openml_dataset(dataset_id=1169, data_dir="test/")+ except ServerError:+ returnsplitter = StratifiedGroupKFold(n_splits=5, shuffle=True, random_state=0)automl = AutoML()diff --git a/test/automl/test_warmstart.py b/test/automl/test_warmstart.pyindex 89d1b2e0d..0611bb2f9 100644--- a/test/automl/test_warmstart.py+++ b/test/automl/test_warmstart.py@@ -106,10 +106,18 @@ class TestWarmStart(unittest.TestCase):print(automl.best_config_per_estimator)def test_FLAML_sample_size_in_starting_points(self):+ from openml.exceptions import OpenMLServerException+ from requests.exceptions import ChunkedEncodingError, SSLError+ from minio.error import ServerErrorfrom flaml.automl.data import load_openml_datasetfrom flaml import AutoML- X_train, X_test, y_train, y_test = load_openml_dataset(dataset_id=1169, data_dir="./")+ try:+ X_train, X_test, y_train, y_test = load_openml_dataset(dataset_id=1169, data_dir="./")+ except (OpenMLServerException, ChunkedEncodingError, SSLError, ServerError):+ from sklearn.datasets import load_wine++ X_train, y_train = load_wine(return_X_y=True)automl_settings = {"time_budget": 3,diff --git a/test/spark/test_exceptions.py b/test/spark/test_exceptions.pyindex a49247c0a..715fb45fc 100644--- a/test/spark/test_exceptions.py+++ b/test/spark/test_exceptions.py@@ -13,7 +13,14 @@ os.environ["FLAML_MAX_CONCURRENT"] = "2"def base_automl(n_concurrent_trials=1, use_ray=False, use_spark=False, verbose=0):- X_train, X_test, y_train, y_test = load_openml_dataset(dataset_id=537, data_dir="./")+ from minio.error import ServerError++ try:+ X_train, X_test, y_train, y_test = load_openml_dataset(dataset_id=537, data_dir="./")+ except ServerError:+ from sklearn.datasets import fetch_california_housing++ X_train, y_train = fetch_california_housing(return_X_y=True)automl = AutoML()settings = {"time_budget": 3, # total running time in secondsdiff --git a/test/spark/test_performance.py b/test/spark/test_performance.pyindex 160fca992..ff514aa71 100644--- a/test/spark/test_performance.py+++ b/test/spark/test_performance.py@@ -1,6 +1,7 @@import sysfrom openml.exceptions import OpenMLServerExceptionfrom requests.exceptions import ChunkedEncodingError, SSLError+from minio.error import ServerErrorfrom flaml.tune.spark.utils import check_sparkimport osimport pytest@@ -34,6 +35,7 @@ def run_automl(budget=3, dataset_format="dataframe", hpo_method=None):ChunkedEncodingError,urllib3.exceptions.ReadTimeoutError,SSLError,+ ServerError,) as e:print(e)returndiff --git a/test/test_autovw.py b/test/test_autovw.pyindex d4d1db6cd..29928ae15 100644--- a/test/test_autovw.py+++ b/test/test_autovw.py@@ -10,6 +10,7 @@ import stringimport osimport openmlfrom requests.exceptions import SSLError+from minio.error import ServerErrorimport sysimport pytest@@ -88,14 +89,10 @@ def shuffle_data(X, y, seed):def get_oml_to_vw(did, max_ns_num, ds_dir=VW_DS_DIR):success = Falseprint("-----getting oml dataset-------", did)- try:- ds = openml.datasets.get_dataset(did)- target_attribute = ds.default_target_attribute- # if target_attribute is None and did in OML_target_attribute_dict:- # target_attribute = OML_target_attribute_dict[did]- except SSLError as e:- print(e)- return+ ds = openml.datasets.get_dataset(did)+ target_attribute = ds.default_target_attribute+ # if target_attribute is None and did in OML_target_attribute_dict:+ # target_attribute = OML_target_attribute_dict[did]print("target=ds.default_target_attribute", target_attribute)data = ds.get_data(target=target_attribute, dataset_format="array")@@ -357,7 +354,11 @@ class TestAutoVW(unittest.TestCase):def test_vw_oml_problem_and_vanilla_vw(self):from vowpalwabbit import pyvw- vw_oml_problem_args, vw_online_aml_problem = get_vw_tuning_problem()+ try:+ vw_oml_problem_args, vw_online_aml_problem = get_vw_tuning_problem()+ except (SSLError, ServerError) as e:+ print(e)+ returnvanilla_vw = pyvw.vw(**vw_oml_problem_args["fixed_hp_config"])cumulative_loss_list = online_learning_loop(vw_online_aml_problem.max_iter_num,@@ -369,7 +370,11 @@ class TestAutoVW(unittest.TestCase):def test_supervised_vw_tune_namespace(self):# basic experiment setting- vw_oml_problem_args, vw_online_aml_problem = get_vw_tuning_problem()+ try:+ vw_oml_problem_args, vw_online_aml_problem = get_vw_tuning_problem()+ except (SSLError, ServerError) as e:+ print(e)+ returnautovw = AutoVW(max_live_model_num=5,search_space=vw_online_aml_problem.search_space,@@ -388,9 +393,14 @@ class TestAutoVW(unittest.TestCase):def test_supervised_vw_tune_namespace_learningrate(self):# basic experiment setting- vw_oml_problem_args, vw_online_aml_problem = get_vw_tuning_problem(- tuning_hp="NamesapceInteraction+LearningRate"- )+ try:+ vw_oml_problem_args, vw_online_aml_problem = get_vw_tuning_problem(+ tuning_hp="NamesapceInteraction+LearningRate"+ )+ except (SSLError, ServerError) as e:+ print(e)+ return+autovw = AutoVW(max_live_model_num=5,search_space=vw_online_aml_problem.search_space,diff --git a/website/blog/2023-07-14-Local-LLMs/index.mdx b/website/blog/2023-07-14-Local-LLMs/index.mdxindex 36ea8d6ce..9faf14982 100644--- a/website/blog/2023-07-14-Local-LLMs/index.mdx+++ b/website/blog/2023-07-14-Local-LLMs/index.mdx@@ -1,5 +1,5 @@----title: Use flaml.autogen for local LLMs+title: Use flaml.autogen for Local LLMsauthors: jialeliutags: [LLM, FLAMLv2]---diff --git a/website/docs/Contribute.md b/website/docs/Contribute.mdindex 6252675eb..28f918d1f 100644--- a/website/docs/Contribute.md+++ b/website/docs/Contribute.md@@ -61,10 +61,10 @@ There is currently no formal reviewer solicitation process. Current reviewers id```bashgit clone https://github.com/microsoft/FLAML.git-pip install -e FLAML[test,notebook]+pip install -e FLAML[notebook,autogen]```-In case the `pip install` command fails, try escaping the brackets such as `pip install -e FLAML\[test,notebook\]`+In case the `pip install` command fails, try escaping the brackets such as `pip install -e FLAML\[notebook,autogen\]`.### Docker@@ -87,9 +87,10 @@ Run `pre-commit install` to install pre-commit into your git hooks. Before you c### Coverage-Any code you commit should not decrease coverage. To run all unit tests:+Any code you commit should not decrease coverage. To run all unit tests, install the [test] option under FLAML/:```bash+pip install -e."[test]"coverage run -m pytest test```diff --git a/website/docs/Use-Cases/Auto-Generation.md b/website/docs/Use-Cases/Auto-Generation.mdindex a66fb7947..9e76d2ebe 100644--- a/website/docs/Use-Cases/Auto-Generation.md+++ b/website/docs/Use-Cases/Auto-Generation.md@@ -13,9 +13,9 @@ The package is under active development with more features upcoming.## Agents (Experimental)-[`flaml.autogen.agents`](../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.agent`](../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.-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 in the `receive` method.+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.### `AssistantAgent`@@ -24,7 +24,9 @@ We have designed different classes of Agents that are capable of communicating w### `UserProxyAgent``UserProxyAgent` is an Agent class that serves as a proxy for the human user. Upon receiving a message, the UserProxyAgent will either solicit the human user's input or prepare an automatically generated reply. The chosen action depends on the settings of the `human_input_mode` and `max_consecutive_auto_reply` when the `UserProxyAgent` instance is constructed, and whether a human user input is available.-Currently, the automatically generated reply is crafted based on automatic code execution. The `UserProxyAgent` triggers code execution automatically when it detects an executable code block in the received message and no human user input is provided. We plan to add more capabilities in `UserProxyAgent` beyond code execution. One can also easily extend it by overriding the `auto_reply` function of the `UserProxyAgent` to add or modify responses to the `AssistantAgent`'s specific type of message. This auto-reply capability allows for more autonomous user-agent communication while retaining the possibility of human intervention.+By default, the automatically generated reply is crafted based on automatic code execution. The `UserProxyAgent` triggers code execution automatically when it detects an executable code block in the received message and no human user input is provided. One can also easily extend it by overriding the `auto_reply` function of the `UserProxyAgent` to add or modify responses.+For example, `AIUserProxyAgent` is a subclass of `UserProxyAgent` which can generate replies using an LLM when code execution is not performed. Code execution can be disabled by setting `code_execution_config` to False.+This auto-reply capability allows for more autonomous user-agent communication while retaining the possibility of human intervention.Example usage of the agents to solve a task with code:```python@@ -39,13 +41,13 @@ user_proxy = UserProxyAgent(human_input_mode="NEVER", # in this mode, the agent will never solicit human input but always auto replymax_consecutive_auto_reply=10, # the maximum number of consecutive auto repliesis_termination_msg=lambda x: x.get("content", "").rstrip().endswith("TERMINATE") or x.get("content", "").rstrip().endswith('"TERMINATE".'), # the function to determine whether a message is a termination message- work_dir=".",+ code_execution_config={"work_dir": "."},)# the assistant receives a message from the user, which contains the task descriptionuser.initiate_chat(assistant,- """What date is today? Which big tech stock has the largest year-to-date gain this year? How much is the gain?""",+ message="""What date is today? Which big tech stock has the largest year-to-date gain this year? How much is the gain?""",)```In the example above, we create an AssistantAgent named "assistant" to serve as the assistant and a UserProxyAgent named "user_proxy" to serve as a proxy for the human user.@@ -61,7 +63,7 @@ Please find a visual illustration of how UserProxyAgent and AssistantAgent collaThe `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"`.- Under the mode `human_input_mode="NEVER"`, the multi-turn conversation between the assistant and the user_proxy stops when the number of auto-reply reaches the upper limit specified by `max_consecutive_auto_reply` or the received message is a termination message according to `is_termination_msg`.- When `human_input_mode` is set to `"ALWAYS"`, the user proxy agent solicits human input every time a message is received; and the conversation stops when the human input is "exit", or when the received message is a termination message and no human input is provided.-- When `human_input_mode` is set to `"TERMINATE"`, the user proxy agent solicits human input only when a termination message is received or the number of auto reply reaches `max_consecutive_auto_reply`.+- When `human_input_mode` is set to `"TERMINATE"`, the user proxy agent solicits human input only when a termination message is received or the number of auto replies reaches `max_consecutive_auto_reply`.#### Function CallingTo leverage [function calling capability of OpenAI's Chat Completions API](https://openai.com/blog/function-calling-and-other-api-updates?ref=upstract.com), one can pass in a list of callable functions or class methods to `UserProxyAgent`, which corresponds to the description of functions passed to OpenAI's API.@@ -103,14 +105,14 @@ chatbot = AssistantAgent("assistant", config_list=config_list, **oai_config)user = UserProxyAgent("user",human_input_mode="NEVER",- work_dir="coding",+ code_execution_config={"work_dir": "coding"},)# define an `execute_code` function according to the function desriptiondef execute_code(code_type, code):# here we reuse the method in the user proxy agent# in general, this is not necessary- return user.execute_code([(code_type, code)])+ return user.execute_code_blocks([(code_type, code)])# register the `execute_code` functionuser.register_function(function_map={"execute_code": execute_code})@@ -118,7 +120,7 @@ user.register_function(function_map={"execute_code": execute_code})# start the conversationuser.initiate_chat(assistant,- "Draw a rocket and save to a file named 'rocket.svg'",+ message="Draw a rocket and save to a file named 'rocket.svg'",)```@@ -135,6 +137,8 @@ user.initiate_chat(* [Multi-Agent Communication and Planning](https://github.com/microsoft/FLAML/blob/main/notebook/autogen_agent_planning.ipynb)+* [Multi-Agent Multi-User Application](https://github.com/microsoft/FLAML/blob/main/notebook/autogen_agent_two_users.ipynb)+## Enhanced InferenceOne can use [`flaml.oai.Completion.create`](../reference/autogen/oai/completion#create) to perform inference.@@ -261,7 +265,7 @@ API call results are cached locally and reused when the same request is issued.#### Runtime error-It is easy to hit error when calling OpenAI APIs, due to connection, rate limit, or timeout. Some of the errors are transient. `flaml.oai.Completion.create` deals with the transient errors and retries automatically. Initial request timeout, retry timeout and retry time interval can be configured via `flaml.oai.request_timeout`, `flaml.oai.retry_timeout` and `flaml.oai.retry_time`.+It is easy to hit error when calling OpenAI APIs, due to connection, rate limit, or timeout. Some of the errors are transient. `flaml.oai.Completion.create` deals with the transient errors and retries automatically. Initial request timeout, retry timeout and retry time interval can be configured via `request_timeout`, `retry_timeout` and `flaml.oai.Completion.retry_time`.Moreover, one can pass a list of configurations of different models/endpoints to mitigate the rate limits. For example,@@ -273,7 +277,7 @@ response = oai.Completion.create("api_key": os.environ.get("AZURE_OPENAI_API_KEY"),"api_type": "azure","api_base": os.environ.get("AZURE_OPENAI_API_BASE"),- "api_version": "2023-03-15-preview",+ "api_version": "2023-06-01-preview",},{"model": "gpt-3.5-turbo",