GPT多轮对话CMAEL框架阅读+复现

,

GPT多轮对话CMAEL框架阅读+复现

  • Title: CAMEL: Communicative Agents for \Mind\ Exploration of Large Scale Language Model Society (CAMEL: 大规模语言模型社会的“心智”探索中的交流代理)
  • URLs: Paper, GitHub

概述 :

  • 本文提出了一种名为CAMEL的多代理交流框架，旨在探索大规模语言模型多Agent的自主合作。通过使用角色扮演和内部提示来自主引导通信代理完成任务，同时保持与人类意图的一致性。研究结果表明，CAMEL可以生成对话数据，用于研究交流代理的行为和能力。
  • 论文尝试解决GPT Agents在合作过程中面临的以下几个问题：
    • 多轮对话中的角色翻转角色翻转：多轮对话的过程中Gpt会忘记自己的身份，指令的执行者有时会反过来发出指令
    • 助手重复指令：执行指令的助手角色对话过程中不执行却重复或转述已发出的指令
    • 控制消息的有限循环：在多GPT多轮对话中给出中断信号，控制有限步长内解决任务。
    • flake replies不准确的回答：有时助理角色依据指令给出的解答方案不够准确，需要鉴别并重新生成。

背景信息:

  • 论文背景: 随着对话和基于聊天的语言模型的快速发展，复杂任务解决取得了显著进展。然而，这些模型的成功很大程度上依赖于人类输入来引导对话，这可能具有挑战性且耗时。本文旨在探索构建可扩展技术以促进交流代理之间的自主合作，并洞察其“认知”过程的潜力。
  • 过去方案: 过去的方法中，人类输入是引导对话的关键，但这需要用户提供相关和准确的提示，这对于缺乏领域专业知识的个体来说可能是困难的。因此，本文提出了一个关键问题：能否用一个能够在没有人类监督的情况下引导对话并完成任务的自主交流代理来取代人类干预？
  • 为了解决这个问题，有必要进行更多的研究，探索完全自主完成任务的交流代理的潜力、能力和局限性。同时，还需要考虑多个代理之间的相互作用，因为这对于预测人工智能的未来至关重要。

方法:

  • 本文提出了一种名为角色扮演的交流代理框架。框架包括两个GPT Agent，一个AI助手和一个AI用户。开始时真实用户为此次给出大致的idea，Agent会先进行一次头脑风暴将此idea扩充并具体化成一个可执行的想法，AI用户根据此具体化的想法一步步生成可行的解决方案指令，而AI助手则在每一步指令下回应给出解决方案，AI用户会判断当前的解决方案是否合理，在确保合理后再进入下一轮循环。对话持续进行，直到AI用户判断当前任务已经完成，给出终止符号或达到对话上限。

Untitled

  • 与对话语言模型的其他技术不同，论文里的提示工程仅在角色扮演开始时进行，用于任务指定和角色分配，随后的多轮对话都发生在两个Agent之间。文中给出的提示词示例，文中将这种模式称为Inception Prompting，大致就是有一个总结出通用的模板提示，后面实际用的时候做一些字符串处理将部分关键词替换成用户实际使用的。下图在初始化阶段给各个角色赋予的提示词示例。

Untitled

