From 57a2bea95a36409e7f895a6d420a26307eebc97a Mon Sep 17 00:00:00 2001 From: Chi Wang Date: Sun, 27 Aug 2023 15:16:52 -0700 Subject: [PATCH] prompt improvement (#1188) * test * chart * plan * separate * bump version to 2.0.1 * explain plan and code/lang * notebook update * notebook update * typo * plan * match can be None --- flaml/autogen/agentchat/assistant_agent.py | 7 +- flaml/autogen/agentchat/groupchat.py | 16 +- flaml/autogen/code_utils.py | 4 +- flaml/version.py | 2 +- ...at_auto_feedback_from_code_execution.ipynb | 431 +++++------ notebook/autogen_agentchat_groupchat.ipynb | 345 +++------ .../autogen_agentchat_human_feedback.ipynb | 235 +++--- notebook/autogen_agentchat_planning.ipynb | 298 +++++--- notebook/autogen_agentchat_two_users.ipynb | 381 +++++----- notebook/autogen_agentchat_web_info.ipynb | 667 ++++++++++++------ 10 files changed, 1205 insertions(+), 1181 deletions(-) diff --git a/flaml/autogen/agentchat/assistant_agent.py b/flaml/autogen/agentchat/assistant_agent.py index 5609d60f8d..7ef9ca999c 100644 --- a/flaml/autogen/agentchat/assistant_agent.py +++ b/flaml/autogen/agentchat/assistant_agent.py @@ -14,9 +14,12 @@ class AssistantAgent(ResponsiveAgent): """ DEFAULT_SYSTEM_MESSAGE = """You are a helpful AI assistant. - In the following cases, suggest python code (in a python coding block) or shell script (in a sh coding block) for the user to execute. You must indicate the script type in the code block. The user cannot provide any other feedback or perform any other action beyond executing the code you suggest. The user can't modify your code. So do not suggest incomplete code which requires users to modify. Don't use a code block if it's not intended to be executed by the user. - 1. When you need to collect info, use the code to output the info you need, for example, browse or search the web, download/read a file, print the content of a webpage or a file, get the current date/time. + Solve tasks using your coding and language skills. + If a plan is not provided, explain the plan first. Be clear which step uses code, and which step uses your language skill. + In the following cases, suggest python code (in a python coding block) or shell script (in a sh coding block) for the user to execute. + 1. When you need to collect info, use the code to output the info you need, for example, browse or search the web, download/read a file, print the content of a webpage or a file, get the current date/time. After sufficient info is printed and the task is ready to be solved based on your language skill, you can solve the task by yourself. 2. When you need to perform some task with code, use the code to perform the task and output the result. Finish the task smartly. Solve the task step by step if you need to. + You must indicate the script type in the code block. The user cannot provide any other feedback or perform any other action beyond executing the code you suggest. The user can't modify your code. So do not suggest incomplete code which requires users to modify. Don't use a code block if it's not intended to be executed by the user. If you want the user to save the code in a file before executing it, put # filename: inside the code block as the first line. Don't include multiple code blocks in one response. Do not ask users to copy and paste the result. Instead, use 'print' function for the output when relevant. Check the execution result returned by the user. If the result indicates there is an error, fix the error and output the code again. Suggest the full code instead of partial code or code changes. If the error can't be fixed or if the task is not solved even after the code is executed successfully, analyze the problem, revisit your assumption, collect additional info you need, and think of a different approach to try. When you find an answer, verify the answer carefully. If a function for planning is provided, call the function to make plans and verify the execution. diff --git a/flaml/autogen/agentchat/groupchat.py b/flaml/autogen/agentchat/groupchat.py index 343c56e9b6..322cfd3101 100644 --- a/flaml/autogen/agentchat/groupchat.py +++ b/flaml/autogen/agentchat/groupchat.py @@ -38,10 +38,18 @@ class GroupChat: Read the following conversation. Then select the next role from {self.agent_names} to play. Only return the role.""" - def select_speaker(self, last_speaker: Agent, selctor: ResponsiveAgent): + def select_speaker(self, last_speaker: Agent, selector: ResponsiveAgent): """Select the next speaker.""" - selctor.update_system_message(self.select_speaker_msg()) - final, name = selctor.generate_oai_reply(self.messages) + selector.update_system_message(self.select_speaker_msg()) + final, name = selector.generate_oai_reply( + self.messages + + [ + { + "role": "system", + "content": f"Read the above conversation. Then select the next role from {self.agent_names} to play. Only return the role.", + } + ] + ) if not final: # i = self._random.randint(0, len(self._agent_names) - 1) # randomly pick an id return self.next_agent(last_speaker) @@ -55,7 +63,7 @@ Then select the next role from {self.agent_names} to play. Only return the role. class GroupChatManager(ResponsiveAgent): - """(WIP) A chat manager agent that can manage a group chat of multiple agents.""" + """(In preview) A chat manager agent that can manage a group chat of multiple agents.""" def __init__( self, diff --git a/flaml/autogen/code_utils.py b/flaml/autogen/code_utils.py index d1251a04a3..0029987b41 100644 --- a/flaml/autogen/code_utils.py +++ b/flaml/autogen/code_utils.py @@ -347,9 +347,9 @@ def execute_code( # extract the exit code from the logs pattern = re.compile(f"{exit_code_str}(\\d+){exit_code_str}") match = pattern.search(logs) - exit_code = int(match.group(1)) + exit_code = 1 if match is None else int(match.group(1)) # remove the exit code from the logs - logs = pattern.sub("", logs) + logs = logs if match is None else pattern.sub("", logs) if original_filename is None: os.remove(filepath) diff --git a/flaml/version.py b/flaml/version.py index 8c0d5d5bb2..159d48b876 100644 --- a/flaml/version.py +++ b/flaml/version.py @@ -1 +1 @@ -__version__ = "2.0.0" +__version__ = "2.0.1" diff --git a/notebook/autogen_agentchat_auto_feedback_from_code_execution.ipynb b/notebook/autogen_agentchat_auto_feedback_from_code_execution.ipynb index fa48b90409..72c5e99269 100644 --- a/notebook/autogen_agentchat_auto_feedback_from_code_execution.ipynb +++ b/notebook/autogen_agentchat_auto_feedback_from_code_execution.ipynb @@ -19,7 +19,7 @@ "source": [ "# Auto Generated Agent Chat: Task Solving with Code Generation, Execution & Debugging\n", "\n", - "`flaml.autogen` offers conversable agents powered by LLM, tool or human, which can be used to perform tasks collectively via automated chat. This framwork allows tool use and human participance through multi-agent conversation.\n", + "FLAML offers conversable 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/Autogen#agents).\n", "\n", "In this notebook, we demonstrate how to use `AssistantAgent` and `UserProxyAgent` to write code and execute the code. Here `AssistantAgent` is an LLM-based agent that can write Python code (in a Python coding block) for a user to execute for a given task. `UserProxyAgent` is an agent which serves as a proxy for the human user to execute the code written by `AssistantAgent`, or automatically execute the code. Depending on the setting of `human_input_mode` and `max_consecutive_auto_reply`, the `UserProxyAgent` either solicits feedback from the human user or returns auto-feedback based on the result of code execution (success or failure and corresponding outputs) to `AssistantAgent`. `AssistantAgent` will debug the code and suggest new code if the result contains error. The two agents keep communicating to each other until the task is done.\n", @@ -45,7 +45,7 @@ }, "outputs": [], "source": [ - "# %pip install flaml[autogen]~=2.0.0" + "# %pip install flaml[autogen]~=2.0.1" ] }, { @@ -69,7 +69,7 @@ "config_list = autogen.config_list_from_json(\n", " \"OAI_CONFIG_LIST\",\n", " filter_dict={\n", - " \"model\": [\"gpt-4\", \"gpt4\", \"gpt-4-32k\", \"gpt-4-32k-0314\", \"gpt-4-32k-v0314\"],\n", + " \"model\": [\"gpt-4\", \"gpt-4-0314\", \"gpt4\", \"gpt-4-32k\", \"gpt-4-32k-0314\", \"gpt-4-32k-v0314\"],\n", " },\n", ")" ] @@ -136,132 +136,91 @@ "--------------------------------------------------------------------------------\n", "\u001b[33massistant\u001b[0m (to user_proxy):\n", "\n", - "To get the current date and compare the year-to-date gain for META (Facebook) and TESLA, we'll need to fetch stock data. We can use the `yfinance` library for this purpose. First, you'll need to install the library by running the following command:\n", + "To solve this task, we will need to do the following:\n", + "\n", + "1. Get the current date: We can use Python's built-in datetime module to get the current date.\n", + "\n", + "2. Get the year-to-date (YTD) gain for META (Facebook) and TESLA: We can use the yfinance module in Python to download the stock data. The YTD gain can be calculated as the percentage change in the closing price from the first trading day of the year to the most recent trading day.\n", + "\n", + "Here is the Python code to perform these tasks:\n", + "\n", + "```python\n", + "# python code\n", + "import datetime\n", + "import yfinance as yf\n", + "\n", + "# Get the current date\n", + "today = datetime.date.today()\n", + "print(\"Today's date is:\", today)\n", + "\n", + "# Get the stock data for META and TESLA\n", + "meta = yf.Ticker(\"META\")\n", + "tesla = yf.Ticker(\"TSLA\")\n", + "\n", + "# Get the historical market data\n", + "meta_hist = meta.history(period=\"ytd\")\n", + "tesla_hist = tesla.history(period=\"ytd\")\n", + "\n", + "# Calculate the YTD gain\n", + "meta_ytd_gain = ((meta_hist['Close'][-1] - meta_hist['Close'][0]) / meta_hist['Close'][0]) * 100\n", + "tesla_ytd_gain = ((tesla_hist['Close'][-1] - tesla_hist['Close'][0]) / tesla_hist['Close'][0]) * 100\n", + "\n", + "print(\"META's YTD gain is: {:.2f}%\".format(meta_ytd_gain))\n", + "print(\"TESLA's YTD gain is: {:.2f}%\".format(tesla_ytd_gain))\n", + "```\n", + "\n", + "Please install the yfinance module if it's not installed yet. You can install it using pip:\n", "\n", "```sh\n", + "# sh code\n", "pip install yfinance\n", "```\n", "\n", - "After installing the library, execute the following Python code to get the current date and compare the year-to-date gain for META and TESLA:\n", - "\n", - "```python\n", - "import yfinance as yf\n", - "from datetime import datetime, timedelta\n", - "\n", - "# Get today's date\n", - "today = datetime.now()\n", - "print(f\"Today's date is: {today.strftime('%Y-%m-%d')}\")\n", - "\n", - "# Calculate the start date for year-to-date\n", - "start_date = datetime(today.year, 1, 1)\n", - "\n", - "# Fetch stock data for META (Facebook) and TESLA\n", - "meta = yf.Ticker(\"FB\")\n", - "tesla = yf.Ticker(\"TSLA\")\n", - "\n", - "# Get historical stock data\n", - "meta_history = meta.history(start=start_date, end=today)\n", - "tesla_history = tesla.history(start=start_date, end=today)\n", - "\n", - "# Calculate year-to-date gain\n", - "meta_ytd_gain = (meta_history[\"Close\"][-1] - meta_history[\"Close\"][0]) / meta_history[\"Close\"][0] * 100\n", - "tesla_ytd_gain = (tesla_history[\"Close\"][-1] - tesla_history[\"Close\"][0]) / tesla_history[\"Close\"][0] * 100\n", - "\n", - "# Print the results\n", - "print(f\"META year-to-date gain: {meta_ytd_gain:.2f}%\")\n", - "print(f\"TESLA year-to-date gain: {tesla_ytd_gain:.2f}%\")\n", - "```\n", + "After running the Python code, you will get the current date and the YTD gain for META and TESLA.\n", "\n", "--------------------------------------------------------------------------------\n", "\u001b[31m\n", - ">>>>>>>> EXECUTING CODE BLOCK 0 (inferred language is sh)...\u001b[0m\n", + ">>>>>>>> EXECUTING CODE BLOCK 0 (inferred language is python)...\u001b[0m\n", "\u001b[31m\n", - ">>>>>>>> EXECUTING CODE BLOCK 1 (inferred language is python)...\u001b[0m\n", + ">>>>>>>> EXECUTING CODE BLOCK 1 (inferred language is sh)...\u001b[0m\n", "\u001b[33muser_proxy\u001b[0m (to assistant):\n", "\n", - "exitcode: 1 (execution failed)\n", + "exitcode: 0 (execution succeeded)\n", "Code output: \n", + "Today's date is: 2023-08-27\n", + "META's YTD gain is: 128.88%\n", + "TESLA's YTD gain is: 120.71%\n", + "\n", "Defaulting to user installation because normal site-packages is not writeable\n", "Requirement already satisfied: yfinance in /home/vscode/.local/lib/python3.9/site-packages (0.2.26)\n", - "Requirement already satisfied: lxml>=4.9.1 in /home/vscode/.local/lib/python3.9/site-packages (from yfinance) (4.9.3)\n", - "Requirement already satisfied: requests>=2.31 in /usr/local/lib/python3.9/site-packages (from yfinance) (2.31.0)\n", - "Requirement already satisfied: multitasking>=0.0.7 in /home/vscode/.local/lib/python3.9/site-packages (from yfinance) (0.0.11)\n", + "Requirement already satisfied: pandas>=1.3.0 in /home/vscode/.local/lib/python3.9/site-packages (from yfinance) (1.3.3)\n", "Requirement already satisfied: appdirs>=1.4.4 in /home/vscode/.local/lib/python3.9/site-packages (from yfinance) (1.4.4)\n", "Requirement already satisfied: html5lib>=1.1 in /home/vscode/.local/lib/python3.9/site-packages (from yfinance) (1.1)\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: pandas>=1.3.0 in /home/vscode/.local/lib/python3.9/site-packages (from yfinance) (1.3.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: beautifulsoup4>=4.11.1 in /home/vscode/.local/lib/python3.9/site-packages (from yfinance) (4.12.2)\n", + "Requirement already satisfied: requests>=2.31 in /usr/local/lib/python3.9/site-packages (from yfinance) (2.31.0)\n", + "Requirement already satisfied: multitasking>=0.0.7 in /home/vscode/.local/lib/python3.9/site-packages (from yfinance) (0.0.11)\n", "Requirement already satisfied: 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: lxml>=4.9.1 in /home/vscode/.local/lib/python3.9/site-packages (from yfinance) (4.9.3)\n", + "Requirement already satisfied: numpy>=1.16.5 in /home/vscode/.local/lib/python3.9/site-packages (from yfinance) (1.25.1)\n", + "Requirement already satisfied: beautifulsoup4>=4.11.1 in /home/vscode/.local/lib/python3.9/site-packages (from yfinance) (4.12.2)\n", "Requirement already satisfied: soupsieve>1.2 in /home/vscode/.local/lib/python3.9/site-packages (from beautifulsoup4>=4.11.1->yfinance) (2.4.1)\n", "Requirement already satisfied: webencodings in /home/vscode/.local/lib/python3.9/site-packages (from html5lib>=1.1->yfinance) (0.5.1)\n", "Requirement already satisfied: six>=1.9 in /usr/local/lib/python3.9/site-packages (from html5lib>=1.1->yfinance) (1.16.0)\n", "Requirement already satisfied: python-dateutil>=2.7.3 in /home/vscode/.local/lib/python3.9/site-packages (from pandas>=1.3.0->yfinance) (2.8.2)\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: charset-normalizer<4,>=2 in /usr/local/lib/python3.9/site-packages (from requests>=2.31->yfinance) (3.2.0)\n", "Requirement already satisfied: certifi>=2017.4.17 in /usr/local/lib/python3.9/site-packages (from requests>=2.31->yfinance) (2023.5.7)\n", + "Requirement already satisfied: charset-normalizer<4,>=2 in /usr/local/lib/python3.9/site-packages (from requests>=2.31->yfinance) (3.2.0)\n", "Requirement already satisfied: idna<4,>=2.5 in /usr/local/lib/python3.9/site-packages (from requests>=2.31->yfinance) (3.4)\n", "\n", - "FB: No timezone found, symbol may be delisted\n", - "Traceback (most recent call last):\n", - " File \"\", line 20, in \n", - " meta_ytd_gain = (meta_history[\"Close\"][-1] - meta_history[\"Close\"][0]) / meta_history[\"Close\"][0] * 100\n", - " File \"/home/vscode/.local/lib/python3.9/site-packages/pandas/core/series.py\", line 939, in __getitem__\n", - " return self._values[key]\n", - "IndexError: index -1 is out of bounds for axis 0 with size 0\n", - "\n", "\n", "--------------------------------------------------------------------------------\n", "\u001b[33massistant\u001b[0m (to user_proxy):\n", "\n", - "I apologize for the error. It seems that the stock symbol for Meta Platforms (formerly Facebook) has changed to \"META\" instead of \"FB\". Let's update the code with the correct stock symbol and try again:\n", + "Great! The code has been executed successfully. \n", "\n", - "```python\n", - "import yfinance as yf\n", - "from datetime import datetime, timedelta\n", + "As of today (August 27, 2023), the year-to-date gain for META (Facebook) is approximately 128.88%, and for TESLA, it's approximately 120.71%.\n", "\n", - "# Get today's date\n", - "today = datetime.now()\n", - "print(f\"Today's date is: {today.strftime('%Y-%m-%d')}\")\n", - "\n", - "# Calculate the start date for year-to-date\n", - "start_date = datetime(today.year, 1, 1)\n", - "\n", - "# Fetch stock data for META (Meta Platforms) and TESLA\n", - "meta = yf.Ticker(\"META\")\n", - "tesla = yf.Ticker(\"TSLA\")\n", - "\n", - "# Get historical stock data\n", - "meta_history = meta.history(start=start_date, end=today)\n", - "tesla_history = tesla.history(start=start_date, end=today)\n", - "\n", - "# Calculate year-to-date gain\n", - "meta_ytd_gain = (meta_history[\"Close\"][-1] - meta_history[\"Close\"][0]) / meta_history[\"Close\"][0] * 100\n", - "tesla_ytd_gain = (tesla_history[\"Close\"][-1] - tesla_history[\"Close\"][0]) / tesla_history[\"Close\"][0] * 100\n", - "\n", - "# Print the results\n", - "print(f\"META year-to-date gain: {meta_ytd_gain:.2f}%\")\n", - "print(f\"TESLA year-to-date gain: {tesla_ytd_gain:.2f}%\")\n", - "```\n", - "\n", - "--------------------------------------------------------------------------------\n", - "\u001b[31m\n", - ">>>>>>>> EXECUTING CODE BLOCK 0 (inferred language is python)...\u001b[0m\n", - "\u001b[33muser_proxy\u001b[0m (to assistant):\n", - "\n", - "exitcode: 0 (execution succeeded)\n", - "Code output: \n", - "Today's date is: 2023-07-31\n", - "META year-to-date gain: 157.94%\n", - "TESLA year-to-date gain: 145.71%\n", - "\n", - "\n", - "--------------------------------------------------------------------------------\n", - "\u001b[33massistant\u001b[0m (to user_proxy):\n", - "\n", - "Great! The code executed successfully. Today's date is 2023-07-31. The year-to-date gain for META (Meta Platforms) is 157.94%, and the year-to-date gain for TESLA is 145.71%. \n", - "\n", - "If you have any other questions or need further assistance, feel free to ask.\n", + "Please let me know if you need help with anything else.\n", "\n", "TERMINATE\n", "\n", @@ -331,102 +290,81 @@ "--------------------------------------------------------------------------------\n", "\u001b[33massistant\u001b[0m (to user_proxy):\n", "\n", - "To plot a chart of the stock price change YTD and save it to a file, we'll use the `matplotlib` library. First, you'll need to install the library by running the following command:\n", + "To plot a chart of the year-to-date (YTD) stock price changes 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", + "```python\n", + "# python code\n", + "# filename: plot_stock_price.py\n", + "import matplotlib.pyplot as plt\n", + "\n", + "# Plot the closing prices of META and TESLA\n", + "plt.figure(figsize=(14, 7))\n", + "plt.plot(meta_hist['Close'], label='META')\n", + "plt.plot(tesla_hist['Close'], label='TESLA')\n", + "plt.title('Year-to-Date Stock Price Change for META and TESLA')\n", + "plt.xlabel('Date')\n", + "plt.ylabel('Closing Price')\n", + "plt.legend()\n", + "\n", + "# Save the plot to a file\n", + "plt.savefig('stock_price_ytd.png')\n", + "```\n", + "\n", + "After running this Python code, a chart of the YTD stock price changes for META and TESLA will be saved to a file named 'stock_price_ytd.png'. \n", + "\n", + "Please make sure you have the matplotlib library installed. If not, you can install it using pip:\n", "\n", "```sh\n", + "# sh code\n", "pip install matplotlib\n", "```\n", "\n", - "After installing the library, execute the following Python code to plot the chart and save it to \"stock_price_ytd.png\":\n", - "\n", - "```python\n", - "import matplotlib.pyplot as plt\n", - "\n", - "# Plot the stock price change YTD\n", - "plt.figure(figsize=(10, 5))\n", - "plt.plot(meta_history.index, meta_history[\"Close\"], label=\"META\")\n", - "plt.plot(tesla_history.index, tesla_history[\"Close\"], label=\"TESLA\")\n", - "plt.xlabel(\"Date\")\n", - "plt.ylabel(\"Stock Price\")\n", - "plt.title(\"Stock Price Change YTD\")\n", - "plt.legend()\n", - "\n", - "# Save the chart to a file\n", - "plt.savefig(\"stock_price_ytd.png\")\n", - "plt.show()\n", - "```\n", - "\n", - "This code will create a chart of the stock price change YTD for META and TESLA and save it to a file named \"stock_price_ytd.png\".\n", - "\n", "--------------------------------------------------------------------------------\n", "\u001b[31m\n", - ">>>>>>>> EXECUTING CODE BLOCK 0 (inferred language is sh)...\u001b[0m\n", - "\u001b[31m\n", - ">>>>>>>> EXECUTING CODE BLOCK 1 (inferred language is python)...\u001b[0m\n", + ">>>>>>>> EXECUTING CODE BLOCK 0 (inferred language is python)...\u001b[0m\n", "\u001b[33muser_proxy\u001b[0m (to assistant):\n", "\n", "exitcode: 1 (execution failed)\n", "Code output: \n", - "Defaulting to user installation because normal site-packages is not writeable\n", - "Requirement already satisfied: matplotlib in /home/vscode/.local/lib/python3.9/site-packages (3.7.2)\n", - "Requirement already satisfied: pillow>=6.2.0 in /home/vscode/.local/lib/python3.9/site-packages (from matplotlib) (10.0.0)\n", - "Requirement already satisfied: pyparsing<3.1,>=2.3.1 in /home/vscode/.local/lib/python3.9/site-packages (from matplotlib) (3.0.9)\n", - "Requirement already satisfied: fonttools>=4.22.0 in /home/vscode/.local/lib/python3.9/site-packages (from matplotlib) (4.41.1)\n", - "Requirement already satisfied: packaging>=20.0 in /home/vscode/.local/lib/python3.9/site-packages (from matplotlib) (23.1)\n", - "Requirement already satisfied: importlib-resources>=3.2.0 in /home/vscode/.local/lib/python3.9/site-packages (from matplotlib) (6.0.0)\n", - "Requirement already satisfied: python-dateutil>=2.7 in /home/vscode/.local/lib/python3.9/site-packages (from matplotlib) (2.8.2)\n", - "Requirement already satisfied: cycler>=0.10 in /home/vscode/.local/lib/python3.9/site-packages (from matplotlib) (0.11.0)\n", - "Requirement already satisfied: contourpy>=1.0.1 in /home/vscode/.local/lib/python3.9/site-packages (from matplotlib) (1.1.0)\n", - "Requirement already satisfied: kiwisolver>=1.0.1 in /home/vscode/.local/lib/python3.9/site-packages (from matplotlib) (1.4.4)\n", - "Requirement already satisfied: numpy>=1.20 in /home/vscode/.local/lib/python3.9/site-packages (from matplotlib) (1.25.1)\n", - "Requirement already satisfied: zipp>=3.1.0 in /home/vscode/.local/lib/python3.9/site-packages (from importlib-resources>=3.2.0->matplotlib) (3.16.2)\n", - "Requirement already satisfied: six>=1.5 in /usr/local/lib/python3.9/site-packages (from python-dateutil>=2.7->matplotlib) (1.16.0)\n", - "\n", "Traceback (most recent call last):\n", - " File \"\", line 5, in \n", - " plt.plot(meta_history.index, meta_history[\"Close\"], label=\"META\")\n", - "NameError: name 'meta_history' is not defined\n", + " File \"\", line 7, in \n", + " plt.plot(meta_hist['Close'], label='META')\n", + "NameError: name 'meta_hist' is not defined\n", "\n", "\n", "--------------------------------------------------------------------------------\n", "\u001b[33massistant\u001b[0m (to user_proxy):\n", "\n", - "I apologize for the error. It seems I forgot to include the previous code to fetch the stock data. Let's combine the code to fetch the stock data and plot the chart:\n", + "I apologize for the oversight. The error occurred because the variables `meta_hist` and `tesla_hist` were defined in the previous script and are not available in the current script. We need to fetch the stock data again in the current script. Here is the corrected Python code:\n", "\n", "```python\n", - "import yfinance as yf\n", - "from datetime import datetime\n", + "# python code\n", + "# filename: plot_stock_price.py\n", "import matplotlib.pyplot as plt\n", + "import yfinance as yf\n", "\n", - "# Get today's date\n", - "today = datetime.now()\n", - "\n", - "# Calculate the start date for year-to-date\n", - "start_date = datetime(today.year, 1, 1)\n", - "\n", - "# Fetch stock data for META (Meta Platforms) and TESLA\n", + "# Get the stock data for META and TESLA\n", "meta = yf.Ticker(\"META\")\n", "tesla = yf.Ticker(\"TSLA\")\n", "\n", - "# Get historical stock data\n", - "meta_history = meta.history(start=start_date, end=today)\n", - "tesla_history = tesla.history(start=start_date, end=today)\n", + "# Get the historical market data\n", + "meta_hist = meta.history(period=\"ytd\")\n", + "tesla_hist = tesla.history(period=\"ytd\")\n", "\n", - "# Plot the stock price change YTD\n", - "plt.figure(figsize=(10, 5))\n", - "plt.plot(meta_history.index, meta_history[\"Close\"], label=\"META\")\n", - "plt.plot(tesla_history.index, tesla_history[\"Close\"], label=\"TESLA\")\n", - "plt.xlabel(\"Date\")\n", - "plt.ylabel(\"Stock Price\")\n", - "plt.title(\"Stock Price Change YTD\")\n", + "# Plot the closing prices of META and TESLA\n", + "plt.figure(figsize=(14, 7))\n", + "plt.plot(meta_hist['Close'], label='META')\n", + "plt.plot(tesla_hist['Close'], label='TESLA')\n", + "plt.title('Year-to-Date Stock Price Change for META and TESLA')\n", + "plt.xlabel('Date')\n", + "plt.ylabel('Closing Price')\n", "plt.legend()\n", "\n", - "# Save the chart to a file\n", - "plt.savefig(\"stock_price_ytd.png\")\n", - "plt.show()\n", + "# Save the plot to a file\n", + "plt.savefig('stock_price_ytd.png')\n", "```\n", "\n", - "This code will fetch the stock data for META and TESLA, create a chart of the stock price change YTD, and save it to a file named \"stock_price_ytd.png\".\n", + "After running this Python code, a chart of the YTD stock price changes for META and TESLA will be saved to a file named 'stock_price_ytd.png'.\n", "\n", "--------------------------------------------------------------------------------\n", "\u001b[31m\n", @@ -435,15 +373,16 @@ "\n", "exitcode: 0 (execution succeeded)\n", "Code output: \n", - "Figure(1000x500)\n", "\n", "\n", "--------------------------------------------------------------------------------\n", "\u001b[33massistant\u001b[0m (to user_proxy):\n", "\n", - "Great! The code executed successfully and created a chart of the stock price change YTD for META and TESLA. The chart has been saved to a file named \"stock_price_ytd.png\".\n", + "Great! The code has been executed successfully and the chart of the Year-to-Date stock price changes for META and TESLA has been saved to a file named 'stock_price_ytd.png'. \n", "\n", - "If you have any other questions or need further assistance, feel free to ask.\n", + "You can now view this image file to see the plotted chart.\n", + "\n", + "Please let me know if you need help with anything else.\n", "\n", "TERMINATE\n", "\n", @@ -474,7 +413,7 @@ "outputs": [ { "data": { - "image/png": "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", + "image/png": "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", "text/plain": [ "" ] @@ -560,56 +499,74 @@ "text": [ "\u001b[33mipython_user_proxy\u001b[0m (to assistant):\n", "\n", - "Plot a chart of META and TESLA stock price change YTD\n", + "What date is today? Plot a chart of META and TESLA stock price change YTD 2023\n", "If you suggest code, the code will be executed in IPython.\n", "\n", "--------------------------------------------------------------------------------\n", "\u001b[33massistant\u001b[0m (to ipython_user_proxy):\n", "\n", - "To plot a chart of META (Facebook) and TESLA stock price change YTD, you can use the `yfinance` library to fetch the stock data and `matplotlib` to plot the chart. First, you need to install the `yfinance` library if you haven't already:\n", - "\n", - "```sh\n", - "pip install yfinance\n", - "```\n", - "\n", - "Now, you can execute the following Python code to plot the chart:\n", + "First, let's get the current date. We can use Python's built-in datetime module for this. Here is the Python code to get the current date:\n", "\n", "```python\n", - "import yfinance as yf\n", - "import matplotlib.pyplot as plt\n", + "# python code\n", "import datetime\n", "\n", "# Get the current date\n", - "today = datetime.date.today()\n", + "current_date = datetime.date.today()\n", "\n", - "# Calculate the start date for YTD\n", - "start_date = datetime.date(today.year, 1, 1)\n", + "print(\"Today's date is:\", current_date)\n", + "```\n", "\n", - "# Download stock data for META (Facebook) and TESLA\n", - "meta_data = yf.download('FB', start=start_date, end=today)\n", - "tesla_data = yf.download('TSLA', start=start_date, end=today)\n", + "Next, we need to plot a chart of META (Facebook's new name) and TESLA stock price change Year-To-Date (YTD) for the year 2023. However, as of now, we are not in the year 2023 yet, so we cannot get the YTD data for 2023. \n", "\n", - "# Calculate the percentage change in stock prices\n", - "meta_pct_change = meta_data['Close'].pct_change().cumsum() * 100\n", - "tesla_pct_change = tesla_data['Close'].pct_change().cumsum() * 100\n", + "But, we can plot the YTD stock price change for the current year. We can use the yfinance module in Python to get the stock price data. If yfinance is not installed, it can be installed using pip:\n", "\n", - "# Plot the chart\n", - "plt.figure(figsize=(12, 6))\n", - "plt.plot(meta_pct_change, label='META (Facebook)')\n", - "plt.plot(tesla_pct_change, label='TESLA')\n", + "```sh\n", + "# sh code\n", + "pip install yfinance\n", + "```\n", + "\n", + "After installing yfinance, we can use the following Python code to get the YTD stock price data for META and TESLA and plot it:\n", + "\n", + "```python\n", + "# python code\n", + "import yfinance as yf\n", + "import matplotlib.pyplot as plt\n", + "\n", + "# Get the current year\n", + "current_year = datetime.date.today().year\n", + "\n", + "# Get the YTD stock price data for META and TESLA\n", + "meta_data = yf.download('FB', start=f'{current_year}-01-01', end=f'{current_year}-12-31')\n", + "tesla_data = yf.download('TSLA', start=f'{current_year}-01-01', end=f'{current_year}-12-31')\n", + "\n", + "# Plot the stock price data\n", + "plt.figure(figsize=(14, 7))\n", + "plt.plot(meta_data['Close'], label='META')\n", + "plt.plot(tesla_data['Close'], label='TESLA')\n", + "plt.title('META vs TESLA Stock Price YTD')\n", "plt.xlabel('Date')\n", - "plt.ylabel('Percentage Change YTD')\n", - "plt.title('META (Facebook) vs TESLA Stock Price Change YTD')\n", + "plt.ylabel('Price (USD)')\n", "plt.legend()\n", - "plt.grid()\n", + "plt.grid(True)\n", "plt.show()\n", "```\n", "\n", - "This code will fetch the stock data for META (Facebook) and TESLA, calculate the percentage change in stock prices YTD, and plot the chart.\n", + "Please note that the stock price data might not be available for the entire current year, depending on the current date. The code will plot the data available till the current date.\n", "\n", "--------------------------------------------------------------------------------\n", "\u001b[31m\n", - ">>>>>>>> EXECUTING CODE BLOCK 0 (inferred language is sh)...\u001b[0m\n" + ">>>>>>>> EXECUTING CODE BLOCK 0 (inferred language is python)...\u001b[0m\n", + "\u001b[31m\n", + ">>>>>>>> EXECUTING CODE BLOCK 1 (inferred language is sh)...\u001b[0m\n" + ] + }, + { + "ename": "SyntaxError", + "evalue": "invalid syntax (2367222363.py, line 2)", + "output_type": "error", + "traceback": [ + "\u001b[0;36m Cell \u001b[0;32mIn[7], line 2\u001b[0;36m\u001b[0m\n\u001b[0;31m pip install yfinance\u001b[0m\n\u001b[0m ^\u001b[0m\n\u001b[0;31mSyntaxError\u001b[0m\u001b[0;31m:\u001b[0m invalid syntax\n" ] }, { @@ -617,14 +574,14 @@ "output_type": "stream", "text": [ "\u001b[31m\n", - ">>>>>>>> EXECUTING CODE BLOCK 1 (inferred language is python)...\u001b[0m\n" + ">>>>>>>> EXECUTING CODE BLOCK 2 (inferred language is python)...\u001b[0m\n" ] }, { "data": { - "image/png": "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", + "image/png": "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", "text/plain": [ - "
" + "
" ] }, "metadata": {}, @@ -638,30 +595,8 @@ "\n", "exitcode: 0 (execution succeeded)\n", "Code output: \n", - "Defaulting to user installation because normal site-packages is not writeable\n", - "Requirement already satisfied: yfinance in /home/vscode/.local/lib/python3.9/site-packages (0.2.26)\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: numpy>=1.16.5 in /home/vscode/.local/lib/python3.9/site-packages (from yfinance) (1.25.1)\n", - "Requirement already satisfied: beautifulsoup4>=4.11.1 in /home/vscode/.local/lib/python3.9/site-packages (from yfinance) (4.12.2)\n", - "Requirement already satisfied: lxml>=4.9.1 in /home/vscode/.local/lib/python3.9/site-packages (from yfinance) (4.9.3)\n", - "Requirement already satisfied: pandas>=1.3.0 in /home/vscode/.local/lib/python3.9/site-packages (from yfinance) (1.3.3)\n", - "Requirement already satisfied: requests>=2.31 in /usr/local/lib/python3.9/site-packages (from yfinance) (2.31.0)\n", - "Requirement already satisfied: pytz>=2022.5 in /home/vscode/.local/lib/python3.9/site-packages (from yfinance) (2023.3)\n", - "Requirement already satisfied: html5lib>=1.1 in /home/vscode/.local/lib/python3.9/site-packages (from yfinance) (1.1)\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: appdirs>=1.4.4 in /home/vscode/.local/lib/python3.9/site-packages (from yfinance) (1.4.4)\n", - "Requirement already satisfied: soupsieve>1.2 in /home/vscode/.local/lib/python3.9/site-packages (from beautifulsoup4>=4.11.1->yfinance) (2.4.1)\n", - "Requirement already satisfied: webencodings in /home/vscode/.local/lib/python3.9/site-packages (from html5lib>=1.1->yfinance) (0.5.1)\n", - "Requirement already satisfied: six>=1.9 in /usr/local/lib/python3.9/site-packages (from html5lib>=1.1->yfinance) (1.16.0)\n", - "Requirement already satisfied: python-dateutil>=2.7.3 in /home/vscode/.local/lib/python3.9/site-packages (from pandas>=1.3.0->yfinance) (2.8.2)\n", - "Requirement already satisfied: certifi>=2017.4.17 in /usr/local/lib/python3.9/site-packages (from requests>=2.31->yfinance) (2023.5.7)\n", - "Requirement already satisfied: idna<4,>=2.5 in /usr/local/lib/python3.9/site-packages (from requests>=2.31->yfinance) (3.4)\n", - "Requirement already satisfied: charset-normalizer<4,>=2 in /usr/local/lib/python3.9/site-packages (from requests>=2.31->yfinance) (3.2.0)\n", - "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", + "Today's date is: 2023-08-27\n", "\n", - "\u001b[1m[\u001b[0m\u001b[34;49mnotice\u001b[0m\u001b[1;39;49m]\u001b[0m\u001b[39;49m A new release of pip is available: \u001b[0m\u001b[31;49m23.0.1\u001b[0m\u001b[39;49m -> \u001b[0m\u001b[32;49m23.2.1\u001b[0m\n", - "\u001b[1m[\u001b[0m\u001b[34;49mnotice\u001b[0m\u001b[1;39;49m]\u001b[0m\u001b[39;49m To update, run: \u001b[0m\u001b[32;49mpip install --upgrade pip\u001b[0m\n", - "Note: you may need to restart the kernel to use updated packages.\n", "\n", "[*********************100%***********************] 1 of 1 completed\n", "[*********************100%***********************] 1 of 1 completed\n", @@ -673,40 +608,33 @@ "--------------------------------------------------------------------------------\n", "\u001b[33massistant\u001b[0m (to ipython_user_proxy):\n", "\n", - "I apologize for the issue. It seems that the stock symbol for Meta Platforms (formerly Facebook) has changed from 'FB' to 'META'. Let's update the code with the correct stock symbol and try again:\n", + "It seems like there was an issue with downloading the data for the 'FB' ticker symbol. This could be due to the fact that Facebook has changed its ticker symbol to 'META' recently. Let's try to download the data using the new ticker symbol 'META'. Here is the updated Python code:\n", "\n", "```python\n", + "# python code\n", "import yfinance as yf\n", "import matplotlib.pyplot as plt\n", - "import datetime\n", "\n", - "# Get the current date\n", - "today = datetime.date.today()\n", + "# Get the current year\n", + "current_year = datetime.date.today().year\n", "\n", - "# Calculate the start date for YTD\n", - "start_date = datetime.date(today.year, 1, 1)\n", + "# Get the YTD stock price data for META and TESLA\n", + "meta_data = yf.download('META', start=f'{current_year}-01-01', end=f'{current_year}-12-31')\n", + "tesla_data = yf.download('TSLA', start=f'{current_year}-01-01', end=f'{current_year}-12-31')\n", "\n", - "# Download stock data for META (Facebook) and TESLA\n", - "meta_data = yf.download('META', start=start_date, end=today)\n", - "tesla_data = yf.download('TSLA', start=start_date, end=today)\n", - "\n", - "# Calculate the percentage change in stock prices\n", - "meta_pct_change = meta_data['Close'].pct_change().cumsum() * 100\n", - "tesla_pct_change = tesla_data['Close'].pct_change().cumsum() * 100\n", - "\n", - "# Plot the chart\n", - "plt.figure(figsize=(12, 6))\n", - "plt.plot(meta_pct_change, label='META (Facebook)')\n", - "plt.plot(tesla_pct_change, label='TESLA')\n", + "# Plot the stock price data\n", + "plt.figure(figsize=(14, 7))\n", + "plt.plot(meta_data['Close'], label='META')\n", + "plt.plot(tesla_data['Close'], label='TESLA')\n", + "plt.title('META vs TESLA Stock Price YTD')\n", "plt.xlabel('Date')\n", - "plt.ylabel('Percentage Change YTD')\n", - "plt.title('META (Facebook) vs TESLA Stock Price Change YTD')\n", + "plt.ylabel('Price (USD)')\n", "plt.legend()\n", - "plt.grid()\n", + "plt.grid(True)\n", "plt.show()\n", "```\n", "\n", - "This code should now fetch the stock data for META (Facebook) and TESLA, calculate the percentage change in stock prices YTD, and plot the chart.\n", + "Please run this code to get the YTD stock price data for META and TESLA and plot it.\n", "\n", "--------------------------------------------------------------------------------\n", "\u001b[31m\n", @@ -715,9 +643,9 @@ }, { "data": { - "image/png": "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", + "image/png": "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", "text/plain": [ - "
" + "
" ] }, "metadata": {}, @@ -738,7 +666,9 @@ "--------------------------------------------------------------------------------\n", "\u001b[33massistant\u001b[0m (to ipython_user_proxy):\n", "\n", - "I'm glad the code executed successfully and you were able to plot the chart of META (Facebook) and TESLA stock price change YTD. If you have any further questions or need assistance with anything else, please feel free to ask.\n", + "Great! The code has executed successfully. It should have downloaded the Year-To-Date (YTD) stock price data for META and TESLA for the current year and plotted it. The plot should show the closing prices of META and TESLA stocks over time. \n", + "\n", + "Please check the plot to see the stock price changes. If the plot is as expected, then the task is completed.\n", "\n", "TERMINATE\n", "\n", @@ -753,11 +683,10 @@ " 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", + " message=\"\"\"What date is today? Plot a chart of META and TESLA stock price change YTD 2023\"\"\",\n", ")" ] } @@ -778,7 +707,7 @@ "name": "python", "nbconvert_exporter": "python", "pygments_lexer": "ipython3", - "version": "3.9.16" + "version": "3.9.17" }, "vscode": { "interpreter": { diff --git a/notebook/autogen_agentchat_groupchat.ipynb b/notebook/autogen_agentchat_groupchat.ipynb index 01251f9b6d..0691d8bfa4 100644 --- a/notebook/autogen_agentchat_groupchat.ipynb +++ b/notebook/autogen_agentchat_groupchat.ipynb @@ -30,12 +30,12 @@ }, { "cell_type": "code", - "execution_count": 5, + "execution_count": 1, "metadata": {}, "outputs": [], "source": [ "%%capture --no-stderr\n", - "# %pip install flaml[autogen]~=2.0.0" + "# %pip install flaml[autogen]~=2.0.1" ] }, { @@ -50,7 +50,7 @@ }, { "cell_type": "code", - "execution_count": 6, + "execution_count": 2, "metadata": {}, "outputs": [], "source": [ @@ -59,7 +59,7 @@ "config_list_gpt4 = autogen.config_list_from_json(\n", " \"OAI_CONFIG_LIST\",\n", " filter_dict={\n", - " \"model\": [\"gpt-4\", \"gpt4\", \"gpt-4-32k\", \"gpt-4-32k-0314\", \"gpt-4-32k-v0314\"],\n", + " \"model\": [\"gpt-4\", \"gpt-4-0314\", \"gpt4\", \"gpt-4-32k\", \"gpt-4-32k-0314\", \"gpt-4-32k-v0314\"],\n", " },\n", ")\n", "# config_list_gpt35 = autogen.config_list_from_json(\n", @@ -122,7 +122,7 @@ }, { "cell_type": "code", - "execution_count": 7, + "execution_count": 3, "metadata": {}, "outputs": [], "source": [ @@ -138,7 +138,9 @@ ")\n", "bob = autogen.AssistantAgent(\n", " name=\"Bob\",\n", - " system_message=\"Code reviewer. Prevent code execution if unsafe or not well documented. Suggest changes. Otherwise, approve and return the final code to execute.\",\n", + " system_message=\"Code and answer reviewer.\"\n", + " \"For code, prevent code execution if unsafe or missing important details, e.g., sort order in arxiv API. Suggest changes. Otherwise, approve and return the final code to execute.\"\n", + " \"For answer, carefully check the interpretation of code result and fix any errors. If the interpretation is correct, approve and return the final answer to the user.\",\n", " llm_config=llm_config,\n", ")\n", "groupchat = autogen.GroupChat(agents=[human, alice, bob], messages=[], max_round=12)\n", @@ -155,7 +157,7 @@ }, { "cell_type": "code", - "execution_count": 8, + "execution_count": 4, "metadata": {}, "outputs": [ { @@ -164,298 +166,131 @@ "text": [ "\u001b[33mHuman\u001b[0m (to chat_manager):\n", "\n", - "find a latest paper about generative agents\n", + "Find a latest paper about gpt-4\n", "\n", "--------------------------------------------------------------------------------\n", "\u001b[33mAlice\u001b[0m (to chat_manager):\n", "\n", - "To accomplish this, we can utilize the \"scholarly\" library in Python, which enables us to search Google Scholar for papers. Here's the Python code to achieve this:\n", + "To find the latest papers about gpt-4, we can use APIs of scholarly databases like Google Scholar, PubMed, Arxiv, etc., or automation tools like Beautiful Soup to scrape the information from webpages. However, a significant number of these methods are in violation of the terms of service of these platforms. Therefore, it's recommended to manually search these databases. \n", + "\n", + "But in our case, we'll use the arXiv API, which is a freely accessible database. It holds a vast collection of articles in the field of computer science and many other disciplines. It is often used by researchers to share their papers before they are published, so it could include articles about GPT-4. \n", + "\n", + "The following Python code uses the requests and feedparser libraries to do this. Requests is used to make a GET request to the arXiv API with the search query as a parameter. Feedparser is used to parse the returned RSS feed. The result is the information of the most recent articles based on publication time related to gpt-4 from arXiv. \n", "\n", "```python\n", - "# filename: googlescholar_search.py\n", - "\n", - "import scholarly\n", - "\n", - "def get_latest_paper(query):\n", - " search_query = scholarly.search_pubs(query)\n", - " paper = next(search_query)\n", - " print(\"The latest paper is:\", paper.bib['title'])\n", - " print(\"The abstract of the paper is:\", paper.bib['abstract'])\n", - " print(\"The year of publication is:\", paper.bib['year'])\n", - "\n", - "get_latest_paper(\"Generative agents\")\n", - "```\n", - "\n", - "To execute this script:\n", - "1. Save the code to a file named googlescholar_search.py\n", - "2. Run `pip install scholarly` to install the necessary library if you haven't installed it yet.\n", - "3. Run `python googlescholar_search.py` to execute the script and get the latest paper on generative agents.\n", - "\n", - "Please note that Google Scholar doesn't provide a stable API and has rate limit restrictions in place, meaning that if you run this code multiple times in a short period, Google might temporarily block your IP.\n", - "\n", - "If the rate limit becomes an issue, you might want to consider using a different database or method, such as utilizing APIs from databases like arXiv or Pubmed, or web scraping, in a manner compliant with the website's robots.txt and terms of usage.\n", - "\n", - "--------------------------------------------------------------------------------\n", - "\u001b[33mBob\u001b[0m (to chat_manager):\n", - "\n", - "The provided code seems fine, however, according to Google's Terms of Service API users are restricted from programmatically sending requests to Google Scholar. Even being an unofficial API, it doesn't make using scholarly legal as per the use policy. It's important you consider these limitations when handling this tool and any consequences that may arise on its usage. \n", - "\n", - "Remember to use APIs responsibly and always in accordance with their terms of service. Without explicit permission from Google, using such a tool can get your IP banned. \n", - "\n", - "I will suggest to use APIs from databases like arXiv or Pubmed, or webscraping, in a manner that is compliant with the website's robots.txt-file and terms of usage.\n", - "\n", - "--------------------------------------------------------------------------------\n", - "\u001b[33mAlice\u001b[0m (to chat_manager):\n", - "\n", - "I apologize for the oversight. You're correct, direct scraping of Google Scholar violates Google's terms of service. Let's change to use the arXiv API which doesn't have this issue and is more reliable. Here's the python code:\n", - "\n", - "```python\n", - "# filename: arxiv_search.py\n", - "import urllib\n", + "# python code\n", + "import requests\n", "import feedparser\n", "\n", - "def search_arxiv(query: str):\n", - " base_url = 'http://export.arxiv.org/api/query?'\n", - " query = {'search_query' : f'ti:{query}', 'start' : 0, 'max_results' : 1, 'sortBy' : 'submittedDate', 'sortOrder' : 'descending'}\n", - " url = base_url + urllib.parse.urlencode(query)\n", - " \n", - " # connect to arXiv API and get response\n", - " response = urllib.request.urlopen(url).read()\n", + "# Search arXiv API for papers related to gpt-4\n", + "url = 'http://export.arxiv.org/api/query'\n", + "params = {'search_query': 'all:gpt-4', 'sortBy': 'submittedDate', 'sortOrder': 'descending'}\n", + "response = requests.get(url, params=params)\n", "\n", - " # parse the response using feedparser\n", - " feed = feedparser.parse(response)\n", - " \n", - " # get the first (and presumably, the most recent) article in the result\n", - " entry = feed.entries[0]\n", + "# Parse the response\n", + "feeds = feedparser.parse(response.content)\n", "\n", - " # print details of the most recent article\n", - " print('The latest paper on', query['search_query'], 'that I could find is:\\n')\n", - " print('Title: ', entry.title)\n", - " print('Author: ', entry.author)\n", - " print('Link: ', entry.link)\n", - " print('\\nAbstract: ', entry.summary)\n", + "# should check if feeds.entries is empty\n", "\n", - "# search for the latest paper about \"generative agents\"\n", - "search_arxiv(\"generative agents\")\n", + "# Get the first paper's information\n", + "latest_paper = feeds.entries[0]\n", + "\n", + "# Print the paper's title, authors, and published date\n", + "print('Title: ', latest_paper['title'])\n", + "print('Authors: ', latest_paper['author'])\n", + "print('Published Date: ', latest_paper['published'])\n", "```\n", - "\n", - "To execute this script:\n", - "1. Save the code to a file named arxiv_search.py\n", - "2. Run `pip install feedparser` to install the necessary library.\n", - "3. Run `python arxiv_search.py` to execute the script and get the latest paper on generative agents.\n", + "You need to install requests and feedparser in your python environment, if they are not installed yet.\n", "\n", "--------------------------------------------------------------------------------\n", "\u001b[33mBob\u001b[0m (to chat_manager):\n", "\n", - "The provided code snippet is clear, efficient, and well-documented. It appropriately uses the arXiv API to retrieve the most recent papers about \"generative agents\". The search terms are correctly URI-encoded and passed to the arXiv query API, and proper error handling is in place.\n", + "The provided code is mostly correct, but it is missing some important error handling measures. As mentioned in the comments, it does not check if the feed entries are empty. It also does not check if the request was successful before trying to parse the response.\n", "\n", - "However, you should ensure that you handle potential exception which may occur when trying to connect to the URL and parse the response. For example, if the internet is disconnected or something is wrong with the server, `urllib.request.urlopen()` will raise a `URLError`. If the returned content is not properly formatted, `feedparser.parse()` may also fail. You should catch and properly handle these exceptions.\n", + "Additionally, the code does not handle any exceptions that may occur during the process, such adding try/except clause would make it more robust.\n", "\n", - "Therefore, I would add these modifications:\n", + "Here's a suggestion on how to improve it:\n", "\n", "```python\n", - "from urllib.error import URLError\n", + "# python code\n", + "import requests\n", + "import feedparser\n", + "\n", + "# Search arXiv API for papers related to gpt-4\n", + "url = 'http://export.arxiv.org/api/query'\n", + "params = {'search_query': 'all:gpt-4', 'sortBy': 'submittedDate', 'sortOrder': 'descending'}\n", "\n", "try:\n", - " # connect to arXiv API and get response\n", - " response = urllib.request.urlopen(url).read()\n", - "\n", - "except URLError as e:\n", - " print(\"There was a problem connecting to the arXiv API:\")\n", - " print(e.reason)\n", - "\n", + " response = requests.get(url, params=params)\n", + " response.raise_for_status()\n", + "except requests.HTTPError as http_err:\n", + " print(f'HTTP error occurred: {http_err}')\n", + "except requests.ConnectionError as conn_err:\n", + " print(f'Error connecting: {conn_err}')\n", + "except requests.Timeout as to_err:\n", + " print(f'Timeout error: {to_err}')\n", + "except requests.RequestException as err:\n", + " print(f'An error occurred: {err}')\n", "else:\n", - " try:\n", - " # parse the response using feedparser\n", - " feed = feedparser.parse(response)\n", - " \n", - " # get the first (and presumably, the most recent) article in the result\n", - " entry = feed.entries[0]\n", + " # Parse the response\n", + " feeds = feedparser.parse(response.content)\n", "\n", - " except Exception as e:\n", - " print(\"There was a problem parsing the result:\")\n", - " print(e)\n", + " # Check if feeds.entries is empty\n", + " if not feeds.entries:\n", + " print(\"No results found.\")\n", + " else: \n", + " # Get the first paper's information\n", + " latest_paper = feeds.entries[0]\n", "\n", - " else:\n", - " # print details of the most recent article\n", - " print('The latest paper on', query['search_query'], 'that I could find is:\\n')\n", - " print('Title: ', entry.title)\n", - " print('Author: ', entry.author)\n", - " print('Link: ', entry.link)\n", - " print('\\nAbstract: ', entry.summary)\n", + " # Print the paper's title, authors, and published date\n", + " print('Title: ', latest_paper['title'])\n", + " print('Authors: ', latest_paper['author'])\n", + " print('Published Date: ', latest_paper['published'])\n", "```\n", - "\n", - "The keyword `except` is used to catch and handle exceptions. The modifications suggested include exception handlers for `URLError` (which are raised if there was a problem connecting to the arXiv API) and a generic Exception (which could be any other exception during parsing the response). The `else` keyword allows us to group together the normal operation code, separating it from the error handling code. \n", - "\n", - "The code is ready to be executed now.\n", + "This version of the script will handle the HTTP, Connection, and Timeout errors as well as any other request error. It also checks that there are results before trying to print.\n", "\n", "--------------------------------------------------------------------------------\n", "\u001b[31m\n", + ">>>>>>>> NO HUMAN INPUT RECEIVED.\u001b[0m\n", + "\u001b[31m\n", + ">>>>>>>> USING AUTO REPLY...\u001b[0m\n", + "\u001b[31m\n", ">>>>>>>> EXECUTING CODE BLOCK 0 (inferred language is python)...\u001b[0m\n", "\u001b[33mHuman\u001b[0m (to chat_manager):\n", "\n", - "exitcode: 1 (execution failed)\n", - "Code output: \n", - "Traceback (most recent call last):\n", - " File \"\", line 5, in \n", - " response = urllib.request.urlopen(url).read()\n", - "NameError: name 'urllib' is not defined\n", - "\n", - "\n", - "--------------------------------------------------------------------------------\n", - "\u001b[33mAlice\u001b[0m (to chat_manager):\n", - "\n", - "Apologies for the oversight. It looks like I missed importing the required `urllib.request` module. Please use the following updated code with the necessary import statement:\n", - "\n", - "```python\n", - "# filename: arxiv_search.py\n", - "import urllib.request\n", - "import urllib.parse\n", - "import feedparser\n", - "from urllib.error import URLError\n", - "\n", - "def search_arxiv(query: str):\n", - " base_url = 'http://export.arxiv.org/api/query?'\n", - " query = {'search_query' : f'ti:{query}', 'start' : 0, 'max_results' : 1, 'sortBy' : 'submittedDate', 'sortOrder' : 'descending'}\n", - " url = base_url + urllib.parse.urlencode(query)\n", - " \n", - " try:\n", - " # connect to arXiv API and get response\n", - " response = urllib.request.urlopen(url).read()\n", - "\n", - " except URLError as e:\n", - " print(\"There was a problem connecting to the arXiv API:\")\n", - " print(e.reason)\n", - "\n", - " else:\n", - " try:\n", - " # parse the response using feedparser\n", - " feed = feedparser.parse(response)\n", - " \n", - " # get the first (and presumably, the most recent) article in the result\n", - " entry = feed.entries[0]\n", - "\n", - " except Exception as e:\n", - " print(\"There was a problem parsing the result:\")\n", - " print(e)\n", - "\n", - " else:\n", - " # print details of the most recent article\n", - " print('The latest paper on', query['search_query'], 'that I could find is:\\n')\n", - " print('Title: ', entry.title)\n", - " print('Author: ', entry.author)\n", - " print('Link: ', entry.link)\n", - " print('\\nAbstract: ', entry.summary)\n", - "\n", - "# search for the latest paper about \"generative agents\"\n", - "search_arxiv(\"generative agents\")\n", - "```\n", - "\n", - "To execute this script:\n", - "1. Save the code to a file named arxiv_search.py\n", - "2. Run `pip install feedparser` to install the necessary library.\n", - "3. Run `python arxiv_search.py` to execute the script and get the latest paper on generative agents.\n", - "\n", - "--------------------------------------------------------------------------------\n", - "\u001b[33mBob\u001b[0m (to chat_manager):\n", - "\n", - "The amendment is correctly appended. You have properly imported the required `urllib.request` module. The code is now ready for execution. It correctly searches for the latest paper about \"generative agents\" using the arXiv API, and handles potential exceptions that may arise during the connection to the API or while parsing the response. Please proceed to execute this code.\n", - "\n", - "--------------------------------------------------------------------------------\n", - "\u001b[31m\n", - ">>>>>>>> EXECUTING CODE BLOCK 0 (inferred language is python)...\u001b[0m\n", - "\u001b[33mHuman\u001b[0m (to chat_manager):\n", - "\n", - "exitcode: 1 (execution failed)\n", - "Code output: \n", - "Traceback (most recent call last):\n", - " File \"arxiv_search.py\", line 4, in \n", - " import feedparser\n", - "ModuleNotFoundError: No module named 'feedparser'\n", - "\n", - "\n", - "--------------------------------------------------------------------------------\n", - "\u001b[33mAlice\u001b[0m (to chat_manager):\n", - "\n", - "My apologies for the inconvenience. It appears that the 'feedparser' module is not installed. Please install the 'feedparser' module by running the following command:\n", - "\n", - "```sh\n", - "pip install feedparser\n", - "```\n", - "\n", - "Once you have installed the 'feedparser' module, please execute the arxiv_search.py script again:\n", - "\n", - "```sh\n", - "python arxiv_search.py\n", - "```\n", - "\n", - "This should execute the script and fetch the latest paper on generative agents.\n", - "\n", - "--------------------------------------------------------------------------------\n", - "\u001b[33mBob\u001b[0m (to chat_manager):\n", - "\n", - "That's correct. Make sure to install the 'feedparser' module using the provided command, and then you should be able to execute the updated arxiv_search.py script successfully. The script will search for the latest paper about \"generative agents\" using the arXiv API, and return information about the most recent article it finds.\n", - "\n", - "--------------------------------------------------------------------------------\n", - "\u001b[31m\n", - ">>>>>>>> EXECUTING CODE BLOCK 0 (inferred language is sh)...\u001b[0m\n", - "\u001b[31m\n", - ">>>>>>>> EXECUTING CODE BLOCK 1 (inferred language is sh)...\u001b[0m\n", - "\u001b[33mHuman\u001b[0m (to chat_manager):\n", - "\n", "exitcode: 0 (execution succeeded)\n", "Code output: \n", - "Defaulting to user installation because normal site-packages is not writeable\n", - "Collecting feedparser\n", - " Downloading feedparser-6.0.10-py3-none-any.whl (81 kB)\n", - " ━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━ 81.1/81.1 KB 17.2 MB/s eta 0:00:00\n", - "Collecting sgmllib3k\n", - " Downloading sgmllib3k-1.0.0.tar.gz (5.8 kB)\n", - " Preparing metadata (setup.py): started\n", - " Preparing metadata (setup.py): finished with status 'done'\n", - "Building wheels for collected packages: sgmllib3k\n", - " Building wheel for sgmllib3k (setup.py): started\n", - " Building wheel for sgmllib3k (setup.py): finished with status 'done'\n", - " Created wheel for sgmllib3k: filename=sgmllib3k-1.0.0-py3-none-any.whl size=6046 sha256=867dc31954f27685ad79808f2ca2b5d8235496de750c61f110c200ba664a50e4\n", - " Stored in directory: /home/vscode/.cache/pip/wheels/65/7a/a7/78c287f64e401255dff4c13fdbc672fed5efbfd21c530114e1\n", - "Successfully built sgmllib3k\n", - "Installing collected packages: sgmllib3k, feedparser\n", - "Successfully installed feedparser-6.0.10 sgmllib3k-1.0.0\n", + "Title: Language as Reality: A Co-Creative Storytelling Game Experience in 1001\n", + " Nights using Generative AI\n", + "Authors: Ali Asadipour\n", + "Published Date: 2023-08-24T16:42:23Z\n", "\n", - "The latest paper on ti:generative agents that I could find is:\n", "\n", - "Title: LayoutLLM-T2I: Eliciting Layout Guidance from LLM for Text-to-Image\n", - " Generation\n", - "Author: Tat-Seng Chua\n", - "Link: http://arxiv.org/abs/2308.05095v1\n", + "--------------------------------------------------------------------------------\n", + "\u001b[33mAlice\u001b[0m (to chat_manager):\n", "\n", - "Abstract: In the text-to-image generation field, recent remarkable progress in Stable\n", - "Diffusion makes it possible to generate rich kinds of novel photorealistic\n", - "images. However, current models still face misalignment issues (e.g.,\n", - "problematic spatial relation understanding and numeration failure) in complex\n", - "natural scenes, which impedes the high-faithfulness text-to-image generation.\n", - "Although recent efforts have been made to improve controllability by giving\n", - "fine-grained guidance (e.g., sketch and scribbles), this issue has not been\n", - "fundamentally tackled since users have to provide such guidance information\n", - "manually. In this work, we strive to synthesize high-fidelity images that are\n", - "semantically aligned with a given textual prompt without any guidance. Toward\n", - "this end, we propose a coarse-to-fine paradigm to achieve layout planning and\n", - "image generation. Concretely, we first generate the coarse-grained layout\n", - "conditioned on a given textual prompt via in-context learning based on Large\n", - "Language Models. Afterward, we propose a fine-grained object-interaction\n", - "diffusion method to synthesize high-faithfulness images conditioned on the\n", - "prompt and the automatically generated layout. Extensive experiments\n", - "demonstrate that our proposed method outperforms the state-of-the-art models in\n", - "terms of layout and image generation. Our code and settings are available at\n", - "\\url{https://layoutllm-t2i.github.io}.\n", + "Based on the output of the code, the latest paper on GPT-4 found was \"Language as Reality: A Co-Creative Storytelling Game Experience in 1001 Nights using Generative AI\" by Ali Asadipour, published on 24th August 2023. \n", "\n", + "This shows the latest found document related to the search term \"GPT-4\" in the arXiv scholarly paper database. Please note that the search query includes all parts of the articles: the title, the abstract, and the full text if available, so it might not be necessarily about GPT-4 but includes the term in some section of the paper.\n", + "\n", + "TERMINATE\n", + "\n", + "--------------------------------------------------------------------------------\n", + "\u001b[33mBob\u001b[0m (to chat_manager):\n", + "\n", + "The interpretation of the code output is correct. The latest document retrieved related to \"GPT-4\" is indeed \"Language as Reality: A Co-Creative Storytelling Game Experience in 1001 Nights using Generative AI\" by Ali Asadipour, published on 24th August 2023.\n", + "\n", + "Make sure to understand that the document might not be solely about GPT-4 as the search used covered all aspects of the document. The term \"GPT-4\" could be mentioned anywhere in the paper.\n", + "\n", + "APPROVED\n", "\n", "--------------------------------------------------------------------------------\n" ] } ], "source": [ - "human.initiate_chat(manager, message=\"find a latest paper about generative agents\")" + "human.initiate_chat(manager, message=\"Find a latest paper about gpt-4\")\n", + "# type exit to terminate the chat" ] } ], diff --git a/notebook/autogen_agentchat_human_feedback.ipynb b/notebook/autogen_agentchat_human_feedback.ipynb index 50a6a8a063..703e871856 100644 --- a/notebook/autogen_agentchat_human_feedback.ipynb +++ b/notebook/autogen_agentchat_human_feedback.ipynb @@ -45,7 +45,7 @@ }, "outputs": [], "source": [ - "# %pip install flaml[autogen]~=2.0.0" + "# %pip install flaml[autogen]~=2.0.1" ] }, { @@ -177,7 +177,7 @@ "name": "stdout", "output_type": "stream", "text": [ - "user_proxy (to assistant):\n", + "\u001b[33muser_proxy\u001b[0m (to assistant):\n", "\n", "\n", "Find $a + b + c$, given that $x+y \\neq -1$ and \n", @@ -188,170 +188,181 @@ "\\end{align}.\n", "\n", "\n", - "--------------------------------------------------------------------------------\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "assistant (to user_proxy):\n", - "\n", - "The problem can be solved using basic operations with the equations and some assumption based on the property that x + y ≠ -1. It seems to be a system of linear equations which has the general format:\n", - "\n", - " ax + by + c = d\n", - " a + bx + cy = e\n", - " ay + b + cx = f\n", - "\n", - "It's clear that we need to reduce this to a form where we can easily calculate the values a, b and c. A common approach with systems of equations is to subtract or add equations to each other.\n", - "\n", - "Although, the calculation is simple, it might be a bit cumbersome to do by hand, let's use the sympy Python library to solve the system of linear equations.\n", - "\n", - "Let's do this step by step. First, let's create the system of equations, and then solve them.\n", - "\n", "--------------------------------------------------------------------------------\n", + "\u001b[33massistant\u001b[0m (to user_proxy):\n", "\n", - ">>>>>>>> NO HUMAN INPUT RECEIVED. USING AUTO REPLY FOR THE USER...\n", - "user_proxy (to assistant):\n", + "To solve this problem, we can follow these steps:\n", "\n", + "1. Identify the equations: We have three equations:\n", + " 1) ax + by + c = x + 7,\n", + " 2) a + bx + cy = 2x + 6y,\n", + " 3) ay + b + cx = 4x + y.\n", + "2. Rearrange the equations to make them easy to solve:\n", + " 1) ax + by + c - x = 7,\n", + " 2) a + cx - 2x + by - 6y = 0,\n", + " 3) ay - y + b + cx - 4x = 0.\n", + "3. Since we need to find the sum a + b + c, substitute the expressions for a, b and c from the rearranged equations into the expression for the sum a + b + c.\n", + "4. Simplify the equation to get a + b + c.\n", "\n", + "The above steps involve both coding and language skills, the coding is used to solve the equations and obtain the values for a, b and c (which involves algebraic computation and symbolic computation). The language skill is used for explanation and clarification of the problem and the steps involved.\n", "\n", - "--------------------------------------------------------------------------------\n", - "assistant (to user_proxy):\n", + "We'll use Python's SymPy library to help us solve these system of equations. SymPy is a Python library for symbolic computation.\n", + "\n", + "Here's the Python code you can execute. We'll use SymPy to solve a system of equations and sympy.solve to find the solution.\n", + "\n", + "Please, execute the following Python code:\n", "\n", "```python\n", - "# filename: solve_equations.py\n", - "\n", + "# SymPy is a Python library for symbolic mathematics\n", "from sympy import symbols, Eq, solve\n", "\n", - "# Define the symbols \n", + "# defining the symbols\n", "x, y, a, b, c = symbols('x y a b c')\n", "\n", - "# Given that x + y ≠ -1, we can use any pair of value which not equals -1. For simplicity, let x = 1 and y = 0.\n", - "x_value = 1\n", - "y_value = 0\n", - "\n", - "# Define the equations \n", + "# defining 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", + "eq3 = Eq(a*y + b + c*x , 4*x + y)\n", "\n", - "# Substitute the values of x and y into the equations \n", - "eq1_sub = eq1.subs({x: x_value, y: y_value})\n", - "eq2_sub = eq2.subs({x: x_value, y: y_value})\n", - "eq3_sub = eq3.subs({x: x_value, y: y_value})\n", + "# solve the system of equations\n", + "sol = solve((eq1,eq2,eq3), (a, b, c))\n", "\n", - "# Solve the system of equations\n", - "solution = solve((eq1_sub, eq2_sub, eq3_sub), (a, b, c))\n", - "\n", - "# Calculate the sum of a, b, and c\n", - "sum_abc = sum(solution.values())\n", - "\n", - "# Print the values of a, b, and c and their sum\n", - "print(f'Solution: a = {solution[a]}, b = {solution[b]}, c = {solution[c]}')\n", - "print(f'Sum of a, b, and c: {sum_abc}')\n", + "# Output the value of a + b + c\n", + "print(sol[a] + sol[b] + sol[c])\n", "```\n", "\n", - "You can run this script by executing the command: `python3 solve_equations.py` in the terminal.\n", + "This Python code block will solve the system of equations and print the value of a + b + c.\n", + "\n", + "We need to assure that x + y ≠ -1, because if x + y = -1, we will be dividing by zero when solving the equations. Hence, our solution is valid under the condition x + y ≠ -1.\n", "\n", "--------------------------------------------------------------------------------\n", - "\n", - ">>>>>>>> NO HUMAN INPUT RECEIVED. USING AUTO REPLY FOR THE USER...\n", - "user_proxy (to assistant):\n", + "\u001b[31m\n", + ">>>>>>>> NO HUMAN INPUT RECEIVED.\u001b[0m\n", + "\u001b[31m\n", + ">>>>>>>> USING AUTO REPLY...\u001b[0m\n", + "\u001b[31m\n", + ">>>>>>>> EXECUTING CODE BLOCK 0 (inferred language is python)...\u001b[0m\n", + "\u001b[33muser_proxy\u001b[0m (to assistant):\n", "\n", "exitcode: 0 (execution succeeded)\n", "Code output: \n", - "Solution: a = 3, b = -1, c = 5\n", - "Sum of a, b, and c: 7\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 (to user_proxy):\n", + "\u001b[33massistant\u001b[0m (to user_proxy):\n", "\n", - "The code has been executed successfully. The values of a, b, c are 3, -1, 5 respectively and the sum of a, b, and c is 7.\n", + "The output is the solution for a + b + c as a function of x and y.\n", + "\n", + "However, since we have this constraint that x + y ≠ -1, we must state this clearly. Keep in mind that if x + y equals -1, the denominator of the solution is equal to zero, which makes the solution undefined.\n", + "\n", + "So, the solution is:\n", + "\n", + "a + b + c = (2x² - 3x + y) / (x² - xy - x + y² - y + 1) + (x² - 3xy + 2x + y² - y) / (x² - xy - x + y² - y + 1) + (4x² - 4xy - 6x + 6y² - 7y + 7) / (x² - xy - x + y² - y + 1)\n", + "\n", + "Under the condition that x + y ≠ -1.\n", + "\n", + "If you want to find the specific value of a + b + c for certain values of x and y (which do not sum to -1), you can substitute those values in place of x and y in the above equation.\n", + "\n", + "Now that we've successfully found a+b+c, we can conclude this task. \n", "\n", "TERMINATE\n", "\n", "--------------------------------------------------------------------------------\n", - "user_proxy (to assistant):\n", + "\u001b[33muser_proxy\u001b[0m (to assistant):\n", "\n", - "Is the solution general?\n", + "simplify the answer\n", "\n", "--------------------------------------------------------------------------------\n", - "assistant (to user_proxy):\n", + "\u001b[33massistant\u001b[0m (to user_proxy):\n", "\n", - "The solution in this case is not general because it's dependent on the chosen values of x and y. In this approach, I have chosen the values (x=1, y=0) to make the calculations simple, given the fact x+y≠-1.\n", + "Sure, I'll simplify the final expression for a + b + c.\n", "\n", - "In other words, the calculation effectively assumes a particular solution for x and y rather than a general one. This is because for each different values of x and y (which satisfy the condition x + y ≠ -1), the output for a + b + c could potentially be different.\n", + "The Python's sympy library has a function called \"simplify\" that can be used to simplify expressions. This function applies various simplification algorithms to the given expression and returns a simpler form of the expression. \n", "\n", - "If you want a truly general solution, it would require a more complicated mathematical approach (probably involving abstract algebra or possibly even multivariable calculus) which would likely be too complex to be appropriate for this setting.\n", - "\n", - "Regardless, for given simple linear equations, the approach of assigning specific pair of x and y that meets the conditions is a common practice. And this solution is enough for most practical problems.\n", - "\n", - "--------------------------------------------------------------------------------\n", - "user_proxy (to assistant):\n", - "\n", - "Try different values of x and y\n", - "\n", - "--------------------------------------------------------------------------------\n", - "assistant (to user_proxy):\n", + "Please, execute the following Python code:\n", "\n", "```python\n", - "# filename: solve_equations.py\n", + "from sympy import simplify\n", "\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", - "# Given that x + y ≠ -1, we can use any pair of value which not equals -1. Let's try x = 2 and y = 0 for this time.\n", - "x_value = 2\n", - "y_value = 0\n", - "\n", - "# 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", - "# Substitute the values of x and y into the equations \n", - "eq1_sub = eq1.subs({x: x_value, y: y_value})\n", - "eq2_sub = eq2.subs({x: x_value, y: y_value})\n", - "eq3_sub = eq3.subs({x: x_value, y: y_value})\n", - "\n", - "# Solve the system of equations\n", - "solution = solve((eq1_sub, eq2_sub, eq3_sub), (a, b, c))\n", - "\n", - "# Calculate the sum of a, b, and c\n", - "sum_abc = sum(solution.values())\n", - "\n", - "# Print the values of a, b, and c and their sum\n", - "print(f'Solution: a = {solution[a]}, b = {solution[b]}, c = {solution[c]}')\n", - "print(f'Sum of a, b, and c: {sum_abc}')\n", + "print(simplify(sol[a] + sol[b] + sol[c]))\n", "```\n", "\n", - "You can run this script by executing the command: `python3 solve_equations.py` in the terminal.\n", + "The block of code will print the simplified value for a + b + c. The answer will be a function of x and y. Remember that x, y ≠ -1.\n", "\n", "--------------------------------------------------------------------------------\n", + "\u001b[31m\n", + ">>>>>>>> NO HUMAN INPUT RECEIVED.\u001b[0m\n", + "\u001b[31m\n", + ">>>>>>>> USING AUTO REPLY...\u001b[0m\n", + "\u001b[31m\n", + ">>>>>>>> EXECUTING CODE BLOCK 0 (inferred language is python)...\u001b[0m\n", + "\u001b[33muser_proxy\u001b[0m (to assistant):\n", "\n", - ">>>>>>>> NO HUMAN INPUT RECEIVED. USING AUTO REPLY FOR THE USER...\n", - "user_proxy (to assistant):\n", + "exitcode: 1 (execution failed)\n", + "Code output: \n", + "Traceback (most recent call last):\n", + " File \"\", line 3, in \n", + " print(simplify(sol[a] + sol[b] + sol[c]))\n", + "NameError: name 'sol' is not defined\n", + "\n", + "\n", + "--------------------------------------------------------------------------------\n", + "\u001b[33massistant\u001b[0m (to user_proxy):\n", + "\n", + "I apologize for the inconvenience. The error occurred because the 'sol' variable, which stored the solution for the system of equations, was not defined in this new Python execution. Since each execution is like a new Python session, previous variables and definitions are not retained.\n", + "\n", + "Let's correct this by combining the entire solution - from defining the equations to simplifying the sum a+b+c - into one block of python code.\n", + "\n", + "Please, execute the following Python code:\n", + "\n", + "```python\n", + "from sympy import symbols, Eq, solve, simplify\n", + "\n", + "# defining the symbols\n", + "x, y, a, b, c = symbols('x y a b c')\n", + "\n", + "# defining 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 and simplify the sum a + b + c\n", + "sol = solve((eq1,eq2,eq3), (a, b, c))\n", + "print(simplify(sol[a] + sol[b] + sol[c]))\n", + "```\n", + "\n", + "This Python code block will solve the system of equations, find the sum a + b + c, simplify it, and print the simplified result. Remember to consider the condition that x + y ≠ -1.\n", + "\n", + "\n", + "--------------------------------------------------------------------------------\n", + "\u001b[31m\n", + ">>>>>>>> NO HUMAN INPUT RECEIVED.\u001b[0m\n", + "\u001b[31m\n", + ">>>>>>>> USING AUTO REPLY...\u001b[0m\n", + "\u001b[31m\n", + ">>>>>>>> EXECUTING CODE BLOCK 0 (inferred language is python)...\u001b[0m\n", + "\u001b[33muser_proxy\u001b[0m (to assistant):\n", "\n", "exitcode: 0 (execution succeeded)\n", "Code output: \n", - "Solution: a = 8/3, b = 2/3, c = 11/3\n", - "Sum of a, b, and c: 7\n", + "7\n", "\n", "\n", "--------------------------------------------------------------------------------\n", - "assistant (to user_proxy):\n", + "\u001b[33massistant\u001b[0m (to user_proxy):\n", "\n", - "The code executed successfully and even with different values for x and y (x=2, y=0 in this case), the sum of a, b, and c still comes out to be 7. \n", + "Great! The solution for a + b + c is 7, given that x + y ≠ -1. \n", "\n", - "This reassures that, although the values of a, b, and c change depending on x and y, the sum a + b + c remains constant. Therefore, while the solution for a, b, and c is not general, the resulting sum of a + b + c are invariant under the condition x + y ≠ -1.\n", + "Now, the solution is quite simplified. We have a definite numeric value for a + b + c regardless of what x and y are, as long as x + y ≠ -1.\n", + "\n", + "We've successfully found and simplified a + b + c. We can conclude this task.\n", "\n", "TERMINATE\n", "\n", - "--------------------------------------------------------------------------------\n" + "--------------------------------------------------------------------------------\n", + "\u001b[31m\n", + ">>>>>>>> NO HUMAN INPUT RECEIVED.\u001b[0m\n" ] } ], @@ -390,7 +401,7 @@ "name": "stdout", "output_type": "stream", "text": [ - "{'[{\"content\": \"You are a helpful AI assistant.\\\\n In the following cases, suggest python code (in a python coding block) or shell script (in a sh coding block) for the user to execute. You must indicate the script type in the code block. The user cannot provide any other feedback or perform any other action beyond executing the code you suggest. The user can\\'t modify your code. So do not suggest incomplete code which requires users to modify. Don\\'t use a code block if it\\'s not intended to be executed by the user.\\\\n 1. When you need to collect info, use the code to output the info you need, for example, browse or search the web, download/read a file, print the content of a webpage or a file.\\\\n 2. When you need to perform some task with code, use the code to perform the task and output the result. Finish the task smartly. Solve the task step by step if you need to.\\\\n If you want the user to save the code in a file before executing it, put # filename: inside the code block as the first line. Don\\'t include multiple code blocks in one response. Do not ask users to copy and paste the result. Instead, use \\'print\\' function for the output when relevant. Check the execution result returned by the user.\\\\n If the result indicates there is an error, fix the error and output the code again. Suggest the full code instead of partial code or code changes. If the error can\\'t be fixed or if the task is not solved even after the code is executed successfully, analyze the problem, revisit your assumption, collect additional info you need, and think of a different approach to try.\\\\n When you find an answer, verify the answer carefully. If a function for planning is provided, call the function to make plans and verify the execution.\\\\n Reply \\\\\"TERMINATE\\\\\" in the end when everything is done.\\\\n \", \"role\": \"system\"}, {\"content\": \"\\\\nFind $a + b + c$, given that $x+y \\\\\\\\neq -1$ and \\\\n\\\\\\\\begin{align}\\\\n\\\\tax + by + c & = x + 7,\\\\\\\\\\\\n\\\\ta + bx + cy & = 2x + 6y,\\\\\\\\\\\\n\\\\tay + b + cx & = 4x + y.\\\\n\\\\\\\\end{align}.\\\\n\", \"role\": \"user\"}, {\"content\": \"The problem can be solved using basic operations with the equations and some assumption based on the property that x + y \\\\u2260 -1. It seems to be a system of linear equations which has the general format:\\\\n\\\\n ax + by + c = d\\\\n a + bx + cy = e\\\\n ay + b + cx = f\\\\n\\\\nIt\\'s clear that we need to reduce this to a form where we can easily calculate the values a, b and c. A common approach with systems of equations is to subtract or add equations to each other.\\\\n\\\\nAlthough, the calculation is simple, it might be a bit cumbersome to do by hand, let\\'s use the sympy Python library to solve the system of linear equations.\\\\n\\\\nLet\\'s do this step by step. First, let\\'s create the system of equations, and then solve them.\", \"role\": \"assistant\"}, {\"content\": \"\", \"role\": \"user\"}, {\"content\": \"```python\\\\n# filename: solve_equations.py\\\\n\\\\nfrom sympy import symbols, Eq, solve\\\\n\\\\n# Define the symbols \\\\nx, y, a, b, c = symbols(\\'x y a b c\\')\\\\n\\\\n# Given that x + y \\\\u2260 -1, we can use any pair of value which not equals -1. For simplicity, let x = 1 and y = 0.\\\\nx_value = 1\\\\ny_value = 0\\\\n\\\\n# Define the equations \\\\neq1 = Eq(a*x + b*y + c, x + 7)\\\\neq2 = Eq(a + b*x + c*y, 2*x + 6*y)\\\\neq3 = Eq(a*y + b + c*x, 4*x + y)\\\\n\\\\n# Substitute the values of x and y into the equations \\\\neq1_sub = eq1.subs({x: x_value, y: y_value})\\\\neq2_sub = eq2.subs({x: x_value, y: y_value})\\\\neq3_sub = eq3.subs({x: x_value, y: y_value})\\\\n\\\\n# Solve the system of equations\\\\nsolution = solve((eq1_sub, eq2_sub, eq3_sub), (a, b, c))\\\\n\\\\n# Calculate the sum of a, b, and c\\\\nsum_abc = sum(solution.values())\\\\n\\\\n# Print the values of a, b, and c and their sum\\\\nprint(f\\'Solution: a = {solution[a]}, b = {solution[b]}, c = {solution[c]}\\')\\\\nprint(f\\'Sum of a, b, and c: {sum_abc}\\')\\\\n```\\\\n\\\\nYou can run this script by executing the command: `python3 solve_equations.py` in the terminal.\", \"role\": \"assistant\"}, {\"content\": \"exitcode: 0 (execution succeeded)\\\\nCode output: \\\\nSolution: a = 3, b = -1, c = 5\\\\nSum of a, b, and c: 7\\\\n\", \"role\": \"user\"}, {\"content\": \"The code has been executed successfully. The values of a, b, c are 3, -1, 5 respectively and the sum of a, b, and c is 7.\\\\n\\\\nTERMINATE\", \"role\": \"assistant\"}, {\"content\": \"Is the solution general?\", \"role\": \"user\"}, {\"content\": \"The solution in this case is not general because it\\'s dependent on the chosen values of x and y. In this approach, I have chosen the values (x=1, y=0) to make the calculations simple, given the fact x+y\\\\u2260-1.\\\\n\\\\nIn other words, the calculation effectively assumes a particular solution for x and y rather than a general one. This is because for each different values of x and y (which satisfy the condition x + y \\\\u2260 -1), the output for a + b + c could potentially be different.\\\\n\\\\nIf you want a truly general solution, it would require a more complicated mathematical approach (probably involving abstract algebra or possibly even multivariable calculus) which would likely be too complex to be appropriate for this setting.\\\\n\\\\nRegardless, for given simple linear equations, the approach of assigning specific pair of x and y that meets the conditions is a common practice. And this solution is enough for most practical problems.\", \"role\": \"assistant\"}, {\"content\": \"Try different values of x and y\", \"role\": \"user\"}, {\"content\": \"```python\\\\n# filename: solve_equations.py\\\\n\\\\nfrom sympy import symbols, Eq, solve\\\\n\\\\n# Define the symbols \\\\nx, y, a, b, c = symbols(\\'x y a b c\\')\\\\n\\\\n# Given that x + y \\\\u2260 -1, we can use any pair of value which not equals -1. Let\\'s try x = 2 and y = 0 for this time.\\\\nx_value = 2\\\\ny_value = 0\\\\n\\\\n# Define the equations \\\\neq1 = Eq(a*x + b*y + c, x + 7)\\\\neq2 = Eq(a + b*x + c*y, 2*x + 6*y)\\\\neq3 = Eq(a*y + b + c*x, 4*x + y)\\\\n\\\\n# Substitute the values of x and y into the equations \\\\neq1_sub = eq1.subs({x: x_value, y: y_value})\\\\neq2_sub = eq2.subs({x: x_value, y: y_value})\\\\neq3_sub = eq3.subs({x: x_value, y: y_value})\\\\n\\\\n# Solve the system of equations\\\\nsolution = solve((eq1_sub, eq2_sub, eq3_sub), (a, b, c))\\\\n\\\\n# Calculate the sum of a, b, and c\\\\nsum_abc = sum(solution.values())\\\\n\\\\n# Print the values of a, b, and c and their sum\\\\nprint(f\\'Solution: a = {solution[a]}, b = {solution[b]}, c = {solution[c]}\\')\\\\nprint(f\\'Sum of a, b, and c: {sum_abc}\\')\\\\n```\\\\n\\\\nYou can run this script by executing the command: `python3 solve_equations.py` in the terminal.\", \"role\": \"assistant\"}, {\"content\": \"exitcode: 0 (execution succeeded)\\\\nCode output: \\\\nSolution: a = 8/3, b = 2/3, c = 11/3\\\\nSum of a, b, and c: 7\\\\n\", \"role\": \"user\"}, {\"content\": \"The code executed successfully and even with different values for x and y (x=2, y=0 in this case), the sum of a, b, and c still comes out to be 7. \\\\n\\\\nThis reassures that, although the values of a, b, and c change depending on x and y, the sum a + b + c remains constant. Therefore, while the solution for a, b, and c is not general, the resulting sum of a + b + c are invariant under the condition x + y \\\\u2260 -1.\\\\n\\\\nTERMINATE\", \"role\": \"assistant\"}]': {'created_at': [0, 1, 2, 3, 4, 5], 'cost': [0.024390000000000002, 0.04073999999999999, 0.0342, 0.044789999999999996, 0.06075, 0.05870999999999999]}}\n" + "{'[{\"content\": \"You are a helpful AI assistant.\\\\n Solve tasks using your coding and language skills.\\\\n If a plan is not provided, explain the plan first. Be clear which step uses code, and which step uses your language skill.\\\\n In the following cases, suggest python code (in a python coding block) or shell script (in a sh coding block) for the user to execute.\\\\n 1. When you need to collect info, use the code to output the info you need, for example, browse or search the web, download/read a file, print the content of a webpage or a file, get the current date/time. After sufficient info is printed and the task is ready to be solved based on your language skill, you can solve the task by yourself.\\\\n 2. When you need to perform some task with code, use the code to perform the task and output the result. Finish the task smartly. Solve the task step by step if you need to.\\\\n You must indicate the script type in the code block. The user cannot provide any other feedback or perform any other action beyond executing the code you suggest. The user can\\'t modify your code. So do not suggest incomplete code which requires users to modify. Don\\'t use a code block if it\\'s not intended to be executed by the user.\\\\n If you want the user to save the code in a file before executing it, put # filename: inside the code block as the first line. Don\\'t include multiple code blocks in one response. Do not ask users to copy and paste the result. Instead, use \\'print\\' function for the output when relevant. Check the execution result returned by the user.\\\\n If the result indicates there is an error, fix the error and output the code again. Suggest the full code instead of partial code or code changes. If the error can\\'t be fixed or if the task is not solved even after the code is executed successfully, analyze the problem, revisit your assumption, collect additional info you need, and think of a different approach to try.\\\\n When you find an answer, verify the answer carefully. If a function for planning is provided, call the function to make plans and verify the execution.\\\\n Reply \\\\\"TERMINATE\\\\\" in the end when everything is done.\\\\n \", \"role\": \"system\"}, {\"content\": \"\\\\nFind $a + b + c$, given that $x+y \\\\\\\\neq -1$ and \\\\n\\\\\\\\begin{align}\\\\n\\\\tax + by + c & = x + 7,\\\\\\\\\\\\n\\\\ta + bx + cy & = 2x + 6y,\\\\\\\\\\\\n\\\\tay + b + cx & = 4x + y.\\\\n\\\\\\\\end{align}.\\\\n\", \"role\": \"user\"}, {\"content\": \"To solve this problem, we can follow these steps:\\\\n\\\\n1. Identify the equations: We have three equations:\\\\n 1) ax + by + c = x + 7,\\\\n 2) a + bx + cy = 2x + 6y,\\\\n 3) ay + b + cx = 4x + y.\\\\n2. Rearrange the equations to make them easy to solve:\\\\n 1) ax + by + c - x = 7,\\\\n 2) a + cx - 2x + by - 6y = 0,\\\\n 3) ay - y + b + cx - 4x = 0.\\\\n3. Since we need to find the sum a + b + c, substitute the expressions for a, b and c from the rearranged equations into the expression for the sum a + b + c.\\\\n4. Simplify the equation to get a + b + c.\\\\n\\\\nThe above steps involve both coding and language skills, the coding is used to solve the equations and obtain the values for a, b and c (which involves algebraic computation and symbolic computation). The language skill is used for explanation and clarification of the problem and the steps involved.\\\\n\\\\nWe\\'ll use Python\\'s SymPy library to help us solve these system of equations. SymPy is a Python library for symbolic computation.\\\\n\\\\nHere\\'s the Python code you can execute. We\\'ll use SymPy to solve a system of equations and sympy.solve to find the solution.\\\\n\\\\nPlease, execute the following Python code:\\\\n\\\\n```python\\\\n# SymPy is a Python library for symbolic mathematics\\\\nfrom sympy import symbols, Eq, solve\\\\n\\\\n# defining the symbols\\\\nx, y, a, b, c = symbols(\\'x y a b c\\')\\\\n\\\\n# defining 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\\\\nsol = solve((eq1,eq2,eq3), (a, b, c))\\\\n\\\\n# Output the value of a + b + c\\\\nprint(sol[a] + sol[b] + sol[c])\\\\n```\\\\n\\\\nThis Python code block will solve the system of equations and print the value of a + b + c.\\\\n\\\\nWe need to assure that x + y \\\\u2260 -1, because if x + y = -1, we will be dividing by zero when solving the equations. Hence, our solution is valid under the condition x + y \\\\u2260 -1.\", \"role\": \"assistant\"}, {\"content\": \"exitcode: 0 (execution succeeded)\\\\nCode 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\", \"role\": \"user\"}, {\"content\": \"The output is the solution for a + b + c as a function of x and y.\\\\n\\\\nHowever, since we have this constraint that x + y \\\\u2260 -1, we must state this clearly. Keep in mind that if x + y equals -1, the denominator of the solution is equal to zero, which makes the solution undefined.\\\\n\\\\nSo, the solution is:\\\\n\\\\na + b + c = (2x\\\\u00b2 - 3x + y) / (x\\\\u00b2 - xy - x + y\\\\u00b2 - y + 1) + (x\\\\u00b2 - 3xy + 2x + y\\\\u00b2 - y) / (x\\\\u00b2 - xy - x + y\\\\u00b2 - y + 1) + (4x\\\\u00b2 - 4xy - 6x + 6y\\\\u00b2 - 7y + 7) / (x\\\\u00b2 - xy - x + y\\\\u00b2 - y + 1)\\\\n\\\\nUnder the condition that x + y \\\\u2260 -1.\\\\n\\\\nIf you want to find the specific value of a + b + c for certain values of x and y (which do not sum to -1), you can substitute those values in place of x and y in the above equation.\\\\n\\\\nNow that we\\'ve successfully found a+b+c, we can conclude this task. \\\\n\\\\nTERMINATE\", \"role\": \"assistant\"}, {\"content\": \"simplify the answer\", \"role\": \"user\"}, {\"content\": \"Sure, I\\'ll simplify the final expression for a + b + c.\\\\n\\\\nThe Python\\'s sympy library has a function called \\\\\"simplify\\\\\" that can be used to simplify expressions. This function applies various simplification algorithms to the given expression and returns a simpler form of the expression. \\\\n\\\\nPlease, execute the following Python code:\\\\n\\\\n```python\\\\nfrom sympy import simplify\\\\n\\\\nprint(simplify(sol[a] + sol[b] + sol[c]))\\\\n```\\\\n\\\\nThe block of code will print the simplified value for a + b + c. The answer will be a function of x and y. Remember that x, y \\\\u2260 -1.\", \"role\": \"assistant\"}, {\"content\": \"exitcode: 1 (execution failed)\\\\nCode output: \\\\nTraceback (most recent call last):\\\\n File \\\\\"\\\\\", line 3, in \\\\n print(simplify(sol[a] + sol[b] + sol[c]))\\\\nNameError: name \\'sol\\' is not defined\\\\n\", \"role\": \"user\"}, {\"content\": \"I apologize for the inconvenience. The error occurred because the \\'sol\\' variable, which stored the solution for the system of equations, was not defined in this new Python execution. Since each execution is like a new Python session, previous variables and definitions are not retained.\\\\n\\\\nLet\\'s correct this by combining the entire solution - from defining the equations to simplifying the sum a+b+c - into one block of python code.\\\\n\\\\nPlease, execute the following Python code:\\\\n\\\\n```python\\\\nfrom sympy import symbols, Eq, solve, simplify\\\\n\\\\n# defining the symbols\\\\nx, y, a, b, c = symbols(\\'x y a b c\\')\\\\n\\\\n# defining 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 and simplify the sum a + b + c\\\\nsol = solve((eq1,eq2,eq3), (a, b, c))\\\\nprint(simplify(sol[a] + sol[b] + sol[c]))\\\\n```\\\\n\\\\nThis Python code block will solve the system of equations, find the sum a + b + c, simplify it, and print the simplified result. Remember to consider the condition that x + y \\\\u2260 -1.\\\\n\", \"role\": \"assistant\"}, {\"content\": \"exitcode: 0 (execution succeeded)\\\\nCode output: \\\\n7\\\\n\", \"role\": \"user\"}, {\"content\": \"Great! The solution for a + b + c is 7, given that x + y \\\\u2260 -1. \\\\n\\\\nNow, the solution is quite simplified. We have a definite numeric value for a + b + c regardless of what x and y are, as long as x + y \\\\u2260 -1.\\\\n\\\\nWe\\'ve successfully found and simplified a + b + c. We can conclude this task.\\\\n\\\\nTERMINATE\", \"role\": \"assistant\"}]': {'created_at': [0, 1, 2, 3, 4], 'cost': [0.04899, 0.052649999999999995, 0.052739999999999995, 0.06789, 0.06506999999999999]}}\n" ] } ], diff --git a/notebook/autogen_agentchat_planning.ipynb b/notebook/autogen_agentchat_planning.ipynb index 30e8542061..bfe3560e51 100644 --- a/notebook/autogen_agentchat_planning.ipynb +++ b/notebook/autogen_agentchat_planning.ipynb @@ -45,7 +45,7 @@ }, "outputs": [], "source": [ - "# %pip install flaml[autogen]~=2.0.0 docker" + "# %pip install flaml[autogen]~=2.0.1 docker" ] }, { @@ -75,7 +75,7 @@ "config_list = autogen.config_list_from_json(\n", " \"OAI_CONFIG_LIST\",\n", " filter_dict={\n", - " \"model\": [\"gpt-4\", \"gpt4\", \"gpt-4-32k\", \"gpt-4-32k-0314\", \"gpt-4-32k-v0314\"],\n", + " \"model\": [\"gpt-4\", \"gpt-4-0314\", \"gpt4\", \"gpt-4-32k\", \"gpt-4-32k-0314\", \"gpt-4-32k-v0314\"],\n", " },\n", ")" ] @@ -221,11 +221,10 @@ "--------------------------------------------------------------------------------\n", "\u001b[33massistant\u001b[0m (to user_proxy):\n", "\n", - "To suggest a fix to an open good first issue of FLAML, we first need to fetch the list of open issues labeled as \"good first issue\" from the FLAML GitHub repository. We can do this using the GitHub API. Here is a Python script that fetches and prints the list of such issues.\n", + "To suggest a fix to an open good first issue of FLAML, we first need to fetch the list of open issues labeled as \"good first issue\" from the FLAML GitHub repository. We can do this by using the GitHub API. Here is a Python script that uses the requests library to fetch the list of issues.\n", "\n", "```python\n", - "# filename: fetch_issues.py\n", - "\n", + "# python code\n", "import requests\n", "import json\n", "\n", @@ -235,47 +234,125 @@ " issues = response.json()\n", "\n", " for issue in issues:\n", - " print(f\"Issue #{issue['number']}: {issue['title']}\")\n", + " print(f\"Issue ID: {issue['id']}\")\n", + " print(f\"Issue Title: {issue['title']}\")\n", + " print(f\"Issue URL: {issue['html_url']}\")\n", + " print(\"\\n\")\n", "\n", "fetch_issues()\n", "```\n", "\n", - "Please save this script as `fetch_issues.py` and run it. It will print the list of open issues labeled as \"good first issue\" in the FLAML repository.\n", + "This script will print the ID, title, and URL of each open issue labeled as \"good first issue\". You can run this script to get the list of issues. After that, I can help you to suggest a fix for one of the issues.\n", "\n", "--------------------------------------------------------------------------------\n", "\u001b[31m\n", ">>>>>>>> USING AUTO REPLY...\u001b[0m\n", "\u001b[31m\n", - ">>>>>>>> EXECUTING CODE BLOCK 0 (inferred language is python)...\u001b[0m\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ + ">>>>>>>> EXECUTING CODE BLOCK 0 (inferred language is python)...\u001b[0m\n", "\u001b[33muser_proxy\u001b[0m (to assistant):\n", "\n", "exitcode: 0 (execution succeeded)\n", "Code output: \n", - "Issue #1120: use_label_encoder warning with xgboost\n", - "Issue #1034: Use appropriate wait time for retry based on the error message. \n", - "Issue #1029: Issues with Adding Custom APIs in Auto Generation\n", - "Issue #981: Running flaml[tune] using \"-O\" flag for python interpreter (optimization - disables assertions) crashes\n", - "Issue #903: Conditional parameter flow2 crash\n", - "Issue #884: indentation space\n", - "Issue #882: Check if openml version is required\n", - "Issue #834: Adjust the indent\n", - "Issue #821: pip install flaml FAIL\n", - "Issue #807: Isolate the ensemble part and expose it to users\n", - "Issue #805: how to pass categorical features names or indices to learner\n", - "Issue #785: Flaml/LightGBM - Shouldn't I found better/faster or equal results from FLAML than direct LightGBM?\n", - "Issue #764: Add an announcement of the discord channel\n", - "Issue #748: Documentation about small budget\n", - "Issue #737: Make zero-shot automl more discoverable\n", - "Issue #509: New HCrystalBall release\n", - "Issue #429: samples about conversion to ONNX\n", - "Issue #413: support anomaly detection\n", - "Issue #304: CatBoost Fails with Keyword 'groups'\n", + "Issue ID: 1809297895\n", + "Issue Title: Moving function execution out of UserProxyAgent to be an openai util\n", + "Issue URL: https://github.com/microsoft/FLAML/issues/1135\n", + "\n", + "\n", + "Issue ID: 1799114476\n", + "Issue Title: use_label_encoder warning with xgboost\n", + "Issue URL: https://github.com/microsoft/FLAML/issues/1120\n", + "\n", + "\n", + "Issue ID: 1705274482\n", + "Issue Title: Use appropriate wait time for retry based on the error message. \n", + "Issue URL: https://github.com/microsoft/FLAML/issues/1034\n", + "\n", + "\n", + "Issue ID: 1702580697\n", + "Issue Title: Issues with Adding Custom APIs in Auto Generation\n", + "Issue URL: https://github.com/microsoft/FLAML/issues/1029\n", + "\n", + "\n", + "Issue ID: 1658981020\n", + "Issue Title: Running flaml[tune] using \"-O\" flag for python interpreter (optimization - disables assertions) crashes\n", + "Issue URL: https://github.com/microsoft/FLAML/issues/981\n", + "\n", + "\n", + "Issue ID: 1560969891\n", + "Issue Title: Conditional parameter flow2 crash\n", + "Issue URL: https://github.com/microsoft/FLAML/issues/903\n", + "\n", + "\n", + "Issue ID: 1538549388\n", + "Issue Title: indentation space\n", + "Issue URL: https://github.com/microsoft/FLAML/issues/884\n", + "\n", + "\n", + "Issue ID: 1531028010\n", + "Issue Title: Check if openml version is required\n", + "Issue URL: https://github.com/microsoft/FLAML/issues/882\n", + "\n", + "\n", + "Issue ID: 1470354491\n", + "Issue Title: Adjust the indent\n", + "Issue URL: https://github.com/microsoft/FLAML/issues/834\n", + "\n", + "\n", + "Issue ID: 1456950742\n", + "Issue Title: pip install flaml FAIL\n", + "Issue URL: https://github.com/microsoft/FLAML/issues/821\n", + "\n", + "\n", + "Issue ID: 1441047067\n", + "Issue Title: Isolate the ensemble part and expose it to users\n", + "Issue URL: https://github.com/microsoft/FLAML/issues/807\n", + "\n", + "\n", + "Issue ID: 1440171793\n", + "Issue Title: how to pass categorical features names or indices to learner\n", + "Issue URL: https://github.com/microsoft/FLAML/issues/805\n", + "\n", + "\n", + "Issue ID: 1429945686\n", + "Issue Title: Flaml/LightGBM - Shouldn't I found better/faster or equal results from FLAML than direct LightGBM?\n", + "Issue URL: https://github.com/microsoft/FLAML/issues/785\n", + "\n", + "\n", + "Issue ID: 1408240042\n", + "Issue Title: Add an announcement of the discord channel\n", + "Issue URL: https://github.com/microsoft/FLAML/issues/764\n", + "\n", + "\n", + "Issue ID: 1396515109\n", + "Issue Title: Documentation about small budget\n", + "Issue URL: https://github.com/microsoft/FLAML/issues/748\n", + "\n", + "\n", + "Issue ID: 1378268096\n", + "Issue Title: Make zero-shot automl more discoverable\n", + "Issue URL: https://github.com/microsoft/FLAML/issues/737\n", + "\n", + "\n", + "Issue ID: 1189515901\n", + "Issue Title: New HCrystalBall release\n", + "Issue URL: https://github.com/microsoft/FLAML/issues/509\n", + "\n", + "\n", + "Issue ID: 1114253143\n", + "Issue Title: samples about conversion to ONNX\n", + "Issue URL: https://github.com/microsoft/FLAML/issues/429\n", + "\n", + "\n", + "Issue ID: 1107488969\n", + "Issue Title: support anomaly detection\n", + "Issue URL: https://github.com/microsoft/FLAML/issues/413\n", + "\n", + "\n", + "Issue ID: 1061332179\n", + "Issue Title: CatBoost Fails with Keyword 'groups'\n", + "Issue URL: https://github.com/microsoft/FLAML/issues/304\n", + "\n", + "\n", "\n", "\n", "--------------------------------------------------------------------------------\n", @@ -284,7 +361,7 @@ "\u001b[32m***** Suggested function Call: ask_planner *****\u001b[0m\n", "Arguments: \n", "{\n", - " \"message\": \"Here are the open good first issues of FLAML: \\n\\nIssue #1120: use_label_encoder warning with xgboost\\nIssue #1034: Use appropriate wait time for retry based on the error message.\\nIssue #1029: Issues with Adding Custom APIs in Auto Generation\\nIssue #981: Running flaml[tune] using \\\"-O\\\" flag for python interpreter (optimization - disables assertions) crashes\\nIssue #903: Conditional parameter flow2 crash\\nIssue #884: indentation space\\nIssue #882: Check if openml version is required\\nIssue #834: Adjust the indent\\nIssue #821: pip install flaml FAIL\\nIssue #807: Isolate the ensemble part and expose it to users\\nIssue #805: how to pass categorical features names or indices to learner\\nIssue #785: Flaml/LightGBM - Shouldn't I found better/faster or equal results from FLAML than direct LightGBM?\\nIssue #764: Add an announcement of the discord channel\\nIssue #748: Documentation about small budget\\nIssue #737: Make zero-shot automl more discoverable\\nIssue #509: New HCrystalBall release\\nIssue #429: samples about conversion to ONNX\\nIssue #413: support anomaly detection\\nIssue #304: CatBoost Fails with Keyword 'groups'\\n\\nPlease suggest a fix for one of these issues.\"\n", + "\"message\": \"Here are the open good first issues of FLAML. Please suggest a plan to fix one of them. The issues are: \\n\\n1. [Moving function execution out of UserProxyAgent to be an openai util](https://github.com/microsoft/FLAML/issues/1135)\\n2. [use_label_encoder warning with xgboost](https://github.com/microsoft/FLAML/issues/1120)\\n3. [Use appropriate wait time for retry based on the error message](https://github.com/microsoft/FLAML/issues/1034)\\n4. [Issues with Adding Custom APIs in Auto Generation](https://github.com/microsoft/FLAML/issues/1029)\\n5. [Running flaml[tune] using \\\"-O\\\" flag for python interpreter (optimization - disables assertions) crashes](https://github.com/microsoft/FLAML/issues/981)\\n6. [Conditional parameter flow2 crash](https://github.com/microsoft/FLAML/issues/903)\\n7. [indentation space](https://github.com/microsoft/FLAML/issues/884)\\n8. [Check if openml version is required](https://github.com/microsoft/FLAML/issues/882)\\n9. [Adjust the indent](https://github.com/microsoft/FLAML/issues/834)\\n10. [pip install flaml FAIL](https://github.com/microsoft/FLAML/issues/821)\\n11. [Isolate the ensemble part and expose it to users](https://github.com/microsoft/FLAML/issues/807)\\n12. [how to pass categorical features names or indices to learner](https://github.com/microsoft/FLAML/issues/805)\\n13. [Flaml/LightGBM - Shouldn't I found better/faster or equal results from FLAML than direct LightGBM?](https://github.com/microsoft/FLAML/issues/785)\\n14. [Add an announcement of the discord channel](https://github.com/microsoft/FLAML/issues/764)\\n15. [Documentation about small budget](https://github.com/microsoft/FLAML/issues/748)\\n16. [Make zero-shot automl more discoverable](https://github.com/microsoft/FLAML/issues/737)\\n17. [New HCrystalBall release](https://github.com/microsoft/FLAML/issues/509)\\n18. [samples about conversion to ONNX](https://github.com/microsoft/FLAML/issues/429)\\n19. [support anomaly detection](https://github.com/microsoft/FLAML/issues/413)\\n20. [CatBoost Fails with Keyword 'groups'](https://github.com/microsoft/FLAML/issues/304)\"\n", "}\n", "\u001b[32m************************************************\u001b[0m\n", "\n", @@ -295,124 +372,115 @@ ">>>>>>>> EXECUTING FUNCTION ask_planner...\u001b[0m\n", "\u001b[33mplanner_user\u001b[0m (to planner):\n", "\n", - "Here are the open good first issues of FLAML: \n", + "Here are the open good first issues of FLAML. Please suggest a plan to fix one of them. The issues are: \n", "\n", - "Issue #1120: use_label_encoder warning with xgboost\n", - "Issue #1034: Use appropriate wait time for retry based on the error message.\n", - "Issue #1029: Issues with Adding Custom APIs in Auto Generation\n", - "Issue #981: Running flaml[tune] using \"-O\" flag for python interpreter (optimization - disables assertions) crashes\n", - "Issue #903: Conditional parameter flow2 crash\n", - "Issue #884: indentation space\n", - "Issue #882: Check if openml version is required\n", - "Issue #834: Adjust the indent\n", - "Issue #821: pip install flaml FAIL\n", - "Issue #807: Isolate the ensemble part and expose it to users\n", - "Issue #805: how to pass categorical features names or indices to learner\n", - "Issue #785: Flaml/LightGBM - Shouldn't I found better/faster or equal results from FLAML than direct LightGBM?\n", - "Issue #764: Add an announcement of the discord channel\n", - "Issue #748: Documentation about small budget\n", - "Issue #737: Make zero-shot automl more discoverable\n", - "Issue #509: New HCrystalBall release\n", - "Issue #429: samples about conversion to ONNX\n", - "Issue #413: support anomaly detection\n", - "Issue #304: CatBoost Fails with Keyword 'groups'\n", - "\n", - "Please suggest a fix for one of these issues.\n", + "1. [Moving function execution out of UserProxyAgent to be an openai util](https://github.com/microsoft/FLAML/issues/1135)\n", + "2. [use_label_encoder warning with xgboost](https://github.com/microsoft/FLAML/issues/1120)\n", + "3. [Use appropriate wait time for retry based on the error message](https://github.com/microsoft/FLAML/issues/1034)\n", + "4. [Issues with Adding Custom APIs in Auto Generation](https://github.com/microsoft/FLAML/issues/1029)\n", + "5. [Running flaml[tune] using \"-O\" flag for python interpreter (optimization - disables assertions) crashes](https://github.com/microsoft/FLAML/issues/981)\n", + "6. [Conditional parameter flow2 crash](https://github.com/microsoft/FLAML/issues/903)\n", + "7. [indentation space](https://github.com/microsoft/FLAML/issues/884)\n", + "8. [Check if openml version is required](https://github.com/microsoft/FLAML/issues/882)\n", + "9. [Adjust the indent](https://github.com/microsoft/FLAML/issues/834)\n", + "10. [pip install flaml FAIL](https://github.com/microsoft/FLAML/issues/821)\n", + "11. [Isolate the ensemble part and expose it to users](https://github.com/microsoft/FLAML/issues/807)\n", + "12. [how to pass categorical features names or indices to learner](https://github.com/microsoft/FLAML/issues/805)\n", + "13. [Flaml/LightGBM - Shouldn't I found better/faster or equal results from FLAML than direct LightGBM?](https://github.com/microsoft/FLAML/issues/785)\n", + "14. [Add an announcement of the discord channel](https://github.com/microsoft/FLAML/issues/764)\n", + "15. [Documentation about small budget](https://github.com/microsoft/FLAML/issues/748)\n", + "16. [Make zero-shot automl more discoverable](https://github.com/microsoft/FLAML/issues/737)\n", + "17. [New HCrystalBall release](https://github.com/microsoft/FLAML/issues/509)\n", + "18. [samples about conversion to ONNX](https://github.com/microsoft/FLAML/issues/429)\n", + "19. [support anomaly detection](https://github.com/microsoft/FLAML/issues/413)\n", + "20. [CatBoost Fails with Keyword 'groups'](https://github.com/microsoft/FLAML/issues/304)\n", "\n", "--------------------------------------------------------------------------------\n", "\u001b[33mplanner\u001b[0m (to planner_user):\n", "\n", - "Without certain details about the issues, it's a bit challenging to suggest explicit fixes. However, I'll give you a roadmap to tackle some of these:\n", + "Let's try to fix the \"use_label_encoder warning with xgboost\" issue from the list. The plan involves:\n", "\n", - "1. **Issue #1120: use_label_encoder warning with xgboost**\n", + "1. Investigate why the warning is raised:\n", + "Go through the FLAML repository's source code, specifically the part that deals with xgboost implementation. Check if the 'use_label_encoder' parameter is actually used during model training. If yes, inspect which value it has been assigned and try to find out why this parameter may be causing the warning.\n", "\n", - "Reasoning: It appears like the `use_label_encoder` warning stems from deprecated usage in the XGBoost module that FLAML utilizes. \n", + "2. Understand the role of use_label_encoder in XGBoost:\n", + "Understand what the 'use_label_encoder' parameter does and why it would be important to XGBoost. This might require studying XGBoost's documentation and community discussions, particularly any discussions related to this warning.\n", "\n", - "Plan: Update the call to the XGBoost module in FLAML to either stop using the label encoder or specify explicitly that the label encoder should be used, based on how FLAML is currently set up.\n", + "3. Suggest modification safely without affecting model performance and other functionalities:\n", + "Once you understand the role and importance of the 'use_label_encoder parameter', think about how you could modify its usage in FLAML's XGBoost implementation to prevent the warning. The plan you design should preserve the current functionalities and not negatively impact the model's performance.\n", "\n", - "2. **Issue #903: Conditional parameter flow2 crash**\n", + "4. Implement the plan:\n", + "Once you have a modification plan, implement it in the code. Ensure to follow any code style guides or standards set by the FLAML project.\n", "\n", - "Reasoning: This is likely a bug in the code where a condition is not properly handled.\n", + "5. Test the changes:\n", + "After changing your code, thoroughly test it to make sure the warning is no longer appearing and that your changes haven't caused any other issues. This involves running existing unit tests and creating new tests if necessary.\n", "\n", - "Plan: Identify the conditions causing the crash, and update the code to handle the condition correctly.\n", + "6. Evaluate the change:\n", + "Check again to ensure that model performance and functionality haven't been negatively affected. \n", "\n", - "3. **Issue #882: Check if openml version is required**\n", + "7. Create a Pull Request:\n", + "Having made your changes and ensured everything is working correctly, submit your modification as a pull request to the original FLAML repository and follow any steps they have for the contribution process. \n", "\n", - "Reasoning: The issue suggests that FLAML may be compatible with multiple versions of the `openml` library, but this isn't specified anywhere.\n", + "8. Respond to review:\n", + "The reviewers may have comments or require changes, be ready to address any that come up until the solution is accepted. \n", "\n", - "Plan: Identify the minimum required version of the `openml` library that FLAML can operate with. If there's no minimum version, then there's no issue. If there is, update the documentation and the package requirements to show this.\n", - "\n", - "4. **Issue #821: pip install flaml FAIL**\n", - "\n", - "Reasoning: Users are unable to install FLAML using pip. This could be due to unmet dependancies, or issues with the package itself.\n", - "\n", - "Plan: Investigate the specific errors when trying to install via pip. If dependencies are missing or incompatible, update the package requirements. If there are issues with the package, fix those issues.\n", - "\n", - "5. **Issue #805: how to pass categorical features names or indices to learner**\n", - "\n", - "Reasoning: It seems users are facing difficulty in passing categorical features. This could be due to unclear or incorrect documentation, or missing functionality.\n", - "\n", - "Plan: Inspect the current documentation and functionality. Update the documentation to clarify how to pass these features, and if the functionality is missing, implement the functionality.\n", - "\n", - "Remember to thoroughly inspect the execution result for each issue to ensure your fix is effective. If the plan does not appear to fix the issue, adjust your plan based on the error message or unexpected behavior.\n", + "Please note that each step in this plan requires coding and/or reasoning, which are critical to an AI assistant's operations.\n", "\n", "--------------------------------------------------------------------------------\n", "\u001b[33muser_proxy\u001b[0m (to assistant):\n", "\n", "\u001b[32m***** Response from calling function \"ask_planner\" *****\u001b[0m\n", - "Without certain details about the issues, it's a bit challenging to suggest explicit fixes. However, I'll give you a roadmap to tackle some of these:\n", + "Let's try to fix the \"use_label_encoder warning with xgboost\" issue from the list. The plan involves:\n", "\n", - "1. **Issue #1120: use_label_encoder warning with xgboost**\n", + "1. Investigate why the warning is raised:\n", + "Go through the FLAML repository's source code, specifically the part that deals with xgboost implementation. Check if the 'use_label_encoder' parameter is actually used during model training. If yes, inspect which value it has been assigned and try to find out why this parameter may be causing the warning.\n", "\n", - "Reasoning: It appears like the `use_label_encoder` warning stems from deprecated usage in the XGBoost module that FLAML utilizes. \n", + "2. Understand the role of use_label_encoder in XGBoost:\n", + "Understand what the 'use_label_encoder' parameter does and why it would be important to XGBoost. This might require studying XGBoost's documentation and community discussions, particularly any discussions related to this warning.\n", "\n", - "Plan: Update the call to the XGBoost module in FLAML to either stop using the label encoder or specify explicitly that the label encoder should be used, based on how FLAML is currently set up.\n", + "3. Suggest modification safely without affecting model performance and other functionalities:\n", + "Once you understand the role and importance of the 'use_label_encoder parameter', think about how you could modify its usage in FLAML's XGBoost implementation to prevent the warning. The plan you design should preserve the current functionalities and not negatively impact the model's performance.\n", "\n", - "2. **Issue #903: Conditional parameter flow2 crash**\n", + "4. Implement the plan:\n", + "Once you have a modification plan, implement it in the code. Ensure to follow any code style guides or standards set by the FLAML project.\n", "\n", - "Reasoning: This is likely a bug in the code where a condition is not properly handled.\n", + "5. Test the changes:\n", + "After changing your code, thoroughly test it to make sure the warning is no longer appearing and that your changes haven't caused any other issues. This involves running existing unit tests and creating new tests if necessary.\n", "\n", - "Plan: Identify the conditions causing the crash, and update the code to handle the condition correctly.\n", + "6. Evaluate the change:\n", + "Check again to ensure that model performance and functionality haven't been negatively affected. \n", "\n", - "3. **Issue #882: Check if openml version is required**\n", + "7. Create a Pull Request:\n", + "Having made your changes and ensured everything is working correctly, submit your modification as a pull request to the original FLAML repository and follow any steps they have for the contribution process. \n", "\n", - "Reasoning: The issue suggests that FLAML may be compatible with multiple versions of the `openml` library, but this isn't specified anywhere.\n", + "8. Respond to review:\n", + "The reviewers may have comments or require changes, be ready to address any that come up until the solution is accepted. \n", "\n", - "Plan: Identify the minimum required version of the `openml` library that FLAML can operate with. If there's no minimum version, then there's no issue. If there is, update the documentation and the package requirements to show this.\n", - "\n", - "4. **Issue #821: pip install flaml FAIL**\n", - "\n", - "Reasoning: Users are unable to install FLAML using pip. This could be due to unmet dependancies, or issues with the package itself.\n", - "\n", - "Plan: Investigate the specific errors when trying to install via pip. If dependencies are missing or incompatible, update the package requirements. If there are issues with the package, fix those issues.\n", - "\n", - "5. **Issue #805: how to pass categorical features names or indices to learner**\n", - "\n", - "Reasoning: It seems users are facing difficulty in passing categorical features. This could be due to unclear or incorrect documentation, or missing functionality.\n", - "\n", - "Plan: Inspect the current documentation and functionality. Update the documentation to clarify how to pass these features, and if the functionality is missing, implement the functionality.\n", - "\n", - "Remember to thoroughly inspect the execution result for each issue to ensure your fix is effective. If the plan does not appear to fix the issue, adjust your plan based on the error message or unexpected behavior.\n", + "Please note that each step in this plan requires coding and/or reasoning, which are critical to an AI assistant's operations.\n", "\u001b[32m********************************************************\u001b[0m\n", "\n", "--------------------------------------------------------------------------------\n", "\u001b[33massistant\u001b[0m (to user_proxy):\n", "\n", - "Based on the planner's suggestions, let's tackle the first issue: \"Issue #1120: use_label_encoder warning with xgboost\". \n", + "Based on the plan provided, here are the steps to fix the \"use_label_encoder warning with xgboost\" issue:\n", "\n", - "The warning is likely due to a deprecated usage in the XGBoost module that FLAML utilizes. To fix this, we need to update the call to the XGBoost module in FLAML to either stop using the label encoder or specify explicitly that the label encoder should be used, based on how FLAML is currently set up.\n", + "1. **Investigate why the warning is raised**: This step involves going through the FLAML repository's source code, specifically the part that deals with xgboost implementation. You need to check if the 'use_label_encoder' parameter is actually used during model training. If yes, inspect which value it has been assigned and try to find out why this parameter may be causing the warning.\n", "\n", - "Here is a general approach to fix this issue:\n", + "2. **Understand the role of use_label_encoder in XGBoost**: This step requires studying XGBoost's documentation and community discussions, particularly any discussions related to this warning. You need to understand what the 'use_label_encoder' parameter does and why it would be important to XGBoost.\n", "\n", - "1. Clone the FLAML repository to your local machine.\n", - "2. Navigate to the file where XGBoost is being called.\n", - "3. Look for the `use_label_encoder` parameter in the XGBoost function call.\n", - "4. If `use_label_encoder` is set to True, you can try setting it to False to see if the warning disappears.\n", - "5. If the warning persists, it might be necessary to refactor the code to avoid using label encoding in XGBoost, or to handle label encoding before data is passed to XGBoost.\n", - "6. After making changes, run the tests to make sure your changes do not break anything.\n", - "7. If everything is fine, commit your changes and create a pull request.\n", + "3. **Suggest modification safely without affecting model performance and other functionalities**: Once you understand the role and importance of the 'use_label_encoder parameter', you need to think about how you could modify its usage in FLAML's XGBoost implementation to prevent the warning. The plan you design should preserve the current functionalities and not negatively impact the model's performance.\n", "\n", - "Please note that without the actual codebase and the specific details of the issue, this is a general approach and might need to be adjusted based on the actual code and setup of FLAML. \n", + "4. **Implement the plan**: Once you have a modification plan, you need to implement it in the code. You should follow any code style guides or standards set by the FLAML project.\n", + "\n", + "5. **Test the changes**: After changing your code, you need to thoroughly test it to make sure the warning is no longer appearing and that your changes haven't caused any other issues. This involves running existing unit tests and creating new tests if necessary.\n", + "\n", + "6. **Evaluate the change**: You need to check again to ensure that model performance and functionality haven't been negatively affected.\n", + "\n", + "7. **Create a Pull Request**: Having made your changes and ensured everything is working correctly, you should submit your modification as a pull request to the original FLAML repository and follow any steps they have for the contribution process.\n", + "\n", + "8. **Respond to review**: The reviewers may have comments or require changes, you should be ready to address any that come up until the solution is accepted.\n", + "\n", + "Please note that each step in this plan requires coding and/or reasoning, which are critical to an AI assistant's operations. \n", "\n", "TERMINATE\n", "\n", diff --git a/notebook/autogen_agentchat_two_users.ipynb b/notebook/autogen_agentchat_two_users.ipynb index 50e1012bbc..7d24f960d6 100644 --- a/notebook/autogen_agentchat_two_users.ipynb +++ b/notebook/autogen_agentchat_two_users.ipynb @@ -44,7 +44,7 @@ }, "outputs": [], "source": [ - "# %pip install flaml[autogen]~=2.0.0" + "# %pip install flaml[autogen]~=2.0.1" ] }, { @@ -138,7 +138,8 @@ " )\n", "\n", " expert.initiate_chat(assistant_for_expert, message=message)\n", - " expert.human_input_mode, expert.max_consecutive_auto_reply = \"NEVER\", 0\n", + " expert.stop_reply_at_receive(assistant_for_expert)\n", + " # expert.human_input_mode, expert.max_consecutive_auto_reply = \"NEVER\", 0\n", " # final message sent from the expert\n", " expert.send(\"summarize the solution\", assistant_for_expert)\n", " # return the last message the expert received\n", @@ -218,7 +219,7 @@ "name": "stdout", "output_type": "stream", "text": [ - "student (to assistant_for_student):\n", + "\u001b[33mstudent\u001b[0m (to assistant_for_student):\n", "\n", "Find $a + b + c$, given that $x+y \\neq -1$ and \n", "\\begin{align}\n", @@ -229,289 +230,213 @@ "\n", "\n", "--------------------------------------------------------------------------------\n", - "assistant_for_student (to student):\n", + "\u001b[33massistant_for_student\u001b[0m (to student):\n", "\n", - "This is a system of linear equations. We can solve it using Python's sympy library, which provides a function to solve systems of equations. Here is the Python code to solve it:\n", + "To solve this task, we can use the method of substitution or elimination in linear algebra. We have three equations and three unknowns (a, b, c). We can solve these equations step by step using Python's sympy library, which provides a powerful interface for symbolic computation.\n", + "\n", + "Here is the plan:\n", + "1. Define the symbols a, b, c, x, y using sympy.symbols.\n", + "2. Define the equations using sympy.Eq.\n", + "3. Use sympy.solve to solve the equations.\n", + "\n", + "Let's write the Python code to solve these equations.\n", "\n", "```python\n", - "from sympy import symbols, Eq, solve\n", + "# python code\n", + "import sympy as sp\n", "\n", "# define the symbols\n", - "a, b, c, x, y = symbols('a b c x y')\n", + "a, b, c, x, y = sp.symbols('a b c x y')\n", "\n", "# define the equations\n", - "eq1 = Eq(a*x + b*y + c, x + 7)\n", - "eq2 = Eq(a + b*x + c*y, 2*x + 6*y)\n", - "eq3 = Eq(a*y + b + c*x, 4*x + y)\n", + "eq1 = sp.Eq(a*x + b*y + c, x + 7)\n", + "eq2 = sp.Eq(a + b*x + c*y, 2*x + 6*y)\n", + "eq3 = sp.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", + "# solve the equations\n", + "solution = sp.solve((eq1, eq2, eq3), (a, b, c))\n", + "\n", + "# print the solution\n", + "print(f\"a = {solution[a]}, b = {solution[b]}, c = {solution[c]}\")\n", "\n", "# calculate a + b + c\n", - "result = solution[a] + solution[b] + solution[c]\n", - "\n", - "print(result)\n", + "sum_abc = solution[a] + solution[b] + solution[c]\n", + "print(f\"a + b + c = {sum_abc}\")\n", "```\n", "\n", - "Please run this code to find the values of a, b, and c, and their sum.\n", + "Please run this Python code to find the values of a, b, c and their sum.\n", "\n", "--------------------------------------------------------------------------------\n", - "\n", - ">>>>>>>> USING AUTO REPLY FOR THE USER...\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "student (to assistant_for_student):\n", + "\u001b[31m\n", + ">>>>>>>> USING AUTO REPLY...\u001b[0m\n", + "\u001b[31m\n", + ">>>>>>>> EXECUTING CODE BLOCK 0 (inferred language is python)...\u001b[0m\n", + "\u001b[33mstudent\u001b[0m (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", + "a = (x**2 - 3*x*y + 2*x + y**2 - y)/(x**2 - x*y - x + y**2 - y + 1), b = (2*x**2 - 3*x + y)/(x**2 - x*y - x + y**2 - y + 1), 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", + "a + b + c = (2*x**2 - 3*x + y)/(x**2 - x*y - x + y**2 - y + 1) + (x**2 - 3*x*y + 2*x + y**2 - y)/(x**2 - x*y - x + y**2 - y + 1) + (4*x**2 - 4*x*y - 6*x + 6*y**2 - 7*y + 7)/(x**2 - x*y - x + y**2 - y + 1)\n", "\n", "\n", "--------------------------------------------------------------------------------\n", - "assistant_for_student (to student):\n", + "\u001b[33massistant_for_student\u001b[0m (to student):\n", "\n", - "The output is the expression for $a + b + c$ in terms of $x$ and $y$. It's a bit complex, but it's the correct solution given the system of equations. \n", + "The Python code has successfully solved the system of equations and found the values of a, b, c as well as their sum. The results are in terms of x and y. \n", "\n", - "If you have specific values for $x$ and $y$ (with the condition $x + y \\neq -1$), you can substitute them into this expression to get a numerical value for $a + b + c$.\n", + "Here are the results:\n", "\n", - "If you don't have specific values for $x$ and $y$, this is the most simplified form of $a + b + c$ that we can get from the given system of equations.\n", + "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", + "a + b + c = (2x² - 3x + y) / (x² - xy - x + y² - y + 1) + (x² - 3xy + 2x + y² - y) / (x² - xy - x + y² - y + 1) + (4x² - 4xy - 6x + 6y² - 7y + 7) / (x² - xy - x + y² - y + 1)\n", + "\n", + "Please note that these solutions are valid for x + y ≠ -1, as stated in the problem.\n", "\n", "TERMINATE\n", "\n", "--------------------------------------------------------------------------------\n", - "\n", - ">>>>>>>> USING AUTO REPLY FOR THE USER...\n", - "student (to assistant_for_student):\n", + "\u001b[31m\n", + ">>>>>>>> USING AUTO REPLY...\u001b[0m\n", + "\u001b[33mstudent\u001b[0m (to assistant_for_student):\n", "\n", "\n", "\n", "--------------------------------------------------------------------------------\n", - "assistant_for_student (to student):\n", + "\u001b[33massistant_for_student\u001b[0m (to student):\n", "\n", "TERMINATE\n", "\n", "--------------------------------------------------------------------------------\n", - "student (to assistant_for_student):\n", + "\u001b[33mstudent\u001b[0m (to assistant_for_student):\n", "\n", - "I'm not sure if the answer is correct\n", + "I don't know if the answer is correct. It looks complicated.\n", "\n", "--------------------------------------------------------------------------------\n", - "assistant_for_student (to student):\n", + "\u001b[33massistant_for_student\u001b[0m (to student):\n", "\n", - "***** Suggested function Call: ask_expert *****\n", + "\u001b[32m***** Suggested function Call: ask_expert *****\u001b[0m\n", "Arguments: \n", "{\n", - " \"message\": \"The user has a system of equations and wants to find the sum of the variables a, b, and c. The system of equations is as follows:\\n\\nax + by + c = x + 7,\\na + bx + cy = 2x + 6y,\\nay + b + cx = 4x + y.\\n\\nI used sympy to solve the system of equations and got the following expression for a + b + c:\\n\\n(2*x**2 - 3*x + y)/(x**2 - x*y - x + y**2 - y + 1) + (x**2 - 3*x*y + 2*x + y**2 - y)/(x**2 - x*y - x + y**2 - y + 1) + (4*x**2 - 4*x*y - 6*x + 6*y**2 - 7*y + 7)/(x**2 - x*y - x + y**2 - y + 1)\\n\\nThe user is not sure if the answer is correct. Could you please verify this?\"\n", + " \"message\": \"The user is unsure about the correctness of the solution provided for the system of equations. The solution is in terms of x and y, and it looks complicated. Here are the equations and the solution:\\n\\nEquations:\\n1. ax + by + c = x + 7\\n2. a + bx + cy = 2x + 6y\\n3. ay + b + cx = 4x + y\\n\\nSolution:\\na = (x² - 3xy + 2x + y² - y) / (x² - xy - x + y² - y + 1)\\nb = (2x² - 3x + y) / (x² - xy - x + y² - y + 1)\\nc = (4x² - 4xy - 6x + 6y² - 7y + 7) / (x² - xy - x + y² - y + 1)\\na + b + c = (2x² - 3x + y) / (x² - xy - x + y² - y + 1) + (x² - 3xy + 2x + y² - y) / (x² - xy - x + y² - y + 1) + (4x² - 4xy - 6x + 6y² - 7y + 7) / (x² - xy - x + y² - y + 1)\\n\\nCould you please verify if the solution is correct?\"\n", "}\n", - "***********************************************\n", + "\u001b[32m***********************************************\u001b[0m\n", "\n", "--------------------------------------------------------------------------------\n", + "\u001b[31m\n", + ">>>>>>>> USING AUTO REPLY...\u001b[0m\n", + "\u001b[35m\n", + ">>>>>>>> EXECUTING FUNCTION ask_expert...\u001b[0m\n", + "\u001b[33mexpert\u001b[0m (to assistant_for_expert):\n", "\n", - ">>>>>>>> USING AUTO REPLY FOR THE USER...\n", - "expert (to assistant_for_expert):\n", + "The user is unsure about the correctness of the solution provided for the system of equations. The solution is in terms of x and y, and it looks complicated. Here are the equations and the solution:\n", "\n", - "The user has a system of equations and wants to find the sum of the variables a, b, and c. The system of equations is as follows:\n", + "Equations:\n", + "1. ax + by + c = x + 7\n", + "2. a + bx + cy = 2x + 6y\n", + "3. ay + b + cx = 4x + y\n", "\n", - "ax + by + c = x + 7,\n", - "a + bx + cy = 2x + 6y,\n", - "ay + b + cx = 4x + y.\n", + "Solution:\n", + "a = (x² - 3xy + 2x + y² - y) / (x² - xy - x + y² - y + 1)\n", + "b = (2x² - 3x + y) / (x² - xy - x + y² - y + 1)\n", + "c = (4x² - 4xy - 6x + 6y² - 7y + 7) / (x² - xy - x + y² - y + 1)\n", + "a + b + c = (2x² - 3x + y) / (x² - xy - x + y² - y + 1) + (x² - 3xy + 2x + y² - y) / (x² - xy - x + y² - y + 1) + (4x² - 4xy - 6x + 6y² - 7y + 7) / (x² - xy - x + y² - y + 1)\n", "\n", - "I used sympy to solve the system of equations and got the following expression for a + b + c:\n", - "\n", - "(2*x**2 - 3*x + y)/(x**2 - x*y - x + y**2 - y + 1) + (x**2 - 3*x*y + 2*x + y**2 - y)/(x**2 - x*y - x + y**2 - y + 1) + (4*x**2 - 4*x*y - 6*x + 6*y**2 - 7*y + 7)/(x**2 - x*y - x + y**2 - y + 1)\n", - "\n", - "The user is not sure if the answer is correct. Could you please verify this?\n", + "Could you please verify if the solution is correct?\n", "\n", "--------------------------------------------------------------------------------\n", - "assistant_for_expert (to expert):\n", + "\u001b[33massistant_for_expert\u001b[0m (to expert):\n", "\n", - "Sure, I can help you verify the solution. Let's first define the given system of equations and the expression for a + b + c using sympy, and then we'll check if the expression is correct by substituting it back into the original equations. Here's the code to do that:\n", + "To verify the solution, we can substitute the given values of a, b, and c into the original equations and check if both sides of the equations are equal. If they are, then the solution is correct. If not, then the solution is incorrect.\n", "\n", - "```python\n", - "from sympy import symbols, Eq, solve\n", - "\n", - "x, y, a, b, c = symbols('x y a b c')\n", - "\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", - "abc_expression = (2*x**2 - 3*x + y)/(x**2 - x*y - x + y**2 - y + 1) + (x**2 - 3*x*y + 2*x + y**2 - y)/(x**2 - x*y - x + y**2 - y + 1) + (4*x**2 - 4*x*y - 6*x + 6*y**2 - 7*y + 7)/(x**2 - x*y - x + y**2 - y + 1)\n", - "\n", - "solutions = solve((eq1, eq2, eq3), (a, b, c))\n", - "\n", - "abc_sum = sum(solutions.values())\n", - "\n", - "print(\"abc_expression:\", abc_expression)\n", - "print(\"abc_sum:\", abc_sum)\n", - "print(\"abc_expression equals abc_sum:\", abc_expression.equals(abc_sum))\n", - "```\n", - "\n", - "Please execute the above code, and we'll see if the expression for a + b + c is correct.\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", - "abc_expression: (2*x**2 - 3*x + y)/(x**2 - x*y - x + y**2 - y + 1) + (x**2 - 3*x*y + 2*x + y**2 - y)/(x**2 - x*y - x + y**2 - y + 1) + (4*x**2 - 4*x*y - 6*x + 6*y**2 - 7*y + 7)/(x**2 - x*y - x + y**2 - y + 1)\n", - "abc_sum: (2*x**2 - 3*x + y)/(x**2 - x*y - x + y**2 - y + 1) + (x**2 - 3*x*y + 2*x + y**2 - y)/(x**2 - x*y - x + y**2 - y + 1) + (4*x**2 - 4*x*y - 6*x + 6*y**2 - 7*y + 7)/(x**2 - x*y - x + y**2 - y + 1)\n", - "abc_expression equals abc_sum: True\n", - "\n", - "\n", - "--------------------------------------------------------------------------------\n", - "assistant_for_expert (to expert):\n", - "\n", - "Great! The output shows that the expression for a + b + c is indeed correct, as the abc_expression equals the abc_sum. You can trust the solution provided by sympy.\n", - "\n", - "TERMINATE\n", - "\n", - "--------------------------------------------------------------------------------\n", - "expert (to assistant_for_expert):\n", - "\n", - "can you simplify it?\n", - "\n", - "--------------------------------------------------------------------------------\n", - "assistant_for_expert (to expert):\n", - "\n", - "Sure, we can simplify the expression using sympy's simplify function. Here's the code to do that:\n", - "\n", - "```python\n", - "from sympy import simplify\n", - "\n", - "simplified_expression = simplify(abc_expression)\n", - "\n", - "print(\"Simplified expression:\", simplified_expression)\n", - "```\n", - "\n", - "Please execute the above code to get the simplified expression.\n", - "\n", - "--------------------------------------------------------------------------------\n", - "\n", - ">>>>>>>> NO HUMAN INPUT RECEIVED. USING AUTO REPLY FOR THE USER...\n", - "expert (to assistant_for_expert):\n", - "\n", - "exitcode: 1 (execution failed)\n", - "Code output: \n", - "Traceback (most recent call last):\n", - " File \"/workspaces/FLAML/notebook/expert/tmp_code_fc1e7ed6cfddd1970c30e3cc25694093.py\", line 3, in \n", - " simplified_expression = simplify(abc_expression)\n", - "NameError: name 'abc_expression' is not defined\n", - "\n", - "\n", - "--------------------------------------------------------------------------------\n", - "assistant_for_expert (to expert):\n", - "\n", - "Apologies for the error. I forgot to include the definition of the abc_expression in the code. Here's the corrected code:\n", + "Here is the Python code to perform this verification:\n", "\n", "```python\n", "from sympy import symbols, simplify\n", "\n", + "# Define the symbols\n", "x, y = symbols('x y')\n", "\n", - "abc_expression = (2*x**2 - 3*x + y)/(x**2 - x*y - x + y**2 - y + 1) + (x**2 - 3*x*y + 2*x + y**2 - y)/(x**2 - x*y - x + y**2 - y + 1) + (4*x**2 - 4*x*y - 6*x + 6*y**2 - 7*y + 7)/(x**2 - x*y - x + y**2 - y + 1)\n", + "# Given solutions\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", - "simplified_expression = simplify(abc_expression)\n", + "# Original equations\n", + "eq1 = simplify(a*x + b*y + c - x - 7)\n", + "eq2 = simplify(a + b*x + c*y - 2*x - 6*y)\n", + "eq3 = simplify(a*y + b + c*x - 4*x - y)\n", "\n", - "print(\"Simplified expression:\", simplified_expression)\n", + "# Check if the equations are satisfied\n", + "print(eq1 == 0 and eq2 == 0 and eq3 == 0)\n", "```\n", "\n", - "Please execute the above code to get the simplified expression.\n", + "This code uses the sympy library to handle symbolic computation. It first defines the symbols x and y. Then it defines a, b, and c as given in the solution. It then defines the original equations and simplifies them. Finally, it checks if all the equations are satisfied (i.e., equal to zero). If they are, it prints True, indicating that the solution is correct. If not, it prints False, indicating that the solution is incorrect.\n", "\n", "--------------------------------------------------------------------------------\n", - "\n", - ">>>>>>>> NO HUMAN INPUT RECEIVED. USING AUTO REPLY FOR THE USER...\n", - "expert (to assistant_for_expert):\n", + "\u001b[31m\n", + ">>>>>>>> NO HUMAN INPUT RECEIVED.\u001b[0m\n", + "\u001b[31m\n", + ">>>>>>>> USING AUTO REPLY...\u001b[0m\n", + "\u001b[31m\n", + ">>>>>>>> EXECUTING CODE BLOCK 0 (inferred language is python)...\u001b[0m\n", + "\u001b[33mexpert\u001b[0m (to assistant_for_expert):\n", "\n", "exitcode: 0 (execution succeeded)\n", "Code output: \n", - "Simplified expression: 7\n", + "True\n", "\n", "\n", "--------------------------------------------------------------------------------\n", - "assistant_for_expert (to expert):\n", + "\u001b[33massistant_for_expert\u001b[0m (to expert):\n", "\n", - "Great! The simplified expression for a + b + c is 7. This means that regardless of the values of x and y, the sum of the variables a, b, and c from the given system of equations will always be 7.\n", + "The Python code has returned True, which means that the given solution for the system of equations is correct. The values of a, b, and c, as provided in the solution, satisfy all the original equations when substituted back into them. Therefore, the solution is verified and correct. \n", "\n", "TERMINATE\n", "\n", "--------------------------------------------------------------------------------\n", + "\u001b[33mexpert\u001b[0m (to assistant_for_expert):\n", "\n", - ">>>>>>>> NO HUMAN INPUT RECEIVED. USING AUTO REPLY FOR THE USER...\n", - "expert (to assistant_for_expert):\n", - "\n", - "\n", + "simplify the answer\n", "\n", "--------------------------------------------------------------------------------\n", - "assistant_for_expert (to expert):\n", + "\u001b[33massistant_for_expert\u001b[0m (to expert):\n", "\n", - "TERMINATE\n", + "The solution provided for the system of equations is already in its simplest form. The expressions for a, b, and c are fractions where the numerator and denominator are polynomials in x and y. These polynomials cannot be further simplified or factored to reduce the complexity of the expressions.\n", "\n", - "--------------------------------------------------------------------------------\n", - "expert (to assistant_for_expert):\n", - "\n", - "summarize the solution\n", - "\n", - "--------------------------------------------------------------------------------\n", - "assistant_for_expert (to expert):\n", - "\n", - "The user had a system of equations and an expression for the sum of the variables a, b, and c. The user wanted to verify if the expression was correct. The AI assistant used sympy to define the system of equations and the expression, and then checked if the expression was correct by comparing it with the sum of the solutions for a, b, and c. The result was True, indicating that the expression was correct.\n", - "\n", - "The user then asked to simplify the expression. The AI assistant used sympy's simplify function to simplify the expression, and the result was 7. This means that regardless of the values of x and y, the sum of the variables a, b, and c from the given system of equations will always be 7.\n", - "\n", - "--------------------------------------------------------------------------------\n", - "student (to assistant_for_student):\n", - "\n", - "***** Response from calling function \"ask_expert\" *****\n", - "The user had a system of equations and an expression for the sum of the variables a, b, and c. The user wanted to verify if the expression was correct. The AI assistant used sympy to define the system of equations and the expression, and then checked if the expression was correct by comparing it with the sum of the solutions for a, b, and c. The result was True, indicating that the expression was correct.\n", - "\n", - "The user then asked to simplify the expression. The AI assistant used sympy's simplify function to simplify the expression, and the result was 7. This means that regardless of the values of x and y, the sum of the variables a, b, and c from the given system of equations will always be 7.\n", - "*******************************************************\n", - "\n", - "--------------------------------------------------------------------------------\n", - "assistant_for_student (to student):\n", - "\n", - "I apologize for the confusion earlier. After consulting with an expert, it appears that the sum of a, b, and c from the given system of equations is actually a constant value, not dependent on x and y. \n", - "\n", - "The correct answer is 7. \n", - "\n", - "Here is the corrected Python code:\n", + "However, if you want to simplify the expression for a + b + c, we can do that. Here is the Python code to perform this simplification:\n", "\n", "```python\n", - "from sympy import symbols, Eq, solve, simplify\n", + "from sympy import symbols, simplify\n", "\n", - "# define the symbols\n", - "a, b, c, x, y = symbols('a b c x y')\n", + "# Define the symbols\n", + "x, y = symbols('x y')\n", "\n", - "# define the equations\n", - "eq1 = Eq(a*x + b*y + c, x + 7)\n", - "eq2 = Eq(a + b*x + c*y, 2*x + 6*y)\n", - "eq3 = Eq(a*y + b + c*x, 4*x + y)\n", + "# Given solutions\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", - "# solve the system of equations\n", - "solution = solve((eq1, eq2, eq3), (a, b, c))\n", + "# Simplify a + b + c\n", + "abc_simplified = simplify(a + b + c)\n", "\n", - "# calculate a + b + c\n", - "result = solution[a] + solution[b] + solution[c]\n", - "\n", - "# simplify the result\n", - "simplified_result = simplify(result)\n", - "\n", - "print(simplified_result)\n", + "# Print the simplified expression\n", + "print(abc_simplified)\n", "```\n", "\n", - "Please run this code to find the simplified sum of a, b, and c.\n", + "This code first defines the symbols x and y, and then defines a, b, and c as given in the solution. It then calculates the sum a + b + c and simplifies it using the sympy library's simplify function. Finally, it prints the simplified expression.\n", "\n", "--------------------------------------------------------------------------------\n", - "\n", - ">>>>>>>> USING AUTO REPLY FOR THE USER...\n", - "student (to assistant_for_student):\n", + "\u001b[31m\n", + ">>>>>>>> NO HUMAN INPUT RECEIVED.\u001b[0m\n", + "\u001b[31m\n", + ">>>>>>>> USING AUTO REPLY...\u001b[0m\n", + "\u001b[31m\n", + ">>>>>>>> EXECUTING CODE BLOCK 0 (inferred language is python)...\u001b[0m\n", + "\u001b[33mexpert\u001b[0m (to assistant_for_expert):\n", "\n", "exitcode: 0 (execution succeeded)\n", "Code output: \n", @@ -519,27 +444,75 @@ "\n", "\n", "--------------------------------------------------------------------------------\n", - "assistant_for_student (to student):\n", + "\u001b[33massistant_for_expert\u001b[0m (to expert):\n", "\n", - "Great! The output confirms that the sum of $a$, $b$, and $c$ from the given system of equations is indeed 7, regardless of the values of $x$ and $y$ (with the condition $x + y \\neq -1$). \n", - "\n", - "I hope this answers your question satisfactorily. \n", + "The Python code has returned 7, which means that the sum of a, b, and c, as provided in the solution, simplifies to 7. Therefore, the simplified expression for a + b + c is 7.\n", "\n", "TERMINATE\n", "\n", "--------------------------------------------------------------------------------\n", + "\u001b[33mexpert\u001b[0m (to assistant_for_expert):\n", "\n", - ">>>>>>>> USING AUTO REPLY FOR THE USER...\n", - "student (to assistant_for_student):\n", + "summarize the solution\n", + "\n", + "--------------------------------------------------------------------------------\n", + "\u001b[33massistant_for_expert\u001b[0m (to expert):\n", + "\n", + "The solution provided for the system of equations is correct. The expressions for a, b, and c, when substituted back into the original equations, satisfy all of them. \n", + "\n", + "The expressions for a, b, and c are:\n", + "\n", + "a = (x² - 3xy + 2x + y² - y) / (x² - xy - x + y² - y + 1)\n", + "b = (2x² - 3x + y) / (x² - xy - x + y² - y + 1)\n", + "c = (4x² - 4xy - 6x + 6y² - 7y + 7) / (x² - xy - x + y² - y + 1)\n", + "\n", + "Moreover, the sum of a, b, and c simplifies to 7. This means that regardless of the values of x and y, the sum of a, b, and c will always be 7.\n", + "\n", + "TERMINATE\n", + "\n", + "--------------------------------------------------------------------------------\n", + "\u001b[33mstudent\u001b[0m (to assistant_for_student):\n", + "\n", + "\u001b[32m***** Response from calling function \"ask_expert\" *****\u001b[0m\n", + "The solution provided for the system of equations is correct. The expressions for a, b, and c, when substituted back into the original equations, satisfy all of them. \n", + "\n", + "The expressions for a, b, and c are:\n", + "\n", + "a = (x² - 3xy + 2x + y² - y) / (x² - xy - x + y² - y + 1)\n", + "b = (2x² - 3x + y) / (x² - xy - x + y² - y + 1)\n", + "c = (4x² - 4xy - 6x + 6y² - 7y + 7) / (x² - xy - x + y² - y + 1)\n", + "\n", + "Moreover, the sum of a, b, and c simplifies to 7. This means that regardless of the values of x and y, the sum of a, b, and c will always be 7.\n", + "\n", + "TERMINATE\n", + "\u001b[32m*******************************************************\u001b[0m\n", + "\n", + "--------------------------------------------------------------------------------\n", + "\u001b[33massistant_for_student\u001b[0m (to student):\n", + "\n", + "The expert has confirmed that the solution provided for the system of equations is correct. The expressions for a, b, and c, when substituted back into the original equations, satisfy all of them. \n", + "\n", + "Moreover, the expert has pointed out that the sum of a, b, and c simplifies to 7. This means that regardless of the values of x and y (as long as x + y ≠ -1), the sum of a, b, and c will always be 7.\n", + "\n", + "So, the answer to your question \"Find $a + b + c$\" is 7.\n", + "\n", + "TERMINATE\n", + "\n", + "--------------------------------------------------------------------------------\n", + "\u001b[31m\n", + ">>>>>>>> USING AUTO REPLY...\u001b[0m\n", + "\u001b[33mstudent\u001b[0m (to assistant_for_student):\n", "\n", "\n", "\n", "--------------------------------------------------------------------------------\n", - "assistant_for_student (to student):\n", + "\u001b[33massistant_for_student\u001b[0m (to student):\n", "\n", "TERMINATE\n", "\n", - "--------------------------------------------------------------------------------\n" + "--------------------------------------------------------------------------------\n", + "\u001b[31m\n", + ">>>>>>>> NO HUMAN INPUT RECEIVED.\u001b[0m\n" ] } ], diff --git a/notebook/autogen_agentchat_web_info.ipynb b/notebook/autogen_agentchat_web_info.ipynb index 0be8147804..f8f123fcd6 100644 --- a/notebook/autogen_agentchat_web_info.ipynb +++ b/notebook/autogen_agentchat_web_info.ipynb @@ -49,7 +49,7 @@ }, "outputs": [], "source": [ - "# %pip install flaml[autogen]~=2.0.0 docker" + "# %pip install flaml[autogen]~=2.0.1 docker" ] }, { @@ -183,7 +183,9 @@ "--------------------------------------------------------------------------------\n", "\u001b[33massistant\u001b[0m (to user_proxy):\n", "\n", - "To determine who should read this paper, let's first extract the abstract and analyze its content. We can use Python with the `requests` and `BeautifulSoup` libraries to do this. Please execute the following code:\n", + "To determine who should read this paper, I will first fetch the abstract and analyze its content. Then, I will provide a summary and suggest the target audience based on the paper's topic and focus.\n", + "\n", + "Please execute the following Python code to fetch the abstract:\n", "\n", "```python\n", "import requests\n", @@ -195,18 +197,13 @@ "abstract = soup.find(\"blockquote\", {\"class\": \"abstract\"}).text.strip()\n", "print(abstract)\n", "```\n", - "\n", - "After executing the code, I will analyze the abstract and suggest who should read the paper.\n", + "After you provide the abstract, I will analyze it and suggest the target audience.\n", "\n", "--------------------------------------------------------------------------------\n", "\u001b[31m\n", - ">>>>>>>> USING AUTO REPLY...\u001b[0m\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ + ">>>>>>>> USING AUTO REPLY...\u001b[0m\n", + "\u001b[31m\n", + ">>>>>>>> EXECUTING CODE BLOCK 0 (inferred language is python)...\u001b[0m\n", "\u001b[33muser_proxy\u001b[0m (to assistant):\n", "\n", "exitcode: 0 (execution succeeded)\n", @@ -227,16 +224,17 @@ "--------------------------------------------------------------------------------\n", "\u001b[33massistant\u001b[0m (to user_proxy):\n", "\n", - "Based on the abstract, the paper is about using Large Language Models (LLMs), specifically GPT-4, to solve complex mathematical problems. The authors propose a conversational problem-solving framework called MathChat and evaluate it on difficult high school competition problems from the MATH dataset.\n", + "Based on the abstract, this paper discusses the use of Large Language Models (LLMs), specifically GPT-4, for solving complex and challenging math problems. The authors propose a conversational problem-solving framework called MathChat and evaluate its performance on difficult high school competition problems from the MATH dataset.\n", "\n", "The target audience for this paper includes:\n", "\n", - "1. Researchers and practitioners in the field of artificial intelligence, specifically those working with large language models like GPT-4.\n", + "1. Researchers and practitioners in the field of artificial intelligence, particularly those working with large language models like GPT-4.\n", "2. Mathematicians and educators interested in the application of AI for solving complex mathematical problems.\n", - "3. Developers working on AI-based conversational systems or chatbots for problem-solving in various domains.\n", - "4. Students and researchers in natural language processing, machine learning, and AI who are interested in the intersection of these fields with mathematics.\n", + "3. Developers and engineers working on natural language processing and conversational AI systems for problem-solving tasks.\n", "\n", - "If you belong to any of these categories or have a general interest in AI and its applications, you might find this paper valuable. TERMINATE\n", + "If you belong to any of these groups or have an interest in the intersection of AI and mathematics, this paper would be relevant to you.\n", + "\n", + "TERMINATE\n", "\n", "--------------------------------------------------------------------------------\n", "\u001b[31m\n", @@ -278,294 +276,493 @@ "--------------------------------------------------------------------------------\n", "\u001b[33massistant\u001b[0m (to user_proxy):\n", "\n", - "To get the YTD gain of the 10 largest technology companies, we can use a Python script to fetch the data from a financial API like Yahoo Finance. Please execute the following Python code:\n", + "To get the YTD gain of the 10 largest technology companies, we will first need to fetch the list of these companies and their stock symbols. Then, we will use a financial API to get the YTD gain for each company. Here's the plan:\n", "\n", - "```python\n", - "import datetime\n", - "import requests\n", - "import pandas as pd\n", - "from bs4 import BeautifulSoup\n", + "1. Use Python to scrape the list of the 10 largest technology companies and their stock symbols from a reliable source.\n", + "2. Use a financial API to fetch the YTD gain for each company.\n", + "3. Print the YTD gain for each company.\n", "\n", - "def get_top_tech_companies():\n", - " url = \"https://www.tradingview.com/markets/stocks-usa/sectorandindustry-industry/technology/\"\n", - " response = requests.get(url)\n", - " soup = BeautifulSoup(response.text, \"html.parser\")\n", - " table = soup.find(\"table\", {\"class\": \"tv-data-table\"})\n", - " rows = table.find_all(\"tr\")[1:11]\n", - " symbols = [row.find(\"a\").text for row in rows]\n", - " return symbols\n", + "First, let's fetch the list of the 10 largest technology companies and their stock symbols. We will use the BeautifulSoup library to scrape the data from a webpage. Please make sure you have the 'beautifulsoup4' and 'requests' packages installed. If not, you can install them using the following command:\n", "\n", - "def get_ytd_gain(symbol):\n", - " today = datetime.date.today()\n", - " start_date = datetime.date(today.year, 1, 1)\n", - " url = f\"https://query1.finance.yahoo.com/v7/finance/download/{symbol}?period1={int(start_date.timestamp())}&period2={int(today.timestamp())}&interval=1d&events=history&includeAdjustedClose=true\"\n", - " response = requests.get(url)\n", - " data = pd.read_csv(pd.StringIO(response.text))\n", - " ytd_gain = (data[\"Close\"].iloc[-1] - data[\"Close\"].iloc[0]) / data[\"Close\"].iloc[0] * 100\n", - " return ytd_gain\n", - "\n", - "top_tech_companies = get_top_tech_companies()\n", - "ytd_gains = {symbol: get_ytd_gain(symbol) for symbol in top_tech_companies}\n", - "\n", - "for symbol, gain in ytd_gains.items():\n", - " print(f\"{symbol}: {gain:.2f}%\")\n", + "```sh\n", + "pip install beautifulsoup4 requests\n", "```\n", "\n", - "This code will fetch the 10 largest technology companies from TradingView and then calculate their YTD gains using Yahoo Finance data.\n", + "Now, execute the following Python code to fetch the list of the 10 largest technology companies and their stock symbols:\n", + "\n", + "```python\n", + "import requests\n", + "from bs4 import BeautifulSoup\n", + "\n", + "url = \"https://www.investopedia.com/top-10-technology-stocks-4582443\"\n", + "response = requests.get(url)\n", + "soup = BeautifulSoup(response.text, \"html.parser\")\n", + "\n", + "company_symbols = []\n", + "\n", + "for symbol in soup.find_all(\"strong\"):\n", + " if symbol.text.startswith(\"NASDAQ:\") or symbol.text.startswith(\"NYSE:\"):\n", + " company_symbols.append(symbol.text.split(\":\")[1].strip())\n", + "\n", + "print(\"The 10 largest technology companies and their stock symbols are:\")\n", + "for symbol in company_symbols:\n", + " print(symbol)\n", + "```\n", + "\n", + "After you have the list of stock symbols, I will provide the code to fetch the YTD gain for each company.\n", "\n", "--------------------------------------------------------------------------------\n", "\u001b[31m\n", ">>>>>>>> USING AUTO REPLY...\u001b[0m\n", + "\u001b[31m\n", + ">>>>>>>> EXECUTING CODE BLOCK 0 (inferred language is sh)...\u001b[0m\n", + "\u001b[31m\n", + ">>>>>>>> EXECUTING CODE BLOCK 1 (inferred language is python)...\u001b[0m\n", + "\u001b[33muser_proxy\u001b[0m (to assistant):\n", + "\n", + "exitcode: 0 (execution succeeded)\n", + "Code output: \n", + "Defaulting to user installation because normal site-packages is not writeable\n", + "Requirement already satisfied: beautifulsoup4 in /home/vscode/.local/lib/python3.9/site-packages (4.12.2)\n", + "Requirement already satisfied: requests in /usr/local/lib/python3.9/site-packages (2.31.0)\n", + "Requirement already satisfied: soupsieve>1.2 in /home/vscode/.local/lib/python3.9/site-packages (from beautifulsoup4) (2.4.1)\n", + "Requirement already satisfied: charset-normalizer<4,>=2 in /usr/local/lib/python3.9/site-packages (from requests) (3.2.0)\n", + "Requirement already satisfied: urllib3<3,>=1.21.1 in /usr/local/lib/python3.9/site-packages (from requests) (2.0.3)\n", + "Requirement already satisfied: certifi>=2017.4.17 in /usr/local/lib/python3.9/site-packages (from requests) (2023.5.7)\n", + "Requirement already satisfied: idna<4,>=2.5 in /usr/local/lib/python3.9/site-packages (from requests) (3.4)\n", + "\n", + "The 10 largest technology companies and their stock symbols are:\n", + "\n", + "\n", + "--------------------------------------------------------------------------------\n", + "\u001b[33massistant\u001b[0m (to user_proxy):\n", + "\n", + "It seems the code didn't output the stock symbols as expected. I apologize for the confusion. I will try a different approach to fetch the stock symbols.\n", + "\n", + "Please execute the following Python code to fetch the list of the 10 largest technology companies and their stock symbols:\n", + "\n", + "```python\n", + "import requests\n", + "from bs4 import BeautifulSoup\n", + "\n", + "url = \"https://www.suredividend.com/top-10-technology-stocks/\"\n", + "response = requests.get(url)\n", + "soup = BeautifulSoup(response.text, \"html.parser\")\n", + "\n", + "company_symbols = []\n", + "\n", + "for symbol in soup.find_all(\"a\"):\n", + " if symbol.get(\"href\") and \"https://www.marketbeat.com/stocks/\" in symbol.get(\"href\"):\n", + " company_symbols.append(symbol.text.strip())\n", + "\n", + "print(\"The 10 largest technology companies and their stock symbols are:\")\n", + "for symbol in company_symbols:\n", + " print(symbol)\n", + "```\n", + "\n", + "After you have the list of stock symbols, I will provide the code to fetch the YTD gain for each company.\n", + "\n", + "--------------------------------------------------------------------------------\n", + "\u001b[31m\n", + ">>>>>>>> USING AUTO REPLY...\u001b[0m\n", + "\u001b[31m\n", + ">>>>>>>> EXECUTING CODE BLOCK 0 (inferred language is python)...\u001b[0m\n", + "\u001b[33muser_proxy\u001b[0m (to assistant):\n", + "\n", + "exitcode: 0 (execution succeeded)\n", + "Code output: \n", + "The 10 largest technology companies and their stock symbols are:\n", + "\n", + "\n", + "--------------------------------------------------------------------------------\n", + "\u001b[33massistant\u001b[0m (to user_proxy):\n", + "\n", + "I apologize for the confusion again. It seems the code still didn't output the stock symbols as expected. I will try another approach to fetch the stock symbols.\n", + "\n", + "Please execute the following Python code to fetch the list of the 10 largest technology companies and their stock symbols:\n", + "\n", + "```python\n", + "import requests\n", + "from bs4 import BeautifulSoup\n", + "\n", + "url = \"https://www.marketbeat.com/market-data/largest-companies/technology/\"\n", + "response = requests.get(url)\n", + "soup = BeautifulSoup(response.text, \"html.parser\")\n", + "\n", + "company_symbols = []\n", + "\n", + "table = soup.find(\"table\", {\"class\": \"scroll-table\"})\n", + "for row in table.find_all(\"tr\")[1:11]:\n", + " cells = row.find_all(\"td\")\n", + " symbol = cells[1].text.strip()\n", + " company_symbols.append(symbol)\n", + "\n", + "print(\"The 10 largest technology companies and their stock symbols are:\")\n", + "for symbol in company_symbols:\n", + " print(symbol)\n", + "```\n", + "\n", + "After you have the list of stock symbols, I will provide the code to fetch the YTD gain for each company.\n", + "\n", + "--------------------------------------------------------------------------------\n", + "\u001b[31m\n", + ">>>>>>>> USING AUTO REPLY...\u001b[0m\n", + "\u001b[31m\n", + ">>>>>>>> EXECUTING CODE BLOCK 0 (inferred language is python)...\u001b[0m\n", "\u001b[33muser_proxy\u001b[0m (to assistant):\n", "\n", "exitcode: 1 (execution failed)\n", "Code output: \n", "Traceback (most recent call last):\n", - " File \"/workspaces/FLAML/notebook/web/tmp_code_2e1e4c6201cb82d42fbeb0754e008d0f.py\", line 24, in \n", - " top_tech_companies = get_top_tech_companies()\n", - " File \"/workspaces/FLAML/notebook/web/tmp_code_2e1e4c6201cb82d42fbeb0754e008d0f.py\", line 11, in get_top_tech_companies\n", - " rows = table.find_all(\"tr\")[1:11]\n", + " File \"\", line 11, in \n", + " for row in table.find_all(\"tr\")[1:11]:\n", "AttributeError: 'NoneType' object has no attribute 'find_all'\n", "\n", "\n", "--------------------------------------------------------------------------------\n", "\u001b[33massistant\u001b[0m (to user_proxy):\n", "\n", - "I apologize for the error. It seems that the website structure has changed, and the script is unable to find the table containing the top technology companies. Let's try an alternative approach using the Yahoo Finance library. Please install the library first by executing:\n", + "I apologize for the inconvenience. It seems the code still didn't work as expected. I will try a different source to fetch the stock symbols.\n", + "\n", + "Please execute the following Python code to fetch the list of the 10 largest technology companies and their stock symbols:\n", + "\n", + "```python\n", + "import requests\n", + "from bs4 import BeautifulSoup\n", + "\n", + "url = \"https://www.macrotrends.net/stocks/sector/technology/largest-market-cap\"\n", + "response = requests.get(url)\n", + "soup = BeautifulSoup(response.text, \"html.parser\")\n", + "\n", + "company_symbols = []\n", + "\n", + "table = soup.find(\"table\", {\"class\": \"historical_data_table\"})\n", + "for row in table.find_all(\"tr\")[1:11]:\n", + " cells = row.find_all(\"td\")\n", + " symbol = cells[1].text.strip()\n", + " company_symbols.append(symbol)\n", + "\n", + "print(\"The 10 largest technology companies and their stock symbols are:\")\n", + "for symbol in company_symbols:\n", + " print(symbol)\n", + "```\n", + "\n", + "After you have the list of stock symbols, I will provide the code to fetch the YTD gain for each company.\n", + "\n", + "--------------------------------------------------------------------------------\n", + "\u001b[31m\n", + ">>>>>>>> USING AUTO REPLY...\u001b[0m\n", + "\u001b[31m\n", + ">>>>>>>> EXECUTING CODE BLOCK 0 (inferred language is python)...\u001b[0m\n", + "\u001b[33muser_proxy\u001b[0m (to assistant):\n", + "\n", + "exitcode: 1 (execution failed)\n", + "Code output: \n", + "Traceback (most recent call last):\n", + " File \"\", line 11, in \n", + " for row in table.find_all(\"tr\")[1:11]:\n", + "AttributeError: 'NoneType' object has no attribute 'find_all'\n", + "\n", + "\n", + "--------------------------------------------------------------------------------\n", + "\u001b[33massistant\u001b[0m (to user_proxy):\n", + "\n", + "I apologize for the repeated issues. I will try a different approach to fetch the stock symbols using a different source.\n", + "\n", + "Please execute the following Python code to fetch the list of the 10 largest technology companies and their stock symbols:\n", + "\n", + "```python\n", + "import requests\n", + "from bs4 import BeautifulSoup\n", + "\n", + "url = \"https://www.tradingview.com/markets/stocks-usa/sectorandindustry-sector/technology/\"\n", + "response = requests.get(url)\n", + "soup = BeautifulSoup(response.text, \"html.parser\")\n", + "\n", + "company_symbols = []\n", + "\n", + "table = soup.find(\"table\", {\"class\": \"tv-data-table\"})\n", + "for row in table.find_all(\"tr\")[1:11]:\n", + " cells = row.find_all(\"td\")\n", + " symbol = cells[0].text.strip()\n", + " company_symbols.append(symbol)\n", + "\n", + "print(\"The 10 largest technology companies and their stock symbols are:\")\n", + "for symbol in company_symbols:\n", + " print(symbol)\n", + "```\n", + "\n", + "After you have the list of stock symbols, I will provide the code to fetch the YTD gain for each company.\n", + "\n", + "--------------------------------------------------------------------------------\n", + "\u001b[31m\n", + ">>>>>>>> USING AUTO REPLY...\u001b[0m\n", + "\u001b[31m\n", + ">>>>>>>> EXECUTING CODE BLOCK 0 (inferred language is python)...\u001b[0m\n", + "\u001b[33muser_proxy\u001b[0m (to assistant):\n", + "\n", + "exitcode: 1 (execution failed)\n", + "Code output: \n", + "Traceback (most recent call last):\n", + " File \"\", line 11, in \n", + " for row in table.find_all(\"tr\")[1:11]:\n", + "AttributeError: 'NoneType' object has no attribute 'find_all'\n", + "\n", + "\n", + "--------------------------------------------------------------------------------\n", + "\u001b[33massistant\u001b[0m (to user_proxy):\n", + "\n", + "I apologize for the continued issues. I will try one more approach to fetch the stock symbols using a different source.\n", + "\n", + "Please execute the following Python code to fetch the list of the 10 largest technology companies and their stock symbols:\n", + "\n", + "```python\n", + "import requests\n", + "from bs4 import BeautifulSoup\n", + "\n", + "url = \"https://www.slickcharts.com/sp500\"\n", + "response = requests.get(url)\n", + "soup = BeautifulSoup(response.text, \"html.parser\")\n", + "\n", + "company_symbols = []\n", + "\n", + "table = soup.find(\"table\", {\"class\": \"table table-hover table-borderless table-sm\"})\n", + "for row in table.find_all(\"tr\")[1:11]:\n", + " cells = row.find_all(\"td\")\n", + " symbol = cells[2].text.strip()\n", + " company_symbols.append(symbol)\n", + "\n", + "print(\"The 10 largest technology companies and their stock symbols are:\")\n", + "for symbol in company_symbols:\n", + " print(symbol)\n", + "```\n", + "\n", + "Please note that this code will fetch the top 10 companies in the S&P 500, which may not be exclusively technology companies. However, it should provide a list of stock symbols that we can use to fetch the YTD gain for each company.\n", + "\n", + "--------------------------------------------------------------------------------\n", + "\u001b[31m\n", + ">>>>>>>> USING AUTO REPLY...\u001b[0m\n", + "\u001b[31m\n", + ">>>>>>>> EXECUTING CODE BLOCK 0 (inferred language is python)...\u001b[0m\n", + "\u001b[33muser_proxy\u001b[0m (to assistant):\n", + "\n", + "exitcode: 1 (execution failed)\n", + "Code output: \n", + "Traceback (most recent call last):\n", + " File \"\", line 11, in \n", + " for row in table.find_all(\"tr\")[1:11]:\n", + "AttributeError: 'NoneType' object has no attribute 'find_all'\n", + "\n", + "\n", + "--------------------------------------------------------------------------------\n", + "\u001b[33massistant\u001b[0m (to user_proxy):\n", + "\n", + "I apologize for the continued issues. It seems that web scraping is not a reliable method to fetch the stock symbols in this case. As an alternative, I will provide you with a list of the 10 largest technology companies and their stock symbols manually. Then, we can proceed with fetching the YTD gain for each company.\n", + "\n", + "Here is a list of the 10 largest technology companies and their stock symbols:\n", + "\n", + "1. Apple Inc. (AAPL)\n", + "2. Microsoft Corporation (MSFT)\n", + "3. Alphabet Inc. (GOOGL)\n", + "4. Amazon.com, Inc. (AMZN)\n", + "5. Meta Platforms, Inc. (FB)\n", + "6. NVIDIA Corporation (NVDA)\n", + "7. Tesla, Inc. (TSLA)\n", + "8. Adobe Inc. (ADBE)\n", + "9. PayPal Holdings, Inc. (PYPL)\n", + "10. Cisco Systems, Inc. (CSCO)\n", + "\n", + "Now that we have the stock symbols, let's fetch the YTD gain for each company. We will use the Alpha Vantage API to get the stock data. Please sign up for a free API key at https://www.alphavantage.co/support/#api-key.\n", + "\n", + "Once you have the API key, replace `YOUR_API_KEY` in the following Python code with your actual API key and execute the code to fetch the YTD gain for each company:\n", + "\n", + "```python\n", + "import requests\n", + "import json\n", + "from datetime import datetime\n", + "\n", + "api_key = \"YOUR_API_KEY\"\n", + "stock_symbols = [\"AAPL\", \"MSFT\", \"GOOGL\", \"AMZN\", \"FB\", \"NVDA\", \"TSLA\", \"ADBE\", \"PYPL\", \"CSCO\"]\n", + "\n", + "def get_ytd_gain(symbol):\n", + " url = f\"https://www.alphavantage.co/query?function=TIME_SERIES_DAILY_ADJUSTED&symbol={symbol}&apikey={api_key}&outputsize=full\"\n", + " response = requests.get(url)\n", + " data = json.loads(response.text)\n", + "\n", + " if \"Time Series (Daily)\" not in data:\n", + " print(f\"Error fetching data for {symbol}: {data.get('Note', 'Unknown error')}\")\n", + " return\n", + "\n", + " time_series = data[\"Time Series (Daily)\"]\n", + " sorted_dates = sorted(time_series.keys(), reverse=True)\n", + " latest_date = sorted_dates[0]\n", + " start_of_year = f\"{datetime.now().year}-01-01\"\n", + "\n", + " if start_of_year not in sorted_dates:\n", + " print(f\"Error: Data for {start_of_year} not found for {symbol}\")\n", + " return\n", + "\n", + " latest_close = float(time_series[latest_date][\"4. close\"])\n", + " start_of_year_close = float(time_series[start_of_year][\"4. close\"])\n", + " ytd_gain = ((latest_close - start_of_year_close) / start_of_year_close) * 100\n", + "\n", + " return ytd_gain\n", + "\n", + "print(\"YTD gain for the 10 largest technology companies:\")\n", + "for symbol in stock_symbols:\n", + " ytd_gain = get_ytd_gain(symbol)\n", + " if ytd_gain is not None:\n", + " print(f\"{symbol}: {ytd_gain:.2f}%\")\n", + "```\n", + "\n", + "This code will print the YTD gain for each of the 10 largest technology companies.\n", + "\n", + "--------------------------------------------------------------------------------\n", + "\u001b[31m\n", + ">>>>>>>> USING AUTO REPLY...\u001b[0m\n", + "\u001b[31m\n", + ">>>>>>>> EXECUTING CODE BLOCK 0 (inferred language is python)...\u001b[0m\n", + "\u001b[33muser_proxy\u001b[0m (to assistant):\n", + "\n", + "exitcode: 0 (execution succeeded)\n", + "Code output: \n", + "YTD gain for the 10 largest technology companies:\n", + "Error fetching data for AAPL: Unknown error\n", + "Error fetching data for MSFT: Unknown error\n", + "Error fetching data for GOOGL: Unknown error\n", + "Error fetching data for AMZN: Unknown error\n", + "Error fetching data for FB: Unknown error\n", + "Error fetching data for NVDA: Unknown error\n", + "Error fetching data for TSLA: Unknown error\n", + "Error fetching data for ADBE: Unknown error\n", + "Error fetching data for PYPL: Unknown error\n", + "Error fetching data for CSCO: Unknown error\n", + "\n", + "\n", + "--------------------------------------------------------------------------------\n", + "\u001b[33massistant\u001b[0m (to user_proxy):\n", + "\n", + "I apologize for the issues with fetching the YTD gain using the Alpha Vantage API. It seems there might be a problem with the API or the API key. As an alternative, we can use the Yahoo Finance API to fetch the YTD gain for each company.\n", + "\n", + "Please install the `yfinance` package using the following command:\n", "\n", "```sh\n", "pip install yfinance\n", "```\n", "\n", - "After installing the library, please execute the following Python code:\n", + "After installing the package, execute the following Python code to fetch the YTD gain for each of the 10 largest technology companies:\n", "\n", "```python\n", "import yfinance as yf\n", - "import datetime\n", + "from datetime import datetime\n", "\n", - "top_tech_companies = [\n", - " \"AAPL\", \"MSFT\", \"GOOGL\", \"GOOG\", \"AMZN\", \"FB\", \"TSLA\", \"NVDA\", \"ASML\", \"ADBE\"\n", - "]\n", + "stock_symbols = [\"AAPL\", \"MSFT\", \"GOOGL\", \"AMZN\", \"FB\", \"NVDA\", \"TSLA\", \"ADBE\", \"PYPL\", \"CSCO\"]\n", "\n", "def get_ytd_gain(symbol):\n", - " today = datetime.date.today()\n", - " start_date = datetime.date(today.year, 1, 1)\n", - " stock = yf.Ticker(symbol)\n", - " data = stock.history(start=start_date, end=today)\n", - " ytd_gain = (data[\"Close\"].iloc[-1] - data[\"Close\"].iloc[0]) / data[\"Close\"].iloc[0] * 100\n", + " start_of_year = f\"{datetime.now().year}-01-01\"\n", + " stock_data = yf.download(symbol, start=start_of_year)\n", + " if stock_data.empty:\n", + " print(f\"Error fetching data for {symbol}\")\n", + " return\n", + "\n", + " latest_close = stock_data.iloc[-1][\"Close\"]\n", + " start_of_year_close = stock_data.iloc[0][\"Close\"]\n", + " ytd_gain = ((latest_close - start_of_year_close) / start_of_year_close) * 100\n", + "\n", " return ytd_gain\n", "\n", - "ytd_gains = {symbol: get_ytd_gain(symbol) for symbol in top_tech_companies}\n", - "\n", - "for symbol, gain in ytd_gains.items():\n", - " print(f\"{symbol}: {gain:.2f}%\")\n", + "print(\"YTD gain for the 10 largest technology companies:\")\n", + "for symbol in stock_symbols:\n", + " ytd_gain = get_ytd_gain(symbol)\n", + " if ytd_gain is not None:\n", + " print(f\"{symbol}: {ytd_gain:.2f}%\")\n", "```\n", "\n", - "This code uses a predefined list of the 10 largest technology companies and calculates their YTD gains using the Yahoo Finance library.\n", + "This code will print the YTD gain for each of the 10 largest technology companies.\n", "\n", "--------------------------------------------------------------------------------\n", "\u001b[31m\n", ">>>>>>>> USING AUTO REPLY...\u001b[0m\n", + "\u001b[31m\n", + ">>>>>>>> EXECUTING CODE BLOCK 0 (inferred language is sh)...\u001b[0m\n", + "\u001b[31m\n", + ">>>>>>>> EXECUTING CODE BLOCK 1 (inferred language is python)...\u001b[0m\n", "\u001b[33muser_proxy\u001b[0m (to assistant):\n", "\n", - "exitcode: 1 (execution failed)\n", + "exitcode: 0 (execution succeeded)\n", "Code output: \n", "Defaulting to user installation because normal site-packages is not writeable\n", "Requirement already satisfied: yfinance in /home/vscode/.local/lib/python3.9/site-packages (0.2.26)\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: pandas>=1.3.0 in /home/vscode/.local/lib/python3.9/site-packages (from yfinance) (1.3.3)\n", - "Requirement already satisfied: beautifulsoup4>=4.11.1 in /home/vscode/.local/lib/python3.9/site-packages (from yfinance) (4.12.2)\n", - "Requirement already satisfied: html5lib>=1.1 in /home/vscode/.local/lib/python3.9/site-packages (from yfinance) (1.1)\n", - "Requirement already satisfied: pytz>=2022.5 in /home/vscode/.local/lib/python3.9/site-packages (from yfinance) (2023.3)\n", - "Requirement already satisfied: appdirs>=1.4.4 in /home/vscode/.local/lib/python3.9/site-packages (from yfinance) (1.4.4)\n", - "Requirement already satisfied: lxml>=4.9.1 in /home/vscode/.local/lib/python3.9/site-packages (from yfinance) (4.9.3)\n", - "Requirement already satisfied: requests>=2.31 in /usr/local/lib/python3.9/site-packages (from yfinance) (2.31.0)\n", "Requirement already satisfied: frozendict>=2.3.4 in /home/vscode/.local/lib/python3.9/site-packages (from yfinance) (2.3.8)\n", + "Requirement already satisfied: 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: pytz>=2022.5 in /home/vscode/.local/lib/python3.9/site-packages (from yfinance) (2023.3)\n", + "Requirement already satisfied: html5lib>=1.1 in /home/vscode/.local/lib/python3.9/site-packages (from yfinance) (1.1)\n", + "Requirement already satisfied: numpy>=1.16.5 in /home/vscode/.local/lib/python3.9/site-packages (from yfinance) (1.25.1)\n", "Requirement already satisfied: multitasking>=0.0.7 in /home/vscode/.local/lib/python3.9/site-packages (from yfinance) (0.0.11)\n", + "Requirement already satisfied: lxml>=4.9.1 in /home/vscode/.local/lib/python3.9/site-packages (from yfinance) (4.9.3)\n", + "Requirement already satisfied: pandas>=1.3.0 in /home/vscode/.local/lib/python3.9/site-packages (from yfinance) (1.3.3)\n", + "Requirement already satisfied: requests>=2.31 in /usr/local/lib/python3.9/site-packages (from yfinance) (2.31.0)\n", "Requirement already satisfied: 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: six>=1.9 in /usr/local/lib/python3.9/site-packages (from html5lib>=1.1->yfinance) (1.16.0)\n", "Requirement already satisfied: python-dateutil>=2.7.3 in /home/vscode/.local/lib/python3.9/site-packages (from pandas>=1.3.0->yfinance) (2.8.2)\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: urllib3<3,>=1.21.1 in /usr/local/lib/python3.9/site-packages (from requests>=2.31->yfinance) (2.0.3)\n", + "Requirement already satisfied: certifi>=2017.4.17 in /usr/local/lib/python3.9/site-packages (from requests>=2.31->yfinance) (2023.5.7)\n", "Requirement already satisfied: charset-normalizer<4,>=2 in /usr/local/lib/python3.9/site-packages (from requests>=2.31->yfinance) (3.2.0)\n", "\n", - "FB: No timezone found, symbol may be delisted\n", - "Traceback (most recent call last):\n", - " File \"/workspaces/FLAML/notebook/web/tmp_code_52c69e134e808cf8ba196ac60faede00.py\", line 16, in \n", - " ytd_gains = {symbol: get_ytd_gain(symbol) for symbol in top_tech_companies}\n", - " File \"/workspaces/FLAML/notebook/web/tmp_code_52c69e134e808cf8ba196ac60faede00.py\", line 16, in \n", - " ytd_gains = {symbol: get_ytd_gain(symbol) for symbol in top_tech_companies}\n", - " File \"/workspaces/FLAML/notebook/web/tmp_code_52c69e134e808cf8ba196ac60faede00.py\", line 13, in get_ytd_gain\n", - " ytd_gain = (data[\"Close\"].iloc[-1] - data[\"Close\"].iloc[0]) / data[\"Close\"].iloc[0] * 100\n", - " File \"/home/vscode/.local/lib/python3.9/site-packages/pandas/core/indexing.py\", line 931, in __getitem__\n", - " return self._getitem_axis(maybe_callable, axis=axis)\n", - " File \"/home/vscode/.local/lib/python3.9/site-packages/pandas/core/indexing.py\", line 1566, in _getitem_axis\n", - " self._validate_integer(key, axis)\n", - " File \"/home/vscode/.local/lib/python3.9/site-packages/pandas/core/indexing.py\", line 1500, in _validate_integer\n", - " raise IndexError(\"single positional indexer is out-of-bounds\")\n", - "IndexError: single positional indexer is out-of-bounds\n", + "YTD gain for the 10 largest technology companies:\n", + "[*********************100%***********************] 1 of 1 completed\n", + "AAPL: 42.81%\n", + "[*********************100%***********************] 1 of 1 completed\n", + "MSFT: 34.81%\n", + "[*********************100%***********************] 1 of 1 completed\n", + "GOOGL: 45.74%\n", + "[*********************100%***********************] 1 of 1 completed\n", + "AMZN: 55.28%\n", + "[*********************100%***********************] 1 of 1 completed\n", + "Error fetching data for FB\n", + "[*********************100%***********************] 1 of 1 completed\n", + "NVDA: 221.47%\n", + "[*********************100%***********************] 1 of 1 completed\n", + "TSLA: 120.71%\n", + "[*********************100%***********************] 1 of 1 completed\n", + "ADBE: 55.84%\n", + "[*********************100%***********************] 1 of 1 completed\n", + "PYPL: -17.95%\n", + "[*********************100%***********************] 1 of 1 completed\n", + "CSCO: 16.19%\n", "\n", "\n", "--------------------------------------------------------------------------------\n", "\u001b[33massistant\u001b[0m (to user_proxy):\n", "\n", - "I apologize for the error. It seems that there is an issue with the data for the \"FB\" symbol. Let's add a try-except block to handle this issue. Please execute the following Python code:\n", + "Great! The code has successfully fetched the YTD gain for the 10 largest technology companies. Here are the results:\n", "\n", - "```python\n", - "import yfinance as yf\n", - "import datetime\n", + "1. Apple Inc. (AAPL): 42.81%\n", + "2. Microsoft Corporation (MSFT): 34.81%\n", + "3. Alphabet Inc. (GOOGL): 45.74%\n", + "4. Amazon.com, Inc. (AMZN): 55.28%\n", + "5. Meta Platforms, Inc. (FB): Error fetching data\n", + "6. NVIDIA Corporation (NVDA): 221.47%\n", + "7. Tesla, Inc. (TSLA): 120.71%\n", + "8. Adobe Inc. (ADBE): 55.84%\n", + "9. PayPal Holdings, Inc. (PYPL): -17.95%\n", + "10. Cisco Systems, Inc. (CSCO): 16.19%\n", "\n", - "top_tech_companies = [\n", - " \"AAPL\", \"MSFT\", \"GOOGL\", \"GOOG\", \"AMZN\", \"FB\", \"TSLA\", \"NVDA\", \"ASML\", \"ADBE\"\n", - "]\n", + "Please note that there was an error fetching data for Meta Platforms, Inc. (FB). This might be due to a temporary issue with the Yahoo Finance API or a change in the stock symbol.\n", "\n", - "def get_ytd_gain(symbol):\n", - " try:\n", - " today = datetime.date.today()\n", - " start_date = datetime.date(today.year, 1, 1)\n", - " stock = yf.Ticker(symbol)\n", - " data = stock.history(start=start_date, end=today)\n", - " ytd_gain = (data[\"Close\"].iloc[-1] - data[\"Close\"].iloc[0]) / data[\"Close\"].iloc[0] * 100\n", - " return ytd_gain\n", - " except Exception as e:\n", - " print(f\"Error fetching data for {symbol}: {e}\")\n", - " return None\n", - "\n", - "ytd_gains = {symbol: get_ytd_gain(symbol) for symbol in top_tech_companies}\n", - "\n", - "for symbol, gain in ytd_gains.items():\n", - " if gain is not None:\n", - " print(f\"{symbol}: {gain:.2f}%\")\n", - " else:\n", - " print(f\"{symbol}: Data not available\")\n", - "```\n", - "\n", - "This code adds error handling to the `get_ytd_gain` function, so if there is an issue with a specific symbol, it will print an error message and continue with the remaining symbols.\n", + "If you have any further questions or need assistance with another task, feel free to ask. Otherwise, if everything is done, you can reply with \"TERMINATE\" to end this session.\n", "\n", "--------------------------------------------------------------------------------\n", "\u001b[31m\n", ">>>>>>>> USING AUTO REPLY...\u001b[0m\n", "\u001b[33muser_proxy\u001b[0m (to assistant):\n", "\n", - "exitcode: 0 (execution succeeded)\n", - "Code output: \n", - "Error fetching data for FB: single positional indexer is out-of-bounds\n", - "AAPL: 57.03%\n", - "MSFT: 41.90%\n", - "GOOGL: 48.77%\n", - "GOOG: 48.28%\n", - "AMZN: 54.06%\n", - "FB: Data not available\n", - "TSLA: 146.48%\n", - "NVDA: 226.67%\n", - "ASML: 31.38%\n", - "ADBE: 56.97%\n", - "\n", - "\n", - "--------------------------------------------------------------------------------\n", - "\u001b[33massistant\u001b[0m (to user_proxy):\n", - "\n", - "I'm glad the code executed successfully. Here are the YTD gains for the 10 largest technology companies, except for Facebook (FB), for which data is not available:\n", - "\n", - "- AAPL: 57.03%\n", - "- MSFT: 41.90%\n", - "- GOOGL: 48.77%\n", - "- GOOG: 48.28%\n", - "- AMZN: 54.06%\n", - "- TSLA: 146.48%\n", - "- NVDA: 226.67%\n", - "- ASML: 31.38%\n", - "- ADBE: 56.97%\n", - "\n", - "Please note that these values are subject to change as the market fluctuates. If you need updated values, you can re-run the code.\n", - "\n", "TERMINATE\n", "\n", - "--------------------------------------------------------------------------------\n", - "\u001b[33muser_proxy\u001b[0m (to assistant):\n", - "\n", - "FB->META\n", - "\n", - "--------------------------------------------------------------------------------\n", - "\u001b[33massistant\u001b[0m (to user_proxy):\n", - "\n", - "I apologize for the confusion. Facebook has changed its stock symbol from \"FB\" to \"META\" due to the company's rebranding. Let's update the code with the new symbol and execute it again:\n", - "\n", - "```python\n", - "import yfinance as yf\n", - "import datetime\n", - "\n", - "top_tech_companies = [\n", - " \"AAPL\", \"MSFT\", \"GOOGL\", \"GOOG\", \"AMZN\", \"META\", \"TSLA\", \"NVDA\", \"ASML\", \"ADBE\"\n", - "]\n", - "\n", - "def get_ytd_gain(symbol):\n", - " try:\n", - " today = datetime.date.today()\n", - " start_date = datetime.date(today.year, 1, 1)\n", - " stock = yf.Ticker(symbol)\n", - " data = stock.history(start=start_date, end=today)\n", - " ytd_gain = (data[\"Close\"].iloc[-1] - data[\"Close\"].iloc[0]) / data[\"Close\"].iloc[0] * 100\n", - " return ytd_gain\n", - " except Exception as e:\n", - " print(f\"Error fetching data for {symbol}: {e}\")\n", - " return None\n", - "\n", - "ytd_gains = {symbol: get_ytd_gain(symbol) for symbol in top_tech_companies}\n", - "\n", - "for symbol, gain in ytd_gains.items():\n", - " if gain is not None:\n", - " print(f\"{symbol}: {gain:.2f}%\")\n", - " else:\n", - " print(f\"{symbol}: Data not available\")\n", - "```\n", - "\n", - "This code replaces \"FB\" with \"META\" in the list of top technology companies and calculates the YTD gains for the updated list.\n", - "\n", - "--------------------------------------------------------------------------------\n", - "\u001b[31m\n", - ">>>>>>>> USING AUTO REPLY...\u001b[0m\n", - "\u001b[33muser_proxy\u001b[0m (to assistant):\n", - "\n", - "exitcode: 0 (execution succeeded)\n", - "Code output: \n", - "AAPL: 57.03%\n", - "MSFT: 41.90%\n", - "GOOGL: 48.77%\n", - "GOOG: 48.28%\n", - "AMZN: 54.06%\n", - "META: 160.93%\n", - "TSLA: 146.48%\n", - "NVDA: 226.67%\n", - "ASML: 31.38%\n", - "ADBE: 56.97%\n", - "\n", - "\n", - "--------------------------------------------------------------------------------\n", - "\u001b[33massistant\u001b[0m (to user_proxy):\n", - "\n", - "Great! The code executed successfully, and here are the updated YTD gains for the 10 largest technology companies, including Meta Platforms (formerly Facebook):\n", - "\n", - "- AAPL: 57.03%\n", - "- MSFT: 41.90%\n", - "- GOOGL: 48.77%\n", - "- GOOG: 48.28%\n", - "- AMZN: 54.06%\n", - "- META: 160.93%\n", - "- TSLA: 146.48%\n", - "- NVDA: 226.67%\n", - "- ASML: 31.38%\n", - "- ADBE: 56.97%\n", - "\n", - "Please note that these values are subject to change as the market fluctuates. If you need updated values, you can re-run the code.\n", - "\n", - "TERMINATE\n", - "\n", - "--------------------------------------------------------------------------------\n", - "\u001b[31m\n", - ">>>>>>>> NO HUMAN INPUT RECEIVED.\u001b[0m\n" + "--------------------------------------------------------------------------------\n" ] } ],