diff --git a/.github/workflows/openai.yml b/.github/workflows/openai.yml index b848ef9fb..41e6cd7b7 100644 --- a/.github/workflows/openai.yml +++ b/.github/workflows/openai.yml @@ -9,11 +9,11 @@ on: paths: - 'autogen/**' - 'test/**' - - 'notebook/autogen_agentchat_auto_feedback_from_code_execution.ipynb' - - 'notebook/autogen_agentchat_function_call.ipynb' - - 'notebook/autogen_agentchat_MathChat.ipynb' - - 'notebook/autogen_openai_completion.ipynb' - - 'notebook/autogen_chatgpt_gpt4.ipynb' + - 'notebook/agentchat_auto_feedback_from_code_execution.ipynb' + - 'notebook/agentchat_function_call.ipynb' + - 'notebook/agentchat_MathChat.ipynb' + - 'notebook/oai_completion.ipynb' + - 'notebook/oai_chatgpt_gpt4.ipynb' - '.github/workflows/openai.yml' jobs: diff --git a/notebook/autogen_agentchat_MathChat.ipynb b/notebook/agentchat_MathChat.ipynb similarity index 95% rename from notebook/autogen_agentchat_MathChat.ipynb rename to notebook/agentchat_MathChat.ipynb index 29709716a..38844708d 100644 --- a/notebook/autogen_agentchat_MathChat.ipynb +++ b/notebook/agentchat_MathChat.ipynb @@ -5,7 +5,7 @@ "cell_type": "markdown", "metadata": {}, "source": [ - "\"Open" + "\"Open" ] }, { @@ -17,7 +17,7 @@ "\n", "AutoGen offers conversable agents powered by LLM, tool or human, which can be used to perform tasks collectively via automated chat. This framwork allows tool use and human participance through multi-agent conversation. Please find documentation about this feature [here](https://microsoft.github.io/autogen/docs/Use-Cases/agent_chat).\n", "\n", - "MathChat is an experimental convesational framework for math problem solving. In this notebook, we demonstrate how to use MathChat to solve math problems. MathChat uses the `AssistantAgent` and `MathUserProxyAgent`, which is similar to the usage of `AssistantAgent` and `UserProxyAgent` in other notebooks (e.g., [Automated Task Solving with Code Generation, Execution & Debugging](https://github.com/microsoft/autogen/blob/main/notebook/autogen_agentchat_auto_feedback_from_code_execution.ipynb)). Essentially, `MathUserProxyAgent` implements a different auto reply mechanism corresponding to the MathChat prompts. You can find more details in the paper [An Empirical Study on Challenging Math Problem Solving with GPT-4](https://arxiv.org/abs/2306.01337) or the [blogpost](https://microsoft.github.io/autogen/blog/2023/06/28/MathChat).\n", + "MathChat is an experimental convesational framework for math problem solving. In this notebook, we demonstrate how to use MathChat to solve math problems. MathChat uses the `AssistantAgent` and `MathUserProxyAgent`, which is similar to the usage of `AssistantAgent` and `UserProxyAgent` in other notebooks (e.g., [Automated Task Solving with Code Generation, Execution & Debugging](https://github.com/microsoft/autogen/blob/main/notebook/agentchat_auto_feedback_from_code_execution.ipynb)). Essentially, `MathUserProxyAgent` implements a different auto reply mechanism corresponding to the MathChat prompts. You can find more details in the paper [An Empirical Study on Challenging Math Problem Solving with GPT-4](https://arxiv.org/abs/2306.01337) or the [blogpost](https://microsoft.github.io/autogen/blog/2023/06/28/MathChat).\n", "\n", "## Requirements\n", "\n", diff --git a/notebook/autogen_agentchat_RetrieveChat.ipynb b/notebook/agentchat_RetrieveChat.ipynb similarity index 99% rename from notebook/autogen_agentchat_RetrieveChat.ipynb rename to notebook/agentchat_RetrieveChat.ipynb index eaa24931e..bdc994d0f 100644 --- a/notebook/autogen_agentchat_RetrieveChat.ipynb +++ b/notebook/agentchat_RetrieveChat.ipynb @@ -1,10 +1,11 @@ { "cells": [ { + "attachments": {}, "cell_type": "markdown", "metadata": {}, "source": [ - "\"Open" + "\"Open" ] }, { @@ -18,7 +19,7 @@ "AutoGen offers conversable agents powered by LLM, tool or human, which can be used to perform tasks collectively via automated chat. This framwork allows tool use and human participance through multi-agent conversation.\n", "Please find documentation about this feature [here](https://microsoft.github.io/autogen/docs/Use-Cases/agent_chat).\n", "\n", - "RetrieveChat is a convesational system for retrieve augmented code generation and question answering. In this notebook, we demonstrate how to utilize RetrieveChat to generate code and answer questions based on customized documentations that are not present in the LLM's training dataset. RetrieveChat uses the `RetrieveAssistantAgent` and `RetrieveUserProxyAgent`, which is similar to the usage of `AssistantAgent` and `UserProxyAgent` in other notebooks (e.g., [Automated Task Solving with Code Generation, Execution & Debugging](https://github.com/microsoft/autogen/blob/main/notebook/autogen_agentchat_auto_feedback_from_code_execution.ipynb)). Essentially, `RetrieveAssistantAgent` and `RetrieveUserProxyAgent` implement a different auto-reply mechanism corresponding to the RetrieveChat prompts.\n", + "RetrieveChat is a convesational system for retrieve augmented code generation and question answering. In this notebook, we demonstrate how to utilize RetrieveChat to generate code and answer questions based on customized documentations that are not present in the LLM's training dataset. RetrieveChat uses the `RetrieveAssistantAgent` and `RetrieveUserProxyAgent`, which is similar to the usage of `AssistantAgent` and `UserProxyAgent` in other notebooks (e.g., [Automated Task Solving with Code Generation, Execution & Debugging](https://github.com/microsoft/autogen/blob/main/notebook/agentchat_auto_feedback_from_code_execution.ipynb)). Essentially, `RetrieveAssistantAgent` and `RetrieveUserProxyAgent` implement a different auto-reply mechanism corresponding to the RetrieveChat prompts.\n", "\n", "## Table of Contents\n", "We'll demonstrates five examples of using RetrieveChat for code generation and question answering:\n", diff --git a/notebook/autogen_agentchat_auto_feedback_from_code_execution.ipynb b/notebook/agentchat_auto_feedback_from_code_execution.ipynb similarity index 99% rename from notebook/autogen_agentchat_auto_feedback_from_code_execution.ipynb rename to notebook/agentchat_auto_feedback_from_code_execution.ipynb index b64360bb4..de81cf4f3 100644 --- a/notebook/autogen_agentchat_auto_feedback_from_code_execution.ipynb +++ b/notebook/agentchat_auto_feedback_from_code_execution.ipynb @@ -5,7 +5,7 @@ "cell_type": "markdown", "metadata": {}, "source": [ - "\"Open" + "\"Open" ] }, { diff --git a/notebook/autogen_agentchat_chess.ipynb b/notebook/agentchat_chess.ipynb similarity index 99% rename from notebook/autogen_agentchat_chess.ipynb rename to notebook/agentchat_chess.ipynb index 253708a51..d859f4701 100644 --- a/notebook/autogen_agentchat_chess.ipynb +++ b/notebook/agentchat_chess.ipynb @@ -5,7 +5,7 @@ "cell_type": "markdown", "metadata": {}, "source": [ - "\"Open" + "\"Open" ] }, { diff --git a/notebook/autogen_agentchat_function_call.ipynb b/notebook/agentchat_function_call.ipynb similarity index 99% rename from notebook/autogen_agentchat_function_call.ipynb rename to notebook/agentchat_function_call.ipynb index 36249153c..35e051f38 100644 --- a/notebook/autogen_agentchat_function_call.ipynb +++ b/notebook/agentchat_function_call.ipynb @@ -6,7 +6,7 @@ "id": "ae1f50ec", "metadata": {}, "source": [ - "\"Open" + "\"Open" ] }, { diff --git a/notebook/autogen_agentchat_groupchat.ipynb b/notebook/agentchat_groupchat.ipynb similarity index 98% rename from notebook/autogen_agentchat_groupchat.ipynb rename to notebook/agentchat_groupchat.ipynb index f6e0d5188..6964408eb 100644 --- a/notebook/autogen_agentchat_groupchat.ipynb +++ b/notebook/agentchat_groupchat.ipynb @@ -5,7 +5,7 @@ "cell_type": "markdown", "metadata": {}, "source": [ - "\"Open" + "\"Open" ] }, { diff --git a/notebook/autogen_agentchat_groupchat_research.ipynb b/notebook/agentchat_groupchat_research.ipynb similarity index 99% rename from notebook/autogen_agentchat_groupchat_research.ipynb rename to notebook/agentchat_groupchat_research.ipynb index 6f01ddacd..599309f1c 100644 --- a/notebook/autogen_agentchat_groupchat_research.ipynb +++ b/notebook/agentchat_groupchat_research.ipynb @@ -5,7 +5,7 @@ "cell_type": "markdown", "metadata": {}, "source": [ - "\"Open" + "\"Open" ] }, { diff --git a/notebook/autogen_agentchat_groupchat_vis.ipynb b/notebook/agentchat_groupchat_vis.ipynb similarity index 99% rename from notebook/autogen_agentchat_groupchat_vis.ipynb rename to notebook/agentchat_groupchat_vis.ipynb index c8be0ced0..4348d224d 100644 --- a/notebook/autogen_agentchat_groupchat_vis.ipynb +++ b/notebook/agentchat_groupchat_vis.ipynb @@ -5,7 +5,7 @@ "cell_type": "markdown", "metadata": {}, "source": [ - "\"Open" + "\"Open" ] }, { diff --git a/notebook/autogen_agentchat_human_feedback.ipynb b/notebook/agentchat_human_feedback.ipynb similarity index 99% rename from notebook/autogen_agentchat_human_feedback.ipynb rename to notebook/agentchat_human_feedback.ipynb index 2119eb5cf..232462ad7 100644 --- a/notebook/autogen_agentchat_human_feedback.ipynb +++ b/notebook/agentchat_human_feedback.ipynb @@ -5,7 +5,7 @@ "cell_type": "markdown", "metadata": {}, "source": [ - "\"Open" + "\"Open" ] }, { diff --git a/notebook/autogen_agentchat_planning.ipynb b/notebook/agentchat_planning.ipynb similarity index 99% rename from notebook/autogen_agentchat_planning.ipynb rename to notebook/agentchat_planning.ipynb index 8622f0cf7..93513fb64 100644 --- a/notebook/autogen_agentchat_planning.ipynb +++ b/notebook/agentchat_planning.ipynb @@ -5,7 +5,7 @@ "cell_type": "markdown", "metadata": {}, "source": [ - "\"Open" + "\"Open" ] }, { diff --git a/notebook/autogen_agentchat_stream.ipynb b/notebook/agentchat_stream.ipynb similarity index 99% rename from notebook/autogen_agentchat_stream.ipynb rename to notebook/agentchat_stream.ipynb index 1c9c53b80..bc2ee88f1 100644 --- a/notebook/autogen_agentchat_stream.ipynb +++ b/notebook/agentchat_stream.ipynb @@ -5,7 +5,7 @@ "cell_type": "markdown", "metadata": {}, "source": [ - "\"Open" + "\"Open" ] }, { diff --git a/notebook/agentchat_teaching.ipynb b/notebook/agentchat_teaching.ipynb new file mode 100644 index 000000000..0d427b70f --- /dev/null +++ b/notebook/agentchat_teaching.ipynb @@ -0,0 +1,970 @@ +{ + "cells": [ + { + "attachments": {}, + "cell_type": "markdown", + "metadata": {}, + "source": [ + "\"Open" + ] + }, + { + "cell_type": "code", + "execution_count": 1, + "metadata": {}, + "outputs": [], + "source": [ + "# %pip install --quiet flaml\"[autogen]\"~=2.1.0" + ] + }, + { + "attachments": {}, + "cell_type": "markdown", + "metadata": {}, + "source": [ + "# Auto Generated Agent Chat: Teaching\n", + "\n", + "AutoGen offers conversable agents powered by LLM, tool or human, which can be used to perform tasks collectively via automated chat. This framwork makes it easy to build many advanced applications of LLMs.\n", + "Please find documentation about this feature [here](https://microsoft.github.io/autogen/docs/Use-Cases/agent_chat).\n", + "\n", + "This notebook demonstrates how AutoGen enables a user to teach AI new skills via natural agent interactions, without requiring knowledge of programming language. It is modified based on https://github.com/microsoft/FLAML/blob/evaluation/notebook/research_paper/teaching.ipynb and https://github.com/microsoft/FLAML/blob/evaluation/notebook/research_paper/teaching_recipe_reuse.ipynb.\n", + "\n", + "## Requirements\n", + "\n", + "AutoGen requires `Python>=3.8`. To run this notebook example, please install:\n", + "```bash\n", + "pip install pyautogen\n", + "```" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [ + "# %pip install --quiet pyautogen~=0.1.0" + ] + }, + { + "attachments": {}, + "cell_type": "markdown", + "metadata": {}, + "source": [ + "## Set your API Endpoint\n", + "\n", + "The [`config_list_from_json`](https://microsoft.github.io/autogen/docs/reference/oai/openai_utils#config_list_from_json) function loads a list of configurations from an environment variable or a json file.\n", + "\n", + "It first looks for environment variable \"OAI_CONFIG_LIST\" which needs to be a valid json string. If that variable is not found, it then looks for a json file named \"OAI_CONFIG_LIST\". It filters the configs by models (you can filter by other keys as well).\n", + "\n", + "The json looks like the following:\n", + "```json\n", + "[\n", + " {\n", + " \"model\": \"gpt-4\",\n", + " \"api_key\": \"\"\n", + " },\n", + " {\n", + " \"model\": \"gpt-4\",\n", + " \"api_key\": \"\",\n", + " \"api_base\": \"\",\n", + " \"api_type\": \"azure\",\n", + " \"api_version\": \"2023-06-01-preview\"\n", + " },\n", + " {\n", + " \"model\": \"gpt-4-32k\",\n", + " \"api_key\": \"\",\n", + " \"api_base\": \"\",\n", + " \"api_type\": \"azure\",\n", + " \"api_version\": \"2023-06-01-preview\"\n", + " }\n", + "]\n", + "```\n", + "\n", + "If you open this notebook in colab, you can upload your files by clicking the file icon on the left panel and then choose \"upload file\" icon.\n" + ] + }, + { + "cell_type": "code", + "execution_count": 2, + "metadata": {}, + "outputs": [], + "source": [ + "from flaml import autogen\n", + "\n", + "llm_config={\n", + " \"request_timeout\": 600,\n", + " \"seed\": 44, # change the seed for different trials\n", + " \"config_list\": autogen.config_list_from_json(\n", + " \"OAI_CONFIG_LIST\",\n", + " filter_dict={\"model\": [\"gpt-4-32k\"]},\n", + " ),\n", + " \"temperature\": 0,\n", + "}" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "## Example Task: Literature Survey\n", + "\n", + "We consider a scenario where one needs to find research papers of a certain topic, categorize the application domains, and plot a bar chart of the number of papers in each domain." + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "### Construct Agents\n", + "\n", + "We create an assistant agent to solve tasks with coding and language skills. We create a user proxy agent to describe tasks and execute the code suggested by the assistant agent." + ] + }, + { + "cell_type": "code", + "execution_count": 3, + "metadata": {}, + "outputs": [], + "source": [ + "# create an AssistantAgent instance named \"assistant\"\n", + "assistant = autogen.AssistantAgent(\n", + " name=\"assistant\",\n", + " llm_config=llm_config,\n", + " is_termination_msg=lambda x: True if \"TERMINATE\" in x.get(\"content\") else False,\n", + ")\n", + "# create a UserProxyAgent instance named \"user_proxy\"\n", + "user_proxy = autogen.UserProxyAgent(\n", + " name=\"user_proxy\",\n", + " human_input_mode=\"NEVER\",\n", + " is_termination_msg=lambda x: True if \"TERMINATE\" in x.get(\"content\") else False,\n", + " max_consecutive_auto_reply=10,\n", + " code_execution_config={\n", + " \"work_dir\": \"work_dir\",\n", + " \"use_docker\": False,\n", + " },\n", + ")" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "### Step-by-step Requests" + ] + }, + { + "cell_type": "code", + "execution_count": 4, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "\u001b[33muser_proxy\u001b[0m (to assistant):\n", + "\n", + "\n", + "Find arxiv papers that show how are people studying trust calibration in AI based systems \n", + "\n", + "\n", + "--------------------------------------------------------------------------------\n", + "\u001b[33massistant\u001b[0m (to user_proxy):\n", + "\n", + "To find arxiv papers related to trust calibration in AI-based systems, we can use the arxiv API to search for relevant papers. I will write a Python script that queries the arxiv API and prints the titles and URLs of the top 10 papers.\n", + "\n", + "Please execute the following Python code:\n", + "\n", + "```python\n", + "import requests\n", + "import feedparser\n", + "\n", + "def search_arxiv(query, max_results=10):\n", + " base_url = \"http://export.arxiv.org/api/query?\"\n", + " search_query = f\"search_query=all:{query}\"\n", + " start = 0\n", + " max_results = f\"max_results={max_results}\"\n", + " url = f\"{base_url}{search_query}&start={start}&{max_results}\"\n", + " response = requests.get(url)\n", + " feed = feedparser.parse(response.content)\n", + " return feed.entries\n", + "\n", + "query = \"trust calibration AI\"\n", + "papers = search_arxiv(query)\n", + "\n", + "for i, paper in enumerate(papers):\n", + " print(f\"{i+1}. {paper.title}\")\n", + " print(f\"URL: {paper.link}\\n\")\n", + "```\n", + "After executing the code, I will analyze the results and provide you with the relevant papers.\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", + "1. Who Should I Trust: AI or Myself? Leveraging Human and AI Correctness\n", + " Likelihood to Promote Appropriate Trust in AI-Assisted Decision-Making\n", + "URL: http://arxiv.org/abs/2301.05809v1\n", + "\n", + "2. Effect of Confidence and Explanation on Accuracy and Trust Calibration\n", + " in AI-Assisted Decision Making\n", + "URL: http://arxiv.org/abs/2001.02114v1\n", + "\n", + "3. Trust Explanations to Do What They Say\n", + "URL: http://arxiv.org/abs/2303.13526v1\n", + "\n", + "4. A Systematic Literature Review of User Trust in AI-Enabled Systems: An\n", + " HCI Perspective\n", + "URL: http://arxiv.org/abs/2304.08795v1\n", + "\n", + "5. Trust Calibration and Trust Respect: A Method for Building Team Cohesion\n", + " in Human Robot Teams\n", + "URL: http://arxiv.org/abs/2110.06809v1\n", + "\n", + "6. Trust Considerations for Explainable Robots: A Human Factors Perspective\n", + "URL: http://arxiv.org/abs/2005.05940v1\n", + "\n", + "7. Experimental Investigation of Trust in Anthropomorphic Agents as Task\n", + " Partners\n", + "URL: http://arxiv.org/abs/2202.01077v2\n", + "\n", + "8. Uncalibrated Models Can Improve Human-AI Collaboration\n", + "URL: http://arxiv.org/abs/2202.05983v3\n", + "\n", + "9. Knowing About Knowing: An Illusion of Human Competence Can Hinder\n", + " Appropriate Reliance on AI Systems\n", + "URL: http://arxiv.org/abs/2301.11333v1\n", + "\n", + "10. A Turing Test for Transparency\n", + "URL: http://arxiv.org/abs/2106.11394v1\n", + "\n", + "\n", + "\n", + "--------------------------------------------------------------------------------\n", + "\u001b[33massistant\u001b[0m (to user_proxy):\n", + "\n", + "I have found the top 10 arxiv papers related to trust calibration in AI-based systems. Here are the titles and URLs of these papers:\n", + "\n", + "1. Who Should I Trust: AI or Myself? Leveraging Human and AI Correctness Likelihood to Promote Appropriate Trust in AI-Assisted Decision-Making\n", + "URL: http://arxiv.org/abs/2301.05809v1\n", + "\n", + "2. Effect of Confidence and Explanation on Accuracy and Trust Calibration in AI-Assisted Decision Making\n", + "URL: http://arxiv.org/abs/2001.02114v1\n", + "\n", + "3. Trust Explanations to Do What They Say\n", + "URL: http://arxiv.org/abs/2303.13526v1\n", + "\n", + "4. A Systematic Literature Review of User Trust in AI-Enabled Systems: An HCI Perspective\n", + "URL: http://arxiv.org/abs/2304.08795v1\n", + "\n", + "5. Trust Calibration and Trust Respect: A Method for Building Team Cohesion in Human Robot Teams\n", + "URL: http://arxiv.org/abs/2110.06809v1\n", + "\n", + "6. Trust Considerations for Explainable Robots: A Human Factors Perspective\n", + "URL: http://arxiv.org/abs/2005.05940v1\n", + "\n", + "7. Experimental Investigation of Trust in Anthropomorphic Agents as Task Partners\n", + "URL: http://arxiv.org/abs/2202.01077v2\n", + "\n", + "8. Uncalibrated Models Can Improve Human-AI Collaboration\n", + "URL: http://arxiv.org/abs/2202.05983v3\n", + "\n", + "9. Knowing About Knowing: An Illusion of Human Competence Can Hinder Appropriate Reliance on AI Systems\n", + "URL: http://arxiv.org/abs/2301.11333v1\n", + "\n", + "10. A Turing Test for Transparency\n", + "URL: http://arxiv.org/abs/2106.11394v1\n", + "\n", + "You can read these papers to learn more about how people are studying trust calibration in AI-based systems. If you need further assistance, please let me know.\n", + "\n", + "TERMINATE\n", + "\n", + "--------------------------------------------------------------------------------\n" + ] + } + ], + "source": [ + "task1 = \"\"\"\n", + "Find arxiv papers that show how are people studying trust calibration in AI based systems \n", + "\"\"\"\n", + "\n", + "user_proxy.initiate_chat(assistant, message=task1)" + ] + }, + { + "cell_type": "code", + "execution_count": 5, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "\u001b[33muser_proxy\u001b[0m (to assistant):\n", + "\n", + "analyze the above the results to list the application domains studied by these papers \n", + "\n", + "--------------------------------------------------------------------------------\n", + "\u001b[33massistant\u001b[0m (to user_proxy):\n", + "\n", + "I will analyze the abstracts of the top 10 arxiv papers related to trust calibration in AI-based systems to identify the application domains studied by these papers. Please execute the following Python code to print the abstracts:\n", + "\n", + "```python\n", + "for i, paper in enumerate(papers):\n", + " print(f\"{i+1}. {paper.title}\")\n", + " print(f\"Abstract: {paper.summary}\\n\")\n", + "```\n", + "\n", + "After executing the code, I will analyze the abstracts and provide you with the application domains studied by these papers.\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 1, in \n", + " for i, paper in enumerate(papers):\n", + "NameError: name 'papers' is not defined\n", + "\n", + "\n", + "--------------------------------------------------------------------------------\n", + "\u001b[33massistant\u001b[0m (to user_proxy):\n", + "\n", + "I apologize for the error. It seems the variable 'papers' is not available anymore. Let me provide you with the complete code to fetch the papers and print their abstracts. Please execute the following Python code:\n", + "\n", + "```python\n", + "import requests\n", + "import feedparser\n", + "\n", + "def search_arxiv(query, max_results=10):\n", + " base_url = \"http://export.arxiv.org/api/query?\"\n", + " search_query = f\"search_query=all:{query}\"\n", + " start = 0\n", + " max_results = f\"max_results={max_results}\"\n", + " url = f\"{base_url}{search_query}&start={start}&{max_results}\"\n", + " response = requests.get(url)\n", + " feed = feedparser.parse(response.content)\n", + " return feed.entries\n", + "\n", + "query = \"trust calibration AI\"\n", + "papers = search_arxiv(query)\n", + "\n", + "for i, paper in enumerate(papers):\n", + " print(f\"{i+1}. {paper.title}\")\n", + " print(f\"Abstract: {paper.summary}\\n\")\n", + "```\n", + "\n", + "After executing the code, I will analyze the abstracts and provide you with the application domains studied by these papers.\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", + "1. Who Should I Trust: AI or Myself? Leveraging Human and AI Correctness\n", + " Likelihood to Promote Appropriate Trust in AI-Assisted Decision-Making\n", + "Abstract: In AI-assisted decision-making, it is critical for human decision-makers to\n", + "know when to trust AI and when to trust themselves. However, prior studies\n", + "calibrated human trust only based on AI confidence indicating AI's correctness\n", + "likelihood (CL) but ignored humans' CL, hindering optimal team decision-making.\n", + "To mitigate this gap, we proposed to promote humans' appropriate trust based on\n", + "the CL of both sides at a task-instance level. We first modeled humans' CL by\n", + "approximating their decision-making models and computing their potential\n", + "performance in similar instances. We demonstrated the feasibility and\n", + "effectiveness of our model via two preliminary studies. Then, we proposed three\n", + "CL exploitation strategies to calibrate users' trust explicitly/implicitly in\n", + "the AI-assisted decision-making process. Results from a between-subjects\n", + "experiment (N=293) showed that our CL exploitation strategies promoted more\n", + "appropriate human trust in AI, compared with only using AI confidence. We\n", + "further provided practical implications for more human-compatible AI-assisted\n", + "decision-making.\n", + "\n", + "2. Effect of Confidence and Explanation on Accuracy and Trust Calibration\n", + " in AI-Assisted Decision Making\n", + "Abstract: Today, AI is being increasingly used to help human experts make decisions in\n", + "high-stakes scenarios. In these scenarios, full automation is often\n", + "undesirable, not only due to the significance of the outcome, but also because\n", + "human experts can draw on their domain knowledge complementary to the model's\n", + "to ensure task success. We refer to these scenarios as AI-assisted decision\n", + "making, where the individual strengths of the human and the AI come together to\n", + "optimize the joint decision outcome. A key to their success is to appropriately\n", + "\\textit{calibrate} human trust in the AI on a case-by-case basis; knowing when\n", + "to trust or distrust the AI allows the human expert to appropriately apply\n", + "their knowledge, improving decision outcomes in cases where the model is likely\n", + "to perform poorly. This research conducts a case study of AI-assisted decision\n", + "making in which humans and AI have comparable performance alone, and explores\n", + "whether features that reveal case-specific model information can calibrate\n", + "trust and improve the joint performance of the human and AI. Specifically, we\n", + "study the effect of showing confidence score and local explanation for a\n", + "particular prediction. Through two human experiments, we show that confidence\n", + "score can help calibrate people's trust in an AI model, but trust calibration\n", + "alone is not sufficient to improve AI-assisted decision making, which may also\n", + "depend on whether the human can bring in enough unique knowledge to complement\n", + "the AI's errors. We also highlight the problems in using local explanation for\n", + "AI-assisted decision making scenarios and invite the research community to\n", + "explore new approaches to explainability for calibrating human trust in AI.\n", + "\n", + "3. Trust Explanations to Do What They Say\n", + "Abstract: How much are we to trust a decision made by an AI algorithm? Trusting an\n", + "algorithm without cause may lead to abuse, and mistrusting it may similarly\n", + "lead to disuse. Trust in an AI is only desirable if it is warranted; thus,\n", + "calibrating trust is critical to ensuring appropriate use. In the name of\n", + "calibrating trust appropriately, AI developers should provide contracts\n", + "specifying use cases in which an algorithm can and cannot be trusted. Automated\n", + "explanation of AI outputs is often touted as a method by which trust can be\n", + "built in the algorithm. However, automated explanations arise from algorithms\n", + "themselves, so trust in these explanations is similarly only desirable if it is\n", + "warranted. Developers of algorithms explaining AI outputs (xAI algorithms)\n", + "should provide similar contracts, which should specify use cases in which an\n", + "explanation can and cannot be trusted.\n", + "\n", + "4. A Systematic Literature Review of User Trust in AI-Enabled Systems: An\n", + " HCI Perspective\n", + "Abstract: User trust in Artificial Intelligence (AI) enabled systems has been\n", + "increasingly recognized and proven as a key element to fostering adoption. It\n", + "has been suggested that AI-enabled systems must go beyond technical-centric\n", + "approaches and towards embracing a more human centric approach, a core\n", + "principle of the human-computer interaction (HCI) field. This review aims to\n", + "provide an overview of the user trust definitions, influencing factors, and\n", + "measurement methods from 23 empirical studies to gather insight for future\n", + "technical and design strategies, research, and initiatives to calibrate the\n", + "user AI relationship. The findings confirm that there is more than one way to\n", + "define trust. Selecting the most appropriate trust definition to depict user\n", + "trust in a specific context should be the focus instead of comparing\n", + "definitions. User trust in AI-enabled systems is found to be influenced by\n", + "three main themes, namely socio-ethical considerations, technical and design\n", + "features, and user characteristics. User characteristics dominate the findings,\n", + "reinforcing the importance of user involvement from development through to\n", + "monitoring of AI enabled systems. In conclusion, user trust needs to be\n", + "addressed directly in every context where AI-enabled systems are being used or\n", + "discussed. In addition, calibrating the user-AI relationship requires finding\n", + "the optimal balance that works for not only the user but also the system.\n", + "\n", + "5. Trust Calibration and Trust Respect: A Method for Building Team Cohesion\n", + " in Human Robot Teams\n", + "Abstract: Recent advances in the areas of human-robot interaction (HRI) and robot\n", + "autonomy are changing the world. Today robots are used in a variety of\n", + "applications. People and robots work together in human autonomous teams (HATs)\n", + "to accomplish tasks that, separately, cannot be easily accomplished. Trust\n", + "between robots and humans in HATs is vital to task completion and effective\n", + "team cohesion. For optimal performance and safety of human operators in HRI,\n", + "human trust should be adjusted to the actual performance and reliability of the\n", + "robotic system. The cost of poor trust calibration in HRI, is at a minimum, low\n", + "performance, and at higher levels it causes human injury or critical task\n", + "failures. While the role of trust calibration is vital to team cohesion it is\n", + "also important for a robot to be able to assess whether or not a human is\n", + "exhibiting signs of mistrust due to some other factor such as anger,\n", + "distraction or frustration. In these situations the robot chooses not to\n", + "calibrate trust, instead the robot chooses to respect trust. The decision to\n", + "respect trust is determined by the robots knowledge of whether or not a human\n", + "should trust the robot based on its actions(successes and failures) and its\n", + "feedback to the human. We show that the feedback in the form of trust\n", + "calibration cues(TCCs) can effectively change the trust level in humans. This\n", + "information is potentially useful in aiding a robot it its decision to respect\n", + "trust.\n", + "\n", + "6. Trust Considerations for Explainable Robots: A Human Factors Perspective\n", + "Abstract: Recent advances in artificial intelligence (AI) and robotics have drawn\n", + "attention to the need for AI systems and robots to be understandable to human\n", + "users. The explainable AI (XAI) and explainable robots literature aims to\n", + "enhance human understanding and human-robot team performance by providing users\n", + "with necessary information about AI and robot behavior. Simultaneously, the\n", + "human factors literature has long addressed important considerations that\n", + "contribute to human performance, including human trust in autonomous systems.\n", + "In this paper, drawing from the human factors literature, we discuss three\n", + "important trust-related considerations for the design of explainable robot\n", + "systems: the bases of trust, trust calibration, and trust specificity. We\n", + "further detail existing and potential metrics for assessing trust in robotic\n", + "systems based on explanations provided by explainable robots.\n", + "\n", + "7. Experimental Investigation of Trust in Anthropomorphic Agents as Task\n", + " Partners\n", + "Abstract: This study investigated whether human trust in a social robot with\n", + "anthropomorphic physicality is similar to that in an AI agent or in a human in\n", + "order to clarify how anthropomorphic physicality influences human trust in an\n", + "agent. We conducted an online experiment using two types of cognitive tasks,\n", + "calculation and emotion recognition tasks, where participants answered after\n", + "referring to the answers of an AI agent, a human, or a social robot. During the\n", + "experiment, the participants rated their trust levels in their partners. As a\n", + "result, trust in the social robot was basically neither similar to that in the\n", + "AI agent nor in the human and instead settled between them. The results showed\n", + "a possibility that manipulating anthropomorphic features would help assist\n", + "human users in appropriately calibrating trust in an agent.\n", + "\n", + "8. Uncalibrated Models Can Improve Human-AI Collaboration\n", + "Abstract: In many practical applications of AI, an AI model is used as a decision aid\n", + "for human users. The AI provides advice that a human (sometimes) incorporates\n", + "into their decision-making process. The AI advice is often presented with some\n", + "measure of \"confidence\" that the human can use to calibrate how much they\n", + "depend on or trust the advice. In this paper, we present an initial exploration\n", + "that suggests showing AI models as more confident than they actually are, even\n", + "when the original AI is well-calibrated, can improve human-AI performance\n", + "(measured as the accuracy and confidence of the human's final prediction after\n", + "seeing the AI advice). We first train a model to predict human incorporation of\n", + "AI advice using data from thousands of human-AI interactions. This enables us\n", + "to explicitly estimate how to transform the AI's prediction confidence, making\n", + "the AI uncalibrated, in order to improve the final human prediction. We\n", + "empirically validate our results across four different tasks--dealing with\n", + "images, text and tabular data--involving hundreds of human participants. We\n", + "further support our findings with simulation analysis. Our findings suggest the\n", + "importance of jointly optimizing the human-AI system as opposed to the standard\n", + "paradigm of optimizing the AI model alone.\n", + "\n", + "9. Knowing About Knowing: An Illusion of Human Competence Can Hinder\n", + " Appropriate Reliance on AI Systems\n", + "Abstract: The dazzling promises of AI systems to augment humans in various tasks hinge\n", + "on whether humans can appropriately rely on them. Recent research has shown\n", + "that appropriate reliance is the key to achieving complementary team\n", + "performance in AI-assisted decision making. This paper addresses an\n", + "under-explored problem of whether the Dunning-Kruger Effect (DKE) among people\n", + "can hinder their appropriate reliance on AI systems. DKE is a metacognitive\n", + "bias due to which less-competent individuals overestimate their own skill and\n", + "performance. Through an empirical study (N = 249), we explored the impact of\n", + "DKE on human reliance on an AI system, and whether such effects can be\n", + "mitigated using a tutorial intervention that reveals the fallibility of AI\n", + "advice, and exploiting logic units-based explanations to improve user\n", + "understanding of AI advice. We found that participants who overestimate their\n", + "performance tend to exhibit under-reliance on AI systems, which hinders optimal\n", + "team performance. Logic units-based explanations did not help users in either\n", + "improving the calibration of their competence or facilitating appropriate\n", + "reliance. While the tutorial intervention was highly effective in helping users\n", + "calibrate their self-assessment and facilitating appropriate reliance among\n", + "participants with overestimated self-assessment, we found that it can\n", + "potentially hurt the appropriate reliance of participants with underestimated\n", + "self-assessment. Our work has broad implications on the design of methods to\n", + "tackle user cognitive biases while facilitating appropriate reliance on AI\n", + "systems. Our findings advance the current understanding of the role of\n", + "self-assessment in shaping trust and reliance in human-AI decision making. This\n", + "lays out promising future directions for relevant HCI research in this\n", + "community.\n", + "\n", + "10. A Turing Test for Transparency\n", + "Abstract: A central goal of explainable artificial intelligence (XAI) is to improve the\n", + "trust relationship in human-AI interaction. One assumption underlying research\n", + "in transparent AI systems is that explanations help to better assess\n", + "predictions of machine learning (ML) models, for instance by enabling humans to\n", + "identify wrong predictions more efficiently. Recent empirical evidence however\n", + "shows that explanations can have the opposite effect: When presenting\n", + "explanations of ML predictions humans often tend to trust ML predictions even\n", + "when these are wrong. Experimental evidence suggests that this effect can be\n", + "attributed to how intuitive, or human, an AI or explanation appears. This\n", + "effect challenges the very goal of XAI and implies that responsible usage of\n", + "transparent AI methods has to consider the ability of humans to distinguish\n", + "machine generated from human explanations. Here we propose a quantitative\n", + "metric for XAI methods based on Turing's imitation game, a Turing Test for\n", + "Transparency. A human interrogator is asked to judge whether an explanation was\n", + "generated by a human or by an XAI method. Explanations of XAI methods that can\n", + "not be detected by humans above chance performance in this binary\n", + "classification task are passing the test. Detecting such explanations is a\n", + "requirement for assessing and calibrating the trust relationship in human-AI\n", + "interaction. We present experimental results on a crowd-sourced text\n", + "classification task demonstrating that even for basic ML models and XAI\n", + "approaches most participants were not able to differentiate human from machine\n", + "generated explanations. We discuss ethical and practical implications of our\n", + "results for applications of transparent ML.\n", + "\n", + "\n", + "\n", + "--------------------------------------------------------------------------------\n", + "\u001b[33massistant\u001b[0m (to user_proxy):\n", + "\n", + "After analyzing the abstracts of the top 10 arxiv papers related to trust calibration in AI-based systems, I have identified the following application domains studied by these papers:\n", + "\n", + "1. AI-assisted decision-making: Papers 1, 2, and 9 focus on how humans can appropriately trust AI systems in decision-making processes, considering factors such as AI confidence, human competence, and the Dunning-Kruger Effect.\n", + "\n", + "2. Human-robot interaction (HRI) and human-autonomous teams (HATs): Papers 5 and 6 discuss trust calibration in the context of human-robot teams, focusing on team cohesion, trust calibration cues, and explainable robot systems.\n", + "\n", + "3. Explainable AI (XAI) and transparency: Papers 3, 8, and 10 explore the role of explanations and transparency in AI systems, addressing issues such as trust in explanations, uncalibrated models, and the Turing Test for Transparency.\n", + "\n", + "4. Human-computer interaction (HCI) perspective on user trust in AI-enabled systems: Paper 4 presents a systematic literature review of user trust in AI-enabled systems from an HCI perspective, discussing trust definitions, influencing factors, and measurement methods.\n", + "\n", + "5. Anthropomorphic agents and social robots: Paper 7 investigates the influence of anthropomorphic physicality on human trust in agents, comparing trust in AI agents, humans, and social robots.\n", + "\n", + "These application domains provide insights into various aspects of trust calibration in AI-based systems, including decision-making, human-robot interaction, explainable AI, and user trust from an HCI perspective.\n", + "\n", + "--------------------------------------------------------------------------------\n", + "\u001b[33muser_proxy\u001b[0m (to assistant):\n", + "\n", + "\n", + "\n", + "--------------------------------------------------------------------------------\n", + "\u001b[33massistant\u001b[0m (to user_proxy):\n", + "\n", + "TERMINATE\n", + "\n", + "--------------------------------------------------------------------------------\n" + ] + } + ], + "source": [ + "task2 = \"analyze the above the results to list the application domains studied by these papers \"\n", + "user_proxy.initiate_chat(assistant, message=task2, clear_history=False)" + ] + }, + { + "cell_type": "code", + "execution_count": 6, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "\u001b[33muser_proxy\u001b[0m (to assistant):\n", + "\n", + "Use this data to generate a bar chart of domains and number of papers in that domain and save to a file \n", + "\n", + "\n", + "--------------------------------------------------------------------------------\n", + "\u001b[33massistant\u001b[0m (to user_proxy):\n", + "\n", + "I will create a Python script that generates a bar chart of the application domains and the number of papers in each domain using the data we have analyzed. The chart will be saved as an image file. Please execute the following Python code:\n", + "\n", + "```python\n", + "import matplotlib.pyplot as plt\n", + "\n", + "domains = {\n", + " \"AI-assisted decision-making\": 3,\n", + " \"Human-robot interaction (HRI) and human-autonomous teams (HATs)\": 2,\n", + " \"Explainable AI (XAI) and transparency\": 3,\n", + " \"HCI perspective on user trust in AI-enabled systems\": 1,\n", + " \"Anthropomorphic agents and social robots\": 1,\n", + "}\n", + "\n", + "fig, ax = plt.subplots()\n", + "ax.bar(domains.keys(), domains.values())\n", + "plt.xticks(rotation=45, ha=\"right\")\n", + "plt.xlabel(\"Application Domains\")\n", + "plt.ylabel(\"Number of Papers\")\n", + "plt.title(\"Number of Papers per Application Domain\")\n", + "\n", + "plt.tight_layout()\n", + "plt.savefig(\"domains_bar_chart.png\")\n", + "plt.show()\n", + "```\n", + "\n", + "This code will generate a bar chart of the application domains and the number of papers in each domain, and save it as an image file named \"domains_bar_chart.png\" in the current working directory.\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", + "Figure(640x480)\n", + "\n", + "\n", + "--------------------------------------------------------------------------------\n", + "\u001b[33massistant\u001b[0m (to user_proxy):\n", + "\n", + "I'm glad the code executed successfully. The bar chart of the application domains and the number of papers in each domain has been generated and saved as an image file named \"domains_bar_chart.png\" in your current working directory. You can now view the chart by opening the image file.\n", + "\n", + "If you need further assistance, please let me know.\n", + "\n", + "TERMINATE\n", + "\n", + "--------------------------------------------------------------------------------\n" + ] + } + ], + "source": [ + "task3 = \"\"\"Use this data to generate a bar chart of domains and number of papers in that domain and save to a file \n", + "\"\"\"\n", + "user_proxy.initiate_chat(assistant, message=task3, clear_history=False)" + ] + }, + { + "cell_type": "code", + "execution_count": 1, + "metadata": {}, + "outputs": [ + { + "data": { + "image/png": "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", + "text/plain": [ + "" + ] + }, + "execution_count": 1, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "# from IPython.display import Image\n", + "\n", + "# Image(filename='work_dir/domains_bar_chart.png')" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "## Create Recipes\n", + "\n", + "Now that the task has finished via a number of interactions. The user does not want to repeat these many steps in future. What can the user do?\n", + "\n", + "A followup request can be made to create a reusable recipe." + ] + }, + { + "cell_type": "code", + "execution_count": 7, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "\u001b[33muser_proxy\u001b[0m (to assistant):\n", + "\n", + "Reflect on the sequence and create a recipe containing all the steps \n", + "necessary and name for it. Suggest well-documented, generalized python function(s)\n", + " to perform similar tasks for coding steps in future. Make sure coding steps and \n", + " non-coding steps are never mixed in one function. In the docstr of the function(s),\n", + " clarify what non-coding steps are needed to use the language skill of the assistant.\n", + "\n", + "\n", + "--------------------------------------------------------------------------------\n", + "\u001b[33massistant\u001b[0m (to user_proxy):\n", + "\n", + "Based on the sequence of tasks performed, I propose the following recipe:\n", + "\n", + "**Recipe Name:** Analyzing and Visualizing Application Domains in Arxiv Papers\n", + "\n", + "**Steps:**\n", + "\n", + "1. Collect relevant papers from arxiv using a search query.\n", + "2. Analyze the abstracts of the collected papers to identify application domains.\n", + "3. Count the number of papers in each application domain.\n", + "4. Generate a bar chart of the application domains and the number of papers in each domain.\n", + "5. Save the bar chart as an image file.\n", + "\n", + "Here are the well-documented, generalized Python functions to perform the coding steps in the future:\n", + "\n", + "```python\n", + "import requests\n", + "import feedparser\n", + "import matplotlib.pyplot as plt\n", + "from typing import List, Dict\n", + "\n", + "def search_arxiv(query: str, max_results: int = 10) -> List[Dict[str, str]]:\n", + " \"\"\"\n", + " Search arxiv for papers related to a specific query.\n", + " \n", + " :param query: The search query for arxiv papers.\n", + " :param max_results: The maximum number of results to return. Default is 10.\n", + " :return: A list of dictionaries containing the title, link, and summary of each paper.\n", + " \"\"\"\n", + " base_url = \"http://export.arxiv.org/api/query?\"\n", + " search_query = f\"search_query=all:{query}\"\n", + " start = 0\n", + " max_results = f\"max_results={max_results}\"\n", + " url = f\"{base_url}{search_query}&start={start}&{max_results}\"\n", + " response = requests.get(url)\n", + " feed = feedparser.parse(response.content)\n", + " \n", + " papers = [{\"title\": entry.title, \"link\": entry.link, \"summary\": entry.summary} for entry in feed.entries]\n", + " return papers\n", + "\n", + "def generate_bar_chart(domains: Dict[str, int], output_file: str) -> None:\n", + " \"\"\"\n", + " Generate a bar chart of application domains and the number of papers in each domain, and save it as an image file.\n", + " \n", + " :param domains: A dictionary containing application domains as keys and the number of papers as values.\n", + " :param output_file: The name of the output image file.\n", + " \"\"\"\n", + " fig, ax = plt.subplots()\n", + " ax.bar(domains.keys(), domains.values())\n", + " plt.xticks(rotation=45, ha=\"right\")\n", + " plt.xlabel(\"Application Domains\")\n", + " plt.ylabel(\"Number of Papers\")\n", + " plt.title(\"Number of Papers per Application Domain\")\n", + "\n", + " plt.tight_layout()\n", + " plt.savefig(output_file)\n", + " plt.show()\n", + "```\n", + "\n", + "**Usage:**\n", + "\n", + "1. Use the `search_arxiv` function to collect relevant papers from arxiv using a search query.\n", + "2. Analyze the abstracts of the collected papers using your language skills to identify application domains and count the number of papers in each domain.\n", + "3. Use the `generate_bar_chart` function to generate a bar chart of the application domains and the number of papers in each domain, and save it as an image file.\n", + "\n", + "In the docstrings of the functions, I have clarified that non-coding steps, such as analyzing the abstracts of the collected papers, are needed to use the language skill of the assistant.\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", + "\n", + "\n", + "--------------------------------------------------------------------------------\n", + "\u001b[33massistant\u001b[0m (to user_proxy):\n", + "\n", + "I'm glad you found the provided recipe and Python functions helpful. If you have any questions or need further assistance, please feel free to ask.\n", + "\n", + "TERMINATE\n", + "\n", + "--------------------------------------------------------------------------------\n" + ] + } + ], + "source": [ + "task4 = \"\"\"Reflect on the sequence and create a recipe containing all the steps \n", + "necessary and name for it. Suggest well-documented, generalized python function(s)\n", + " to perform similar tasks for coding steps in future. Make sure coding steps and \n", + " non-coding steps are never mixed in one function. In the docstr of the function(s),\n", + " clarify what non-coding steps are needed to use the language skill of the assistant.\n", + "\"\"\"\n", + "user_proxy.initiate_chat(assistant, message=task4, clear_history=False)" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "## Reuse Recipes\n", + "\n", + "The user can apply the same recipe to similar tasks in future.\n", + "\n", + "### Example Application" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [ + "# create an AssistantAgent instance named \"assistant\"\n", + "assistant = autogen.AssistantAgent(\n", + " name=\"assistant\",\n", + " llm_config=llm_config,\n", + " is_termination_msg=lambda x: True if \"TERMINATE\" in x.get(\"content\") else False,\n", + ")\n", + "# create a UserProxyAgent instance named \"user_proxy\"\n", + "user_proxy = autogen.UserProxyAgent(\n", + " name=\"user_proxy\",\n", + " human_input_mode=\"NEVER\",\n", + " is_termination_msg=lambda x: True if \"TERMINATE\" in x.get(\"content\") else False,\n", + " max_consecutive_auto_reply=10,\n", + " code_execution_config={\n", + " \"work_dir\": \"work_dir\",\n", + " \"use_docker\": False,\n", + " },\n", + ")\n", + "\n", + "task1 = '''\n", + "This recipe is available for you to reuse..\n", + "\n", + "\n", + "**Recipe Name:** Analyzing and Visualizing Application Domains in Arxiv Papers\n", + "\n", + "**Steps:**\n", + "\n", + "1. Collect relevant papers from arxiv using a search query.\n", + "2. Analyze the abstracts of the collected papers to identify application domains.\n", + "3. Count the number of papers in each application domain.\n", + "4. Generate a bar chart of the application domains and the number of papers in each domain.\n", + "5. Save the bar chart as an image file.\n", + "\n", + "Here are the well-documented, generalized Python functions to perform the coding steps in the future:\n", + "\n", + "```python\n", + "import requests\n", + "import feedparser\n", + "import matplotlib.pyplot as plt\n", + "from typing import List, Dict\n", + "\n", + "def search_arxiv(query: str, max_results: int = 10) -> List[Dict[str, str]]:\n", + " \"\"\"\n", + " Search arxiv for papers related to a specific query.\n", + " \n", + " :param query: The search query for arxiv papers.\n", + " :param max_results: The maximum number of results to return. Default is 10.\n", + " :return: A list of dictionaries containing the title, link, and summary of each paper.\n", + " \"\"\"\n", + " base_url = \"http://export.arxiv.org/api/query?\"\n", + " search_query = f\"search_query=all:{query}\"\n", + " start = 0\n", + " max_results = f\"max_results={max_results}\"\n", + " url = f\"{base_url}{search_query}&start={start}&{max_results}\"\n", + " response = requests.get(url)\n", + " feed = feedparser.parse(response.content)\n", + " \n", + " papers = [{\"title\": entry.title, \"link\": entry.link, \"summary\": entry.summary} for entry in feed.entries]\n", + " return papers\n", + "\n", + "def generate_bar_chart(domains: Dict[str, int], output_file: str) -> None:\n", + " \"\"\"\n", + " Generate a bar chart of application domains and the number of papers in each domain, and save it as an image file.\n", + " \n", + " :param domains: A dictionary containing application domains as keys and the number of papers as values.\n", + " :param output_file: The name of the output image file.\n", + " \"\"\"\n", + " fig, ax = plt.subplots()\n", + " ax.bar(domains.keys(), domains.values())\n", + " plt.xticks(rotation=45, ha=\"right\")\n", + " plt.xlabel(\"Application Domains\")\n", + " plt.ylabel(\"Number of Papers\")\n", + " plt.title(\"Number of Papers per Application Domain\")\n", + "\n", + " plt.tight_layout()\n", + " plt.savefig(output_file)\n", + " plt.show()\n", + "```\n", + "\n", + "**Usage:**\n", + "\n", + "1. Use the `search_arxiv` function to collect relevant papers from arxiv using a search query.\n", + "2. Analyze the abstracts of the collected papers using your language skills to identify application domains and count the number of papers in each domain.\n", + "3. Use the `generate_bar_chart` function to generate a bar chart of the application domains and the number of papers in each domain, and save it as an image file.\n", + "\n", + "\n", + "\n", + "\n", + "Here is a new task:\n", + "Plot a chart for application domains of GPT models\n", + "'''\n", + "\n", + "user_proxy.initiate_chat(assistant, message=task1)" + ] + } + ], + "metadata": { + "kernelspec": { + "display_name": "flaml-eval", + "language": "python", + "name": "python3" + }, + "language_info": { + "codemirror_mode": { + "name": "ipython", + "version": 3 + }, + "file_extension": ".py", + "mimetype": "text/x-python", + "name": "python", + "nbconvert_exporter": "python", + "pygments_lexer": "ipython3", + "version": "3.9.17" + }, + "orig_nbformat": 4 + }, + "nbformat": 4, + "nbformat_minor": 2 +} diff --git a/notebook/autogen_agentchat_two_users.ipynb b/notebook/agentchat_two_users.ipynb similarity index 99% rename from notebook/autogen_agentchat_two_users.ipynb rename to notebook/agentchat_two_users.ipynb index dba644ca9..1c20a58b1 100644 --- a/notebook/autogen_agentchat_two_users.ipynb +++ b/notebook/agentchat_two_users.ipynb @@ -5,7 +5,7 @@ "cell_type": "markdown", "metadata": {}, "source": [ - "\"Open" + "\"Open" ] }, { diff --git a/notebook/autogen_agentchat_web_info.ipynb b/notebook/agentchat_web_info.ipynb similarity index 99% rename from notebook/autogen_agentchat_web_info.ipynb rename to notebook/agentchat_web_info.ipynb index d8cd9c21f..6ec0b0671 100644 --- a/notebook/autogen_agentchat_web_info.ipynb +++ b/notebook/agentchat_web_info.ipynb @@ -5,7 +5,7 @@ "cell_type": "markdown", "metadata": {}, "source": [ - "\"Open" + "\"Open" ] }, { diff --git a/notebook/autogen_chatgpt_gpt4.ipynb b/notebook/oai_chatgpt_gpt4.ipynb similarity index 99% rename from notebook/autogen_chatgpt_gpt4.ipynb rename to notebook/oai_chatgpt_gpt4.ipynb index db07b23af..c3f09943e 100644 --- a/notebook/autogen_chatgpt_gpt4.ipynb +++ b/notebook/oai_chatgpt_gpt4.ipynb @@ -5,7 +5,7 @@ "cell_type": "markdown", "metadata": {}, "source": [ - "\"Open" + "\"Open" ] }, { diff --git a/notebook/autogen_openai_completion.ipynb b/notebook/oai_completion.ipynb similarity index 99% rename from notebook/autogen_openai_completion.ipynb rename to notebook/oai_completion.ipynb index 5ffde3cf0..01cd77a49 100644 --- a/notebook/autogen_openai_completion.ipynb +++ b/notebook/oai_completion.ipynb @@ -5,7 +5,7 @@ "cell_type": "markdown", "metadata": {}, "source": [ - "\"Open" + "\"Open" ] }, { diff --git a/test/test_notebook.py b/test/test_notebook.py index 880249cdf..9d50f7325 100644 --- a/test/test_notebook.py +++ b/test/test_notebook.py @@ -48,45 +48,45 @@ def run_notebook(input_nb, output_nb="executed_openai_notebook.ipynb", save=Fals skip or not sys.version.startswith("3.10"), reason="do not run if openai is not installed or py!=3.10", ) -def test_autogen_agentchat_auto_feedback_from_code(save=False): - run_notebook("autogen_agentchat_auto_feedback_from_code_execution.ipynb", save=save) +def test_agentchat_auto_feedback_from_code(save=False): + run_notebook("agentchat_auto_feedback_from_code_execution.ipynb", save=save) @pytest.mark.skipif( skip or not sys.version.startswith("3.10"), reason="do not run if openai is not installed or py!=3.10", ) -def test_autogen_openai_completion(save=False): - run_notebook("autogen_openai_completion.ipynb", save=save) +def test_openai_completion(save=False): + run_notebook("openai_completion.ipynb", save=save) @pytest.mark.skipif( skip or not sys.version.startswith("3.10"), reason="do not run if openai is not installed or py!=3.10", ) -def test_autogen_agentchat_function_call(save=False): - run_notebook("autogen_agentchat_function_call.ipynb", save=save) +def test_agentchat_function_call(save=False): + run_notebook("agentchat_function_call.ipynb", save=save) @pytest.mark.skipif( skip or not sys.version.startswith("3.10"), reason="do not run if openai is not installed or py!=3.10", ) -def test_autogen_agentchat_MathChat(save=False): - run_notebook("autogen_agentchat_MathChat.ipynb", save=save) +def test_agentchat_MathChat(save=False): + run_notebook("agentchat_MathChat.ipynb", save=save) @pytest.mark.skipif( skip or not sys.version.startswith("3.11"), reason="do not run if openai is not installed or py!=3.11", ) -def test_autogen_chatgpt_gpt4(save=False): - run_notebook("autogen_chatgpt_gpt4.ipynb", save=save) +def test_chatgpt_gpt4(save=False): + run_notebook("chatgpt_gpt4.ipynb", save=save) if __name__ == "__main__": - test_autogen_agentchat_auto_feedback_from_code(save=True) - # test_autogen_chatgpt_gpt4(save=True) - # test_autogen_openai_completion(save=True) - # test_autogen_agentchat_MathChat(save=True) - # test_autogen_agentchat_function_call(save=True) + test_agentchat_auto_feedback_from_code(save=True) + # test_chatgpt_gpt4(save=True) + # test_openai_completion(save=True) + # test_agentchat_MathChat(save=True) + # test_agentchat_function_call(save=True) diff --git a/website/blog/2023-06-28-MathChat/index.mdx b/website/blog/2023-06-28-MathChat/index.mdx index 986beed4e..cb2bcf296 100644 --- a/website/blog/2023-06-28-MathChat/index.mdx +++ b/website/blog/2023-06-28-MathChat/index.mdx @@ -75,7 +75,7 @@ We found that compared to basic prompting, which demonstrates the innate capabil For categories like Algebra and Prealgebra, PoT and PS showed little improvement, and in some instances, even led to a decrease in accuracy. However, MathChat was able to enhance total accuracy by around 6% compared to PoT and PS, showing competitive performance across all categories. Remarkably, MathChat improved accuracy in the Algebra category by about 15% over other methods. Note that categories like Intermediate Algebra and Precalculus remained challenging for all methods, with only about 20% of problems solved accurately. The code for experiments can be found at this [repository](https://github.com/kevin666aa/FLAML/tree/gpt_math_solver/flaml/autogen/math). -We now provide an implementation of MathChat using the interactive agents in AutoGen. See this [notebook](https://github.com/microsoft/autogen/blob/main/notebook/autogen_agentchat_MathChat.ipynb) for example usage. +We now provide an implementation of MathChat using the interactive agents in AutoGen. See this [notebook](https://github.com/microsoft/autogen/blob/main/notebook/agentchat_MathChat.ipynb) for example usage. ## Future Directions diff --git a/website/docs/Examples/AutoGen-AgentChat.md b/website/docs/Examples/AutoGen-AgentChat.md index e34d3cf70..a41cd2f25 100644 --- a/website/docs/Examples/AutoGen-AgentChat.md +++ b/website/docs/Examples/AutoGen-AgentChat.md @@ -4,14 +4,15 @@ AutoGen offers conversable agents powered by LLM, tool or human, which can be us Please find documentation about this feature [here](/docs/Use-Cases/agent_chat). Links to notebook examples: -* [Automated Task Solving with Code Generation, Execution & Debugging](https://github.com/microsoft/autogen/blob/main/notebook/autogen_agentchat_auto_feedback_from_code_execution.ipynb) -* [Auto Code Generation, Execution, Debugging and Human Feedback](https://github.com/microsoft/autogen/blob/main/notebook/autogen_agentchat_human_feedback.ipynb) -* [Solve Tasks Requiring Web Info](https://github.com/microsoft/autogen/blob/main/notebook/autogen_agentchat_web_info.ipynb) -* [Use Provided Tools as Functions](https://github.com/microsoft/autogen/blob/main/notebook/autogen_agentchat_function_call.ipynb) -* [Automated Task Solving with Coding & Planning Agents](https://github.com/microsoft/autogen/blob/main/notebook/autogen_agentchat_planning.ipynb) -* [Automated Task Solving with GPT-4 + Multiple Human Users](https://github.com/microsoft/autogen/blob/main/notebook/autogen_agentchat_two_users.ipynb) -* [Automated Chess Game Playing & Chitchatting by GPT-4 Agents](https://github.com/microsoft/autogen/blob/main/notebook/autogen_agentchat_chess.ipynb) -* [Automated Task Solving by Group Chat (with 3 group member agents and 1 manager agent)](https://github.com/microsoft/autogen/blob/main/notebook/autogen_agentchat_groupchat.ipynb) -* [Automated Data Visualization by Group Chat (with 3 group member agents and 1 manager agent)](https://github.com/microsoft/autogen/blob/main/notebook/autogen_agentchat_groupchat_vis.ipynb) -* [Automated Complex Task Solving by Group Chat (with 6 group member agents and 1 manager agent)](https://github.com/microsoft/autogen/blob/main/notebook/autogen_agentchat_groupchat_research.ipynb) -* [Automated Continual Learning from New Data](https://github.com/microsoft/autogen/blob/main/notebook/autogen_agentchat_stream.ipynb) +* [Automated Task Solving with Code Generation, Execution & Debugging](https://github.com/microsoft/autogen/blob/main/notebook/agentchat_auto_feedback_from_code_execution.ipynb) +* [Auto Code Generation, Execution, Debugging and Human Feedback](https://github.com/microsoft/autogen/blob/main/notebook/agentchat_human_feedback.ipynb) +* [Solve Tasks Requiring Web Info](https://github.com/microsoft/autogen/blob/main/notebook/agentchat_web_info.ipynb) +* [Use Provided Tools as Functions](https://github.com/microsoft/autogen/blob/main/notebook/agentchat_function_call.ipynb) +* [Automated Task Solving with Coding & Planning Agents](https://github.com/microsoft/autogen/blob/main/notebook/agentchat_planning.ipynb) +* [Automated Task Solving with GPT-4 + Multiple Human Users](https://github.com/microsoft/autogen/blob/main/notebook/agentchat_two_users.ipynb) +* [Automated Chess Game Playing & Chitchatting by GPT-4 Agents](https://github.com/microsoft/autogen/blob/main/notebook/agentchat_chess.ipynb) +* [Automated Task Solving by Group Chat (with 3 group member agents and 1 manager agent)](https://github.com/microsoft/autogen/blob/main/notebook/agentchat_groupchat.ipynb) +* [Automated Data Visualization by Group Chat (with 3 group member agents and 1 manager agent)](https://github.com/microsoft/autogen/blob/main/notebook/agentchat_groupchat_vis.ipynb) +* [Automated Complex Task Solving by Group Chat (with 6 group member agents and 1 manager agent)](https://github.com/microsoft/autogen/blob/main/notebook/agentchat_groupchat_research.ipynb) +* [Automated Continual Learning from New Data](https://github.com/microsoft/autogen/blob/main/notebook/agentchat_stream.ipynb) +* [Teach Agents New Skills & Reuse via Automated Chat](https://github.com/microsoft/autogen/blob/main/notebook/agentchat_teaching.ipynb) diff --git a/website/docs/Examples/AutoGen-OpenAI.md b/website/docs/Examples/AutoGen-OpenAI.md index c44b77018..d68504a1c 100644 --- a/website/docs/Examples/AutoGen-OpenAI.md +++ b/website/docs/Examples/AutoGen-OpenAI.md @@ -4,5 +4,5 @@ AutoGen also offers a cost-effective hyperparameter optimization technique [EcoO Please find documentation about this feature [here](/docs/Use-Cases/enhanced_inference). Links to notebook examples: -* [Optimize for Code Generation](https://github.com/microsoft/autogen/blob/main/notebook/autogen_openai_completion.ipynb) | [Open in colab](https://colab.research.google.com/github/microsoft/autogen/blob/main/notebook/autogen_openai_completion.ipynb) -* [Optimize for Math](https://github.com/microsoft/autogen/blob/main/notebook/autogen_chatgpt_gpt4.ipynb) | [Open in colab](https://colab.research.google.com/github/microsoft/autogen/blob/main/notebook/autogen_chatgpt_gpt4.ipynb) +* [Optimize for Code Generation](https://github.com/microsoft/autogen/blob/main/notebook/oai_completion.ipynb) | [Open in colab](https://colab.research.google.com/github/microsoft/autogen/blob/main/notebook/oai_completion.ipynb) +* [Optimize for Math](https://github.com/microsoft/autogen/blob/main/notebook/oai_chatgpt_gpt4.ipynb) | [Open in colab](https://colab.research.google.com/github/microsoft/autogen/blob/main/notebook/oai_chatgpt_gpt4.ipynb) diff --git a/website/docs/Use-Cases/agent_chat.md b/website/docs/Use-Cases/agent_chat.md index 231d96f9f..9da5c8ec1 100644 --- a/website/docs/Use-Cases/agent_chat.md +++ b/website/docs/Use-Cases/agent_chat.md @@ -69,29 +69,29 @@ On the one hand, one can achieve fully autonomous conversations after an initial By adopting the conversation-driven control with both programming language and natural language, AutoGen inherently allows dynamic conversation. Dynamic conversation allows the agent topology to change depending on the actual flow of conversation under different input problem instances, while the flow of a static conversation always follows a pre-defined topology. The dynamic conversation pattern is useful in complex applications where the patterns of interaction cannot be predetermined in advance. AutoGen provides two general approaches to achieving dynamic conversation: -- Registered auto-reply. With the pluggable auto-reply function, one can choose to invoke conversations with other agents depending on the content of the current message and context. A working system demonstrating this type of dynamic conversation can be found in this code example, demonstrating a [dynamic group chat](https://github.com/microsoft/autogen/blob/main/notebook/autogen_agentchat_groupchat.ipynb). In the system, we register an auto-reply function in the group chat manager, which lets LLM decide who will the next speaker be in a group chat setting. +- Registered auto-reply. With the pluggable auto-reply function, one can choose to invoke conversations with other agents depending on the content of the current message and context. A working system demonstrating this type of dynamic conversation can be found in this code example, demonstrating a [dynamic group chat](https://github.com/microsoft/autogen/blob/main/notebook/agentchat_groupchat.ipynb). In the system, we register an auto-reply function in the group chat manager, which lets LLM decide who will the next speaker be in a group chat setting. -- LLM-based function call. In this approach, LLM decides whether or not to call a particular function depending on the conversation status in each inference call. -By messaging additional agents in the called functions, the LLM can drive dynamic multi-agent conversation. A working system showcasing this type of dynamic conversation can be found in the [multi-user math problem solving scenario](https://github.com/microsoft/autogen/blob/main/notebook/autogen_agentchat_two_users.ipynb), where a student assistant would automatically resort to an expert using function calls. +- LLM-based function call. In this approach, LLM decides whether or not to call a particular function depending on the conversation status in each inference call. +By messaging additional agents in the called functions, the LLM can drive dynamic multi-agent conversation. A working system showcasing this type of dynamic conversation can be found in the [multi-user math problem solving scenario](https://github.com/microsoft/autogen/blob/main/notebook/agentchat_two_users.ipynb), where a student assistant would automatically resort to an expert using function calls. -### Diverse Applications Implemented with AutoGen +### Diverse Applications Implemented with AutoGen The figure below shows six examples of applications built using AutoGen. ![Applications](images/app.png) -* [Automated Task Solving with Code Generation, Execution & Debugging](https://github.com/microsoft/autogen/blob/main/notebook/autogen_agentchat_auto_feedback_from_code_execution.ipynb) -* [Auto Code Generation, Execution, Debugging and Human Feedback](https://github.com/microsoft/autogen/blob/main/notebook/autogen_agentchat_human_feedback.ipynb) -* [Solve Tasks Requiring Web Info](https://github.com/microsoft/autogen/blob/main/notebook/autogen_agentchat_web_info.ipynb) -* [Use Provided Tools as Functions](https://github.com/microsoft/autogen/blob/main/notebook/autogen_agentchat_function_call.ipynb) -* [Automated Task Solving with Coding & Planning Agents](https://github.com/microsoft/autogen/blob/main/notebook/autogen_agentchat_planning.ipynb) -* [Automated Task Solving with GPT-4 + Multiple Human Users](https://github.com/microsoft/autogen/blob/main/notebook/autogen_agentchat_two_users.ipynb) -* [Automated Chess Game Playing & Chitchatting by GPT-4 Agents](https://github.com/microsoft/autogen/blob/main/notebook/autogen_agentchat_chess.ipynb) -* [Automated Task Solving by Group Chat (with 3 group member agents and 1 manager agent)](https://github.com/microsoft/autogen/blob/main/notebook/autogen_agentchat_groupchat.ipynb) -* [Automated Data Visualization by Group Chat (with 3 group member agents and 1 manager agent)](https://github.com/microsoft/autogen/blob/main/notebook/autogen_agentchat_groupchat_vis.ipynb) -* [Automated Complex Task Solving by Group Chat (with 6 group member agents and 1 manager agent)](https://github.com/microsoft/autogen/blob/main/notebook/autogen_agentchat_groupchat_research.ipynb) -* [Automated Continual Learning from New Data](https://github.com/microsoft/autogen/blob/main/notebook/autogen_agentchat_stream.ipynb) - +* [Automated Task Solving with Code Generation, Execution & Debugging](https://github.com/microsoft/autogen/blob/main/notebook/agentchat_auto_feedback_from_code_execution.ipynb) +* [Auto Code Generation, Execution, Debugging and Human Feedback](https://github.com/microsoft/autogen/blob/main/notebook/agentchat_human_feedback.ipynb) +* [Solve Tasks Requiring Web Info](https://github.com/microsoft/autogen/blob/main/notebook/agentchat_web_info.ipynb) +* [Use Provided Tools as Functions](https://github.com/microsoft/autogen/blob/main/notebook/agentchat_function_call.ipynb) +* [Automated Task Solving with Coding & Planning Agents](https://github.com/microsoft/autogen/blob/main/notebook/agentchat_planning.ipynb) +* [Automated Task Solving with GPT-4 + Multiple Human Users](https://github.com/microsoft/autogen/blob/main/notebook/agentchat_two_users.ipynb) +* [Automated Chess Game Playing & Chitchatting by GPT-4 Agents](https://github.com/microsoft/autogen/blob/main/notebook/agentchat_chess.ipynb) +* [Automated Task Solving by Group Chat (with 3 group member agents and 1 manager agent)](https://github.com/microsoft/autogen/blob/main/notebook/agentchat_groupchat.ipynb) +* [Automated Data Visualization by Group Chat (with 3 group member agents and 1 manager agent)](https://github.com/microsoft/autogen/blob/main/notebook/agentchat_groupchat_vis.ipynb) +* [Automated Complex Task Solving by Group Chat (with 6 group member agents and 1 manager agent)](https://github.com/microsoft/autogen/blob/main/notebook/agentchat_groupchat_research.ipynb) +* [Automated Continual Learning from New Data](https://github.com/microsoft/autogen/blob/main/notebook/agentchat_stream.ipynb) +* [Teach Agents New Skills & Reuse via Automated Chat](https://github.com/microsoft/autogen/blob/main/notebook/agentchat_teaching.ipynb) @@ -101,4 +101,4 @@ The figure below shows six examples of applications built using AutoGen. * [AutoGen: Enabling Next-Gen LLM Applications via Multi-Agent Conversation Framework](https://arxiv.org/abs/2308.08155). Qingyun Wu, Gagan Bansal, Jieyu Zhang, Yiran Wu, Shaokun Zhang, Erkang Zhu, Beibin Li, Li Jiang, Xiaoyun Zhang and Chi Wang. ArXiv 2023. -* [An Empirical Study on Challenging Math Problem Solving with GPT-4](https://arxiv.org/abs/2306.01337). Yiran Wu, Feiran Jia, Shaokun Zhang, Hangyu Li, Erkang Zhu, Yue Wang, Yin Tat Lee, Richard Peng, Qingyun Wu, Chi Wang. ArXiv preprint arXiv:2306.01337 (2023). \ No newline at end of file +* [An Empirical Study on Challenging Math Problem Solving with GPT-4](https://arxiv.org/abs/2306.01337). Yiran Wu, Feiran Jia, Shaokun Zhang, Hangyu Li, Erkang Zhu, Yue Wang, Yin Tat Lee, Richard Peng, Qingyun Wu, Chi Wang. ArXiv preprint arXiv:2306.01337 (2023). diff --git a/website/docs/Use-Cases/enhanced_inference.md b/website/docs/Use-Cases/enhanced_inference.md index 5de73003c..8bf27661d 100644 --- a/website/docs/Use-Cases/enhanced_inference.md +++ b/website/docs/Use-Cases/enhanced_inference.md @@ -6,8 +6,8 @@ There are a number of benefits of using `autogen` to perform inference: performa ## Tune Inference Parameters *Links to notebook examples:* -* [Optimize for Code Generation](https://github.com/microsoft/autogen/blob/main/notebook/autogen_openai_completion.ipynb) -* [Optimize for Math](https://github.com/microsoft/autogen/blob/main/notebook/autogen_chatgpt_gpt4.ipynb) +* [Optimize for Code Generation](https://github.com/microsoft/autogen/blob/main/notebook/oai_completion.ipynb) +* [Optimize for Math](https://github.com/microsoft/autogen/blob/main/notebook/oai_chatgpt_gpt4.ipynb) ### Choices to optimize @@ -158,7 +158,7 @@ response = autogen.Completion.create( It will try querying Azure OpenAI gpt-4, OpenAI gpt-3.5-turbo, and a locally hosted llama-7B one by one, ignoring AuthenticationError, RateLimitError and Timeout, until a valid result is returned. This can speed up the development process where the rate limit is a bottleneck. An error will be raised if the last choice fails. So make sure the last choice in the list has the best availability. -For convenience, we provide a number of utility functions to load config lists, such as `config_list_from_json`. +For convenience, we provide a number of utility functions to load config lists, such as [`config_list_from_json`](/docs/reference/oai/openai_utils#config_list_from_json). ### Logic error @@ -364,4 +364,3 @@ Set `compact=False` in `start_logging()` to switch. ``` It can be seen that the individual API call history contains redundant information of the conversation. For a long conversation the degree of redundancy is high. The compact history is more efficient and the individual API call history contains more details. -