结果:

  • 实验设置:

    • 使用LLM模型生成AI Society和Code两个数据集，以减少人类参与生成过程。
    • 对于每个角色组合，生成50个助手角色、50个用户角色和10个任务，共生成了25000个对话。
    • 对于每个语言和领域的组合，生成了20种编程语言、50个领域和50个任务，共生成了50000个对话。
    • 在分析生成的数据集过程中，发现了角色翻转、助手重复指令、无效回复和无限对话循环等挑战。
    • 对话终止的条件包括用户连续3轮不给助手指令、助手给用户指令、用户表示任务完成、达到令牌限制和达到最大消息数。

  • 实验结果:

    Untitled

    • 对AI Society和Code数据集的对话终止原因进行了分析。AI Society数据集的主要终止原因是助手指令，而Code数据集的主要终止原因是令牌限制。观察到包含代码的回复往往较长，导致由于令牌限制而终止的次数更多。两个数据集中由于最大消息数而终止的次数较少，表明40条最大消息限制是合理的。
    • 研究了启动提示设计对对话终止分布的影响。进行了两个启动提示修改：Prompt V2去除了助手回应格式，Prompt V1 + Task Planner在原始提示的基础上添加了任务规划器。这两个修改都显著增加了以任务令牌结束的对话数量，并减少了助手指令的消息数量。然而，与原始Prompt V1相比，Prompt V2和Prompt V1 + Task Planner的无效消息数量显著增加。
    • 可视化了AI Society和Code数据集的指令和任务的信息地图。AI Society数据集涵盖了广泛的主题，包括生活方式、社交媒体、内容创作和软件开发。任务包括提供支持、分析、培训和头脑风暴。Code数据集涵盖了与广泛人群相关的主题，包括情感分析、语言和数据处理、数据收集和机器学习。

    复现

    使用LangChain框架，先实现一个CAMELAgent

    1
    2
    3
    4
    5
    6
    7
    8
    9
    10
    11
    12
    13
    14
    15
    16
    17
    18
    19
    20
    21
    22
    23
    24
    25
    26
    27
    28
    29
    30
    31
    class CAMELAgent:
        def __init__(
            self,
            system_message: SystemMessage,
            model: AzureChatOpenAI,
        ) -> None:
            self.system_message = system_message
            self.model = model
            self.init_messages()

        def reset(self) -> None:
            self.init_messages()
            return self.stored_messages

        def init_messages(self) -> None:
            self.stored_messages = [self.system_message]

        def update_messages(self, message: BaseMessage) -> List[BaseMessage]:
            self.stored_messages.append(message)
            return self.stored_messages

        def step(
            self,
            input_message: HumanMessage,
        ) -> AIMessage:
            messages = self.update_messages(input_message)

            output_message = self.model(messages)
            self.update_messages(output_message)

            return output_message

    然后依据论文里的提示词模板调整实现inception prompt基础模板。

    将模板和自定义的几个关键词组合形成初始化时用于引导两个Agent对话的基础代码

    1
    2
    3
    4
    5
    6
    7
    8
    9
    10
    11
    12
    13
    14
    15
    16
    17
    18
    19
    20
    def get_sys_msgs(assistant_role_name: str, user_role_name: str, task: str):
        assistant_sys_template = SystemMessagePromptTemplate.from_template(
            template=assistant_inception_prompt
        )
        assistant_sys_msg = assistant_sys_template.format_messages(
            assistant_role_name=assistant_role_name,
            user_role_name=user_role_name,
            task=task,
        )[0]

        user_sys_template = SystemMessagePromptTemplate.from_template(
            template=user_inception_prompt
        )
        user_sys_msg = user_sys_template.format_messages(
            assistant_role_name=assistant_role_name,
            user_role_name=user_role_name,
            task=task,
        )[0]

        return assistant_sys_msg, user_sys_msg

    最后基于user_sys_msg assistant_sys_msg创建两个示例，在循环中互相对话即可

    1
    2
    3
    4
    5
    6
    7
    8
    9
    10
    11
    12
    13
    14
    15
    16
    17
    18
    19
    20
    21
    22
    user_msg = HumanMessage(
        content=(
            f"{user_sys_msg.content}. "
            "Now start to give me introductions one by one. "
            "Only reply with Instruction and Input."
        )
    )

    assistant_msg = HumanMessage(content=f"{assistant_sys_msg.content}")
    assistant_msg = assistant_agent.step(user_msg)
    chat_turn_limit, n = 30, 0
    while n < chat_turn_limit:
        n += 1
        user_ai_msg = user_agent.step(assistant_msg)
        user_msg = HumanMessage(content=user_ai_msg.content)
        print(f"AI User ({user_role_name}):\n\n{user_msg.content}\n\n")

        assistant_ai_msg = assistant_agent.step(user_msg)
        assistant_msg = HumanMessage(content=assistant_ai_msg.content)
        print(f"AI Assistant ({assistant_role_name}):\n\n{assistant_msg.content}\n\n")
        if "<CAMEL_TASK_DONE>" in user_msg.content:
            break

    之前LangChain的这一段实现有Bug，复现的时候把bug修好上传发起pull request二十分钟不到就被merge了🤣

    https://github.com/langchain-ai/langchain/commit/89a8121eaa1796f6cfdc1853678a8517acfdee19

    本地运作输出结果，这里试的是写一个flappy bird

    D:\Env\anaconda\python.exe C:\Users\Administrator\PycharmProjects\GPTProj\camel.py
    Specified task: Develop a flappy bird game in Python using Pygame. The game should feature a bird avatar that player can fly by tapping; pipes as obstacles to dodge; and a scoring system to count the number of pipes successfully passed.
    Original task prompt:
    Develop a flappy bird with pygame

    Specified task prompt:
    Develop a flappy bird game in Python using Pygame. The game should feature a bird avatar that player can fly by tapping; pipes as obstacles to dodge; and a scoring system to count the number of pipes successfully passed.

    AI Assistant (Python Programmer):

    Instruction: Start by installing the Pygame library.
    Input: None

    AI User (Game Designer):

    Solution: To install the Pygame library, you can use pip, which is a package manager for Python. Here is the command you need to run in your terminal or command prompt:

    1
    pip install pygame

    If you are using a version of Python 3, you might need to use pip3 instead:

    1
    pip3 install pygame

    This command will download and install the Pygame library on your system. Next request.

    AI Assistant (Python Programmer):

    Instruction: Create a window for the game.
    Input: The window size should be 288x512 pixels.

    AI User (Game Designer):

    Solution: To create a window for the game using Pygame, we first need to initialize Pygame and then set the window size. Here is how you can do it:

    1
    2
    3
    4
    5
    6
    7
    8
    9
    10
    11
    12
    13
    14
    15
    16
    17
    18
    import pygame

    # Initialize Pygame
    pygame.init()

    # Set the dimensions of the game window
    window_width = 288
    window_height = 512
    game_window = pygame.display.set_mode((window_width, window_height))

    # Game loop to keep the window open
    running = True
    while running:
        for event in pygame.event.get():
            if event.type == pygame.QUIT:
                running = False

    pygame.quit()

    In this code, we first import the Pygame library and initialize it with pygame.init(). Then we set the dimensions of the game window to 288x512 pixels. The pygame.display.set_mode() function is used to create the game window.

    The game loop is used to keep the game window open until the user closes it. It checks for a QUIT event, which occurs when the user closes the window, and sets running to False to exit the loop when that happens. Finally, pygame.quit() is called to close the Pygame window.

    Next request.

    AI Assistant (Python Programmer):

    Instruction: Create a bird avatar for the game.
    Input: The bird avatar should be placed in the middle of the window.

    AI User (Game Designer):

    Solution: To create a bird avatar, we first need an image file for the bird. Once we have that, we can load it into our game using Pygame’s pygame.image.load() function. Here’s how you can do it:

    1
    2
    3
    4
    5
    6
    7
    8
    9
    10
    11
    12
    13
    14
    15
    16
    17
    18
    19
    20
    21
    22
    23
    24
    25
    26
    27
    28
    29
    30
    31
    32
    33
    34
    35
    import pygame

    # Initialize Pygame
    pygame.init()

    # Set the dimensions of the game window
    window_width = 288
    window_height = 512
    game_window = pygame.display.set_mode((window_width, window_height))

    # Load the bird image
    bird = pygame.image.load('bird.png')  # Replace 'bird.png' with the path to your bird image file

    # Get the dimensions of the bird image
    bird_width = bird.get_width()
    bird_height = bird.get_height()

    # Calculate the position of the bird to place it in the middle of the window
    bird_x = (window_width - bird_width) / 2
    bird_y = (window_height - bird_height) / 2

    # Game loop to keep the window open
    running = True
    while running:
        for event in pygame.event.get():
            if event.type == pygame.QUIT:
                running = False

        # Draw the bird on the window
        game_window.blit(bird, (bird_x, bird_y))

        # Update the display
        pygame.display.update()

    pygame.quit()

    In this code, we first load the bird image using pygame.image.load(). Then we get the dimensions of the bird image using the get_width() and get_height() methods. We calculate the position of the bird to place it in the middle of the window. In the game loop, we draw the bird on the window using the blit() method of the game window, and then we update the display with pygame.display.update().

    Please replace ‘bird.png’ with the path to your bird image file.

    Next request.

    AI Assistant (Python Programmer):

    Instruction: Implement the functionality for the bird to move up when the player taps.
    Input: The bird should move up by 10 pixels each tap.

    AI User (Game Designer):

    Solution: To make the bird move up when the player taps, we can listen for a KEYDOWN event in our game loop. When a KEYDOWN event occurs, we can check if the key that was pressed is the space bar, and if it is, we move the bird up by 10 pixels. Here’s how you can do it:

    1
    2
    3
    4
    5
    6
    7
    8
    9
    10
    11
    12
    13
    14
    15
    16
    17
    18
    19
    20
    21
    22
    23
    24
    25
    26
    27
    28
    29
    30
    31
    32
    33
    34
    35
    36
    37
    38
    39
    import pygame

    # Initialize Pygame
    pygame.init()

    # Set the dimensions of the game window
    window_width = 288
    window_height = 512
    game_window = pygame.display.set_mode((window_width, window_height))

    # Load the bird image
    bird = pygame.image.load('bird.png')  # Replace 'bird.png' with the path to your bird image file

    # Get the dimensions of the bird image
    bird_width = bird.get_width()
    bird_height = bird.get_height()

    # Calculate the position of the bird to place it in the middle of the window
    bird_x = (window_width - bird_width) / 2
    bird_y = (window_height - bird_height) / 2

    # Game loop to keep the window open
    running = True
    while running:
        for event in pygame.event.get():
            if event.type == pygame.QUIT:
                running = False
            elif event.type == pygame.KEYDOWN:
                if event.key == pygame.K_SPACE:
                    bird_y -= 10  # Move the bird up by 10 pixels

        # Draw the bird on the window
        game_window.fill((0, 0, 0))  # Fill the window with black to clear the old frame
        game_window.blit(bird, (bird_x, bird_y))

        # Update the display
        pygame.display.update()

    pygame.quit()

    In this code, we added an additional check in our event loop to listen for KEYDOWN events. When a KEYDOWN event occurs, we check if the key that was pressed is the space bar (pygame.K_SPACE), and if it is, we subtract 10 from bird_y to move the bird up by 10 pixels. We also added a call to game_window.fill((0, 0, 0)) before drawing the bird, to clear the old frame before drawing the new one.

    Next request.

    AI Assistant (Python Programmer):

    Instruction: Implement the functionality for the bird to fall down due to gravity.
    Input: The bird should fall down by 5 pixels every frame.

    AI User (Game Designer):

    Solution: To simulate gravity, we can add a constant value to the bird’s y-coordinate every frame. This will make the bird fall down over time. Here’s how you can do it:

    1
    2
    3
    4
    5
    6
    7
    8
    9
    10
    11
    12
    13
    14
    15
    16
    17
    18
    19
    20
    21
    22
    23
    24
    25
    26
    27
    28
    29
    30
    31
    32
    33
    34
    35
    36
    37
    38
    39
    40
    41
    import pygame

    # Initialize Pygame
    pygame.init()

    # Set the dimensions of the game window
    window_width = 288
    window_height = 512
    game_window = pygame.display.set_mode((window_width, window_height))

    # Load the bird image
    bird = pygame.image.load('bird.png')  # Replace 'bird.png' with the path to your bird image file

    # Get the dimensions of the bird image
    bird_width = bird.get_width()
    bird_height = bird.get_height()

    # Calculate the position of the bird to place it in the middle of the window
    bird_x = (window_width - bird_width) / 2
    bird_y = (window_height - bird_height) / 2

    # Game loop to keep the window open
    running = True
    while running:
        for event in pygame.event.get():
            if event.type == pygame.QUIT:
                running = False
            elif event.type == pygame.KEYDOWN:
                if event.key == pygame.K_SPACE:
                    bird_y -= 10  # Move the bird up by 10 pixels

        bird_y += 5  # Simulate gravity by moving the bird down by 5 pixels every frame

        # Draw the bird on the window
        game_window.fill((0, 0, 0))  # Fill the window with black to clear the old frame
        game_window.blit(bird, (bird_x, bird_y))

        # Update the display
        pygame.display.update()

    pygame.quit()

    In this code, we added bird_y += 5 after the event loop. This line of code is executed every frame, regardless of whether any events occurred, so it will make the bird fall down by 5 pixels every frame.

    Next request.

    AI Assistant (Python Programmer):

    Instruction: Create pipes as obstacles for the bird to dodge.
    Input: The pipes should be placed randomly along the y-axis and move from right to left.

    AI User (Game Designer):

    Solution: To create pipes as obstacles, we need an image for the pipes. We can then create a list of pipes, where each pipe is a dictionary with ‘x’, ‘y’, and ‘passed’ keys. ‘x’ and ‘y’ are the coordinates of the pipe, and ‘passed’ is a boolean that indicates whether the bird has passed the pipe. We can then move the pipes from right to left by subtracting from their ‘x’ coordinate every frame. Here’s how you can do it:

    1
    2
    3
    4
    5
    6
    7
    8
    9
    10
    11
    12
    13
    14
    15
    16
    17
    18
    19
    20
    21
    22
    23
    24
    25
    26
    27
    28
    29
    30
    31
    32
    33
    34
    35
    36
    37
    38
    39
    40
    41
    42
    43
    44
    45
    46
    47
    48
    49
    50
    51
    52
    53
    54
    55
    56
    import pygame
    import random

    # Initialize Pygame
    pygame.init()

    # Set the dimensions of the game window
    window_width = 288
    window_height = 512
    game_window = pygame.display.set_mode((window_width, window_height))

    # Load the bird and pipe images
    bird = pygame.image.load('bird.png')  # Replace 'bird.png' with the path to your bird image file
    pipe = pygame.image.load('pipe.png')  # Replace 'pipe.png' with the path to your pipe image file

    # Get the dimensions of the bird image
    bird_width = bird.get_width()
    bird_height = bird.get_height()

    # Calculate the position of the bird to place it in the middle of the window
    bird_x = (window_width - bird_width) / 2
    bird_y = (window_height - bird_height) / 2

    # Create a list of pipes
    pipes = [{'x': window_width, 'y': random.randint(0, window_height - pipe.get_height()), 'passed': False} for _ in range(5)]

    # Game loop to keep the window open
    running = True
    while running:
        for event in pygame.event.get():
            if event.type == pygame.QUIT:
                running = False
            elif event.type == pygame.KEYDOWN:
                if event.key == pygame.K_SPACE:
                    bird_y -= 10  # Move the bird up by 10 pixels

        bird_y += 5  # Simulate gravity by moving the bird down by 5 pixels every frame

        # Move the pipes
        for p in pipes:
            p['x'] -= 5
            if p['x'] + pipe.get_width() < 0:  # If the pipe is no longer visible
                p['x'] = window_width  # Move it back to the right side of the window
                p['y'] = random.randint(0, window_height - pipe.get_height())  # Give it a new random height
                p['passed'] = False  # Reset the 'passed' status

        # Draw the bird and the pipes on the window
        game_window.fill((0, 0, 0))  # Fill the window with black to clear the old frame
        game_window.blit(bird, (bird_x, bird_y))
        for p in pipes:
            game_window.blit(pipe, (p['x'], p['y']))

        # Update the display
        pygame.display.update()

    pygame.quit()

    In this code, we first load the pipe image. Then we create a list of pipes, where each pipe is a dictionary with ‘x’, ‘y’, and ‘passed’ keys. In the game loop, we move the pipes by subtracting from their ‘x’ coordinate, and if a pipe is no longer visible, we move it back to the right side of the window and give it a new random height. We also draw the pipes on the window in the same way we draw the bird.

    Please replace ‘pipe.png’ with the path to your pipe image file.

    Next request.

    AI Assistant (Python Programmer):

    Instruction: Implement a scoring system to count the number of pipes successfully passed.
    Input: The score should increase by 1 for each pipe passed.

    AI User (Game Designer):

    Solution: To implement a scoring system, we can add a ‘score’ variable that starts at 0. Then, in our game loop, we can check for each pipe if the bird has passed it, and if it has, we increase the score by 1 and set the ‘passed’ key of the pipe to True to prevent the score from increasing again for the same pipe. Here’s how you can do it:

    1
    2
    3
    4
    5
    6
    7
    8
    9
    10
    11
    12
    13
    14
    15
    16
    17
    18
    19
    20
    21
    22
    23
    24
    25
    26
    27
    28
    29
    30
    31
    32
    33
    34
    35
    36
    37
    38
    39
    40
    41
    42
    43
    44
    45
    46
    47
    48
    49
    50
    51
    52
    53
    54
    55
    56
    57
    58
    59
    60
    61
    62
    63
    64
    import pygame
    import random

    # Initialize Pygame
    pygame.init()

    # Set the dimensions of the game window
    window_width = 288
    window_height = 512
    game_window = pygame.display.set_mode((window_width, window_height))

    # Load the bird and pipe images
    bird = pygame.image.load('bird.png')  # Replace 'bird.png' with the path to your bird image file
    pipe = pygame.image.load('pipe.png')  # Replace 'pipe.png' with the path to your pipe image file

    # Get the dimensions of the bird image
    bird_width = bird.get_width()
    bird_height = bird.get_height()

    # Calculate the position of the bird to place it in the middle of the window
    bird_x = (window_width - bird_width) / 2
    bird_y = (window_height - bird_height) / 2

    # Create a list of pipes
    pipes = [{'x': window_width, 'y': random.randint(0, window_height - pipe.get_height()), 'passed': False} for _ in range(5)]

    # Initialize the score
    score = 0

    # Game loop to keep the window open
    running = True
    while running:
        for event in pygame.event.get():
            if event.type == pygame.QUIT:
                running = False
            elif event.type == pygame.KEYDOWN:
                if event.key == pygame.K_SPACE:
                    bird_y -= 10  # Move the bird up by 10 pixels

        bird_y += 5  # Simulate gravity by moving the bird down by 5 pixels every frame

        # Move the pipes and check if the bird passed any pipes
        for p in pipes:
            p['x'] -= 5
            if p['x'] + pipe.get_width() < bird_x and not p['passed']:
                p['passed'] = True
                score += 1
            if p['x'] + pipe.get_width() < 0:  # If the pipe is no longer visible
                p['x'] = window_width  # Move it back to the right side of the window
                p['y'] = random.randint(0, window_height - pipe.get_height())  # Give it a new random height
                p['passed'] = False  # Reset the 'passed' status

        # Draw the bird and the pipes on the window
        game_window.fill((0, 0, 0))  # Fill the window with black to clear the old frame
        game_window.blit(bird, (bird_x, bird_y))
        for p in pipes:
            game_window.blit(pipe, (p['x'], p['y']))

        # Update the display
        pygame.display.update()

        print(f'Score: {score}')  # Print the score

    pygame.quit()

    In this code, we added a ‘score’ variable that starts at 0. In the game loop, we added a check for each pipe to see if the bird has passed it, and if it has, we increase the score by 1 and set the ‘passed’ key of the pipe to True. We also print the score after updating the display.

    Next request.

    AI Assistant (Python Programmer):

    Instruction: Implement a game over condition when the bird hits a pipe or the ground.
    Input: The game should stop and display a “Game Over” message when the game over condition is met.

    AI User (Game Designer):

    Solution: To implement a game over condition, we can add a collision check in our game loop. If the bird’s rectangle intersects with a pipe’s rectangle or the bird’s y-coordinate is greater than the window height, we set running to False to end the game. We can then display a “Game Over” message using Pygame’s font module. Here’s how you can do it:

    1
    2
    3
    4
    5
    6
    7
    8
    9
    10
    11
    12
    13
    14
    15
    16
    17
    18
    19
    20
    21
    22
    23
    24
    25
    26
    27
    28
    29
    30
    31
    32
    33
    34
    35
    36
    37
    38
    39
    40
    41
    42
    43
    44
    45
    46
    47
    48
    49
    50
    51
    52
    53
    54
    55
    56
    57
    58
    59
    60
    61
    62
    63
    64
    65
    66
    67
    68
    69
    70
    71
    72
    73
    74
    75
    76
    77
    78
    79
    import pygame
    import random

    # Initialize Pygame
    pygame.init()

    # Set the dimensions of the game window
    window_width = 288
    window_height = 512
    game_window = pygame.display.set_mode((window_width, window_height))

    # Load the bird and pipe images
    bird = pygame.image.load('bird.png')  # Replace 'bird.png' with the path to your bird image file
    pipe = pygame.image.load('pipe.png')  # Replace 'pipe.png' with the path to your pipe image file

    # Get the dimensions of the bird and pipe images
    bird_width = bird.get_width()
    bird_height = bird.get_height()
    pipe_width = pipe.get_width()
    pipe_height = pipe.get_height()

    # Calculate the position of the bird to place it in the middle of the window
    bird_x = (window_width - bird_width) / 2
    bird_y = (window_height - bird_height) / 2

    # Create a list of pipes
    pipes = [{'x': window_width, 'y': random.randint(0, window_height - pipe_height), 'passed': False} for _ in range(5)]

    # Initialize the score
    score = 0

    # Create a font object for the game over message
    font = pygame.font.Font(None, 36)

    # Game loop to keep the window open
    running = True
    while running:
        for event in pygame.event.get():
            if event.type == pygame.QUIT:
                running = False
            elif event.type == pygame.KEYDOWN:
                if event.key == pygame.K_SPACE:
                    bird_y -= 10  # Move the bird up by 10 pixels

        bird_y += 5  # Simulate gravity by moving the bird down by 5 pixels every frame

        # Move the pipes and check if the bird passed any pipes or collided with a pipe
        for p in pipes:
            p['x'] -= 5
            if p['x'] + pipe_width < bird_x and not p['passed']:
                p['passed'] = True
                score += 1
            if p['x'] < bird_x + bird_width and p['x'] + pipe_width > bird_x and p['y'] < bird_y + bird_height and p['y'] + pipe_height > bird_y:
                running = False  # End the game if the bird collided with a pipe
            if p['x'] + pipe_width < 0:  # If the pipe is no longer visible
                p['x'] = window_width  # Move it back to the right side of the window
                p['y'] = random.randint(0, window_height - pipe_height)  # Give it a new random height
                p['passed'] = False  # Reset the 'passed' status

        if bird_y + bird_height > window_height:
            running = False  # End the game if the bird hit the ground

        # Draw the bird and the pipes on the window
        game_window.fill((0, 0, 0))  # Fill the window with black to clear the old frame
        game_window.blit(bird, (bird_x, bird_y))
        for p in pipes:
            game_window.blit(pipe, (p['x'], p['y']))

        # Update the display
        pygame.display.update()

        print(f'Score: {score}')  # Print the score

    # Display the game over message
    text = font.render('Game Over', True, (255, 255, 255))
    game_window.blit(text, ((window_width - text.get_width()) / 2, (window_height - text.get_height()) / 2))
    pygame.display.update()

    pygame.quit()

    In this code, we added a collision check for each pipe in the game loop. If the bird’s rectangle intersects with a pipe’s rectangle, we set running to False to end the game. We also added a check to see if the bird hit the ground, and if it did, we also end the game. After the game loop, we display a “Game Over” message in the middle of the window.

    Next request.

    AI Assistant (Python Programmer):