A programming framework for agentic AI
Prompt improvement (#1203)
Chi Wang44932712c450
diff --git a/flaml/autogen/agentchat/assistant_agent.py b/flaml/autogen/agentchat/assistant_agent.pyindex 7ef9ca999..85fb93a90 100644--- a/flaml/autogen/agentchat/assistant_agent.py+++ b/flaml/autogen/agentchat/assistant_agent.py@@ -14,16 +14,16 @@ class AssistantAgent(ResponsiveAgent):"""DEFAULT_SYSTEM_MESSAGE = """You are a helpful AI assistant.- 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.+Solve tasks using your coding and language skills.+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: <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.- Reply "TERMINATE" in the end when everything is done.+ 2. When you need to perform some task with code, use the code to perform the task and output the result. Finish the task smartly.+Solve the task step by step if you need to. If a plan is not provided, explain your plan first. Be clear which step uses code, and which step uses your language skill.+When using code, 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: <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. Include verifiable evidence in your response if possible.+Reply "TERMINATE" in the end when everything is done."""def __init__(diff --git a/flaml/autogen/agentchat/responsive_agent.py b/flaml/autogen/agentchat/responsive_agent.pyindex 00fb4ad30..0884b8891 100644--- a/flaml/autogen/agentchat/responsive_agent.py+++ b/flaml/autogen/agentchat/responsive_agent.py@@ -895,10 +895,11 @@ class ResponsiveAgent(Agent):exitcode, logs, image = (1,f"unknown language {lang}",- self._code_execution_config["use_docker"],+ None,)# raise NotImplementedError- self._code_execution_config["use_docker"] = image+ if image is not None:+ self._code_execution_config["use_docker"] = imagelogs_all += "\n" + logsif exitcode != 0:return exitcode, logs_alldiff --git a/flaml/version.py b/flaml/version.pyindex 159d48b87..0309ae290 100644--- a/flaml/version.py+++ b/flaml/version.py@@ -1 +1 @@-__version__ = "2.0.1"+__version__ = "2.0.2"diff --git a/notebook/autogen_agentchat_auto_feedback_from_code_execution.ipynb b/notebook/autogen_agentchat_auto_feedback_from_code_execution.ipynbindex 72c5e9926..5f5c7f4fe 100644--- a/notebook/autogen_agentchat_auto_feedback_from_code_execution.ipynb+++ b/notebook/autogen_agentchat_auto_feedback_from_code_execution.ipynb@@ -45,7 +45,7 @@},"outputs": [],"source": [- "# %pip install flaml[autogen]~=2.0.1"+ "# %pip install flaml[autogen]~=2.0.2"]},{@@ -136,91 +136,190 @@"--------------------------------------------------------------------------------\n","\u001b[33massistant\u001b[0m (to user_proxy):\n","\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",+ "First, let's find out today's date. Then, we will fetch the stock prices for META (Facebook) and TESLA and calculate the year-to-date gain for both.\n","\n",+ "Step 1: Get today's date\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",+ "from datetime import date\n",+ "today = date.today()\n",+ "print(\"Today's date:\", today)\n","```\n","\n",- "Please install the yfinance module if it's not installed yet. You can install it using pip:\n",+ "Step 2: Fetch stock prices for META and TESLA\n",+ "We will use the `yfinance` library to fetch the stock prices. If you don't have it installed, please install it using the following command:\n","\n","```sh\n",- "# sh code\n","pip install yfinance\n","```\n","\n",- "After running the Python code, you will get the current date and the YTD gain for META and TESLA.\n",+ "Step 3: Calculate the year-to-date gain for META and TESLA\n",+ "```python\n",+ "import yfinance as yf\n",+ "from datetime import datetime\n",+ "\n",+ "def get_ytd_gain(ticker):\n",+ " stock = yf.Ticker(ticker)\n",+ " start_date = datetime(today.year, 1, 1)\n",+ " end_date = today\n",+ " historical_data = stock.history(start=start_date, end=end_date)\n",+ " start_price = historical_data.iloc[0]['Close']\n",+ " end_price = historical_data.iloc[-1]['Close']\n",+ " ytd_gain = (end_price - start_price) / start_price * 100\n",+ " return ytd_gain\n",+ "\n",+ "meta_ytd_gain = get_ytd_gain(\"FB\")\n",+ "tesla_ytd_gain = get_ytd_gain(\"TSLA\")\n",+ "\n",+ "print(f\"Year-to-date gain for META (Facebook): {meta_ytd_gain:.2f}%\")\n",+ "print(f\"Year-to-date gain for TESLA: {tesla_ytd_gain:.2f}%\")\n",+ "```\n",+ "\n",+ "Please execute the code blocks in the order mentioned above.\n","\n","--------------------------------------------------------------------------------\n","\u001b[31m\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",+ "\u001b[31m\n",+ ">>>>>>>> EXECUTING CODE BLOCK 2 (inferred language is python)...\u001b[0m\n","\u001b[33muser_proxy\u001b[0m (to assistant):\n","\n",- "exitcode: 0 (execution succeeded)\n",+ "exitcode: 1 (execution failed)\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",+ "Today's date: 2023-08-29\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: 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: 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: lxml>=4.9.1 in /home/vscode/.local/lib/python3.9/site-packages (from yfinance) (4.9.3)\n","Requirement already satisfied: pytz>=2022.5 in /home/vscode/.local/lib/python3.9/site-packages (from yfinance) (2023.3)\n","Requirement already satisfied: 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: multitasking>=0.0.7 in /home/vscode/.local/lib/python3.9/site-packages (from yfinance) (0.0.11)\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: pandas>=1.3.0 in /home/vscode/.local/lib/python3.9/site-packages (from yfinance) (1.3.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: 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: webencodings in /home/vscode/.local/lib/python3.9/site-packages (from html5lib>=1.1->yfinance) (0.5.1)\n","Requirement already satisfied: python-dateutil>=2.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: 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: urllib3<3,>=1.21.1 in /usr/local/lib/python3.9/site-packages (from requests>=2.31->yfinance) (2.0.3)\n","Requirement already satisfied: idna<4,>=2.5 in /usr/local/lib/python3.9/site-packages (from requests>=2.31->yfinance) (3.4)\n","\n",+ "Traceback (most recent call last):\n",+ " File \"\", line 14, in <module>\n",+ " meta_ytd_gain = get_ytd_gain(\"FB\")\n",+ " File \"\", line 6, in get_ytd_gain\n",+ " start_date = datetime(today.year, 1, 1)\n",+ "NameError: name 'today' is not defined\n",+ "\n",+ "\n",+ "--------------------------------------------------------------------------------\n",+ "\u001b[33massistant\u001b[0m (to user_proxy):\n",+ "\n",+ "Apologies for the error. It seems I forgot to include the `today` variable in the last code block. Here's the corrected code:\n",+ "\n",+ "```python\n",+ "import yfinance as yf\n",+ "from datetime import datetime, date\n",+ "\n",+ "today = date.today()\n",+ "\n",+ "def get_ytd_gain(ticker):\n",+ " stock = yf.Ticker(ticker)\n",+ " start_date = datetime(today.year, 1, 1)\n",+ " end_date = today\n",+ " historical_data = stock.history(start=start_date, end=end_date)\n",+ " start_price = historical_data.iloc[0]['Close']\n",+ " end_price = historical_data.iloc[-1]['Close']\n",+ " ytd_gain = (end_price - start_price) / start_price * 100\n",+ " return ytd_gain\n",+ "\n",+ "meta_ytd_gain = get_ytd_gain(\"FB\")\n",+ "tesla_ytd_gain = get_ytd_gain(\"TSLA\")\n",+ "\n",+ "print(f\"Year-to-date gain for META (Facebook): {meta_ytd_gain:.2f}%\")\n",+ "print(f\"Year-to-date gain for TESLA: {tesla_ytd_gain:.2f}%\")\n",+ "```\n",+ "\n",+ "Please execute this code block to get the year-to-date gain for META and TESLA.\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: 1 (execution failed)\n",+ "Code output: \n",+ "FB: No timezone found, symbol may be delisted\n",+ "Traceback (most recent call last):\n",+ " File \"\", line 16, in <module>\n",+ " meta_ytd_gain = get_ytd_gain(\"FB\")\n",+ " File \"\", line 11, in get_ytd_gain\n",+ " start_price = historical_data.iloc[0]['Close']\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",+ "\n","\n","--------------------------------------------------------------------------------\n","\u001b[33massistant\u001b[0m (to user_proxy):\n","\n",- "Great! The code has been executed successfully. \n",+ "I apologize for the error. It seems that the \"FB\" ticker symbol is not working as expected. Facebook has changed its parent company name to Meta Platforms, Inc., and its ticker symbol has been changed to \"META\". Let's update the code to use the new ticker symbol:\n",+ "\n",+ "```python\n",+ "import yfinance as yf\n",+ "from datetime import datetime, date\n","\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",+ "today = date.today()\n","\n",- "Please let me know if you need help with anything else.\n",+ "def get_ytd_gain(ticker):\n",+ " stock = yf.Ticker(ticker)\n",+ " start_date = datetime(today.year, 1, 1)\n",+ " end_date = today\n",+ " historical_data = stock.history(start=start_date, end=end_date)\n",+ " start_price = historical_data.iloc[0]['Close']\n",+ " end_price = historical_data.iloc[-1]['Close']\n",+ " ytd_gain = (end_price - start_price) / start_price * 100\n",+ " return ytd_gain\n",+ "\n",+ "meta_ytd_gain = get_ytd_gain(\"META\")\n",+ "tesla_ytd_gain = get_ytd_gain(\"TSLA\")\n",+ "\n",+ "print(f\"Year-to-date gain for META (Facebook): {meta_ytd_gain:.2f}%\")\n",+ "print(f\"Year-to-date gain for TESLA: {tesla_ytd_gain:.2f}%\")\n",+ "```\n",+ "\n",+ "Please execute this updated code block to get the year-to-date gain for META and TESLA.\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",+ "Year-to-date gain for META (Facebook): 132.69%\n",+ "Year-to-date gain for TESLA: 120.93%\n",+ "\n",+ "\n",+ "--------------------------------------------------------------------------------\n",+ "\u001b[33massistant\u001b[0m (to user_proxy):\n",+ "\n",+ "Great! The code executed successfully. Here are the year-to-date gains for META (Facebook) and TESLA:\n",+ "\n",+ "- Year-to-date gain for META (Facebook): 132.69%\n",+ "- Year-to-date gain for TESLA: 120.93%\n",+ "\n",+ "Please note that these values are based on the stock market data at the time of execution and may change as the market fluctuates.\n","\n","TERMINATE\n","\n",@@ -290,99 +389,87 @@"--------------------------------------------------------------------------------\n","\u001b[33massistant\u001b[0m (to user_proxy):\n","\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",+ "To plot the chart and save it as an image, we will use the `matplotlib` library. If you don't have it installed, please install it using the following command:\n","\n","```sh\n",- "# sh code\n","pip install matplotlib\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: 1 (execution failed)\n",- "Code output: \n",- "Traceback (most recent call last):\n",- " File \"\", line 7, in <module>\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 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",+ "Now, let's plot the chart of the stock price change YTD for META and TESLA and save it to a file named \"stock_price_ytd.png\":\n","\n","```python\n",- "# python code\n",- "# filename: plot_stock_price.py\n",- "import matplotlib.pyplot as plt\n",+ "# filename: plot_stock_price_ytd.py\n",+ "\n","import yfinance as yf\n",+ "import matplotlib.pyplot as plt\n",+ "from datetime import datetime, date\n",+ "\n",+ "today = date.today()\n","\n",- "# Get the stock data for META and TESLA\n",- "meta = yf.Ticker(\"META\")\n",- "tesla = yf.Ticker(\"TSLA\")\n",+ "def get_stock_data(ticker):\n",+ " stock = yf.Ticker(ticker)\n",+ " start_date = datetime(today.year, 1, 1)\n",+ " end_date = today\n",+ " historical_data = stock.history(start=start_date, end=end_date)\n",+ " return historical_data\n","\n",- "# Get the historical market data\n",- "meta_hist = meta.history(period=\"ytd\")\n",- "tesla_hist = tesla.history(period=\"ytd\")\n",+ "meta_data = get_stock_data(\"META\")\n",+ "tesla_data = get_stock_data(\"TSLA\")\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.figure(figsize=(12, 6))\n",+ "plt.plot(meta_data.index, meta_data['Close'], label='META (Facebook)')\n",+ "plt.plot(tesla_data.index, tesla_data['Close'], label='TESLA')\n","plt.xlabel('Date')\n",- "plt.ylabel('Closing Price')\n",+ "plt.ylabel('Stock Price')\n",+ "plt.title('Stock Price Change YTD for META and TESLA')\n","plt.legend()\n",- "\n",- "# Save the plot to a file\n","plt.savefig('stock_price_ytd.png')\n",+ "plt.show()\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",+ "Please save the above code in a file named \"plot_stock_price_ytd.py\" and execute it using the following command:\n",+ "\n",+ "```sh\n",+ "python plot_stock_price_ytd.py\n",+ "```\n",+ "\n",+ "This will create a chart of the stock price change YTD for META and TESLA and save it as \"stock_price_ytd.png\" in the same directory where the script is located.\n","\n","--------------------------------------------------------------------------------\n","\u001b[31m\n",- ">>>>>>>> EXECUTING CODE BLOCK 0 (inferred language is python)...\u001b[0m\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[31m\n",+ ">>>>>>>> EXECUTING CODE BLOCK 2 (inferred language is sh)...\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: matplotlib in /home/vscode/.local/lib/python3.9/site-packages (3.7.2)\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: kiwisolver>=1.0.1 in /home/vscode/.local/lib/python3.9/site-packages (from matplotlib) (1.4.4)\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: pillow>=6.2.0 in /home/vscode/.local/lib/python3.9/site-packages (from matplotlib) (10.0.0)\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: pyparsing<3.1,>=2.3.1 in /home/vscode/.local/lib/python3.9/site-packages (from matplotlib) (3.0.9)\n",+ "Requirement already satisfied: packaging>=20.0 in /home/vscode/.local/lib/python3.9/site-packages (from matplotlib) (23.1)\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: 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",+ "Figure(1200x600)\n","\n",- "--------------------------------------------------------------------------------\n",- "\u001b[33massistant\u001b[0m (to user_proxy):\n",+ "Figure(1200x600)\n","\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",- "You can now view this image file to see the plotted chart.\n",+ "--------------------------------------------------------------------------------\n",+ "\u001b[33massistant\u001b[0m (to user_proxy):\n","\n",- "Please let me know if you need help with anything else.\n",+ "Great! The code executed successfully, and the chart of the stock price change YTD for META and TESLA has been saved as \"stock_price_ytd.png\" in the same directory where the script is located. You can now view the chart by opening the \"stock_price_ytd.png\" file.\n","\n","TERMINATE\n","\n",@@ -413,7 +500,7 @@"outputs": [{"data": {- "image/png": "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",+ "image/png": "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","text/plain": ["<IPython.core.display.Image object>"]@@ -499,94 +586,72 @@"text": ["\u001b[33mipython_user_proxy\u001b[0m (to assistant):\n","\n",- "What date is today? Plot a chart of META and TESLA stock price change YTD 2023\n",+ "Plot a chart of META and TESLA stock price gain YTD\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",- "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",+ "First, we need to install the necessary libraries to fetch stock data and plot the chart. Please execute the following code to install the required libraries:\n","\n","```python\n",- "# python code\n",- "import datetime\n",- "\n",- "# Get the current date\n",- "current_date = datetime.date.today()\n",- "\n",- "print(\"Today's date is:\", current_date)\n",+ "!pip install yfinance matplotlib\n","```\n","\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",- "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",- "```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",+ "After installing the libraries, execute the following code to fetch the stock data and plot the chart:\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 year\n",- "current_year = datetime.date.today().year\n",+ "# Get the current date\n",+ "today = datetime.date.today()\n",+ "\n",+ "# Calculate the start date for YTD\n",+ "start_date = datetime.date(today.year, 1, 1)\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",+ "# Fetch stock data for META (Facebook) and TESLA\n",+ "meta = yf.download('FB', start=start_date, end=today)\n",+ "tesla = yf.download('TSLA', start=start_date, end=today)\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",+ "# Calculate the percentage gain for each stock\n",+ "meta['Gain'] = (meta['Close'] / meta['Close'][0]) * 100\n",+ "tesla['Gain'] = (tesla['Close'] / tesla['Close'][0]) * 100\n",+ "\n",+ "# Plot the chart\n",+ "plt.figure(figsize=(12, 6))\n",+ "plt.plot(meta.index, meta['Gain'], label='META (Facebook)')\n",+ "plt.plot(tesla.index, tesla['Gain'], label='TESLA')\n","plt.xlabel('Date')\n",- "plt.ylabel('Price (USD)')\n",+ "plt.ylabel('Percentage Gain YTD')\n",+ "plt.title('META (Facebook) vs TESLA Stock Price Gain YTD')\n","plt.legend()\n",- "plt.grid(True)\n",+ "plt.grid()\n","plt.show()\n","```\n","\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",+ "This code will fetch the stock data for META (Facebook) and TESLA from the start of the year to the current date, calculate the percentage gain, and plot the chart.\n","\n","--------------------------------------------------------------------------------\n","\u001b[31m\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"+ ">>>>>>>> EXECUTING CODE BLOCK 1 (inferred language is python)...\u001b[0m\n"]},{- "ename": "SyntaxError",- "evalue": "invalid syntax (2367222363.py, line 2)",+ "ename": "IndexError",+ "evalue": "index 0 is out of bounds for axis 0 with size 0","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"- ]- },- {- "name": "stdout",- "output_type": "stream",- "text": [- "\u001b[31m\n",- ">>>>>>>> EXECUTING CODE BLOCK 2 (inferred language is python)...\u001b[0m\n"+ "\u001b[0;31m---------------------------------------------------------------------------\u001b[0m",+ "\u001b[0;31mIndexError\u001b[0m Traceback (most recent call last)",+ "Cell \u001b[0;32mIn[7], line 16\u001b[0m\n\u001b[1;32m 13\u001b[0m tesla \u001b[39m=\u001b[39m yf\u001b[39m.\u001b[39mdownload(\u001b[39m'\u001b[39m\u001b[39mTSLA\u001b[39m\u001b[39m'\u001b[39m, start\u001b[39m=\u001b[39mstart_date, end\u001b[39m=\u001b[39mtoday)\n\u001b[1;32m 15\u001b[0m \u001b[39m# Calculate the percentage gain for each stock\u001b[39;00m\n\u001b[0;32m---> 16\u001b[0m meta[\u001b[39m'\u001b[39m\u001b[39mGain\u001b[39m\u001b[39m'\u001b[39m] \u001b[39m=\u001b[39m (meta[\u001b[39m'\u001b[39m\u001b[39mClose\u001b[39m\u001b[39m'\u001b[39m] \u001b[39m/\u001b[39m meta[\u001b[39m'\u001b[39;49m\u001b[39mClose\u001b[39;49m\u001b[39m'\u001b[39;49m][\u001b[39m0\u001b[39;49m]) \u001b[39m*\u001b[39m \u001b[39m100\u001b[39m\n\u001b[1;32m 17\u001b[0m tesla[\u001b[39m'\u001b[39m\u001b[39mGain\u001b[39m\u001b[39m'\u001b[39m] \u001b[39m=\u001b[39m (tesla[\u001b[39m'\u001b[39m\u001b[39mClose\u001b[39m\u001b[39m'\u001b[39m] \u001b[39m/\u001b[39m tesla[\u001b[39m'\u001b[39m\u001b[39mClose\u001b[39m\u001b[39m'\u001b[39m][\u001b[39m0\u001b[39m]) \u001b[39m*\u001b[39m \u001b[39m100\u001b[39m\n\u001b[1;32m 19\u001b[0m \u001b[39m# Plot the chart\u001b[39;00m\n",+ "File \u001b[0;32m~/.local/lib/python3.9/site-packages/pandas/core/series.py:939\u001b[0m, in \u001b[0;36mSeries.__getitem__\u001b[0;34m(self, key)\u001b[0m\n\u001b[1;32m 936\u001b[0m key \u001b[39m=\u001b[39m unpack_1tuple(key)\n\u001b[1;32m 938\u001b[0m \u001b[39mif\u001b[39;00m is_integer(key) \u001b[39mand\u001b[39;00m \u001b[39mself\u001b[39m\u001b[39m.\u001b[39mindex\u001b[39m.\u001b[39m_should_fallback_to_positional():\n\u001b[0;32m--> 939\u001b[0m \u001b[39mreturn\u001b[39;00m \u001b[39mself\u001b[39;49m\u001b[39m.\u001b[39;49m_values[key]\n\u001b[1;32m 941\u001b[0m \u001b[39melif\u001b[39;00m key_is_scalar:\n\u001b[1;32m 942\u001b[0m \u001b[39mreturn\u001b[39;00m \u001b[39mself\u001b[39m\u001b[39m.\u001b[39m_get_value(key)\n",+ "\u001b[0;31mIndexError\u001b[0m: index 0 is out of bounds for axis 0 with size 0"]},- {- "data": {- "image/png": "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",- "text/plain": [- "<Figure size 1400x700 with 1 Axes>"- ]- },- "metadata": {},- "output_type": "display_data"- },{"name": "stdout","output_type": "stream",@@ -595,8 +660,39 @@"\n","exitcode: 0 (execution succeeded)\n","Code output: \n",- "Today's date is: 2023-08-27\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: matplotlib in /home/vscode/.local/lib/python3.9/site-packages (3.7.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: frozendict>=2.3.4 in /home/vscode/.local/lib/python3.9/site-packages (from yfinance) (2.3.8)\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: 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: 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: 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: kiwisolver>=1.0.1 in /home/vscode/.local/lib/python3.9/site-packages (from matplotlib) (1.4.4)\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: pillow>=6.2.0 in /home/vscode/.local/lib/python3.9/site-packages (from matplotlib) (10.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: fonttools>=4.22.0 in /home/vscode/.local/lib/python3.9/site-packages (from matplotlib) (4.41.1)\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: packaging>=20.0 in /home/vscode/.local/lib/python3.9/site-packages (from matplotlib) (23.1)\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: cycler>=0.10 in /home/vscode/.local/lib/python3.9/site-packages (from matplotlib) (0.11.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: 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: idna<4,>=2.5 in /usr/local/lib/python3.9/site-packages (from requests>=2.31->yfinance) (3.4)\n",+ "Requirement already satisfied: urllib3<3,>=1.21.1 in /usr/local/lib/python3.9/site-packages (from requests>=2.31->yfinance) (2.0.3)\n",+ "Requirement already satisfied: certifi>=2017.4.17 in /usr/local/lib/python3.9/site-packages (from requests>=2.31->yfinance) (2023.5.7)\n",+ "Requirement already satisfied: charset-normalizer<4,>=2 in /usr/local/lib/python3.9/site-packages (from requests>=2.31->yfinance) (3.2.0)\n","\n",+ "\u001b[1m[\u001b[0m\u001b[34;49mnotice\u001b[0m\u001b[1;39;49m]\u001b[0m\u001b[39;49m A new release of pip is available: \u001b[0m\u001b[31;49m23.0.1\u001b[0m\u001b[39;49m -> \u001b[0m\u001b[32;49m23.2.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","\n","[*********************100%***********************] 1 of 1 completed\n","[*********************100%***********************] 1 of 1 completed\n",@@ -608,33 +704,40 @@"--------------------------------------------------------------------------------\n","\u001b[33massistant\u001b[0m (to ipython_user_proxy):\n","\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",+ "It seems that there was an issue with fetching the stock data for META (Facebook) using the ticker symbol 'FB'. The stock symbol for META has been changed to 'META' recently. Let's update the code to use the new symbol and try again:\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 year\n",- "current_year = datetime.date.today().year\n",+ "# Get the current date\n",+ "today = datetime.date.today()\n",+ "\n",+ "# Calculate the start date for YTD\n",+ "start_date = datetime.date(today.year, 1, 1)\n","\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",+ "# Fetch stock data for META (Facebook) and TESLA\n",+ "meta = yf.download('META', start=start_date, end=today)\n",+ "tesla = yf.download('TSLA', start=start_date, end=today)\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",+ "# Calculate the percentage gain for each stock\n",+ "meta['Gain'] = (meta['Close'] / meta['Close'][0]) * 100\n",+ "tesla['Gain'] = (tesla['Close'] / tesla['Close'][0]) * 100\n",+ "\n",+ "# Plot the chart\n",+ "plt.figure(figsize=(12, 6))\n",+ "plt.plot(meta.index, meta['Gain'], label='META (Facebook)')\n",+ "plt.plot(tesla.index, tesla['Gain'], label='TESLA')\n","plt.xlabel('Date')\n",- "plt.ylabel('Price (USD)')\n",+ "plt.ylabel('Percentage Gain YTD')\n",+ "plt.title('META (Facebook) vs TESLA Stock Price Gain YTD')\n","plt.legend()\n",- "plt.grid(True)\n",+ "plt.grid()\n","plt.show()\n","```\n","\n",- "Please run this code to get the YTD stock price data for META and TESLA and plot it.\n",+ "Please execute the updated code to fetch the stock data and plot the chart.\n","\n","--------------------------------------------------------------------------------\n","\u001b[31m\n",@@ -643,9 +746,9 @@},{"data": {- "image/png": "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",+ "image/png": "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","text/plain": [- "<Figure size 1400x700 with 1 Axes>"+ "<Figure size 1200x600 with 1 Axes>"]},"metadata": {},@@ -666,9 +769,7 @@"--------------------------------------------------------------------------------\n","\u001b[33massistant\u001b[0m (to ipython_user_proxy):\n","\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",+ "I'm glad the code executed successfully. You should now see a chart comparing the YTD percentage gain of META (Facebook) and TESLA stocks. If you have any further questions or need assistance with another task, feel free to ask.\n","\n","TERMINATE\n","\n",@@ -686,7 +787,7 @@"# the assistant receives a message from the user, which contains the task description\n","ipy_user.initiate_chat(\n"," assistant,\n",- " message=\"\"\"What date is today? Plot a chart of META and TESLA stock price change YTD 2023\"\"\",\n",+ " message=\"\"\"Plot a chart of META and TESLA stock price gain YTD\"\"\",\n",")"]}diff --git a/notebook/autogen_agentchat_groupchat.ipynb b/notebook/autogen_agentchat_groupchat.ipynbindex 0691d8bfa..af4f1e6c7 100644--- a/notebook/autogen_agentchat_groupchat.ipynb+++ b/notebook/autogen_agentchat_groupchat.ipynb@@ -35,7 +35,7 @@"outputs": [],"source": ["%%capture --no-stderr\n",- "# %pip install flaml[autogen]~=2.0.1"+ "# %pip install flaml[autogen]~=2.0.2"]},{@@ -138,9 +138,7 @@")\n","bob = autogen.AssistantAgent(\n"," name=\"Bob\",\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",+ " system_message=\"Scientist. Provide expert knowledge.\",\n"," llm_config=llm_config,\n",")\n","groupchat = autogen.GroupChat(agents=[human, alice, bob], messages=[], max_round=12)\n",@@ -166,88 +164,62 @@"text": ["\u001b[33mHuman\u001b[0m (to chat_manager):\n","\n",- "Find a latest paper about gpt-4\n",+ "Find a latest paper about gpt-4 on arxiv and find its potential application.\n","\n","--------------------------------------------------------------------------------\n","\u001b[33mAlice\u001b[0m (to chat_manager):\n","\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",- "# 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",- "response = requests.get(url, params=params)\n",- "\n",- "# Parse the response\n",- "feeds = feedparser.parse(response.content)\n",- "\n",- "# should check if feeds.entries is empty\n",- "\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",- "You need to install requests and feedparser in your python environment, if they are not installed yet.\n",+ "To find the latest paper about GPT-4 on arxiv, I will use the arxiv API to query and filter the search results. First, I'll execute the following code to get the latest paper information.\n","\n","--------------------------------------------------------------------------------\n",- "\u001b[33mBob\u001b[0m (to chat_manager):\n",- "\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",- "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",- "Here's a suggestion on how to improve it:\n",+ "\u001b[33mAlice\u001b[0m (to chat_manager):\n","\n","```python\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",- " 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",+ "from bs4 import BeautifulSoup\n",+ "import re\n",+ "\n",+ "\n",+ "def search_arxiv(query, sort_by=\"submittedDate\", order=\"descending\", max_results=1):\n",+ " search_url = \"http://export.arxiv.org/api/query\"\n",+ " query_string = f\"search_query=all:{query.replace(' ', '+')}&sortBy={sort_by}&sortOrder={order}&max_results={max_results}\"\n",+ " url = f\"{search_url}?{query_string}\"\n",+ " response = requests.get(url)\n",+ " return response.text\n",+ "\n",+ "\n",+ "def parse_paper_info(xml_response):\n",+ " soup = BeautifulSoup(xml_response, \"lxml-xml\")\n",+ " entry = soup.find(\"entry\")\n",+ " if not entry:\n",+ " return {}\n",+ "\n",+ " paper_info = {\n",+ " \"title\": entry.find(\"title\").text.strip(),\n",+ " \"authors\": [author.text for author in entry.find_all(\"author\")],\n",+ " \"published\": entry.find(\"published\").text,\n",+ " \"updated\": entry.find(\"updated\").text,\n",+ " \"summary\": entry.find(\"summary\").text.strip(),\n",+ " \"url\": entry.find(\"id\").text,\n",+ " }\n",+ " return paper_info\n",+ "\n",+ "\n",+ "query = \"gpt-4\"\n",+ "arxiv_response = search_arxiv(query)\n",+ "paper_info = parse_paper_info(arxiv_response)\n",+ "\n",+ "if paper_info:\n",+ " print(f\"Title: {paper_info['title']}\")\n",+ " print(f\"Authors: {', '.join(paper_info['authors'])}\")\n",+ " print(f\"Published: {paper_info['published']}\")\n",+ " print(f\"Updated: {paper_info['updated']}\")\n",+ " print(f\"Abstract: {paper_info['summary']}\")\n",+ " print(f\"URL: {paper_info['url']}\")\n","else:\n",- " # Parse the response\n",- " feeds = feedparser.parse(response.content)\n",- "\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",- " # 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",+ " print(\"No papers about GPT-4 were found on arxiv.\")\n","```\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","--------------------------------------------------------------------------------\n","\u001b[31m\n",@@ -260,36 +232,56 @@"\n","exitcode: 0 (execution succeeded)\n","Code output: \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",+ "Title: Breaking the Bank with ChatGPT: Few-Shot Text Classification for Finance\n",+ "Authors: \n",+ "Lefteris Loukas\n",+ ", \n",+ "Ilias Stogiannidis\n",+ ", \n",+ "Prodromos Malakasiotis\n",+ ", \n",+ "Stavros Vassos\n",+ "\n",+ "Published: 2023-08-28T15:04:16Z\n",+ "Updated: 2023-08-28T15:04:16Z\n",+ "Abstract: We propose the use of conversational GPT models for easy and quick few-shot\n",+ "text classification in the financial domain using the Banking77 dataset. Our\n",+ "approach involves in-context learning with GPT-3.5 and GPT-4, which minimizes\n",+ "the technical expertise required and eliminates the need for expensive GPU\n",+ "computing while yielding quick and accurate results. Additionally, we fine-tune\n",+ "other pre-trained, masked language models with SetFit, a recent contrastive\n",+ "learning technique, to achieve state-of-the-art results both in full-data and\n",+ "few-shot settings. Our findings show that querying GPT-3.5 and GPT-4 can\n",+ "outperform fine-tuned, non-generative models even with fewer examples. However,\n",+ "subscription fees associated with these solutions may be considered costly for\n",+ "small organizations. Lastly, we find that generative models perform better on\n",+ "the given task when shown representative samples selected by a human expert\n",+ "rather than when shown random ones. We conclude that a) our proposed methods\n",+ "offer a practical solution for few-shot tasks in datasets with limited label\n",+ "availability, and b) our state-of-the-art results can inspire future work in\n",+ "the area.\n",+ "URL: http://arxiv.org/abs/2308.14634v1\n","\n","\n","--------------------------------------------------------------------------------\n",- "\u001b[33mAlice\u001b[0m (to chat_manager):\n",- "\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",+ "\u001b[33mBob\u001b[0m (to chat_manager):\n","\n",- "TERMINATE\n",+ "The latest paper about GPT-4 on arxiv is titled \"Breaking the Bank with ChatGPT: Few-Shot Text Classification for Finance\" by Lefteris Loukas, Ilias Stogiannidis, Prodromos Malakasiotis, and Stavros Vassos. It was published on 2023-08-28.\n","\n",- "--------------------------------------------------------------------------------\n",- "\u001b[33mBob\u001b[0m (to chat_manager):\n",+ "The potential application of GPT-4 in this paper is for few-shot text classification in the financial domain using the Banking77 dataset. The authors propose using conversational GPT models like GPT-3.5 and GPT-4 for in-context learning, which minimizes the technical expertise required and eliminates the need for expensive GPU computing while yielding quick and accurate results.\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",+ "Additionally, the paper explores fine-tuning other pre-trained, masked language models with SetFit, a recent contrastive learning technique, to achieve state-of-the-art results in both full-data and few-shot settings.\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",+ "The findings of this paper show that querying GPT-3.5 and GPT-4 can outperform fine-tuned, non-generative models even with fewer examples. However, subscription fees associated with these solutions may be considered costly for small organizations. The authors also find that generative models perform better on the given task when shown representative samples selected by a human expert rather than when shown random ones. The proposed methods offer a practical solution for few-shot tasks in datasets with limited label availability, and the state-of-the-art results can inspire future work in the area.\n","\n",- "APPROVED\n",+ "You can access the full paper [here](http://arxiv.org/abs/2308.14634v1).\n","\n","--------------------------------------------------------------------------------\n"]}],"source": [- "human.initiate_chat(manager, message=\"Find a latest paper about gpt-4\")\n",+ "human.initiate_chat(manager, message=\"Find a latest paper about gpt-4 on arxiv and find its potential application.\")\n","# type exit to terminate the chat"]}diff --git a/notebook/autogen_agentchat_human_feedback.ipynb b/notebook/autogen_agentchat_human_feedback.ipynbindex 703e87185..e37768b32 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.1"+ "# %pip install flaml[autogen]~=2.0.2"]},{@@ -191,49 +191,50 @@"--------------------------------------------------------------------------------\n","\u001b[33massistant\u001b[0m (to user_proxy):\n","\n",- "To solve this problem, we can follow these steps:\n",+ "To solve the system of linear equations, I will use NumPy library in Python to calculate the coefficients and constants and then use the linalg.solve() function to find the values of a, b, and c. Finally, I will add them up to find $a + b + c$.\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",+ "Step 1: Define the coefficients and constants\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",+ "Step 2: Solve the system of equations using NumPy\n","\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",+ "Step 3: Calculate the sum of a, b, and c\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",+ "\u001b[33muser_proxy\u001b[0m (to assistant):\n","\n",- "Please, execute the following Python code:\n",+ "use sympy\n","\n",- "```python\n",- "# SymPy is a Python library for symbolic mathematics\n",+ "--------------------------------------------------------------------------------\n",+ "\u001b[33massistant\u001b[0m (to user_proxy):\n",+ "\n",+ "Sure, I will use Sympy to solve the system of linear equations.\n",+ "\n",+ "Step 1: Import Sympy library and define the symbols\n",+ "``` python\n","from sympy import symbols, Eq, solve\n","\n",- "# defining the symbols\n",- "x, y, a, b, c = symbols('x y a b c')\n",+ "a, b, c, x, y = symbols('a b c x y')\n",+ "```\n","\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",+ "Step 2: Define the equations\n",+ "``` python\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","\n",- "# solve the system of equations\n",- "sol = solve((eq1,eq2,eq3), (a, b, c))\n",+ "Step 3: Solve the system of equations\n",+ "``` python\n",+ "solutions = solve((eq1, eq2, eq3), (a, b, c))\n",+ "```\n","\n",- "# Output the value of a + b + c\n",- "print(sol[a] + sol[b] + sol[c])\n",+ "Step 4: Calculate the sum of a, b, and c\n",+ "``` python\n",+ "a_value, b_value, c_value = solutions[a], solutions[b], solutions[c]\n",+ "sum_abc = a_value + b_value + c_value\n","```\n","\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","\u001b[31m\n",@@ -244,51 +245,36 @@">>>>>>>> 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",+ "exitcode: 1 (execution failed)\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",+ " File \"\", line 2\n",+ " Step 2: Define the equations\n",+ " ^\n",+ "SyntaxError: invalid syntax\n","\n","\n","--------------------------------------------------------------------------------\n","\u001b[33massistant\u001b[0m (to user_proxy):\n","\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",+ "Apologies for the confusion. I should have provided the code in a single block without the step-by-step comments. Here is the code to solve the system of linear equations using Sympy:\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",- "\u001b[33muser_proxy\u001b[0m (to assistant):\n",- "\n",- "simplify the answer\n",- "\n",- "--------------------------------------------------------------------------------\n",- "\u001b[33massistant\u001b[0m (to user_proxy):\n",+ "```python\n",+ "from sympy import symbols, Eq, solve\n","\n",- "Sure, I'll simplify the final expression for a + b + c.\n",+ "a, b, c, x, y = symbols('a b c x y')\n","\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",+ "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",- "Please, execute the following Python code:\n",+ "solutions = solve((eq1, eq2, eq3), (a, b, c))\n","\n",- "```python\n",- "from sympy import simplify\n",- "\n",- "print(simplify(sol[a] + sol[b] + sol[c]))\n",+ "a_value, b_value, c_value = solutions[a], solutions[b], solutions[c]\n",+ "sum_abc = a_value + b_value + c_value\n",+ "print(sum_abc)\n","```\n","\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",+ "Please run the provided code to find the sum of a, b, and c.\n","\n","--------------------------------------------------------------------------------\n","\u001b[31m\n",@@ -299,41 +285,40 @@">>>>>>>> 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",+ "exitcode: 0 (execution succeeded)\n","Code output: \n",- "Traceback (most recent call last):\n",- " File \"\", line 3, in <module>\n",- " print(simplify(sol[a] + sol[b] + sol[c]))\n",- "NameError: name 'sol' is not defined\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","\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",+ "I apologize for the confusion. The code provided the sum of a, b, and c in a symbolic representation. To get an answer, we need to put some constraints on x and y for which x + y is not equal to -1.\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",+ "We can choose any values for x and y that don't satisfy x + y = -1, and then substitute them into the equation to find the corresponding sum of a, b, and c. Let's use x = 1 and y = 0, which satisfy the given condition.\n","\n",- "Please, execute the following Python code:\n",+ "Here is the updated code with the chosen values for x and y:\n","\n","```python\n",- "from sympy import symbols, Eq, solve, simplify\n",+ "from sympy import symbols, Eq, solve\n","\n",- "# defining the symbols\n",- "x, y, a, b, c = symbols('x y a b c')\n",+ "a, b, c, x, y = symbols('a b c x y')\n","\n",- "# 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",+ "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",+ "solutions = solve((eq1, eq2, eq3), (a, b, c))\n",+ "\n",+ "chosen_x = 1\n",+ "chosen_y = 0\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",+ "a_value, b_value, c_value = solutions[a].subs(x, chosen_x).subs(y, chosen_y), solutions[b].subs(x, chosen_x).subs(y, chosen_y), solutions[c].subs(x, chosen_x).subs(y, chosen_y)\n",+ "sum_abc = a_value + b_value + c_value\n",+ "print(sum_abc)\n",+ "```\n","\n",+ "Please run the provided code again to find the sum of a, b, and c.\n","\n","--------------------------------------------------------------------------------\n","\u001b[31m\n",@@ -352,11 +337,9 @@"--------------------------------------------------------------------------------\n","\u001b[33massistant\u001b[0m (to user_proxy):\n","\n",- "Great! The solution for a + b + c is 7, given that x + y ≠ -1. \n",- "\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",+ "Great! Now we have the sum of a, b, and c. The answer is:\n","\n",- "We've successfully found and simplified a + b + c. We can conclude this task.\n",+ "$$a + b + c = 7$$\n","\n","TERMINATE\n","\n",@@ -401,7 +384,7 @@"name": "stdout","output_type": "stream","text": [- "{'[{\"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: <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 <module>\\\\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"+ "{'[{\"content\": \"You are a helpful AI assistant.\\\\nSolve tasks using your coding and language skills.\\\\nIn 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.\\\\nSolve the task step by step if you need to. If a plan is not provided, explain your plan first. Be clear which step uses code, and which step uses your language skill.\\\\nWhen using code, 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.\\\\nIf you want the user to save the code in a file before executing it, put # filename: <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.\\\\nIf 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.\\\\nWhen you find an answer, verify the answer carefully. Include verifiable evidence in your response if possible.\\\\nReply \\\\\"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 the system of linear equations, I will use NumPy library in Python to calculate the coefficients and constants and then use the linalg.solve() function to find the values of a, b, and c. Finally, I will add them up to find $a + b + c$.\\\\n\\\\nStep 1: Define the coefficients and constants\\\\n\\\\nStep 2: Solve the system of equations using NumPy\\\\n\\\\nStep 3: Calculate the sum of a, b, and c\", \"role\": \"assistant\"}, {\"content\": \"use sympy\", \"role\": \"user\"}, {\"content\": \"Sure, I will use Sympy to solve the system of linear equations.\\\\n\\\\nStep 1: Import Sympy library and define the symbols\\\\n``` python\\\\nfrom sympy import symbols, Eq, solve\\\\n\\\\na, b, c, x, y = symbols(\\'a b c x y\\')\\\\n```\\\\n\\\\nStep 2: Define the equations\\\\n``` python\\\\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\\\\nStep 3: Solve the system of equations\\\\n``` python\\\\nsolutions = solve((eq1, eq2, eq3), (a, b, c))\\\\n```\\\\n\\\\nStep 4: Calculate the sum of a, b, and c\\\\n``` python\\\\na_value, b_value, c_value = solutions[a], solutions[b], solutions[c]\\\\nsum_abc = a_value + b_value + c_value\\\\n```\\\\n\\\\n\", \"role\": \"assistant\"}, {\"content\": \"exitcode: 1 (execution failed)\\\\nCode output: \\\\n File \\\\\"\\\\\", line 2\\\\n Step 2: Define the equations\\\\n ^\\\\nSyntaxError: invalid syntax\\\\n\", \"role\": \"user\"}, {\"content\": \"Apologies for the confusion. I should have provided the code in a single block without the step-by-step comments. Here is the code to solve the system of linear equations using Sympy:\\\\n\\\\n```python\\\\nfrom sympy import symbols, Eq, solve\\\\n\\\\na, b, c, x, y = symbols(\\'a b c x y\\')\\\\n\\\\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\\\\nsolutions = solve((eq1, eq2, eq3), (a, b, c))\\\\n\\\\na_value, b_value, c_value = solutions[a], solutions[b], solutions[c]\\\\nsum_abc = a_value + b_value + c_value\\\\nprint(sum_abc)\\\\n```\\\\n\\\\nPlease run the provided code to find the sum of a, b, and c.\", \"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\": \"I apologize for the confusion. The code provided the sum of a, b, and c in a symbolic representation. To get an answer, we need to put some constraints on x and y for which x + y is not equal to -1.\\\\n\\\\nWe can choose any values for x and y that don\\'t satisfy x + y = -1, and then substitute them into the equation to find the corresponding sum of a, b, and c. Let\\'s use x = 1 and y = 0, which satisfy the given condition.\\\\n\\\\nHere is the updated code with the chosen values for x and y:\\\\n\\\\n```python\\\\nfrom sympy import symbols, Eq, solve\\\\n\\\\na, b, c, x, y = symbols(\\'a b c x y\\')\\\\n\\\\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\\\\nsolutions = solve((eq1, eq2, eq3), (a, b, c))\\\\n\\\\nchosen_x = 1\\\\nchosen_y = 0\\\\n\\\\na_value, b_value, c_value = solutions[a].subs(x, chosen_x).subs(y, chosen_y), solutions[b].subs(x, chosen_x).subs(y, chosen_y), solutions[c].subs(x, chosen_x).subs(y, chosen_y)\\\\nsum_abc = a_value + b_value + c_value\\\\nprint(sum_abc)\\\\n```\\\\n\\\\nPlease run the provided code again to find the sum of a, b, and c.\", \"role\": \"assistant\"}, {\"content\": \"exitcode: 0 (execution succeeded)\\\\nCode output: \\\\n7\\\\n\", \"role\": \"user\"}, {\"content\": \"Great! Now we have the sum of a, b, and c. The answer is:\\\\n\\\\n$$a + b + c = 7$$\\\\n\\\\nTERMINATE\", \"role\": \"assistant\"}]': {'created_at': [0, 1, 2, 3, 4], 'cost': [0.022019999999999998, 0.03305999999999999, 0.04019999999999999, 0.058589999999999996, 0.050969999999999994]}}\n"]}],diff --git a/notebook/autogen_agentchat_planning.ipynb b/notebook/autogen_agentchat_planning.ipynbindex bfe3560e5..d1c1d01eb 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.1 docker"+ "# %pip install flaml[autogen]~=2.0.2 docker"]},{@@ -221,28 +221,31 @@"--------------------------------------------------------------------------------\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 by using the GitHub API. Here is a Python script that uses the requests library to fetch the list of 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 using the GitHub API.\n",+ "\n",+ "Here is a Python script that uses the requests library to fetch the list of open issues labeled as \"good first issue\" from the FLAML GitHub repository.\n","\n","```python\n",- "# python code\n",+ "# filename: fetch_issues.py\n",+ "\n","import requests\n","import json\n","\n","def fetch_issues():\n"," url = \"https://api.github.com/repos/microsoft/FLAML/issues\"\n",- " response = requests.get(url, params={\"state\": \"open\", \"labels\": \"good first issue\"})\n",+ " params = {\n",+ " \"state\": \"open\",\n",+ " \"labels\": \"good first issue\"\n",+ " }\n",+ " response = requests.get(url, params=params)\n"," issues = response.json()\n",- "\n"," for issue in issues:\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",+ " print(f\"Issue ID: {issue['id']}, Title: {issue['title']}, URL: {issue['html_url']}\")\n","\n","fetch_issues()\n","```\n","\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",+ "Please run this script to fetch the list of open issues. After that, we can select one issue and suggest a fix for it.\n","\n","--------------------------------------------------------------------------------\n","\u001b[31m\n",@@ -253,106 +256,26 @@"\n","exitcode: 0 (execution succeeded)\n","Code output: \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",+ "Issue ID: 1809297895, Title: Moving function execution out of UserProxyAgent to be an openai util, URL: https://github.com/microsoft/FLAML/issues/1135\n",+ "Issue ID: 1799114476, Title: use_label_encoder warning with xgboost, URL: https://github.com/microsoft/FLAML/issues/1120\n",+ "Issue ID: 1705274482, Title: Use appropriate wait time for retry based on the error message. , URL: https://github.com/microsoft/FLAML/issues/1034\n",+ "Issue ID: 1702580697, Title: Issues with Adding Custom APIs in Auto Generation, URL: https://github.com/microsoft/FLAML/issues/1029\n",+ "Issue ID: 1658981020, Title: Running flaml[tune] using \"-O\" flag for python interpreter (optimization - disables assertions) crashes, URL: https://github.com/microsoft/FLAML/issues/981\n",+ "Issue ID: 1560969891, Title: Conditional parameter flow2 crash, URL: https://github.com/microsoft/FLAML/issues/903\n",+ "Issue ID: 1538549388, Title: indentation space, URL: https://github.com/microsoft/FLAML/issues/884\n",+ "Issue ID: 1531028010, Title: Check if openml version is required, URL: https://github.com/microsoft/FLAML/issues/882\n",+ "Issue ID: 1470354491, Title: Adjust the indent, URL: https://github.com/microsoft/FLAML/issues/834\n",+ "Issue ID: 1456950742, Title: pip install flaml FAIL, URL: https://github.com/microsoft/FLAML/issues/821\n",+ "Issue ID: 1441047067, Title: Isolate the ensemble part and expose it to users, URL: https://github.com/microsoft/FLAML/issues/807\n",+ "Issue ID: 1440171793, Title: how to pass categorical features names or indices to learner, URL: https://github.com/microsoft/FLAML/issues/805\n",+ "Issue ID: 1429945686, Title: Flaml/LightGBM - Shouldn't I found better/faster or equal results from FLAML than direct LightGBM?, URL: https://github.com/microsoft/FLAML/issues/785\n",+ "Issue ID: 1408240042, Title: Add an announcement of the discord channel, URL: https://github.com/microsoft/FLAML/issues/764\n",+ "Issue ID: 1396515109, Title: Documentation about small budget, URL: https://github.com/microsoft/FLAML/issues/748\n",+ "Issue ID: 1378268096, Title: Make zero-shot automl more discoverable, URL: https://github.com/microsoft/FLAML/issues/737\n",+ "Issue ID: 1189515901, Title: New HCrystalBall release, URL: https://github.com/microsoft/FLAML/issues/509\n",+ "Issue ID: 1114253143, Title: samples about conversion to ONNX, URL: https://github.com/microsoft/FLAML/issues/429\n",+ "Issue ID: 1107488969, Title: support anomaly detection, URL: https://github.com/microsoft/FLAML/issues/413\n",+ "Issue ID: 1061332179, Title: CatBoost Fails with Keyword 'groups', URL: https://github.com/microsoft/FLAML/issues/304\n","\n","\n","--------------------------------------------------------------------------------\n",@@ -361,7 +284,7 @@"\u001b[32m***** Suggested function Call: ask_planner *****\u001b[0m\n","Arguments: \n","{\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",+ "\"message\": \"We have fetched a list of open issues labeled as 'good first issue' from the FLAML GitHub repository. Now, we need to select one issue and suggest a fix for it. Could you please provide a plan for this?\"\n","}\n","\u001b[32m************************************************\u001b[0m\n","\n",@@ -372,115 +295,92 @@">>>>>>>> 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. Please suggest a plan to fix one of them. The issues are: \n",- "\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",+ "We have fetched a list of open issues labeled as 'good first issue' from the FLAML GitHub repository. Now, we need to select one issue and suggest a fix for it. Could you please provide a plan for this?\n","\n","--------------------------------------------------------------------------------\n","\u001b[33mplanner\u001b[0m (to planner_user):\n","\n",- "Let's try to fix the \"use_label_encoder warning with xgboost\" issue from the list. The plan involves:\n",- "\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",- "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",+ "Sure, here's a plan for selecting one issue from the list and suggesting a fix for it:\n","\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",+ "1. Import the fetched list of open issues labeled as 'good first issue' from the FLAML GitHub repository into your AI assistant. \n",+ "2. Examine the list for common issue attributes like 'title', 'description', 'labels', 'issue number', 'created at', and 'updated at'. \n",+ "3. To select a suitable issue for fixing, apply a selection criteria based on your preferences, such as prioritizing by the 'created at' attribute in descending order to pick the most recent issue, or filtering by a specific label in addition to 'good first issue'. Write code to filter and sort the issues accordingly.\n",+ "4. Inspect the execution result. If the selection criteria are not applied correctly, modify the code to fix any errors.\n",+ "5. Once the issue is selected, read the issue's title, description, and any linked resources or documents to understand the problem to be solved.\n",+ "6. Break down the issue into smaller tasks that can be addressed by writing code, and create a step-by-step plan.\n","\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",+ "For instance, the following could be smaller tasks to address the selected issue:\n",+ " a. Understand the issue's background and requirements.\n",+ " b. Write clear and concise instructions to reproduce the issue.\n",+ " c. Analyze existing code or tests related to the issue.\n",+ " d. Devise a solution to fix the issue.\n",+ " e. Implement the solution in separate code pieces.\n",+ " f. Verify that the solution addresses the issue.\n",+ " g. Write unit tests to ensure the solution is robust and handles edge cases.\n","\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",+ "7. Inspect the execution result. If the issue is misunderstood or the tasks' breakdown is incorrect, revise the understanding of the issue and modify the tasks accordingly.\n",+ "8. With the defined tasks and step-by-step plan, work on each task, and test the implemented code to ensure the issue is solved.\n",+ "9. If any issues arise during the task execution, analyze the errors and adjust the plan or code accordingly.\n",+ "10. Once the issue is fixed, prepare a pull request on GitHub, mentioning the issue number and giving a brief description of the solution in the merge request.\n","\n",- "6. Evaluate the change:\n",- "Check again to ensure that model performance and functionality haven't been negatively affected. \n",- "\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",- "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",- "Please note that each step in this plan requires coding and/or reasoning, which are critical to an AI assistant's operations.\n",+ "Remember that this is meant to be a general plan, and the specific tasks may vary depending on the selected issue. Adjust the plan as needed, based on the selected issue's requirements and your problem-solving approach.\n","\n","--------------------------------------------------------------------------------\n","\u001b[33muser_proxy\u001b[0m (to assistant):\n","\n","\u001b[32m***** Response from calling function \"ask_planner\" *****\u001b[0m\n",- "Let's try to fix the \"use_label_encoder warning with xgboost\" issue from the list. The plan involves:\n",- "\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",- "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",- "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",- "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",- "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",- "6. Evaluate the change:\n",- "Check again to ensure that model performance and functionality haven't been negatively affected. \n",- "\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",- "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",- "Please note that each step in this plan requires coding and/or reasoning, which are critical to an AI assistant's operations.\n",+ "Sure, here's a plan for selecting one issue from the list and suggesting a fix for it:\n",+ "\n",+ "1. Import the fetched list of open issues labeled as 'good first issue' from the FLAML GitHub repository into your AI assistant. \n",+ "2. Examine the list for common issue attributes like 'title', 'description', 'labels', 'issue number', 'created at', and 'updated at'. \n",+ "3. To select a suitable issue for fixing, apply a selection criteria based on your preferences, such as prioritizing by the 'created at' attribute in descending order to pick the most recent issue, or filtering by a specific label in addition to 'good first issue'. Write code to filter and sort the issues accordingly.\n",+ "4. Inspect the execution result. If the selection criteria are not applied correctly, modify the code to fix any errors.\n",+ "5. Once the issue is selected, read the issue's title, description, and any linked resources or documents to understand the problem to be solved.\n",+ "6. Break down the issue into smaller tasks that can be addressed by writing code, and create a step-by-step plan.\n",+ "\n",+ "For instance, the following could be smaller tasks to address the selected issue:\n",+ " a. Understand the issue's background and requirements.\n",+ " b. Write clear and concise instructions to reproduce the issue.\n",+ " c. Analyze existing code or tests related to the issue.\n",+ " d. Devise a solution to fix the issue.\n",+ " e. Implement the solution in separate code pieces.\n",+ " f. Verify that the solution addresses the issue.\n",+ " g. Write unit tests to ensure the solution is robust and handles edge cases.\n",+ "\n",+ "7. Inspect the execution result. If the issue is misunderstood or the tasks' breakdown is incorrect, revise the understanding of the issue and modify the tasks accordingly.\n",+ "8. With the defined tasks and step-by-step plan, work on each task, and test the implemented code to ensure the issue is solved.\n",+ "9. If any issues arise during the task execution, analyze the errors and adjust the plan or code accordingly.\n",+ "10. Once the issue is fixed, prepare a pull request on GitHub, mentioning the issue number and giving a brief description of the solution in the merge request.\n",+ "\n",+ "Remember that this is meant to be a general plan, and the specific tasks may vary depending on the selected issue. Adjust the plan as needed, based on the selected issue's requirements and your problem-solving approach.\n","\u001b[32m********************************************************\u001b[0m\n","\n","--------------------------------------------------------------------------------\n","\u001b[33massistant\u001b[0m (to user_proxy):\n","\n",- "Based on the plan provided, here are the steps to fix the \"use_label_encoder warning with xgboost\" issue:\n",+ "Based on the plan, let's select the most recent issue from the list. The most recent issue is \"Moving function execution out of UserProxyAgent to be an openai util\" with the URL: https://github.com/microsoft/FLAML/issues/1135\n",+ "\n",+ "To suggest a fix for this issue, we need to understand the problem first. Please visit the issue URL and read the issue's description and any comments to understand the problem.\n",+ "\n",+ "Once you understand the problem, here are the steps you can follow to suggest a fix:\n","\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",+ "1. Understand the issue's background and requirements: Read the issue description and any linked resources or documents to understand what needs to be done.\n","\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",+ "2. Write clear and concise instructions to reproduce the issue: Based on the issue description, write down the steps to reproduce the issue. This will help you understand the problem better and will be useful when you test your fix.\n","\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",+ "3. Analyze existing code or tests related to the issue: Look at the code in the FLAML repository that is related to the issue. Try to understand how it works and how it might be causing the issue.\n","\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",+ "4. Devise a solution to fix the issue: Based on your understanding of the problem and the code, come up with a solution to fix the issue. This might involve writing new code or modifying existing code.\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",+ "5. Implement the solution in separate code pieces: Write the code for your solution. Make sure to break it down into small, manageable pieces. This will make it easier to understand and test.\n","\n",- "6. **Evaluate the change**: You need to check again to ensure that model performance and functionality haven't been negatively affected.\n",+ "6. Verify that the solution addresses the issue: Test your code to make sure it solves the issue. You can do this by following the instructions you wrote to reproduce the issue.\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",+ "7. Write unit tests to ensure the solution is robust and handles edge cases: In addition to testing your solution manually, write unit tests to automatically test your code. This will help ensure that your solution works in all cases and that future changes to the code won't break your solution.\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",+ "8. Prepare a pull request on GitHub: Once you're confident that your solution works, prepare a pull request on GitHub. In the pull request description, mention the issue number and give a brief description of your solution.\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",+ "Please note that this is a general plan and the specific steps may vary depending on the issue. Adjust the plan as needed based on the issue's requirements and your problem-solving approach. \n","\n","TERMINATE\n","\n",diff --git a/notebook/autogen_agentchat_two_users.ipynb b/notebook/autogen_agentchat_two_users.ipynbindex 7d24f960d..1f72142b3 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.1"+ "# %pip install flaml[autogen]~=2.0.2"]},{@@ -141,7 +141,7 @@" 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",+ " expert.send(\"summarize the solution and explain the answer in an easy-to-understand way\", assistant_for_expert)\n"," # return the last message the expert received\n"," return expert.last_message()[\"content\"]\n"]@@ -164,6 +164,7 @@"source": ["assistant_for_student = autogen.AssistantAgent(\n"," name=\"assistant_for_student\",\n",+ " system_message=\"You are a helpful assistant. Reply TERMINATE when the task is done.\",\n"," llm_config={\n"," \"request_timeout\": 600,\n"," \"seed\": 42,\n",@@ -232,149 +233,100 @@"--------------------------------------------------------------------------------\n","\u001b[33massistant_for_student\u001b[0m (to student):\n","\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",+ "To find the values of $a$, $b$, and $c$, we need to solve the system of equations. However, the system of equations you provided seems to be incomplete or incorrect. The equations are not properly formatted, and it's unclear how $x$ and $y$ are related to $a$, $b$, and $c$. \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",- "# python code\n",- "import sympy as sp\n",- "\n",- "# define the symbols\n",- "a, b, c, x, y = sp.symbols('a b c x y')\n",- "\n",- "# define the equations\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 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",- "sum_abc = solution[a] + solution[b] + solution[c]\n",- "print(f\"a + b + c = {sum_abc}\")\n",- "```\n",- "\n",- "Please run this Python code to find the values of a, b, c and their sum.\n",+ "Could you please provide the correct system of equations?\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[33mstudent\u001b[0m (to assistant_for_student):\n","\n",- "exitcode: 0 (execution succeeded)\n",- "Code output: \n",- "a = (x**2 - 3*x*y + 2*x + y**2 - y)/(x**2 - x*y - x + y**2 - y + 1), 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","\u001b[33massistant_for_student\u001b[0m (to student):\n","\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",- "Here are the results:\n",- "\n",- "a = (x² - 3xy + 2x + y² - y) / (x² - xy - x + y² - y + 1)\n",- "\n",- "b = (2x² - 3x + y) / (x² - xy - x + y² - y + 1)\n",- "\n",- "c = (4x² - 4xy - 6x + 6y² - 7y + 7) / (x² - xy - x + y² - y + 1)\n",- "\n",- "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",+ "\u001b[32m***** Suggested function Call: ask_expert *****\u001b[0m\n",+ "Arguments: \n",+ "{\n",+ " \"message\": \"The user provided a system of equations and asked to find $a + b + c$, given that $x+y \\\\neq -1$ and \\n\\\\begin{align}\\n\\tax + by + c & = x + 7,\\\\\\n\\ta + bx + cy & = 2x + 6y,\\\\\\n\\tay + b + cx & = 4x + y.\\n\\\\end{align}. However, the system of equations seems to be incomplete or incorrectly formatted. How should I proceed?\"\n",+ "}\n",+ "\u001b[32m***********************************************\u001b[0m\n","\n","--------------------------------------------------------------------------------\n","\u001b[31m\n",">>>>>>>> USING AUTO REPLY...\u001b[0m\n",- "\u001b[33mstudent\u001b[0m (to assistant_for_student):\n",- "\n",+ "\u001b[35m\n",+ ">>>>>>>> EXECUTING FUNCTION ask_expert...\u001b[0m\n",+ "\u001b[33mexpert\u001b[0m (to assistant_for_expert):\n","\n",+ "The user provided a system of equations and asked to find $a + b + c$, given that $x+y \\neq -1$ and \n",+ "\\begin{align}\n",+ "\tax + by + c & = x + 7,\\\n",+ "\ta + bx + cy & = 2x + 6y,\\\n",+ "\tay + b + cx & = 4x + y.\n",+ "\\end{align}. However, the system of equations seems to be incomplete or incorrectly formatted. How should I proceed?\n","\n","--------------------------------------------------------------------------------\n",- "\u001b[33massistant_for_student\u001b[0m (to student):\n",+ "\u001b[33massistant_for_expert\u001b[0m (to expert):\n","\n",- "TERMINATE\n",+ "To proceed, we can first try to solve the given system of equations and see if we can find a unique solution for $a$, $b$, and $c$. If we can't find a unique solution, we can then determine if there's any additional information needed or if the system is indeed incomplete or incorrectly formatted.\n",+ "\n",+ "Let's solve the given system of equations using Python's SymPy library.\n","\n","--------------------------------------------------------------------------------\n",- "\u001b[33mstudent\u001b[0m (to assistant_for_student):\n",+ "\u001b[33mexpert\u001b[0m (to assistant_for_expert):\n","\n",- "I don't know if the answer is correct. It looks complicated.\n",+ "make sure you simplify the answer\n","\n","--------------------------------------------------------------------------------\n",- "\u001b[33massistant_for_student\u001b[0m (to student):\n",+ "\u001b[33massistant_for_expert\u001b[0m (to expert):\n","\n",- "\u001b[32m***** Suggested function Call: ask_expert *****\u001b[0m\n",- "Arguments: \n",- "{\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",- "\u001b[32m***********************************************\u001b[0m\n",+ "Sure, I will simplify the answer. Let's solve the given system of equations using Python's SymPy library and simplify the result.\n","\n","--------------------------------------------------------------------------------\n","\u001b[31m\n",+ ">>>>>>>> NO HUMAN INPUT RECEIVED.\u001b[0m\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",- "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",- "Equations:\n",- "1. ax + by + c = x + 7\n",- "2. a + bx + cy = 2x + 6y\n",- "3. ay + b + cx = 4x + y\n",- "\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",- "Could you please verify if the solution is correct?\n","\n","--------------------------------------------------------------------------------\n","\u001b[33massistant_for_expert\u001b[0m (to expert):\n","\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",+ "First, let's install the SymPy library if you haven't already. Execute the following command to install it:\n",+ "\n",+ "```sh\n",+ "pip install sympy\n",+ "```\n","\n",- "Here is the Python code to perform this verification:\n",+ "Now, let's solve the given system of equations using Python's SymPy library and simplify the result.\n","\n","```python\n",- "from sympy import symbols, simplify\n",+ "from sympy import symbols, Eq, solve, simplify\n","\n",- "# Define the symbols\n",- "x, y = symbols('x y')\n",+ "a, b, c, x, y = symbols('a b c x y')\n","\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",+ "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",- "# 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",+ "solutions = solve((eq1, eq2, eq3), (a, b, c))\n","\n",- "# Check if the equations are satisfied\n",- "print(eq1 == 0 and eq2 == 0 and eq3 == 0)\n",+ "simplified_solutions = {key: simplify(value) for key, value in solutions.items()}\n",+ "a_val, b_val, c_val = simplified_solutions[a], simplified_solutions[b], simplified_solutions[c]\n",+ "sum_abc = simplify(a_val + b_val + c_val)\n",+ "\n",+ "print(f\"a: {a_val}\")\n",+ "print(f\"b: {b_val}\")\n",+ "print(f\"c: {c_val}\")\n",+ "print(f\"a + b + c: {sum_abc}\")\n","```\n","\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",+ "Please execute the above Python code to solve the system of equations and simplify the result.\n","\n","--------------------------------------------------------------------------------\n","\u001b[31m\n",@@ -382,121 +334,123 @@"\u001b[31m\n",">>>>>>>> USING AUTO REPLY...\u001b[0m\n","\u001b[31m\n",- ">>>>>>>> EXECUTING CODE BLOCK 0 (inferred language is python)...\u001b[0m\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[33mexpert\u001b[0m (to assistant_for_expert):\n","\n","exitcode: 0 (execution succeeded)\n","Code output: \n",- "True\n",- "\n",- "\n",- "--------------------------------------------------------------------------------\n",- "\u001b[33massistant_for_expert\u001b[0m (to expert):\n",+ "Defaulting to user installation because normal site-packages is not writeable\n",+ "Requirement already satisfied: sympy in /home/vscode/.local/lib/python3.9/site-packages (1.12)\n",+ "Requirement already satisfied: mpmath>=0.19 in /home/vscode/.local/lib/python3.9/site-packages (from sympy) (1.3.0)\n","\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",+ "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",+ "a + b + c: 7\n","\n",- "simplify the answer\n","\n","--------------------------------------------------------------------------------\n","\u001b[33massistant_for_expert\u001b[0m (to expert):\n","\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",+ "The given system of equations has been solved and simplified. The result is:\n","\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",+ "a = \\frac{x^2 - 3xy + 2x + y^2 - y}{x^2 - xy - x + y^2 - y + 1}, \\\\\n",+ "b = \\frac{2x^2 - 3x + y}{x^2 - xy - x + y^2 - y + 1}, \\\\\n",+ "c = \\frac{4x^2 - 4xy - 6x + 6y^2 - 7y + 7}{x^2 - xy - x + y^2 - y + 1}.\n",+ "$$\n","\n",- "```python\n",- "from sympy import symbols, simplify\n",- "\n",- "# Define the symbols\n",- "x, y = symbols('x y')\n",- "\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",- "# Simplify a + b + c\n",- "abc_simplified = simplify(a + b + c)\n",- "\n",- "# Print the simplified expression\n",- "print(abc_simplified)\n",- "```\n",+ "The sum $a + b + c$ is equal to $7$. Since we were able to find a unique solution for $a$, $b$, and $c$, the system of equations is complete and correctly formatted.\n","\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",+ "TERMINATE\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[33mexpert\u001b[0m (to assistant_for_expert):\n","\n",- "exitcode: 0 (execution succeeded)\n",- "Code output: \n",- "7\n","\n","\n","--------------------------------------------------------------------------------\n","\u001b[33massistant_for_expert\u001b[0m (to expert):\n","\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[31m\n",+ ">>>>>>>> NO HUMAN INPUT RECEIVED.\u001b[0m\n","\u001b[33mexpert\u001b[0m (to assistant_for_expert):\n","\n",- "summarize the solution\n",+ "summarize the solution and explain the answer in an easy-to-understand way\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",+ "Sure, let me summarize the solution and explain the answer in an easy-to-understand way.\n","\n",- "The expressions for a, b, and c are:\n",+ "We were given a system of three equations with three unknowns, $a$, $b$, and $c$. The equations were:\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",+ "1. $ax + by + c = x + 7$\n",+ "2. $a + bx + cy = 2x + 6y$\n",+ "3. $ay + b + cx = 4x + y$\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",+ "We were asked to find the sum $a + b + c$ given that $x + y \\neq -1$.\n","\n",- "TERMINATE\n",+ "We used Python's SymPy library to solve the system of equations and found the following solutions for $a$, $b$, and $c$:\n",+ "\n",+ "$$\n",+ "a = \\frac{x^2 - 3xy + 2x + y^2 - y}{x^2 - xy - x + y^2 - y + 1}, \\\\\n",+ "b = \\frac{2x^2 - 3x + y}{x^2 - xy - x + y^2 - y + 1}, \\\\\n",+ "c = \\frac{4x^2 - 4xy - 6x + 6y^2 - 7y + 7}{x^2 - xy - x + y^2 - y + 1}.\n",+ "$$\n",+ "\n",+ "These solutions are expressed in terms of $x$ and $y$. However, we were able to find the sum $a + b + c$ without knowing the values of $x$ and $y$. The sum $a + b + c$ simplifies to $7$.\n",+ "\n",+ "In conclusion, the sum $a + b + c$ for the given system of equations is equal to $7$.\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",+ "Sure, let me summarize the solution and explain the answer in an easy-to-understand way.\n","\n",- "The expressions for a, b, and c are:\n",+ "We were given a system of three equations with three unknowns, $a$, $b$, and $c$. The equations were:\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",+ "1. $ax + by + c = x + 7$\n",+ "2. $a + bx + cy = 2x + 6y$\n",+ "3. $ay + b + cx = 4x + y$\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",+ "We were asked to find the sum $a + b + c$ given that $x + y \\neq -1$.\n","\n",- "TERMINATE\n",+ "We used Python's SymPy library to solve the system of equations and found the following solutions for $a$, $b$, and $c$:\n",+ "\n",+ "$$\n",+ "a = \\frac{x^2 - 3xy + 2x + y^2 - y}{x^2 - xy - x + y^2 - y + 1}, \\\\\n",+ "b = \\frac{2x^2 - 3x + y}{x^2 - xy - x + y^2 - y + 1}, \\\\\n",+ "c = \\frac{4x^2 - 4xy - 6x + 6y^2 - 7y + 7}{x^2 - xy - x + y^2 - y + 1}.\n",+ "$$\n",+ "\n",+ "These solutions are expressed in terms of $x$ and $y$. However, we were able to find the sum $a + b + c$ without knowing the values of $x$ and $y$. The sum $a + b + c$ simplifies to $7$.\n",+ "\n",+ "In conclusion, the sum $a + b + c$ for the given system of equations is equal to $7$.\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",+ "The solution to the system of equations you provided is:\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",+ "1. $a = \\frac{x^2 - 3xy + 2x + y^2 - y}{x^2 - xy - x + y^2 - y + 1}$\n",+ "2. $b = \\frac{2x^2 - 3x + y}{x^2 - xy - x + y^2 - y + 1}$\n",+ "3. $c = \\frac{4x^2 - 4xy - 6x + 6y^2 - 7y + 7}{x^2 - xy - x + y^2 - y + 1}$\n","\n",- "So, the answer to your question \"Find $a + b + c$\" is 7.\n",+ "These solutions are expressed in terms of $x$ and $y$. However, we can find the sum $a + b + c$ without knowing the values of $x$ and $y$. The sum $a + b + c$ simplifies to $7$.\n","\n",- "TERMINATE\n",+ "So, the sum $a + b + c$ for the given system of equations is equal to $7$.\n","\n","--------------------------------------------------------------------------------\n","\u001b[31m\n",diff --git a/notebook/autogen_agentchat_web_info.ipynb b/notebook/autogen_agentchat_web_info.ipynbindex f8f123fcd..4f8469d9c 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.1 docker"+ "# %pip install flaml[autogen]~=2.0.2 docker"]},{@@ -183,21 +183,28 @@"--------------------------------------------------------------------------------\n","\u001b[33massistant\u001b[0m (to user_proxy):\n","\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",+ "To determine who should read the paper, we need to first understand the content and context of the paper. We can do this by fetching the abstract of the paper from the provided URL and analyzing it. \n","\n",- "Please execute the following Python code to fetch the abstract:\n",+ "Here is a Python script that uses the BeautifulSoup library to scrape the abstract of the paper from the webpage. \n","\n","```python\n",+ "# Python script to scrape the abstract of the paper\n",+ "\n","import requests\n","from bs4 import BeautifulSoup\n","\n",+ "def get_abstract(url):\n",+ " response = requests.get(url)\n",+ " soup = BeautifulSoup(response.text, 'html.parser')\n",+ " abstract = soup.find('blockquote', attrs={'class': 'abstract mathjax'}).text.strip()\n",+ " return abstract\n",+ "\n","url = \"https://arxiv.org/abs/2306.01337\"\n",- "response = requests.get(url)\n",- "soup = BeautifulSoup(response.text, \"html.parser\")\n",- "abstract = soup.find(\"blockquote\", {\"class\": \"abstract\"}).text.strip()\n",+ "abstract = get_abstract(url)\n","print(abstract)\n","```\n",- "After you provide the abstract, I will analyze it and suggest the target audience.\n",+ "\n",+ "Please run this script and provide the output. Based on the abstract, I can suggest who might be interested in reading this paper.\n","\n","--------------------------------------------------------------------------------\n","\u001b[31m\n",@@ -224,15 +231,21 @@"--------------------------------------------------------------------------------\n","\u001b[33massistant\u001b[0m (to user_proxy):\n","\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",+ "Based on the abstract, the paper is about using Large Language Models (LLMs), specifically GPT-4, to solve complex mathematical problems. The paper introduces a new conversational problem-solving framework called MathChat and evaluates its performance on difficult high school competition problems from the MATH dataset.\n","\n",- "The target audience for this paper includes:\n",+ "Given this, the paper would be of interest to the following groups:\n","\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 and engineers working on natural language processing and conversational AI systems for problem-solving tasks.\n",+ "1. **Researchers in Artificial Intelligence and Natural Language Processing**: The paper discusses the use of a large language model (GPT-4) for problem-solving, which is a key research area in AI and NLP.\n","\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",+ "2. **Mathematicians and Math Educators**: The paper focuses on solving complex mathematical problems, so those with a background in mathematics might find the techniques and results interesting.\n",+ "\n",+ "3. **Data Scientists and Machine Learning Engineers**: These professionals often use models like GPT-4 in their work and might be interested in new applications and techniques.\n",+ "\n",+ "4. **Students studying AI, NLP, or Mathematics**: The paper could provide valuable insights for these students into how AI can be used in problem-solving.\n",+ "\n",+ "5. **Developers working on AI-based chatbots or conversational agents**: The paper introduces a new conversational problem-solving framework, which could be of interest to these developers.\n",+ "\n",+ "Please note that while the paper is likely to be of interest to these groups, the specific relevance will depend on the individual's specific interests and research needs.\n","\n","TERMINATE\n","\n",@@ -247,7 +260,7 @@"user_proxy.initiate_chat(\n"," assistant,\n"," message=\"\"\"\n",- "Who should read this paper: https://arxiv.org/abs/2306.01337\n",+ "Who should read this paper: https://arxiv.org/abs/2308.08155\n","\"\"\",\n",")"]@@ -276,133 +289,54 @@"--------------------------------------------------------------------------------\n","\u001b[33massistant\u001b[0m (to user_proxy):\n","\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",- "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",+ "To get the YTD gain of the 10 largest technology companies, we need to do the following:\n","\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",+ "1. Identify the 10 largest technology companies. We can use the list of the largest technology companies by market capitalization. This list can change frequently, so we need to get the latest data. We can use web scraping to get this data from a reliable source.\n","\n",- "```sh\n",- "pip install beautifulsoup4 requests\n",- "```\n",+ "2. Get the YTD gain for each of these companies. We can use a financial data API to get this data. Yahoo Finance is a popular source for this kind of data.\n","\n",- "Now, execute the following Python code to fetch the list of the 10 largest technology companies and their stock symbols:\n",+ "Here is a Python script that uses the BeautifulSoup library for web scraping and the yfinance library to get data from Yahoo Finance. This script will print the 10 largest technology companies and their YTD gains.\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",+ "# filename: ytd_gain.py\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",+ "import yfinance as yf\n",+ "import pandas as pd\n","\n",- "url = \"https://www.suredividend.com/top-10-technology-stocks/\"\n",+ "# Get the list of largest tech companies by market cap\n",+ "url = \"https://companiesmarketcap.com/technology/largest-technology-companies-by-market-cap/\"\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",+ "soup = BeautifulSoup(response.text, 'html.parser')\n",+ "\n",+ "# Find the table with the data\n",+ "table = soup.find('table')\n",+ "\n",+ "# Get the ticker symbols of the 10 largest companies\n",+ "tickers = []\n",+ "for row in table.find_all('tr')[1:11]: # Skip the header row\n",+ " ticker = row.find_all('td')[1].text\n",+ " tickers.append(ticker)\n",+ "\n",+ "# Get the YTD gain for each company\n",+ "ytd_gains = {}\n",+ "for ticker in tickers:\n",+ " ticker_data = yf.Ticker(ticker)\n",+ " hist = ticker_data.history(period=\"ytd\")\n",+ " start_price = hist.iloc[0]['Close']\n",+ " end_price = hist.iloc[-1]['Close']\n",+ " ytd_gain = (end_price - start_price) / start_price * 100\n",+ " ytd_gains[ticker] = ytd_gain\n",+ "\n",+ "# Print the results\n",+ "for ticker, ytd_gain in ytd_gains.items():\n",+ " print(f\"{ticker}: {ytd_gain:.2f}%\")\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",+ "To run this script, save it to a file named `ytd_gain.py`, then run it with the command `python ytd_gain.py`.\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",+ "Please note that this script requires the BeautifulSoup, requests, yfinance, and pandas libraries. If you don't have these libraries installed, you can install them with the command `pip install beautifulsoup4 requests yfinance pandas`.\n","\n","--------------------------------------------------------------------------------\n","\u001b[31m\n",@@ -414,85 +348,46 @@"exitcode: 1 (execution failed)\n","Code output: \n","Traceback (most recent call last):\n",- " File \"\", line 11, in <module>\n",- " for row in table.find_all(\"tr\")[1:11]:\n",+ " File \"ytd_gain.py\", line 18, in <module>\n",+ " for row in table.find_all('tr')[1:11]: # Skip the header row\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 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 <module>\n",- " for row in table.find_all(\"tr\")[1:11]:\n",- "AttributeError: 'NoneType' object has no attribute 'find_all'\n",- "\n",+ "I apologize for the error. It seems that the script failed to find the table in the webpage. This could be due to changes in the webpage structure or because the page uses JavaScript to load the table, which BeautifulSoup can't handle.\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",+ "Let's try a different approach. We'll use the yfinance library to get the data for the 10 largest technology companies. These are currently: Apple (AAPL), Microsoft (MSFT), Alphabet (GOOGL), Amazon (AMZN), Facebook (FB), Tesla (TSLA), Nvidia (NVDA), Paypal (PYPL), Adobe (ADBE), and Netflix (NFLX).\n","\n",- "Please execute the following Python code to fetch the list of the 10 largest technology companies and their stock symbols:\n",+ "Here's the updated Python script:\n","\n","```python\n",- "import requests\n",- "from bs4 import BeautifulSoup\n",+ "# filename: ytd_gain.py\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",+ "import yfinance as yf\n","\n",- "print(\"The 10 largest technology companies and their stock symbols are:\")\n",- "for symbol in company_symbols:\n",- " print(symbol)\n",+ "# List of the 10 largest tech companies by market cap\n",+ "tickers = ['AAPL', 'MSFT', 'GOOGL', 'AMZN', 'FB', 'TSLA', 'NVDA', 'PYPL', 'ADBE', 'NFLX']\n",+ "\n",+ "# Get the YTD gain for each company\n",+ "ytd_gains = {}\n",+ "for ticker in tickers:\n",+ " ticker_data = yf.Ticker(ticker)\n",+ " hist = ticker_data.history(period=\"ytd\")\n",+ " start_price = hist.iloc[0]['Close']\n",+ " end_price = hist.iloc[-1]['Close']\n",+ " ytd_gain = (end_price - start_price) / start_price * 100\n",+ " ytd_gains[ticker] = ytd_gain\n",+ "\n",+ "# Print the results\n",+ "for ticker, ytd_gain in ytd_gains.items():\n",+ " print(f\"{ticker}: {ytd_gain:.2f}%\")\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",+ "To run this script, save it to a file named `ytd_gain.py`, then run it with the command `python ytd_gain.py`.\n",+ "\n",+ "Please note that this script requires the yfinance library. If you don't have this library installed, you can install it with the command `pip install yfinance`.\n","\n","--------------------------------------------------------------------------------\n","\u001b[31m\n",@@ -503,41 +398,57 @@"\n","exitcode: 1 (execution failed)\n","Code output: \n",+ "FB: No data found, symbol may be delisted\n","Traceback (most recent call last):\n",- " File \"\", line 11, in <module>\n",- " for row in table.find_all(\"tr\")[1:11]:\n",- "AttributeError: 'NoneType' object has no attribute 'find_all'\n",+ " File \"ytd_gain.py\", line 13, in <module>\n",+ " start_price = hist.iloc[0]['Close']\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","\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",+ "I apologize for the error. It seems that the script failed to get the data for Facebook (FB). This could be due to a temporary issue with the Yahoo Finance API.\n","\n",- "Please execute the following Python code to fetch the list of the 10 largest technology companies and their stock symbols:\n",+ "Let's modify the script to handle this situation. We'll add a try-except block to skip any companies for which we can't get data.\n","\n",- "```python\n",- "import requests\n",- "from bs4 import BeautifulSoup\n",+ "Here's the updated Python script:\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",+ "```python\n",+ "# filename: ytd_gain.py\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",+ "import yfinance as yf\n","\n",- "print(\"The 10 largest technology companies and their stock symbols are:\")\n",- "for symbol in company_symbols:\n",- " print(symbol)\n",+ "# List of the 10 largest tech companies by market cap\n",+ "tickers = ['AAPL', 'MSFT', 'GOOGL', 'AMZN', 'FB', 'TSLA', 'NVDA', 'PYPL', 'ADBE', 'NFLX']\n",+ "\n",+ "# Get the YTD gain for each company\n",+ "ytd_gains = {}\n",+ "for ticker in tickers:\n",+ " try:\n",+ " ticker_data = yf.Ticker(ticker)\n",+ " hist = ticker_data.history(period=\"ytd\")\n",+ " start_price = hist.iloc[0]['Close']\n",+ " end_price = hist.iloc[-1]['Close']\n",+ " ytd_gain = (end_price - start_price) / start_price * 100\n",+ " ytd_gains[ticker] = ytd_gain\n",+ " except IndexError:\n",+ " print(f\"Could not get data for {ticker}\")\n",+ "\n",+ "# Print the results\n",+ "for ticker, ytd_gain in ytd_gains.items():\n",+ " print(f\"{ticker}: {ytd_gain:.2f}%\")\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",+ "To run this script, save it to a file named `ytd_gain.py`, then run it with the command `python ytd_gain.py`.\n",+ "\n",+ "Please note that this script requires the yfinance library. If you don't have this library installed, you can install it with the command `pip install yfinance`.\n","\n","--------------------------------------------------------------------------------\n","\u001b[31m\n",@@ -546,223 +457,128 @@">>>>>>>> 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",+ "exitcode: 0 (execution succeeded)\n","Code output: \n",- "Traceback (most recent call last):\n",- " File \"\", line 11, in <module>\n",- " for row in table.find_all(\"tr\")[1:11]:\n",- "AttributeError: 'NoneType' object has no attribute 'find_all'\n",+ "Could not get data for FB\n",+ "AAPL: 46.41%\n",+ "MSFT: 37.63%\n",+ "GOOGL: 51.13%\n",+ "AMZN: 56.22%\n",+ "TSLA: 131.46%\n",+ "NVDA: 237.68%\n",+ "PYPL: -16.49%\n",+ "ADBE: 59.79%\n",+ "NFLX: 43.41%\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",+ "The script has successfully fetched the Year-to-Date (YTD) gain for the largest technology companies, except for Facebook (FB). The YTD gains are as follows:\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",+ "- Apple (AAPL): 46.41%\n",+ "- Microsoft (MSFT): 37.63%\n",+ "- Alphabet (GOOGL): 51.13%\n",+ "- Amazon (AMZN): 56.22%\n",+ "- Tesla (TSLA): 131.46%\n",+ "- Nvidia (NVDA): 237.68%\n",+ "- Paypal (PYPL): -16.49%\n",+ "- Adobe (ADBE): 59.79%\n",+ "- Netflix (NFLX): 43.41%\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",+ "Unfortunately, the script could not fetch the data for Facebook (FB). This could be due to a temporary issue with the Yahoo Finance API or the ticker symbol might have changed.\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",+ "Please note that these values are subject to change as the stock market fluctuates. \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",+ "TERMINATE\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",+ "FB -> META\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",+ "Thank you for the update. Facebook Inc. has indeed rebranded to Meta Platforms Inc. and its ticker symbol has changed from FB to META on the NASDAQ stock exchange.\n","\n",- "```sh\n",- "pip install yfinance\n",- "```\n",- "\n",- "After installing the package, execute the following Python code to fetch the YTD gain for each of the 10 largest technology companies:\n",+ "Let's update the script to reflect this change:\n","\n","```python\n",- "import yfinance as yf\n",- "from datetime import datetime\n",+ "# filename: ytd_gain.py\n","\n",- "stock_symbols = [\"AAPL\", \"MSFT\", \"GOOGL\", \"AMZN\", \"FB\", \"NVDA\", \"TSLA\", \"ADBE\", \"PYPL\", \"CSCO\"]\n",- "\n",- "def get_ytd_gain(symbol):\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",+ "import yfinance as yf\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",+ "# List of the 10 largest tech companies by market cap\n",+ "# Updated Facebook (FB) to Meta Platforms (META)\n",+ "tickers = ['AAPL', 'MSFT', 'GOOGL', 'AMZN', 'META', 'TSLA', 'NVDA', 'PYPL', 'ADBE', 'NFLX']\n",+ "\n",+ "# Get the YTD gain for each company\n",+ "ytd_gains = {}\n",+ "for ticker in tickers:\n",+ " try:\n",+ " ticker_data = yf.Ticker(ticker)\n",+ " hist = ticker_data.history(period=\"ytd\")\n",+ " start_price = hist.iloc[0]['Close']\n",+ " end_price = hist.iloc[-1]['Close']\n",+ " ytd_gain = (end_price - start_price) / start_price * 100\n",+ " ytd_gains[ticker] = ytd_gain\n",+ " except IndexError:\n",+ " print(f\"Could not get data for {ticker}\")\n",+ "\n",+ "# Print the results\n",+ "for ticker, ytd_gain in ytd_gains.items():\n",+ " print(f\"{ticker}: {ytd_gain:.2f}%\")\n","```\n","\n",- "This code will print the YTD gain for each of the 10 largest technology companies.\n",+ "To run this script, save it to a file named `ytd_gain.py`, then run it with the command `python ytd_gain.py`.\n",+ "\n",+ "Please note that this script requires the yfinance library. If you don't have this library installed, you can install it with the command `pip install yfinance`.\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",+ ">>>>>>>> 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",- "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: 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: 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: 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",- "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",+ "AAPL: 46.34%\n",+ "MSFT: 37.55%\n",+ "GOOGL: 51.08%\n",+ "AMZN: 56.17%\n",+ "META: 133.67%\n",+ "TSLA: 131.02%\n",+ "NVDA: 237.38%\n",+ "PYPL: -16.55%\n",+ "ADBE: 59.71%\n",+ "NFLX: 43.44%\n","\n","\n","--------------------------------------------------------------------------------\n","\u001b[33massistant\u001b[0m (to user_proxy):\n","\n",- "Great! The code has successfully fetched the YTD gain for the 10 largest technology companies. Here are the results:\n",+ "The script has successfully fetched the Year-to-Date (YTD) gain for the largest technology companies, including Meta Platforms (formerly Facebook). The YTD gains are as follows:\n","\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",+ "- Apple (AAPL): 46.34%\n",+ "- Microsoft (MSFT): 37.55%\n",+ "- Alphabet (GOOGL): 51.08%\n",+ "- Amazon (AMZN): 56.17%\n",+ "- Meta Platforms (META): 133.67%\n",+ "- Tesla (TSLA): 131.02%\n",+ "- Nvidia (NVDA): 237.38%\n",+ "- Paypal (PYPL): -16.55%\n",+ "- Adobe (ADBE): 59.71%\n",+ "- Netflix (NFLX): 43.44%\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",+ "Please note that these values are subject to change as the stock market fluctuates. \n","\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",+ "TERMINATE\n","\n","--------------------------------------------------------------------------------\n","\u001b[31m\n",- ">>>>>>>> USING AUTO REPLY...\u001b[0m\n",- "\u001b[33muser_proxy\u001b[0m (to assistant):\n",- "\n",- "TERMINATE\n",- "\n",- "--------------------------------------------------------------------------------\n"+ ">>>>>>>> NO HUMAN INPUT RECEIVED.\u001b[0m\n"]}],