Spaces:
Runtime error
Runtime error
| import os | |
| import sys | |
| sys.path.insert(0, "/home/srush/Projects/MiniChain/venv/lib/python3.10/site-packages") | |
| print(sys.path) | |
| import gradio as gr | |
| from dataclasses import dataclass | |
| from chalk import * | |
| from colour import Color | |
| import inspect | |
| import os | |
| import openai | |
| from typing import List, Tuple, Optional | |
| from enum import Enum | |
| import io | |
| from contextlib import redirect_stdout | |
| import imageio | |
| import tiktoken | |
| import time | |
| openai.api_key = "" | |
| tab = " " | |
| def start2(prompt, board, api_key): | |
| out = "" | |
| # for chunk in openai.ChatCompletion.create( | |
| # model="gpt-4", | |
| # messages=[{ | |
| # "role": "user", | |
| # "content": prompt, | |
| # }], | |
| # stream=True, | |
| # temperature= 0 | |
| # ): | |
| board = board#Game(boundary=(9, 9), key=(1, 1), flag=(2, 2), init=(0, 0), walls=[(2, 0)]) | |
| actions = [Actions.DOWNRIGHT, Actions.RIGHT, Actions.DOWNRIGHT, Actions.PICKUP, Actions.DOWNRIGHT] | |
| contents = example(board, actions) | |
| print(contents) | |
| # encoding = tiktoken.encoding_for_model("gpt-4") | |
| # num_tokens = encoding.encode(string) | |
| for content in contents: | |
| time.sleep(0.005) | |
| content = content | |
| if content is not None: | |
| out += content | |
| print(content, end="") | |
| yield out | |
| yield out | |
| def start(prompt, board, api_key): | |
| out = "" | |
| # encoding = tiktoken.encoding_for_model("gpt-4") | |
| # num_tokens = encoding.encode(string) | |
| content = "" | |
| openai.api_key = api_key | |
| for chunk in openai.ChatCompletion.create( | |
| model="gpt-4", | |
| messages=[{ | |
| "role": "user", | |
| "content": prompt, | |
| }], | |
| stream=True, | |
| temperature= 0 | |
| ): | |
| # for content in contents: | |
| time.sleep(0.005) | |
| content = chunk["choices"][0].get("delta", {}).get("content") | |
| if content is not None: | |
| out += content | |
| print(content, end="") | |
| yield out | |
| yield out | |
| def num_tokens_from_string(string: str, encoding_name: str="gpt-4") -> int: | |
| """Returns the number of tokens in a text string.""" | |
| encoding = tiktoken.encoding_for_model(encoding_name) | |
| num_tokens = len(encoding.encode(string)) | |
| return num_tokens | |
| # + [markdown] id="LMTjwXdD7v-I" | |
| # ## Game Code | |
| # | |
| # This code creates a mini-game to play. It takes place on a hexagon. You are represented by a circle. You need to first pick up a key represented by a triangle. You finally need to make it to the cross to finish the game. The actions show each of the directions you can move. | |
| # | |
| # | |
| # + id="Fv3eTRKiV2ZB" cellView="form" | |
| #@title Game Code | |
| # Possible Actions | |
| class Actions(Enum): | |
| UPRIGHT = "UR" | |
| RIGHT = "R" | |
| DOWNRIGHT = "DR" | |
| DOWNLEFT = "DL" | |
| LEFT = "L" | |
| UPLEFT = "UL" | |
| PICKUP = "Pickup" | |
| # Movements | |
| change = { | |
| Actions.UPRIGHT : (-1, 1), | |
| Actions.RIGHT : (0, 2), | |
| Actions.DOWNRIGHT : (1, 1), | |
| Actions.DOWNLEFT : (1, -1), | |
| Actions.LEFT : (0, -2), | |
| Actions.UPLEFT : (-1, -1), | |
| Actions.PICKUP : (0, 0), | |
| } | |
| change_str = {action.value: change[action] for action in Actions} | |
| def add(a, b): | |
| return a[0] + b[0], a[1] + b[1] | |
| class Board: | |
| grid: List[str] | |
| player_pos: Tuple[int, int] | |
| flag_pos: Tuple[int, int] | |
| wall_pos:List[Tuple[int, int]] | |
| key_pos:Optional[Tuple[int, int]] | |
| def move(self, action: Actions) -> 'Board': | |
| "Move by creating a new board." | |
| d_m = change[action] | |
| if action == Actions.PICKUP: | |
| if self.player_pos == self.key_pos: | |
| return Board(self.grid, self.player_pos, self.flag_pos, self.wall_pos, None) | |
| else: | |
| return self | |
| new_player_pos = add(self.player_pos, d_m) | |
| # Out of bounds | |
| if new_player_pos[0] < 0 or new_player_pos[0] >= len(self.grid): | |
| return self | |
| if new_player_pos[1] < 0 or new_player_pos[1] >= len(self.grid[0]): | |
| return self | |
| # Can't move through walls | |
| if self.grid[new_player_pos[0]][new_player_pos[1]] == 'W': | |
| return self | |
| new_grid = [row[:] for row in self.grid] # Create a copy of the grid | |
| new_grid[self.player_pos[0]][self.player_pos[1]] = '.' | |
| new_grid[new_player_pos[0]][new_player_pos[1]] = '@' | |
| return Board(new_grid, new_player_pos, self.flag_pos, self.wall_pos, self.key_pos) | |
| def __str__(self) -> str: | |
| return '\n'.join(''.join(row) for i, row in enumerate(self.grid)) | |
| def create_empty_board(cls, size: Tuple[int, int], key_pos, flag_pos, init, wall_pos) -> 'Board': | |
| grid = [['.' if i % 2 == j % 2 else " " for i in range(size[1])] for j in range(size[0])] | |
| player_pos = init | |
| flag_pos = flag_pos | |
| grid[player_pos[0]][player_pos[1]] = '@' | |
| grid[flag_pos[0]][flag_pos[1]] = 'P' | |
| grid[key_pos[0]][key_pos[1]] = 'K' | |
| for pos in wall_pos: | |
| grid[pos[0]][pos[1]] = 'W' | |
| return cls(grid, player_pos, flag_pos, wall_pos, key_pos) | |
| class Game: | |
| def __init__(self, init, flag, walls, key, boundary): | |
| "Create the version of the game that the AI sees." | |
| self.boundary = boundary | |
| self.board = Board.create_empty_board(boundary, key, flag, init, walls) | |
| self.original = self.board | |
| self.actions = [] | |
| def move(self, action): | |
| self.board = self.board.move(action) | |
| self.actions.append(action) | |
| def walls(self): | |
| return self.board.wall_pos | |
| def __repr__(self) -> str: | |
| walls = ",".join(map(str, self.board.wall_pos)) | |
| return f"Game(init={self.board.player_pos}, flag={self.board.flag_pos}, walls={self.board.wall_pos}, boundary={self.boundary}, key={self.board.key_pos})" | |
| # This is the version of move that the AI can see. | |
| def move(game, action, old_pos): | |
| # ACTIONS (must be legal) | |
| game.move(Actions(action)) | |
| offset = change_str[action] | |
| pos = (old_pos[0] + offset[0], old_pos[1] + offset[1]) | |
| assert 0 <= pos[0] < game.boundary[0], "Row position out of bounds" | |
| assert 0 <= pos[1] < game.boundary[1], "Col position out of bounds" | |
| assert pos not in game.walls, f"Walked into wall {pos}" | |
| if action == "PU": | |
| assert pos == game.key, f"Not over key" | |
| return pos | |
| # + [markdown] id="PDOcPiQq8u_Y" | |
| # We can look at the board by drawing it. | |
| # + colab={"base_uri": "https://localhost:8080/", "height": 221} id="Ic7WgOTi8uF1" outputId="4dc07cb9-9e5f-4d28-d4ea-470ad4b13141" | |
| #@title Drawing code | |
| def draw_board(grid, num=0): | |
| hex = regular_polygon(6, 1).rotate_by(1/12).line_width(0.5).fill_color(Color("white")) | |
| w = hex.get_envelope().width | |
| canvas = empty() | |
| for r, b in enumerate(grid): | |
| def show(v): | |
| if v == ".": | |
| return hex | |
| if v == "@": | |
| return hex + circle(0.35).fill_color(Color("red")) | |
| if v == "P": | |
| x = rectangle(0.25, 0.7).fill_color(Color("blue")).line_width(0) | |
| return hex + (x.rotate_by(0.25/2) + x.rotate_by(-0.25/2)) | |
| if v == "K": | |
| return hex + triangle(0.75).fill_color(Color("purple")) | |
| if v == "W": | |
| return hex.fill_color(Color("black")) | |
| if v ==" ": | |
| return hex | |
| row = hcat(show(v) for i, v in enumerate(b[1 if r %2 else 0::2])) | |
| canvas += row.translate(w * 0.5 if r%2 else 0, 1.5 * r) | |
| canvas = canvas.center_xy().frame(0.5) | |
| canvas = rectangle(canvas.get_envelope().width, canvas.get_envelope().height).line_width(0.5).fill_color(Color("orange")) + canvas | |
| canvas.render_svg(f"pic{num}.svg", 256) | |
| return canvas | |
| # + colab={"base_uri": "https://localhost:8080/", "height": 424} id="nqgPKLu0AMhU" outputId="19e4c6d0-b792-4a34-f4c4-81902974c346" | |
| # game = Game(boundary=(5, 5), key=(0, 2), flag=(4, 4), init=(0, 0), walls=[(2, 2)]) | |
| # display(draw_board(game.board.grid)) | |
| # move(game, "DR", (0,0)) | |
| # display(draw_board(game.board.grid)) | |
| # + [markdown] id="PhqF9af5_jvh" | |
| # ## Prompt Code | |
| # | |
| # The puzzle is to write prompt code to make the model accomplish this task. We have provided some scaffolding code for you. The code creates: | |
| # | |
| # * A header for describing the game. | |
| # * A function `make_fun` that shows the AI how to move in code. | |
| # * A footer to describe the final game board that you want the mode to solve. | |
| # | |
| # You can fill this in a watch how the model moves around. | |
| # + id="jFf7TCOJaVHX" | |
| #@title Make the Prompt | |
| def make_fun(board, actions): | |
| "This function generates python code for few-shot examples" | |
| out = tab + "p = " + str(board.player_pos) | |
| for i, action in enumerate(actions): | |
| new_board = board.move(action) | |
| out += f""" | |
| # TODO ADD CODE | |
| p = move(b, "{action.value}", p) # TODO ADD CODE""" | |
| board = new_board | |
| return out | |
| def example(game, actions): | |
| """ | |
| This code makes a few shot example. You don't need to edit it. | |
| """ | |
| return f""" | |
| def my_example(): | |
| b = {repr(game)} | |
| {make_fun(game.board, actions)} | |
| return b | |
| """ | |
| ex = 0 | |
| def prompt(game): | |
| """ | |
| You should fill these sections out to teach the AI how to play the game. | |
| Or you may do your own thing :) | |
| """ | |
| print(f""" | |
| # TODO: DESCRIBE THE GAME | |
| # TODO: DESCRIBE THE ACTIONS | |
| change_str = {change_str} | |
| {inspect.getsource(move)} | |
| """) | |
| def example(game, actions): | |
| """ | |
| This code makes a few shot example. You don't need to edit it. | |
| """ | |
| global ex | |
| ex += 1 | |
| print(f""" | |
| def example{ex}(): | |
| b = {repr(game)} | |
| {make_fun(game.board, actions)} | |
| return b | |
| # ------------ | |
| """) | |
| # Create a few shot example (you may not need this) | |
| board = Game(boundary=(3, 3), key=(1, 1), flag=(2, 2), init=(0, 0), walls=[(2, 0)]) | |
| actions = [Actions.DOWNRIGHT, Actions.PICKUP, Actions.DOWNRIGHT] | |
| example(board, actions) | |
| # Test case | |
| print(f""" | |
| # ---- | |
| # TODO: ADD any custom example code | |
| #--- | |
| # TODO: FINAL description. | |
| # Contraints for this function:", {repr(game)} | |
| # Please fill this in with code like the examples above (do not provide a description): | |
| # | |
| # The following function `my_example` instantiates a GameBoard called b with these constraints. | |
| """) | |
| # + [markdown] id="-iecyV7nAbFT" | |
| # This code lets you make a game and see the output for a prompt for that game. There are easy, medium, and hard games. | |
| # + colab={"base_uri": "https://localhost:8080/"} id="cOneYFok_OMe" outputId="97080186-7322-4ba9-b500-095fb39071aa" | |
| # Easy | |
| easy_game = Game(boundary=(3, 3), key=(1, 1), flag=(2, 2), init=(0, 0), walls=[]) | |
| # Medium | |
| medium_game = Game(boundary=(5, 5), key=(3, 1), flag=(4, 4), init=(0, 0), walls=[(1, 1)]) | |
| # Hard (This is the main one) | |
| hard_game = Game(boundary=(8, 15), key=(3, 1), flag=(7, 13), init=(0, 0), walls=[(2, 2), (1, 1), (5, 3), (1, 11), (5, 5), (6, 6), (6, 10), (2, 6), (4, 12)]) | |
| # Evil | |
| evil_game = Game(boundary=(8, 15), key=(5, 1), flag=(7, 13), init=(0, 0), walls=[(2, 2), (3, 3), (4, 2), (1, 1), (2, 4), (7, 11), (5, 3), (1, 11), (5, 5), (6, 6), (6, 10), (2, 6), (4, 12)]) | |
| games = {"Easy": easy_game, "Medium": medium_game, "Hard": hard_game, "Evil": evil_game} | |
| # Animate the outputs as a GIF | |
| def animate(l): | |
| images = [] | |
| for i in range(l): | |
| images.append(imageio.v2.imread(f"pic{i}.png")) | |
| return imageio.v2.mimsave('movie.gif', images, **{ 'duration': 0.5 }) | |
| def load(inp): | |
| if inp in games: | |
| board = games[inp] | |
| else: | |
| board = eval(inp) | |
| draw_board(board.board.grid, 0).render_svg("tmp.svg") | |
| return ["tmp.svg"], repr(board) | |
| draw_board(hard_game.board.grid, 0).render_svg("hard.svg") | |
| draw_board(easy_game.board.grid, 0).render_svg("easy.svg") | |
| with gr.Blocks() as app: | |
| # test = gr.Code(label="test") | |
| # im2 = gr.Gallery() | |
| # im2.style(preview=True) | |
| gr.Markdown(""" | |
| # GPTWorld | |
| GPTWorld is a prompting game. Your goal is to get an LLM to complete a maze. If you can do this successfully, it will be able to navigate itself through the world from the start (o) to the key the exit (x). In the bottom right we show you a sample target output of GPT for a maze. Your goal is to get the model to generate this from scratch for an unseen maze. | |
| The game takes place on a hexagonal grid with walls. Even rows are labeled (0,0), (0, 2), (0,4) and odd rows are labeled (1, 1), (1, 3), (1, 5). This was done to make the puzzle a bit less common. | |
| """) | |
| with gr.Row(): | |
| with gr.Column(): | |
| game_desc = gr.Text(label="Game") | |
| examples = gr.Radio(show_label=False, | |
| choices=["Easy", "Medium", "Hard", "Evil"]) | |
| api_key = gr.Text(label="OpenAI Key", type="password", | |
| value=os.environ.get("OPENAI_API_KEY")) | |
| prompt = gr.Code(label="prompt", language="python", lines=40, value=f""" | |
| # A prompt to describe this game to the GPT model. | |
| # Ideas: | |
| # * Describe how the game works | |
| # * Give code examples that solve similar mazes. | |
| # * Give examples to explain the reasoning process | |
| # For example you might want to tell it how the moves work | |
| change_str = {change_str} | |
| # Or make up a clear implementation for the move function | |
| def move(board, action, old_pos): | |
| # ACTIONS (must be legal) | |
| board.move(action) | |
| offset = change_str[action] | |
| pos = (old_pos[0] + offset[0], old_pos[1] + offset[1]) | |
| assert 0 <= pos[0] < board.boundary[0] | |
| assert 0 <= pos[1] < board.boundary[1] | |
| assert pos not in board.walls | |
| if action == "Pickup": | |
| assert pos == board.key | |
| return pos | |
| # You can test your code on the right side. | |
| # Finally use %GAME% to inject the game description above. | |
| """) | |
| with gr.Row(): | |
| start_btn = gr.Button("Prompt >") | |
| cancel_btn = gr.Button("Cancel") | |
| with gr.Column(): | |
| im = gr.Gallery() | |
| im.style(preview=True) | |
| output = gr.Code(language="python", value="""def my_example(): | |
| b = Game(init=(0, 0), flag=(2, 2), walls= [], boundary= (3, 3), key= (1, 1)) | |
| p = (0, 0) | |
| # This is the code you want it to generate. | |
| p = move(b, "DR", p) | |
| p = move(b, "Pickup", p) | |
| p = move(b, "DL", p) | |
| p = move(b, "R", p) | |
| return b | |
| """, lines=50) | |
| msg_box = gr.Text(label="Errors") | |
| counter = gr.Slider(label="length", minimum=0, maximum=3000) | |
| run_btn = gr.Button("Rerun ^") | |
| examples.change(load, inputs=[examples], outputs=[im, game_desc]) | |
| game_desc.submit(load, inputs=[game_desc], outputs=[im, game_desc]) | |
| def run(data): | |
| board = eval(data[game_desc]) #games[data[examples]] | |
| inp = data[prompt].replace("%GAME%", repr(board)) | |
| print(inp) | |
| q = {} | |
| i = 0 | |
| count = 0 | |
| im_ = [f"tmp.svg"] | |
| yield {im: im_, counter: 0, output: "", msg_box: ""} | |
| for prefix in start(inp, board, data[api_key]): | |
| ps = prefix.split("\n") | |
| count += 1 | |
| if len(ps) > 3 and not ps[-2].strip().startswith("#") and prefix.endswith("\n"): | |
| print("rendering") | |
| try: | |
| exec(prefix + f"\n return b\nq['board'] = my_example({repr(board)})") | |
| except AssertionError as e: | |
| print("fail") | |
| yield {im: [f"pic{j}.svg" for j in range(i)], counter: count, output: prefix, msg_box: f"You made an illegal move: {e}"} | |
| return | |
| draw_board(q["board"].board.grid, i).render_svg("tmp.svg") | |
| i += 1 | |
| im_ = [f"pic{j}.svg" for j in [i-1]] | |
| yield {im: im_, counter: count, output: prefix} | |
| else: | |
| yield {im: im_, counter: count, output: prefix} | |
| yield {im: [f"pic{j}.svg" for j in range(i)], counter: count, output: prefix} | |
| start_prompt = start_btn.click(run, inputs={prompt, game_desc, api_key}, outputs={im, output, counter, msg_box}) | |
| cancel_btn.click(None, cancels=[start_prompt]) | |
| def run2(data): | |
| c = data[output] | |
| print(c) | |
| i = 0 | |
| for j in range(len(c)): | |
| q = {} | |
| prefix = c[:j] | |
| ps = prefix.split("\n") | |
| if len(ps) > 3 and not ps[-2].strip().startswith("#") and prefix.endswith("\n"): | |
| print("rendering", prefix) | |
| exec(prefix + "\n return b\nq['board'] = my_example()") | |
| draw_board(q["board"].board.grid, i) | |
| i += 1 | |
| animate(i) | |
| out = {im: [f"pic{j}.svg" for j in range(i)]} | |
| print(out) | |
| return out | |
| run_btn.click(run2, inputs={output}, outputs={im}) | |
| app.queue().launch() | |
| # f = io.StringIO() | |
| # with redirect_stdout(f): | |
| # ex = 0 | |
| # prompt(game) | |
| # my_prompt = f.getvalue() | |
| # print(my_prompt) | |
| # # + id="LONWUsBLjOHo" colab={"base_uri": "https://localhost:8080/", "height": 1000} outputId="472afd19-48c1-4924-cabd-639b5e2ad298" | |
| # # Run an LLM and execute it as it runs. | |
| # q = {} | |
| # i = 0 | |
| # for prefix in start(my_prompt): | |
| # ps = prefix.split("\n") | |
| # if len(ps) > 3 and not ps[-2].strip().startswith("#") and prefix.endswith("\n"): | |
| # exec(prefix + "\n return b\nq['board'] = my_example()") | |
| # display(draw_board(q["board"].board.grid, i)) | |
| # i += 1 | |
| # animate(i) | |
| # display(Image("movie.gif")) | |
| # # Print the number of tokens used | |
| # print("Input Tokens:", num_tokens_from_string(my_prompt)) | |
| # print("Output Tokens:", num_tokens_from_string(prefix)) | |