diff --git a/.github/workflows/contrib-tests.yml b/.github/workflows/contrib-tests.yml
index f46d6883fbca..ced35dc115bd 100644
--- a/.github/workflows/contrib-tests.yml
+++ b/.github/workflows/contrib-tests.yml
@@ -247,7 +247,7 @@ jobs:
- name: Coverage
run: |
pip install coverage>=5.3
- coverage run -a -m pytest test/agentchat/contrib/test_img_utils.py test/agentchat/contrib/test_lmm.py test/agentchat/contrib/test_llava.py test/agentchat/contrib/capabilities/test_image_generation_capability.py --skip-openai
+ coverage run -a -m pytest test/agentchat/contrib/test_img_utils.py test/agentchat/contrib/test_lmm.py test/agentchat/contrib/test_llava.py test/agentchat/contrib/capabilities/test_image_generation_capability.py test/agentchat/contrib/capabilities/test_vision_capability.py --skip-openai
coverage xml
- name: Upload coverage to Codecov
uses: codecov/codecov-action@v3
diff --git a/autogen/agentchat/contrib/capabilities/vision_capability.py b/autogen/agentchat/contrib/capabilities/vision_capability.py
new file mode 100644
index 000000000000..acfb9c8f6d82
--- /dev/null
+++ b/autogen/agentchat/contrib/capabilities/vision_capability.py
@@ -0,0 +1,211 @@
+import copy
+from typing import Callable, Dict, List, Optional, Union
+
+from autogen.agentchat.assistant_agent import ConversableAgent
+from autogen.agentchat.contrib.capabilities.agent_capability import AgentCapability
+from autogen.agentchat.contrib.img_utils import (
+ convert_base64_to_data_uri,
+ get_image_data,
+ get_pil_image,
+ gpt4v_formatter,
+ message_formatter_pil_to_b64,
+)
+from autogen.agentchat.contrib.multimodal_conversable_agent import MultimodalConversableAgent
+from autogen.agentchat.conversable_agent import colored
+from autogen.code_utils import content_str
+from autogen.oai.client import OpenAIWrapper
+
+DEFAULT_DESCRIPTION_PROMPT = (
+ "Write a detailed caption for this image. "
+ "Pay special attention to any details that might be useful or relevant "
+ "to the ongoing conversation."
+)
+
+
+class VisionCapability(AgentCapability):
+ """We can add vision capability to regular ConversableAgent, even if the agent does not have the multimodal capability,
+ such as GPT-3.5-turbo agent, Llama, Orca, or Mistral agents. This vision capability will invoke a LMM client to describe
+ the image (captioning) before sending the information to the agent's actual client.
+
+ The vision capability will hook to the ConversableAgent's `process_last_received_message`.
+
+ Some technical details:
+ When the agent (who has the vision capability) received an message, it will:
+ 1. _process_received_message:
+ a. _append_oai_message
+ 2. generate_reply: if the agent is a MultimodalAgent, it will also use the image tag.
+ a. hook process_last_received_message (NOTE: this is where the vision capability will be hooked to.)
+ b. hook process_all_messages_before_reply
+ 3. send:
+ a. hook process_message_before_send
+ b. _append_oai_message
+ """
+
+ def __init__(
+ self,
+ lmm_config: Dict,
+ description_prompt: Optional[str] = DEFAULT_DESCRIPTION_PROMPT,
+ custom_caption_func: Callable = None,
+ ) -> None:
+ """
+ Initializes a new instance, setting up the configuration for interacting with
+ a Language Multimodal (LMM) client and specifying optional parameters for image
+ description and captioning.
+
+ Args:
+ lmm_config (Dict): Configuration for the LMM client, which is used to call
+ the LMM service for describing the image. This must be a dictionary containing
+ the necessary configuration parameters. If `lmm_config` is False or an empty dictionary,
+ it is considered invalid, and initialization will assert.
+ description_prompt (Optional[str], optional): The prompt to use for generating
+ descriptions of the image. This parameter allows customization of the
+ prompt passed to the LMM service. Defaults to `DEFAULT_DESCRIPTION_PROMPT` if not provided.
+ custom_caption_func (Callable, optional): A callable that, if provided, will be used
+ to generate captions for images. This allows for custom captioning logic outside
+ of the standard LMM service interaction.
+ The callable should take three parameters as input:
+ 1. an image URL (or local location)
+ 2. image_data (a PIL image)
+ 3. lmm_client (to call remote LMM)
+ and then return a description (as string).
+ If not provided, captioning will rely on the LMM client configured via `lmm_config`.
+ If provided, we will not run the default self._get_image_caption method.
+
+ Raises:
+ AssertionError: If neither a valid `lmm_config` nor a `custom_caption_func` is provided,
+ an AssertionError is raised to indicate that the Vision Capability requires
+ one of these to be valid for operation.
+ """
+ self._lmm_config = lmm_config
+ self._description_prompt = description_prompt
+ self._parent_agent = None
+
+ if lmm_config:
+ self._lmm_client = OpenAIWrapper(**lmm_config)
+ else:
+ self._lmm_client = None
+
+ self._custom_caption_func = custom_caption_func
+ assert (
+ self._lmm_config or custom_caption_func
+ ), "Vision Capability requires a valid lmm_config or custom_caption_func."
+
+ def add_to_agent(self, agent: ConversableAgent) -> None:
+ self._parent_agent = agent
+
+ # Append extra info to the system message.
+ agent.update_system_message(agent.system_message + "\nYou've been given the ability to interpret images.")
+
+ # Register a hook for processing the last message.
+ agent.register_hook(hookable_method="process_last_received_message", hook=self.process_last_received_message)
+
+ def process_last_received_message(self, content: Union[str, List[dict]]) -> str:
+ """
+ Processes the last received message content by normalizing and augmenting it
+ with descriptions of any included images. The function supports input content
+ as either a string or a list of dictionaries, where each dictionary represents
+ a content item (e.g., text, image). If the content contains image URLs, it
+ fetches the image data, generates a caption for each image, and inserts the
+ caption into the augmented content.
+
+ The function aims to transform the content into a format compatible with GPT-4V
+ multimodal inputs, specifically by formatting strings into PIL-compatible
+ images if needed and appending text descriptions for images. This allows for
+ a more accessible presentation of the content, especially in contexts where
+ images cannot be displayed directly.
+
+ Args:
+ content (Union[str, List[dict]]): The last received message content, which
+ can be a plain text string or a list of dictionaries representing
+ different types of content items (e.g., text, image_url).
+
+ Returns:
+ str: The augmented message content
+
+ Raises:
+ AssertionError: If an item in the content list is not a dictionary.
+
+ Examples:
+ Assuming `self._get_image_caption(img_data)` returns
+ "A beautiful sunset over the mountains" for the image.
+
+ - Input as String:
+ content = "Check out this cool photo!"
+ Output: "Check out this cool photo!"
+ (Content is a string without an image, remains unchanged.)
+
+ - Input as String, with image location:
+ content = "What's weather in this cool photo: "
+ Output: "What's weather in this cool photo: in case you can not see, the caption of this image is:
+ A beautiful sunset over the mountains\n"
+ (Caption added after the image)
+
+ - Input as List with Text Only:
+ content = [{"type": "text", "text": "Here's an interesting fact."}]
+ Output: "Here's an interesting fact."
+ (No images in the content, it remains unchanged.)
+
+ - Input as List with Image URL:
+ content = [
+ {"type": "text", "text": "What's weather in this cool photo:"},
+ {"type": "image_url", "image_url": {"url": "http://example.com/photo.jpg"}}
+ ]
+ Output: "What's weather in this cool photo: in case you can not see, the caption of this image is:
+ A beautiful sunset over the mountains\n"
+ (Caption added after the image)
+ """
+ copy.deepcopy(content)
+ # normalize the content into the gpt-4v format for multimodal
+ # we want to keep the URL format to keep it concise.
+ if isinstance(content, str):
+ content = gpt4v_formatter(content, img_format="url")
+
+ aug_content: str = ""
+ for item in content:
+ assert isinstance(item, dict)
+ if item["type"] == "text":
+ aug_content += item["text"]
+ elif item["type"] == "image_url":
+ img_url = item["image_url"]["url"]
+ img_caption = ""
+
+ if self._custom_caption_func:
+ img_caption = self._custom_caption_func(img_url, get_pil_image(img_url), self._lmm_client)
+ elif self._lmm_client:
+ img_data = get_image_data(img_url)
+ img_caption = self._get_image_caption(img_data)
+ else:
+ img_caption = ""
+
+ aug_content += f" in case you can not see, the caption of this image is: {img_caption}\n"
+ else:
+ print(f"Warning: the input type should either be `test` or `image_url`. Skip {item['type']} here.")
+
+ return aug_content
+
+ def _get_image_caption(self, img_data: str) -> str:
+ """
+ Args:
+ img_data (str): base64 encoded image data.
+ Returns:
+ str: caption for the given image.
+ """
+ response = self._lmm_client.create(
+ context=None,
+ messages=[
+ {
+ "role": "user",
+ "content": [
+ {"type": "text", "text": self._description_prompt},
+ {
+ "type": "image_url",
+ "image_url": {
+ "url": convert_base64_to_data_uri(img_data),
+ },
+ },
+ ],
+ }
+ ],
+ )
+ description = response.choices[0].message.content
+ return content_str(description)
diff --git a/autogen/agentchat/contrib/img_utils.py b/autogen/agentchat/contrib/img_utils.py
index 6062f3b05530..2d2592418747 100644
--- a/autogen/agentchat/contrib/img_utils.py
+++ b/autogen/agentchat/contrib/img_utils.py
@@ -24,6 +24,12 @@ def get_pil_image(image_file: Union[str, Image.Image]) -> Image.Image:
# Already a PIL Image object
return image_file
+ # Remove quotes if existed
+ if image_file.startswith('"') and image_file.endswith('"'):
+ image_file = image_file[1:-1]
+ if image_file.startswith("'") and image_file.endswith("'"):
+ image_file = image_file[1:-1]
+
if image_file.startswith("http://") or image_file.startswith("https://"):
# A URL file
response = requests.get(image_file)
diff --git a/autogen/agentchat/conversable_agent.py b/autogen/agentchat/conversable_agent.py
index 2a2de8b551e0..ef350f7d9e26 100644
--- a/autogen/agentchat/conversable_agent.py
+++ b/autogen/agentchat/conversable_agent.py
@@ -5,37 +5,35 @@
import json
import logging
import re
+import warnings
from collections import defaultdict
from functools import partial
from typing import Any, Callable, Dict, List, Literal, Optional, Tuple, Type, TypeVar, Union
-import warnings
+
from openai import BadRequestError
from autogen.exception_utils import InvalidCarryOverType, SenderRequired
-from ..coding.base import CodeExecutor
-from ..coding.factory import CodeExecutorFactory
-from ..formatting_utils import colored
-
-from ..oai.client import OpenAIWrapper, ModelClient
-from ..runtime_logging import logging_enabled, log_new_agent
+from .._pydantic import model_dump
from ..cache.cache import Cache
from ..code_utils import (
UNKNOWN,
- content_str,
check_can_use_docker_or_throw,
+ content_str,
decide_use_docker,
execute_code,
extract_code,
infer_lang,
)
-from .utils import gather_usage_summary, consolidate_chat_info
-from .chat import ChatResult, initiate_chats, a_initiate_chats
-
-
+from ..coding.base import CodeExecutor
+from ..coding.factory import CodeExecutorFactory
+from ..formatting_utils import colored
from ..function_utils import get_function_schema, load_basemodels_if_needed, serialize_to_str
+from ..oai.client import ModelClient, OpenAIWrapper
+from ..runtime_logging import log_new_agent, logging_enabled
from .agent import Agent, LLMAgent
-from .._pydantic import model_dump
+from .chat import ChatResult, a_initiate_chats, initiate_chats
+from .utils import consolidate_chat_info, gather_usage_summary
__all__ = ("ConversableAgent",)
@@ -2603,22 +2601,25 @@ def process_last_received_message(self, messages):
return messages # Last message contains a context key.
if "content" not in last_message:
return messages # Last message has no content.
- user_text = last_message["content"]
- if not isinstance(user_text, str):
- return messages # Last message content is not a string. TODO: Multimodal agents will use a dict here.
- if user_text == "exit":
+
+ user_content = last_message["content"]
+ if not isinstance(user_content, str) and not isinstance(user_content, list):
+ # if the user_content is a string, it is for regular LLM
+ # if the user_content is a list, it should follow the multimodal LMM format.
+ return messages
+ if user_content == "exit":
return messages # Last message is an exit command.
# Call each hook (in order of registration) to process the user's message.
- processed_user_text = user_text
+ processed_user_content = user_content
for hook in hook_list:
- processed_user_text = hook(processed_user_text)
- if processed_user_text == user_text:
+ processed_user_content = hook(processed_user_content)
+ if processed_user_content == user_content:
return messages # No hooks actually modified the user's message.
# Replace the last user message with the expanded one.
messages = messages.copy()
- messages[-1]["content"] = processed_user_text
+ messages[-1]["content"] = processed_user_content
return messages
def print_usage_summary(self, mode: Union[str, List[str]] = ["actual", "total"]) -> None:
diff --git a/notebook/agentchat_lmm_gpt-4v.ipynb b/notebook/agentchat_lmm_gpt-4v.ipynb
index b49f4472a504..3da51028b634 100644
--- a/notebook/agentchat_lmm_gpt-4v.ipynb
+++ b/notebook/agentchat_lmm_gpt-4v.ipynb
@@ -5,7 +5,13 @@
"id": "2c75da30",
"metadata": {},
"source": [
- "# Agent Chat with Multimodal Models: GPT-4V"
+ "# Engaging with Multimodal Models: GPT-4V in AutoGen\n",
+ "\n",
+ "In AutoGen, leveraging multimodal models can be done through two different methodologies:\n",
+ "1. **MultimodalAgent**: Supported by GPT-4V and other LMMs, this agent is endowed with visual cognitive abilities, allowing it to engage in interactions comparable to those of other ConversableAgents.\n",
+ "2. **VisionCapability**: For LLM-based agents lacking inherent visual comprehension, we introduce vision capabilities by converting images into descriptive captions.\n",
+ "\n",
+ "This guide will delve into each approach, providing insights into their application and integration."
]
},
{
@@ -14,9 +20,13 @@
"metadata": {},
"source": [
"### Before everything starts, install AutoGen with the `lmm` option\n",
+ "\n",
+ "Install `pyautogen`:\n",
"```bash\n",
- "pip install \"pyautogen[lmm]>=0.2.3\"\n",
- "```"
+ "pip install \"pyautogen[lmm]>=0.2.17\"\n",
+ "```\n",
+ "\n",
+ "For more information, please refer to the [installation guide](/docs/installation/).\n"
]
},
{
@@ -36,10 +46,14 @@
"import requests\n",
"from PIL import Image\n",
"from termcolor import colored\n",
+ "import numpy as np\n",
"\n",
"import autogen\n",
+ "from autogen.code_utils import content_str\n",
"from autogen import Agent, AssistantAgent, ConversableAgent, UserProxyAgent\n",
- "from autogen.agentchat.contrib.multimodal_conversable_agent import MultimodalConversableAgent"
+ "from autogen.agentchat.contrib.capabilities.vision_capability import VisionCapability\n",
+ "from autogen.agentchat.contrib.multimodal_conversable_agent import MultimodalConversableAgent\n",
+ "from autogen.agentchat.contrib.img_utils import get_pil_image, pil_to_data_uri"
]
},
{
@@ -91,37 +105,16 @@
]
},
{
- "cell_type": "code",
- "execution_count": 3,
- "id": "6868785c",
+ "cell_type": "markdown",
+ "id": "e9c628db",
"metadata": {},
- "outputs": [
- {
- "name": "stdout",
- "output_type": "stream",
- "text": [
- "[1, 2, 4]\n"
- ]
- }
- ],
"source": [
- "x = [1, 2, gpt4_llm_config]\n",
- "\n",
- "\n",
- "def replace(arr, x, y):\n",
- " idx = arr.index(x)\n",
- " if idx >= 0:\n",
- " arr[idx] = y\n",
- "\n",
- "\n",
- "replace(x, gpt4_llm_config, 4)\n",
- "\n",
- "print(x)"
+ "Learn more about configuring LLMs for agents [here](/docs/topics/llm_configuration)."
]
},
{
"cell_type": "code",
- "execution_count": 4,
+ "execution_count": 3,
"id": "67157629",
"metadata": {
"scrolled": false
@@ -133,7 +126,7 @@
"text": [
"\u001b[33mUser_proxy\u001b[0m (to image-explainer):\n",
"\n",
- "What's the breed of this dog here? \n",
+ "What's the breed of this dog?\n",
".\n",
"\n",
"--------------------------------------------------------------------------------\n",
@@ -141,10 +134,28 @@
">>>>>>>> USING AUTO REPLY...\u001b[0m\n",
"\u001b[33mimage-explainer\u001b[0m (to User_proxy):\n",
"\n",
- "The dog in the image appears to be a Poodle or a Poodle mix, possibly a Labradoodle or Goldendoodle, given its curly coat and overall facial structure. These types of dogs are known for their curly, hypoallergenic fur and friendly disposition. The exact breed can be difficult to determine from a photo alone, especially with mixed breeds, as they can inherit various traits from each parent breed.\n",
+ "The dog in the image appears to be a Goldendoodle, which is a crossbreed between a Golden Retriever and a Poodle. They are known for their curly, hypoallergenic coats, which can vary in color, and their friendly and affectionate nature.\n",
"\n",
"--------------------------------------------------------------------------------\n"
]
+ },
+ {
+ "name": "stderr",
+ "output_type": "stream",
+ "text": [
+ "/home/beibinli/autogen/autogen/agentchat/conversable_agent.py:1121: UserWarning: Cannot extract summary using last_msg: 'list' object has no attribute 'replace'. Using an empty str as summary.\n",
+ " warnings.warn(f\"Cannot extract summary using last_msg: {e}. Using an empty str as summary.\", UserWarning)\n"
+ ]
+ },
+ {
+ "data": {
+ "text/plain": [
+ "ChatResult(chat_id=None, chat_history=[{'content': \"What's the breed of this dog?\\n.\", 'role': 'assistant'}, {'content': 'The dog in the image appears to be a Goldendoodle, which is a crossbreed between a Golden Retriever and a Poodle. They are known for their curly, hypoallergenic coats, which can vary in color, and their friendly and affectionate nature.', 'role': 'user'}], summary='', cost=({'total_cost': 0.013030000000000002, 'gpt-4-1106-vision-preview': {'cost': 0.013030000000000002, 'prompt_tokens': 1132, 'completion_tokens': 57, 'total_tokens': 1189}}, {'total_cost': 0}), human_input=[])"
+ ]
+ },
+ "execution_count": 3,
+ "metadata": {},
+ "output_type": "execute_result"
}
],
"source": [
@@ -184,7 +195,7 @@
},
{
"cell_type": "code",
- "execution_count": 5,
+ "execution_count": 4,
"id": "73a2b234",
"metadata": {
"scrolled": false
@@ -196,7 +207,7 @@
"text": [
"\u001b[33mUser_proxy\u001b[0m (to image-explainer):\n",
"\n",
- "How about this breed? \n",
+ "What is this breed?\n",
"\n",
"\n",
"Among the breeds, which one barks less?\n",
@@ -206,9 +217,9 @@
">>>>>>>> USING AUTO REPLY...\u001b[0m\n",
"\u001b[33mimage-explainer\u001b[0m (to User_proxy):\n",
"\n",
- "The dog in the image is a Siberian Husky, identifiable by its thick fur, erect triangular ears, and distinctive facial markings.\n",
+ "The dog in the image is a Siberian Husky. They are known for their striking appearance, with thick fur, erect triangular ears, and distinctive markings.\n",
"\n",
- "Between Siberian Huskies and Poodles (or their mixes like Labradoodles and Goldendoodles), Siberian Huskies are generally known to be less prone to barking. They are more likely to howl or talk in other vocal ways. Poodles and their mixes can vary in their tendency to bark, but they are often more vocal than Huskies in terms of barking. However, individual temperaments can vary greatly within any breed, and training also plays a significant role in a dog's vocal behavior.\n",
+ "When comparing the barking tendencies of Siberian Huskies and Goldendoodles, Huskies are generally known to bark less. Siberian Huskies are more prone to howling and vocalizing in other ways rather than barking. Goldendoodles can vary in their tendency to bark based on the traits they inherit from their Golden Retriever and Poodle parents. However, every dog is an individual, and their environment, training, and socialization can greatly influence their tendency to bark.\n",
"\n",
"--------------------------------------------------------------------------------\n"
]
@@ -240,6 +251,16 @@
"- Critics: LMM-based agent that provides comments and feedback on the generated image."
]
},
+ {
+ "cell_type": "code",
+ "execution_count": 5,
+ "id": "1e057758",
+ "metadata": {},
+ "outputs": [],
+ "source": [
+ "working_dir = \"tmp/\""
+ ]
+ },
{
"cell_type": "code",
"execution_count": 6,
@@ -247,7 +268,7 @@
"metadata": {},
"outputs": [],
"source": [
- "class FigureCreator(AssistantAgent):\n",
+ "class FigureCreator(ConversableAgent):\n",
" def __init__(self, n_iters=2, **kwargs):\n",
" \"\"\"\n",
" Initializes a FigureCreator instance.\n",
@@ -267,7 +288,6 @@
" error_msg = f\"Either {messages=} or {sender=} must be provided.\"\n",
" logger.error(error_msg) # noqa: F821\n",
" raise AssertionError(error_msg)\n",
- "\n",
" if messages is None:\n",
" messages = self._oai_messages[sender]\n",
"\n",
@@ -280,7 +300,7 @@
" max_consecutive_auto_reply=10,\n",
" system_message=\"Help me run the code, and tell other agents it is in the file location.\",\n",
" is_termination_msg=lambda x: x.get(\"content\", \"\").rstrip().endswith(\"TERMINATE\"),\n",
- " code_execution_config={\"last_n_messages\": 3, \"work_dir\": \".\", \"use_docker\": False},\n",
+ " code_execution_config={\"last_n_messages\": 3, \"work_dir\": working_dir, \"use_docker\": False},\n",
" llm_config=self.llm_config,\n",
" )\n",
"\n",
@@ -307,13 +327,17 @@
"\n",
" # Data flow begins\n",
" commander.initiate_chat(coder, message=user_question)\n",
- " img = Image.open(\"result.jpg\")\n",
+ " img = Image.open(os.path.join(working_dir, \"result.jpg\"))\n",
" plt.imshow(img)\n",
" plt.axis(\"off\") # Hide the axes\n",
" plt.show()\n",
"\n",
" for i in range(self._n_iters):\n",
- " commander.send(message=\"Improve \", recipient=critics, request_reply=True)\n",
+ " commander.send(\n",
+ " message=f\"Improve \",\n",
+ " recipient=critics,\n",
+ " request_reply=True,\n",
+ " )\n",
"\n",
" feedback = commander._oai_messages[critics][-1][\"content\"]\n",
" if feedback.find(\"NO_ISSUES\") >= 0:\n",
@@ -324,12 +348,12 @@
" recipient=coder,\n",
" request_reply=True,\n",
" )\n",
- " img = Image.open(\"result.jpg\")\n",
+ " img = Image.open(os.path.join(working_dir, \"result.jpg\"))\n",
" plt.imshow(img)\n",
" plt.axis(\"off\") # Hide the axes\n",
" plt.show()\n",
"\n",
- " return True, \"result.jpg\""
+ " return True, os.path.join(working_dir, \"result.jpg\")"
]
},
{
@@ -347,7 +371,7 @@
"\u001b[33mUser\u001b[0m (to Figure Creator~):\n",
"\n",
"\n",
- "Plot a figure by using the data from here:\n",
+ "Plot a figure by using the data from:\n",
"https://raw.githubusercontent.com/vega/vega/main/docs/data/seattle-weather.csv\n",
"\n",
"I want to show both temperature high and low.\n",
@@ -357,7 +381,7 @@
"\u001b[33mCommander\u001b[0m (to Coder):\n",
"\n",
"\n",
- "Plot a figure by using the data from here:\n",
+ "Plot a figure by using the data from:\n",
"https://raw.githubusercontent.com/vega/vega/main/docs/data/seattle-weather.csv\n",
"\n",
"I want to show both temperature high and low.\n",
@@ -366,63 +390,88 @@
"--------------------------------------------------------------------------------\n",
"\u001b[33mCoder\u001b[0m (to Commander):\n",
"\n",
- "To achieve this, I will provide you with a Python script that uses the `pandas` library to read data from the CSV file located at the provided URL, and `matplotlib` to plot both the high and low temperatures. If you don't already have `pandas` and `matplotlib` installed, you will need to install them first by running `pip install pandas matplotlib`.\n",
+ "Sure, let's first download the CSV data from the provided URL using Python and then we'll plot the figure with both temperature high and low.\n",
"\n",
- "Please execute the following Python code:\n",
+ "To start with, I'll provide you with a Python script that will download the CSV file and then plot the temperatures highs and lows.\n",
+ "\n",
+ "Please run this Python code:\n",
"\n",
"```python\n",
"# filename: plot_temperatures.py\n",
"import pandas as pd\n",
"import matplotlib.pyplot as plt\n",
"\n",
- "# URL of the CSV file\n",
+ "# URL to download the CSV data\n",
"url = \"https://raw.githubusercontent.com/vega/vega/main/docs/data/seattle-weather.csv\"\n",
"\n",
- "# Read the data from the URL\n",
+ "# Download the data\n",
"data = pd.read_csv(url)\n",
"\n",
- "# Extract the Date, Temperature High, and Temperature Low columns\n",
- "dates = pd.to_datetime(data['date'])\n",
- "temp_high = data['temp_max']\n",
- "temp_low = data['temp_min']\n",
- "\n",
- "# Plot the high and low temperatures\n",
+ "# Now, let us plot the high and low temperatures\n",
"plt.figure(figsize=(10, 5))\n",
- "plt.plot(dates, temp_high, label='High Temperature', color='r')\n",
- "plt.plot(dates, temp_low, label='Low Temperature', color='b')\n",
+ "plt.plot(data['date'], data['temp_max'], label='High Temp')\n",
+ "plt.plot(data['date'], data['temp_min'], label='Low Temp')\n",
+ "\n",
+ "# Providing labels and title\n",
"plt.xlabel('Date')\n",
"plt.ylabel('Temperature (°C)')\n",
"plt.title('High and Low Temperatures in Seattle')\n",
"plt.legend()\n",
- "plt.grid(True)\n",
+ "\n",
+ "# Rotate the dates on x-axis for better readability\n",
+ "plt.xticks(rotation=45)\n",
+ "plt.tight_layout()\n",
"\n",
"# Save the figure\n",
"plt.savefig('result.jpg')\n",
"\n",
- "# Show the plot\n",
- "plt.show()\n",
+ "print(\"The plot has been saved as 'result.jpg'.\")\n",
+ "```\n",
+ "\n",
+ "Make sure you have the required packages (`pandas` and `matplotlib`) installed. If they are not installed, you can install them using `pip`:\n",
+ "\n",
+ "```sh\n",
+ "pip install pandas matplotlib\n",
"```\n",
"\n",
- "After running this script, it will output a plot of the high and low temperatures and save the figure as `result.jpg` in the current directory. Open the `result.jpg` file to view the figure.\n",
+ "After running the script, you should see a message indicating that the plot has been saved as 'result.jpg'.\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[33mCommander\u001b[0m (to Coder):\n",
"\n",
"exitcode: 0 (execution succeeded)\n",
"Code output: \n",
- "Figure(1000x500)\n",
+ "The plot has been saved as 'result.jpg'.\n",
+ "\n",
+ "Requirement already satisfied: pandas in /home/beibinli/anaconda3/lib/python3.9/site-packages (1.5.3)\n",
+ "Requirement already satisfied: matplotlib in /home/beibinli/anaconda3/lib/python3.9/site-packages (3.7.1)\n",
+ "Requirement already satisfied: python-dateutil>=2.8.1 in /home/beibinli/anaconda3/lib/python3.9/site-packages (from pandas) (2.8.2)\n",
+ "Requirement already satisfied: pytz>=2020.1 in /home/beibinli/anaconda3/lib/python3.9/site-packages (from pandas) (2022.7.1)\n",
+ "Requirement already satisfied: numpy>=1.20.3 in /home/beibinli/anaconda3/lib/python3.9/site-packages (from pandas) (1.23.5)\n",
+ "Requirement already satisfied: contourpy>=1.0.1 in /home/beibinli/anaconda3/lib/python3.9/site-packages (from matplotlib) (1.0.5)\n",
+ "Requirement already satisfied: cycler>=0.10 in /home/beibinli/anaconda3/lib/python3.9/site-packages (from matplotlib) (0.11.0)\n",
+ "Requirement already satisfied: fonttools>=4.22.0 in /home/beibinli/anaconda3/lib/python3.9/site-packages (from matplotlib) (4.25.0)\n",
+ "Requirement already satisfied: kiwisolver>=1.0.1 in /home/beibinli/anaconda3/lib/python3.9/site-packages (from matplotlib) (1.4.4)\n",
+ "Requirement already satisfied: packaging>=20.0 in /home/beibinli/anaconda3/lib/python3.9/site-packages (from matplotlib) (23.2)\n",
+ "Requirement already satisfied: pillow>=6.2.0 in /home/beibinli/anaconda3/lib/python3.9/site-packages (from matplotlib) (10.1.0)\n",
+ "Requirement already satisfied: pyparsing>=2.3.1 in /home/beibinli/anaconda3/lib/python3.9/site-packages (from matplotlib) (3.0.9)\n",
+ "Requirement already satisfied: importlib-resources>=3.2.0 in /home/beibinli/anaconda3/lib/python3.9/site-packages (from matplotlib) (5.13.0)\n",
+ "Requirement already satisfied: zipp>=3.1.0 in /home/beibinli/anaconda3/lib/python3.9/site-packages (from importlib-resources>=3.2.0->matplotlib) (3.11.0)\n",
+ "Requirement already satisfied: six>=1.5 in /home/beibinli/anaconda3/lib/python3.9/site-packages (from python-dateutil>=2.8.1->pandas) (1.16.0)\n",
"\n",
"\n",
"--------------------------------------------------------------------------------\n",
"\u001b[33mCoder\u001b[0m (to Commander):\n",
"\n",
- "The script executed successfully, and it created a figure of the high and low temperatures from the Seattle weather dataset. You should find the figure saved as `result.jpg` in the current directory.\n",
+ "The Python script executed successfully, and the plot has been saved as 'result.jpg'. You should now be able to find the figure file at the mentioned location. \n",
"\n",
- "You can view this figure by opening the `result.jpg` file on your computer.\n",
+ "The necessary packages were already installed in your environment, as indicated by your output, so no further action was required there.\n",
"\n",
- "If there's anything more you'd like to do with this plot or if you have any other requests, please let me know.\n",
+ "The figure shows the high and low temperatures for Seattle as indicated by the data in the CSV file you provided. If you have any other requests or need further assistance, feel free to ask. If not, and if you are satisfied with the result, we can conclude this task.\n",
"\n",
"TERMINATE\n",
"\n",
@@ -431,7 +480,7 @@
},
{
"data": {
- "image/png": "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",
+ "image/png": "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",
"text/plain": [
"