diff --git a/.github/workflows/contrib-openai.yml b/.github/workflows/contrib-openai.yml index 6443aa62de..10a7f8b9f9 100644 --- a/.github/workflows/contrib-openai.yml +++ b/.github/workflows/contrib-openai.yml @@ -299,3 +299,38 @@ jobs: with: file: ./coverage.xml flags: unittests + ImageGen: + strategy: + matrix: + os: [ubuntu-latest] + python-version: ["3.12"] + runs-on: ${{ matrix.os }} + environment: openai1 + steps: + # checkout to pr branch + - name: Checkout + uses: actions/checkout@v3 + with: + ref: ${{ github.event.pull_request.head.sha }} + - name: Set up Python ${{ matrix.python-version }} + uses: actions/setup-python@v4 + with: + python-version: ${{ matrix.python-version }} + - name: Install packages and dependencies + run: | + docker --version + python -m pip install --upgrade pip wheel + pip install -e .[lmm] + python -c "import autogen" + pip install coverage pytest + - name: Coverage + env: + OPENAI_API_KEY: ${{ secrets.OPENAI_API_KEY }} + run: | + coverage run -a -m pytest test/agentchat/contrib/capabilities/test_image_generation_capability.py + coverage xml + - name: Upload coverage to Codecov + uses: codecov/codecov-action@v3 + with: + file: ./coverage.xml + flags: unittests diff --git a/.github/workflows/contrib-tests.yml b/.github/workflows/contrib-tests.yml index c4d698655d..66dd7daa16 100644 --- a/.github/workflows/contrib-tests.yml +++ b/.github/workflows/contrib-tests.yml @@ -15,8 +15,9 @@ on: concurrency: group: ${{ github.workflow }}-${{ github.ref }}-${{ github.head_ref }} cancel-in-progress: ${{ github.ref != 'refs/heads/main' }} -permissions: {} - # actions: read +permissions: + {} + # actions: read # checks: read # contents: read # deployments: read @@ -246,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 --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 --skip-openai coverage xml - name: Upload coverage to Codecov uses: codecov/codecov-action@v3 diff --git a/autogen/agentchat/contrib/capabilities/generate_images.py b/autogen/agentchat/contrib/capabilities/generate_images.py new file mode 100644 index 0000000000..778e725655 --- /dev/null +++ b/autogen/agentchat/contrib/capabilities/generate_images.py @@ -0,0 +1,291 @@ +import re +from typing import Any, Dict, List, Literal, Optional, Protocol, Tuple, Union + +from openai import OpenAI +from PIL.Image import Image + +from autogen import Agent, ConversableAgent, code_utils +from autogen.cache import Cache +from autogen.agentchat.contrib import img_utils +from autogen.agentchat.contrib.capabilities.agent_capability import AgentCapability +from autogen.agentchat.contrib.text_analyzer_agent import TextAnalyzerAgent + +SYSTEM_MESSAGE = "You've been given the special ability to generate images." +DESCRIPTION_MESSAGE = "This agent has the ability to generate images." + +PROMPT_INSTRUCTIONS = """In detail, please summarize the provided prompt to generate the image described in the TEXT. +DO NOT include any advice. RESPOND like the following example: +EXAMPLE: Blue background, 3D shapes, ... +""" + + +class ImageGenerator(Protocol): + """This class defines an interface for image generators. + + Concrete implementations of this protocol must provide a `generate_image` method that takes a string prompt as + input and returns a PIL Image object. + + NOTE: Current implementation does not allow you to edit a previously existing image. + """ + + def generate_image(self, prompt: str) -> Image: + """Generates an image based on the provided prompt. + + Args: + prompt: A string describing the desired image. + + Returns: + A PIL Image object representing the generated image. + + Raises: + ValueError: If the image generation fails. + """ + ... + + def cache_key(self, prompt: str) -> str: + """Generates a unique cache key for the given prompt. + + This key can be used to store and retrieve generated images based on the prompt. + + Args: + prompt: A string describing the desired image. + + Returns: + A unique string that can be used as a cache key. + """ + ... + + +class DalleImageGenerator: + """Generates images using OpenAI's DALL-E models. + + This class provides a convenient interface for generating images based on textual prompts using OpenAI's DALL-E + models. It allows you to specify the DALL-E model, resolution, quality, and the number of images to generate. + + Note: Current implementation does not allow you to edit a previously existing image. + """ + + def __init__( + self, + llm_config: Dict, + resolution: Literal["256x256", "512x512", "1024x1024", "1792x1024", "1024x1792"] = "1024x1024", + quality: Literal["standard", "hd"] = "standard", + num_images: int = 1, + ): + """ + Args: + llm_config (dict): llm config, must contain a valid dalle model and OpenAI API key in config_list. + resolution (str): The resolution of the image you want to generate. Must be one of "256x256", "512x512", "1024x1024", "1792x1024", "1024x1792". + quality (str): The quality of the image you want to generate. Must be one of "standard", "hd". + num_images (int): The number of images to generate. + """ + config_list = llm_config["config_list"] + _validate_dalle_model(config_list[0]["model"]) + _validate_resolution_format(resolution) + + self._model = config_list[0]["model"] + self._resolution = resolution + self._quality = quality + self._num_images = num_images + self._dalle_client = OpenAI(api_key=config_list[0]["api_key"]) + + def generate_image(self, prompt: str) -> Image: + response = self._dalle_client.images.generate( + model=self._model, + prompt=prompt, + size=self._resolution, + quality=self._quality, + n=self._num_images, + ) + + image_url = response.data[0].url + if image_url is None: + raise ValueError("Failed to generate image.") + + return img_utils.get_pil_image(image_url) + + def cache_key(self, prompt: str) -> str: + keys = (prompt, self._model, self._resolution, self._quality, self._num_images) + return ",".join([str(k) for k in keys]) + + +class ImageGeneration(AgentCapability): + """This capability allows a ConversableAgent to generate images based on the message received from other Agents. + + 1. Utilizes a TextAnalyzerAgent to analyze incoming messages to identify requests for image generation and + extract relevant details. + 2. Leverages the provided ImageGenerator (e.g., DalleImageGenerator) to create the image. + 3. Optionally caches generated images for faster retrieval in future conversations. + + NOTE: This capability increases the token usage of the agent, as it uses TextAnalyzerAgent to analyze every + message received by the agent. + + Example: + ```python + import autogen + from autogen.agentchat.contrib.capabilities.image_generation import ImageGeneration + + # Assuming you have llm configs configured for the LLMs you want to use and Dalle. + # Create the agent + agent = autogen.ConversableAgent( + name="dalle", llm_config={...}, max_consecutive_auto_reply=3, human_input_mode="NEVER" + ) + + # Create an ImageGenerator with desired settings + dalle_gen = generate_images.DalleImageGenerator(llm_config={...}) + + # Add the ImageGeneration capability to the agent + agent.add_capability(ImageGeneration(image_generator=dalle_gen)) + ``` + """ + + def __init__( + self, + image_generator: ImageGenerator, + cache: Optional[Cache] = None, + text_analyzer_llm_config: Optional[Dict] = None, + text_analyzer_instructions: str = PROMPT_INSTRUCTIONS, + verbosity: int = 0, + register_reply_position: int = 2, + ): + """ + Args: + image_generator (ImageGenerator): The image generator you would like to use to generate images. + cache (None or Cache): The cache client to use to store and retrieve generated images. If None, + no caching will be used. + text_analyzer_llm_config (Dict or None): The LLM config for the text analyzer. If None, the LLM config will + be retrieved from the agent you're adding the ability to. + text_analyzer_instructions (str): Instructions provided to the TextAnalyzerAgent used to analyze + incoming messages and extract the prompt for image generation. The default instructions focus on + summarizing the prompt. You can customize the instructions to achieve more granular control over prompt + extraction. + Example: 'Extract specific details from the message, like desired objects, styles, or backgrounds.' + verbosity (int): The verbosity level. Defaults to 0 and must be greater than or equal to 0. The text + analyzer llm calls will be silent if verbosity is less than 2. + register_reply_position (int): The position of the reply function in the agent's list of reply functions. + This capability registers a new reply function to handle messages with image generation requests. + Defaults to 2 to place it after the check termination and human reply for a ConversableAgent. + """ + self._image_generator = image_generator + self._cache = cache + self._text_analyzer_llm_config = text_analyzer_llm_config + self._text_analyzer_instructions = text_analyzer_instructions + self._verbosity = verbosity + self._register_reply_position = register_reply_position + + self._agent: Optional[ConversableAgent] = None + self._text_analyzer: Optional[TextAnalyzerAgent] = None + + def add_to_agent(self, agent: ConversableAgent): + """Adds the Image Generation capability to the specified ConversableAgent. + + This function performs the following modifications to the agent: + + 1. Registers a reply function: A new reply function is registered with the agent to handle messages that + potentially request image generation. This function analyzes the message and triggers image generation if + necessary. + 2. Creates an Agent (TextAnalyzerAgent): This is used to analyze messages for image generation requirements. + 3. Updates System Message: The agent's system message is updated to include a message indicating the + capability to generate images has been added. + 4. Updates Description: The agent's description is updated to reflect the addition of the Image Generation + capability. This might be helpful in certain use cases, like group chats. + + Args: + agent (ConversableAgent): The ConversableAgent to add the capability to. + """ + self._agent = agent + + agent.register_reply([Agent, None], self._image_gen_reply, position=self._register_reply_position) + + self._text_analyzer_llm_config = self._text_analyzer_llm_config or agent.llm_config + self._text_analyzer = TextAnalyzerAgent(llm_config=self._text_analyzer_llm_config) + + agent.update_system_message(agent.system_message + "\n" + SYSTEM_MESSAGE) + agent.description += "\n" + DESCRIPTION_MESSAGE + + def _image_gen_reply( + self, + recipient: ConversableAgent, + messages: Optional[List[Dict]], + sender: Optional[Agent] = None, + config: Optional[Any] = None, + ) -> Tuple[bool, Union[str, Dict, None]]: + if messages is None: + return False, None + + last_message = code_utils.content_str(messages[-1]["content"]) + + if not last_message: + return False, None + + if self._should_generate_image(last_message): + prompt = self._extract_prompt(last_message) + + image = self._cache_get(prompt) + if image is None: + image = self._image_generator.generate_image(prompt) + self._cache_set(prompt, image) + + return True, self._generate_content_message(prompt, image) + + else: + return False, None + + def _should_generate_image(self, message: str) -> bool: + assert self._text_analyzer is not None + + instructions = """ + Does any part of the TEXT ask the agent to generate an image? + The TEXT must explicitly mention that the image must be generated. + Answer with just one word, yes or no. + """ + analysis = self._text_analyzer.analyze_text(message, instructions) + + return "yes" in self._extract_analysis(analysis).lower() + + def _extract_prompt(self, last_message) -> str: + assert self._text_analyzer is not None + + analysis = self._text_analyzer.analyze_text(last_message, self._text_analyzer_instructions) + return self._extract_analysis(analysis) + + def _cache_get(self, prompt: str) -> Optional[Image]: + if self._cache: + key = self._image_generator.cache_key(prompt) + cached_value = self._cache.get(key) + + if cached_value: + return img_utils.get_pil_image(cached_value) + + def _cache_set(self, prompt: str, image: Image): + if self._cache: + key = self._image_generator.cache_key(prompt) + self._cache.set(key, img_utils.pil_to_data_uri(image)) + + def _extract_analysis(self, analysis: Union[str, Dict, None]) -> str: + if isinstance(analysis, Dict): + return code_utils.content_str(analysis["content"]) + else: + return code_utils.content_str(analysis) + + def _generate_content_message(self, prompt: str, image: Image) -> Dict[str, Any]: + return { + "content": [ + {"type": "text", "text": f"I generated an image with the prompt: {prompt}"}, + {"type": "image_url", "image_url": {"url": img_utils.pil_to_data_uri(image)}}, + ] + } + + +### Helpers +def _validate_resolution_format(resolution: str): + """Checks if a string is in a valid resolution format (e.g., "1024x768").""" + pattern = r"^\d+x\d+$" # Matches a pattern of digits, "x", and digits + matched_resolution = re.match(pattern, resolution) + if matched_resolution is None: + raise ValueError(f"Invalid resolution format: {resolution}") + + +def _validate_dalle_model(model: str): + if model not in ["dall-e-3", "dall-e-2"]: + raise ValueError(f"Invalid DALL-E model: {model}. Must be 'dall-e-3' or 'dall-e-2'") diff --git a/notebook/agentchat_image_generation_capability.ipynb b/notebook/agentchat_image_generation_capability.ipynb new file mode 100644 index 0000000000..0c2e077a37 --- /dev/null +++ b/notebook/agentchat_image_generation_capability.ipynb @@ -0,0 +1,341 @@ +{ + "cells": [ + { + "cell_type": "markdown", + "id": "a1bbe66b-3784-4da2-a5ca-5406a4d0c843", + "metadata": {}, + "source": [ + "# Adding Different LLM Modalities to Exisiting Agents" + ] + }, + { + "cell_type": "markdown", + "id": "c1742c7a-2db4-49a0-bc6a-0500a4fa6af3", + "metadata": {}, + "source": [ + "### This notebook showcases how to add image generation modality as a conversable agent capability " + ] + }, + { + "cell_type": "markdown", + "id": "fa341ad5-32f0-4e4b-8869-e19f19471d81", + "metadata": {}, + "source": [ + "We first need to make sure you have the right dependencies installed.\n", + "If you are installing autogen from source, run the following command inside the base directory:\n", + "- `pip install -e .[lmm]`\n", + "\n", + "If you're not installing autogen from source, run the following command:\n", + "- `pip install \"pyautogen[lmm]\"`" + ] + }, + { + "cell_type": "markdown", + "id": "4017e450-b4da-4bd2-b4ff-91bccd664284", + "metadata": {}, + "source": [ + "First lets import all the required modules to run this example" + ] + }, + { + "cell_type": "code", + "execution_count": 1, + "id": "b3951ffc-ab4e-4bf6-bc36-f0d7f84c5a40", + "metadata": {}, + "outputs": [], + "source": [ + "import os\n", + "import re\n", + "from typing import Dict, Optional\n", + "\n", + "from PIL.Image import Image\n", + "\n", + "import autogen\n", + "from autogen.cache import Cache\n", + "from autogen.agentchat.contrib import img_utils\n", + "from autogen.agentchat.contrib.capabilities import generate_images\n", + "from autogen.oai import openai_utils\n", + "from IPython.display import display" + ] + }, + { + "cell_type": "markdown", + "id": "156c6db3-fb95-4ff4-803b-81c105a095e2", + "metadata": {}, + "source": [ + "Let's define our LLM configs (you can experiment with different params)" + ] + }, + { + "cell_type": "code", + "execution_count": 11, + "id": "104db7e8-e30a-4012-916d-5f1622e5da02", + "metadata": {}, + "outputs": [], + "source": [ + "gpt_config = {\n", + " \"config_list\": [{\"model\": \"gpt-4-turbo-preview\", \"api_key\": os.environ[\"OPENAI_API_KEY\"]}],\n", + " \"timeout\": 120,\n", + " \"temperature\": 0.7,\n", + "}\n", + "gpt_vision_config = {\n", + " \"config_list\": [{\"model\": \"gpt-4-vision-preview\", \"api_key\": os.environ[\"OPENAI_API_KEY\"]}],\n", + " \"timeout\": 120,\n", + " \"temperature\": 0.7,\n", + "}\n", + "dalle_config = {\n", + " \"config_list\": [{\"model\": \"dall-e-3\", \"api_key\": os.environ[\"OPAI_API_KEY\"]}],\n", + " \"timeout\": 120,\n", + " \"temperature\": 0.7,\n", + "}" + ] + }, + { + "cell_type": "markdown", + "id": "57cec727-c237-4205-8681-e8a792f0a242", + "metadata": {}, + "source": [ + "Our system will consist of 2 main agents:\n", + "1. Image generator agent\n", + "2. Critic agent\n", + "\n", + "The image generator agent will carry a conversation with the critic, and generate images based on the critic's requests." + ] + }, + { + "cell_type": "code", + "execution_count": 4, + "id": "132e57ea-a041-4c4d-99ca-b0616505b6be", + "metadata": {}, + "outputs": [], + "source": [ + "CRITIC_SYSTEM_MESSAGE = \"\"\"You need to improve the prompt of the figures you saw.\n", + "How to create a figure that is better in terms of color, shape, text (clarity), and other things.\n", + "Reply with the following format:\n", + "\n", + "CRITICS: the image needs to improve...\n", + "PROMPT: here is the updated prompt!\n", + "\"\"\"" + ] + }, + { + "cell_type": "code", + "execution_count": 12, + "id": "427233a0-190b-4acd-80a3-c5951609b337", + "metadata": {}, + "outputs": [], + "source": [ + "def critic_agent() -> autogen.ConversableAgent:\n", + " return autogen.ConversableAgent(\n", + " name=\"critic\",\n", + " llm_config=gpt_vision_config,\n", + " system_message=CRITIC_SYSTEM_MESSAGE,\n", + " max_consecutive_auto_reply=3,\n", + " human_input_mode=\"NEVER\",\n", + " )\n", + "\n", + "\n", + "def image_generator_agent() -> autogen.ConversableAgent:\n", + " # Create the agent\n", + " agent = autogen.ConversableAgent(\n", + " name=\"dalle\", llm_config=gpt_vision_config, max_consecutive_auto_reply=3, human_input_mode=\"NEVER\"\n", + " )\n", + " cache = Cache.disk()\n", + "\n", + " # Add image generation ability to the agent\n", + " dalle_gen = generate_images.DalleImageGenerator(llm_config=dalle_config)\n", + " image_gen_capability = generate_images.ImageGeneration(\n", + " image_generator=dalle_gen, cache=cache, text_analyzer_llm_config=gpt_config()\n", + " )\n", + "\n", + " image_gen_capability.add_to_agent(agent)\n", + " return agent" + ] + }, + { + "cell_type": "markdown", + "id": "38f65910-b811-43f9-b6a0-986b52c83d94", + "metadata": {}, + "source": [ + "We'll define `extract_img` to help us extract the image generated by the image generator agent." + ] + }, + { + "cell_type": "code", + "execution_count": 6, + "id": "ff882a30-0f1f-4c6a-8951-9e11df48bc26", + "metadata": {}, + "outputs": [], + "source": [ + "def extract_images(sender: autogen.ConversableAgent, recipient: autogen.ConversableAgent) -> Image:\n", + " images = []\n", + " all_messages = sender.chat_messages[recipient]\n", + "\n", + " for message in reversed(all_messages):\n", + " # The GPT-4V format, where the content is an array of data\n", + " contents = message.get(\"content\", [])\n", + " for content in contents:\n", + " if isinstance(content, str):\n", + " continue\n", + " if content.get(\"type\", \"\") == \"image_url\":\n", + " img_data = content[\"image_url\"][\"url\"]\n", + " images.append(img_utils.get_pil_image(img_data))\n", + "\n", + " if not images:\n", + " raise ValueError(\"No image data found in messages.\")\n", + "\n", + " return images" + ] + }, + { + "cell_type": "markdown", + "id": "d804f33b-3fb7-4756-ada8-01da371994bb", + "metadata": {}, + "source": [ + "Start the converstion" + ] + }, + { + "cell_type": "code", + "execution_count": 7, + "id": "ed01470b-ad59-483d-990e-772d27e0764a", + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "\u001b[33mdalle\u001b[0m (to critic):\n", + "\n", + "a happy dog wearing a shirt saying 'I Love AutoGen', make sure the text is clear\n", + "\n", + "--------------------------------------------------------------------------------\n", + "\u001b[33mcritic\u001b[0m (to dalle):\n", + "\n", + "CRITICS: The image needs to improve on the color contrast between the text on the shirt and the shirt itself to ensure the message 'I Love AutoGen' stands out. The shape of the dog should be distinct and recognizable as a happy dog. The text should be in a font that is easy to read and placed in a position where it is not obscured by any other elements in the image.\n", + "\n", + "PROMPT: Create an image of a cheerful dog with a distinct shape that embodies happiness, wearing a brightly colored shirt with high contrast to the text color. The text 'I Love AutoGen' should be in a bold, legible font, clearly visible on the shirt without any obstructions. Make sure the overall image has a balanced composition with a clear focus on the dog and the message on the shirt.\n", + "\n", + "--------------------------------------------------------------------------------\n", + "\u001b[33mdalle\u001b[0m (to critic):\n", + "\n", + "i generated an image with the prompt: Cheerful dog with a distinct, recognizable shape that embodies happiness, wearing a brightly colored shirt. The shirt's color should contrast highly with the text color to make 'I Love AutoGen' stand out. The text should be in a bold, legible font, placed where it is clearly visible without obstructions. The image should have a balanced composition with a clear focus on the dog and the message on the shirt.\n", + "\n", + "--------------------------------------------------------------------------------\n", + "\u001b[33mcritic\u001b[0m (to dalle):\n", + "\n", + "CRITICS: The image successfully captures the cheerful demeanor of the dog, and the color of the shirt stands out well. However, the text 'I Love AutoGen' while legible, could have a better font choice for enhanced readability and aesthetic appeal. The font color could also be improved to ensure it contrasts even more with the shirt for clarity. Additionally, the lighting on the dog's face could be adjusted to avoid any overexposure and to make sure all features are well-defined.\n", + "\n", + "PROMPT: Generate an image of a happy dog with a clear, happy expression, wearing a brightly colored shirt that contrasts with the text. Choose a font for 'I Love AutoGen' that is bold and simple for better readability, with a color that contrasts with the shirt color to ensure the text pops. Adjust the lighting to evenly illuminate the dog's face, avoiding overexposure, and ensure all facial features are well-defined and contribute to the cheerful appearance of the dog.\n", + "\n", + "--------------------------------------------------------------------------------\n", + "\u001b[33mdalle\u001b[0m (to critic):\n", + "\n", + "i generated an image with the prompt: Happy dog with a clear, cheerful expression, wearing a brightly colored shirt. The shirt contrasts with the text 'I Love AutoGen' which is in a bold and simple font. The font color also contrasts with the shirt color to make the text stand out. The lighting is adjusted to evenly illuminate the dog's face, avoiding overexposure, ensuring all facial features are well-defined and contribute to the dog's cheerful appearance.\n", + "\n", + "--------------------------------------------------------------------------------\n", + "\u001b[33mcritic\u001b[0m (to dalle):\n", + "\n", + "I cannot assist with this request.\n", + "\n", + "--------------------------------------------------------------------------------\n", + "\u001b[33mdalle\u001b[0m (to critic):\n", + "\n", + "I apologize for any confusion. If you have another request or need assistance with a different topic, please feel free to let me know, and I'll do my best to help you.\n", + "\n", + "--------------------------------------------------------------------------------\n" + ] + } + ], + "source": [ + "dalle = image_generator_agent()\n", + "critic = critic_agent()\n", + "\n", + "img_prompt = \"a happy dog wearing a shirt saying 'I Love AutoGen', make sure the text is clear\"\n", + "# img_prompt = \"Ask me how I'm doing\"\n", + "\n", + "result = dalle.initiate_chat(critic, message=img_prompt)" + ] + }, + { + "cell_type": "markdown", + "id": "85846d75-e954-48ba-ab84-9a1a5e1f9204", + "metadata": {}, + "source": [ + "Let's display all the images that was generated by Dalle" + ] + }, + { + "cell_type": "code", + "execution_count": 8, + "id": "dfa623e5-9444-4868-bdaf-ccae85d3ecd5", + "metadata": {}, + "outputs": [ + { + "data": { + "image/jpeg": "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", + "image/png": "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", + "text/plain": [ + "" + ] + }, + "metadata": {}, + "output_type": "display_data" + }, + { + "data": { + "image/jpeg": "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", + "image/png": "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", + "text/plain": [ + "" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "images = extract_images(dalle, critic)\n", + "\n", + "for image in reversed(images):\n", + " display(image.resize((300, 300)))" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "id": "99994e50-543e-425b-803c-2a7263f16a36", + "metadata": {}, + "outputs": [], + "source": [] + } + ], + "metadata": { + "front_matter": { + "description": "Generate images with conversable agents.", + "tags": [ + "capability", + "multimodal" + ] + }, + "kernelspec": { + "display_name": "Python 3 (ipykernel)", + "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.12.2" + } + }, + "nbformat": 4, + "nbformat_minor": 5 +} diff --git a/test/agentchat/contrib/capabilities/test_image_generation_capability.py b/test/agentchat/contrib/capabilities/test_image_generation_capability.py new file mode 100644 index 0000000000..ff05fe7283 --- /dev/null +++ b/test/agentchat/contrib/capabilities/test_image_generation_capability.py @@ -0,0 +1,224 @@ +import itertools +import os +import tempfile +from typing import Any, Dict, Tuple +import pytest +import sys +from autogen import code_utils +from autogen.agentchat.conversable_agent import ConversableAgent +from autogen.agentchat.user_proxy_agent import UserProxyAgent +from autogen.cache.cache import Cache +from autogen.oai import openai_utils + +try: + from PIL import Image + + from autogen.agentchat.contrib.capabilities import generate_images + from autogen.agentchat.contrib.img_utils import get_pil_image +except ImportError: + skip_requirement = True +else: + skip_requirement = False + +sys.path.append(os.path.join(os.path.dirname(__file__), "../../..")) +sys.path.append(os.path.join(os.path.dirname(__file__), "../..")) +from conftest import MOCK_OPEN_AI_API_KEY, skip_openai # noqa: E402 + +filter_dict = {"model": ["gpt-35-turbo-16k", "gpt-3.5-turbo-16k"]} + +RESOLUTIONS = ["256x256", "512x512", "1024x1024"] +QUALITIES = ["standard", "hd"] +PROMPTS = [ + "Generate an image of a robot holding a 'I Love Autogen' sign", + "Generate an image of a dog holding a 'I Love Autogen' sign", +] + + +class _TestImageGenerator: + def __init__(self, image): + self._image = image + + def generate_image(self, prompt: str): + return self._image + + def cache_key(self, prompt: str): + return prompt + + +def create_test_agent(name: str = "test_agent", default_auto_reply: str = "") -> ConversableAgent: + return ConversableAgent(name=name, llm_config=False, default_auto_reply=default_auto_reply) + + +def dalle_image_generator(dalle_config: Dict[str, Any], resolution: str, quality: str): + return generate_images.DalleImageGenerator(dalle_config, resolution=resolution, quality=quality, num_images=1) + + +def api_key(): + return MOCK_OPEN_AI_API_KEY if skip_openai else os.environ.get("OPENAI_API_KEY") + + +@pytest.fixture +def dalle_config() -> Dict[str, Any]: + config_list = openai_utils.config_list_from_models(model_list=["dall-e-2"], exclude="aoai") + if not config_list: + config_list = [{"model": "dall-e-2", "api_key": api_key()}] + return {"config_list": config_list, "timeout": 120, "cache_seed": None} + + +@pytest.fixture +def gpt3_config() -> Dict[str, Any]: + config_list = [ + { + "model": "gpt-35-turbo-16k", + "api_key": api_key(), + }, + { + "model": "gpt-3.5-turbo-16k", + "api_key": api_key(), + }, + ] + return {"config_list": config_list, "timeout": 120, "cache_seed": None} + + +@pytest.fixture +def image_gen_capability(): + image_generator = _TestImageGenerator(Image.new("RGB", (256, 256))) + return generate_images.ImageGeneration(image_generator) + + +@pytest.mark.skipif(skip_openai, reason="Requested to skip.") +@pytest.mark.skipif(skip_requirement, reason="Dependencies are not installed.") +def test_dalle_image_generator(dalle_config: Dict[str, Any]): + """Tests DalleImageGenerator capability to generate images by calling the OpenAI API.""" + dalle_generator = dalle_image_generator(dalle_config, RESOLUTIONS[0], QUALITIES[0]) + image = dalle_generator.generate_image(PROMPTS[0]) + + assert isinstance(image, Image.Image) + + +# Using cartesian product to generate all possible combinations of resolution, quality, and prompt +@pytest.mark.parametrize("gen_config_1", itertools.product(RESOLUTIONS, QUALITIES, PROMPTS)) +@pytest.mark.parametrize("gen_config_2", itertools.product(RESOLUTIONS, QUALITIES, PROMPTS)) +@pytest.mark.skipif(skip_requirement, reason="Dependencies are not installed.") +def test_dalle_image_generator_cache_key( + dalle_config: Dict[str, Any], gen_config_1: Tuple[str, str, str], gen_config_2: Tuple[str, str, str] +): + """Tests if DalleImageGenerator creates unique cache keys. + + Args: + dalle_config: The LLM config for the DalleImageGenerator. + gen_config_1: A tuple containing the resolution, quality, and prompt for the first image generator. + gen_config_2: A tuple containing the resolution, quality, and prompt for the second image generator. + """ + + dalle_generator_1 = dalle_image_generator(dalle_config, resolution=gen_config_1[0], quality=gen_config_1[1]) + dalle_generator_2 = dalle_image_generator(dalle_config, resolution=gen_config_2[0], quality=gen_config_2[1]) + + cache_key_1 = dalle_generator_1.cache_key(gen_config_1[2]) + cache_key_2 = dalle_generator_2.cache_key(gen_config_2[2]) + + if gen_config_1 == gen_config_2: + assert cache_key_1 == cache_key_2 + else: + assert cache_key_1 != cache_key_2 + + +@pytest.mark.skipif(skip_requirement, reason="Dependencies are not installed.") +def test_image_generation_capability_positive(monkeypatch, image_gen_capability): + """Tests ImageGeneration capability to generate images by calling the ImageGenerator. + + This tests if the message is asking the agent to generate an image. + """ + auto_reply = "Didn't need to generate an image." + + # Patching the _should_generate_image and _extract_prompt methods to avoid TextAnalyzerAgent to make API calls + # Improves reproducibility and falkiness of the test + monkeypatch.setattr(generate_images.ImageGeneration, "_should_generate_image", lambda _, __: True) + monkeypatch.setattr(generate_images.ImageGeneration, "_extract_prompt", lambda _, __: PROMPTS[0]) + + user = UserProxyAgent("user", human_input_mode="NEVER") + agent = create_test_agent(default_auto_reply=auto_reply) + image_gen_capability.add_to_agent(agent) + + user.send(message=PROMPTS[0], recipient=agent, request_reply=True, silent=True) + last_message = agent.last_message() + + assert last_message + + processed_message = code_utils.content_str(last_message["content"]) + + assert "" in processed_message + assert auto_reply not in processed_message + + +@pytest.mark.skipif(skip_requirement, reason="Dependencies are not installed.") +def test_image_generation_capability_negative(monkeypatch, image_gen_capability): + """Tests ImageGeneration capability to generate images by calling the ImageGenerator. + + This tests if the message is not asking the agent to generate an image. + """ + auto_reply = "Didn't need to generate an image." + + # Patching the _should_generate_image and _extract_prompt methods to avoid TextAnalyzerAgent making API calls. + # Improves reproducibility and flakiness of the test. + monkeypatch.setattr(generate_images.ImageGeneration, "_should_generate_image", lambda _, __: False) + monkeypatch.setattr(generate_images.ImageGeneration, "_extract_prompt", lambda _, __: PROMPTS[0]) + + user = UserProxyAgent("user", human_input_mode="NEVER") + agent = ConversableAgent("test_agent", llm_config=False, default_auto_reply=auto_reply) + image_gen_capability.add_to_agent(agent) + + user.send(message=PROMPTS[0], recipient=agent, request_reply=True, silent=True) + last_message = agent.last_message() + + assert last_message + + processed_message = code_utils.content_str(last_message["content"]) + + assert "" not in processed_message + assert auto_reply == processed_message + + +@pytest.mark.skipif(skip_requirement, reason="Dependencies are not installed.") +def test_image_generation_capability_cache(monkeypatch): + """Tests ImageGeneration capability to cache the generated images.""" + test_image_size = (256, 256) + + # Patching the _should_generate_image and _extract_prompt methods to avoid TextAnalyzerAgent making API calls. + monkeypatch.setattr(generate_images.ImageGeneration, "_should_generate_image", lambda _, __: True) + monkeypatch.setattr(generate_images.ImageGeneration, "_extract_prompt", lambda _, __: PROMPTS[0]) + + with tempfile.TemporaryDirectory() as temp_dir: + cache = Cache.disk(cache_path_root=temp_dir) + + user = UserProxyAgent("user", human_input_mode="NEVER") + agent = create_test_agent() + + test_image_generator = _TestImageGenerator(Image.new("RGB", test_image_size)) + image_gen_capability = generate_images.ImageGeneration(test_image_generator, cache=cache) + image_gen_capability.add_to_agent(agent) + + user.send(message=PROMPTS[0], recipient=agent, request_reply=True, silent=True) + + # Checking if the image has been cached by creating a new agent with a different image generator. + agent = create_test_agent(name="test_agent_2") + test_image_generator = _TestImageGenerator(Image.new("RGB", (512, 512))) + image_gen_capability = generate_images.ImageGeneration(test_image_generator, cache=cache) + image_gen_capability.add_to_agent(agent) + + user.send(message=PROMPTS[0], recipient=agent, request_reply=True, silent=True) + + last_message = agent.last_message() + + assert last_message + + image_dict = [image for image in last_message["content"] if image["type"] == "image_url"] + image = get_pil_image(image_dict[0]["image_url"]["url"]) + + assert image.size == test_image_size + + +if __name__ == "__main__": + test_dalle_image_generator( + dalle_config={"config_list": openai_utils.config_list_from_models(model_list=["dall-e-2"], exclude="aoai")} + )