diff --git a/new_src/agent.py b/new_src/agent.py index a04a81d..8593b17 100644 --- a/new_src/agent.py +++ b/new_src/agent.py @@ -1,8 +1,10 @@ +from typing import Dict from matplotlib import pyplot as plt from lux.kit import obs_to_game_state, GameState, EnvConfig from lux.utils import direction_to, my_turn_to_place_factory from lux.forward_sim import stop_movement_collisions import numpy as np +from numpy.linalg import norm import sys class Agent(): def __init__(self, player: str, env_cfg: EnvConfig) -> None: @@ -12,6 +14,11 @@ def __init__(self, player: str, env_cfg: EnvConfig) -> None: self.env_cfg: EnvConfig = env_cfg self.factory_score = None + self.units_master_factory = dict() # unit_id -> factory_id + + self.robots_ice_factory = dict() # factory_id -> {unit_id: unit} + self.robots_ore_factory = dict() # factory_id -> {unit_id: unit} + def early_setup(self, step: int, obs, remainingOverageTime: int = 60): if step == 0: # bid 0 to not waste resources bidding and declare as the default faction @@ -37,10 +44,6 @@ def early_setup(self, step: int, obs, remainingOverageTime: int = 60): # distances[x][y] is the distance to the nearest ice tile self.factory_score += np.clip(ice_distances-3, a_min=0, a_max=None) + np.clip(ore_distances-3, a_min=0, a_max=None) * 0.3 - - plt.imshow(self.factory_score, cmap="gray", norm=plt.Normalize(vmin=0, vmax=20, clip=True)) - plt.show() - # how much water and metal you have in your starting pool to give to new factories water_left = game_state.teams[self.player].water @@ -54,8 +57,6 @@ def early_setup(self, step: int, obs, remainingOverageTime: int = 60): # Build factory at the position with the lowest factory_score factory_score = self.factory_score + (obs["board"]["valid_spawns_mask"] == 0) * 1e9 - plt.imshow(factory_score, cmap="gray", norm=plt.Normalize(vmin=0, vmax=20, clip=True)) - plt.show() spawn_loc = np.argmin(factory_score) map_size = self.env_cfg.map_size @@ -64,50 +65,117 @@ def early_setup(self, step: int, obs, remainingOverageTime: int = 60): return dict(spawn=spawn_loc, metal=150, water=150) return dict() - def act(self, step: int, obs, remainingOverageTime: int = 60): - actions = dict() - game_state = obs_to_game_state(step, self.env_cfg, obs) - factories = game_state.factories[self.player] + def _get_factory_misc(self, factories: Dict[str, "Factory"]): + factory_tiles, factory_units = [], [] - for unit_id, factory in factories.items(): - if factory.power >= self.env_cfg.ROBOTS["HEAVY"].POWER_COST and \ - factory.cargo.metal >= self.env_cfg.ROBOTS["HEAVY"].METAL_COST: - actions[unit_id] = factory.build_heavy() - # elif factory.power >= self.env_cfg.ROBOTS["LIGHT"].POWER_COST and \ - # factory.cargo.metal >= self.env_cfg.ROBOTS["LIGHT"].METAL_COST: - # actions[unit_id] = factory.build_light() - remaining_steps = self.env_cfg.max_episode_length - game_state.real_env_steps - if remaining_steps < 70: - if factory.water_cost(game_state) <= factory.cargo.water - remaining_steps: - actions[unit_id] = factory.water() + factory_ids = [] + for factory_id, factory in factories.items(): factory_tiles += [factory.pos] factory_units += [factory] - factory_tiles = np.array(factory_tiles) + factory_ids += [factory_id] - units = game_state.units[self.player] - ice_map = game_state.board.ice - ice_tile_locations = np.argwhere(ice_map == 1) + return factory_tiles, factory_units, factory_ids + def _initialize_robot_bindings(self, factories): + for factory_id in factories.keys(): + self.robots_ice_factory[factory_id] = dict() + self.robots_ore_factory[factory_id] = dict() + @staticmethod + def _num_robot_type_from_list(robot_dict, robot_type): + num_robots = 0 + for unit_id, unit in robot_dict.items(): + if unit.unit_type == robot_type: + num_robots += 1 + return num_robots + + + def num_lights_ore_factory(self, factory_id): + return self._num_robot_type_from_list(self.robots_ore_factory[factory_id], "LIGHT") - for unit_id, unit in units.items(): + + def num_heavies_ore_factory(self, factory_id): + return self._num_robot_type_from_list(self.robots_ore_factory[factory_id], "HEAVY") + + + def num_lights_ice_factory(self, factory_id): + return self._num_robot_type_from_list(self.robots_ice_factory[factory_id], "LIGHT") + + + def num_heavies_ice_factory(self, factory_id): + return self._num_robot_type_from_list(self.robots_ice_factory[factory_id], "HEAVY") - # track the closest factory - closest_factory = None - adjacent_to_factory = False - if len(factory_tiles) > 0: - factory_distances = np.linalg.norm(factory_tiles - unit.pos, ord=1, axis=1) - closest_factory_tile = factory_tiles[np.argmin(factory_distances)] - closest_factory = factory_units[np.argmin(factory_distances)] - adjacent_to_factory = np.linalg.norm(closest_factory_tile - unit.pos, ord=np.inf) <= 1 + def act(self, step: int, obs, remainingOverageTime: int = 60): + """ + 1. If robot is idle, then allocate it to a factory and give occupation (ice/ore) + + TODO + 2. collision + 3. factory needs to reallocate robots + If unit is enough, then water to gain more power + power_requirement + unit action_queue_cost + """ + actions = dict() + game_state = obs_to_game_state(step, self.env_cfg, obs) + + + factories = game_state.factories[self.player] + factory_tiles, factory_units, factory_ids = self._get_factory_misc(factories) + units = game_state.units[self.player] + + if obs['real_env_steps'] == 0: + self._initialize_robot_bindings(factories) + + ice_map = game_state.board.ice + ice_tile_locations = np.argwhere(ice_map == 1) + ore_map = game_state.board.ore + ore_tile_locations = np.argwhere(ore_map == 1) + + # TODO Remove robots from factories factory is dead + + # Register robots to factories if not registered + for unit_id, unit in units.items(): + if not unit_id in self.units_master_factory: + factory_distances = norm(factory_tiles - unit.pos, ord=1, axis=1) + factory_id = factory_ids[np.argmin(factory_distances)] + + self.units_master_factory[unit_id] = factory_id + + # Allocate robot + if unit.unit_type == "LIGHT": + if self.num_lights_ice_factory(factory_id) < self.num_lights_ore_factory(factory_id): + self.robots_ice_factory[factory_id][unit_id] = unit + else: + self.robots_ore_factory[factory_id][unit_id] = unit + else: + if self.num_heavies_ice_factory(factory_id) < self.num_heavies_ore_factory(factory_id): + self.robots_ice_factory[factory_id][unit_id] = unit + else: + self.robots_ore_factory[factory_id][unit_id] = unit + + # Remove robots from factories if they are dead + for factory_id, factory in factories.items(): + for robot_dict in [self.robots_ice_factory[factory_id], self.robots_ore_factory[factory_id]]: + for unit_id, unit in list(robot_dict.items()): + if not unit_id in units: + del robot_dict[unit_id] + del self.units_master_factory[unit_id] + + # handle action of robots bound to factories + for factory_id, factory in factories.items(): + # handle robots adding ice to factory + for unit_id, unit in self.robots_ice_factory[factory_id].items(): + + adjacent_to_factory = norm(factory.pos - unit.pos, ord=np.inf) <= 1 ice_threshold = 40 # previous ice mining code if adjacent_to_factory and unit.power < unit.unit_cfg.INIT_POWER: actions[unit_id] = [unit.pickup(4, unit.unit_cfg.BATTERY_CAPACITY, repeat=0, n=1)] # 4 means power elif unit.cargo.ice < ice_threshold: - ice_tile_distances = np.linalg.norm(ice_tile_locations - unit.pos, ord=1, axis=1) + ice_tile_distances = norm(ice_tile_locations - unit.pos, ord=1, axis=1) closest_ice_tile = ice_tile_locations[np.argmin(ice_tile_distances)] if np.all(closest_ice_tile == unit.pos): if unit.power >= unit.dig_cost(game_state) + unit.action_queue_cost(game_state): @@ -119,7 +187,7 @@ def act(self, step: int, obs, remainingOverageTime: int = 60): actions[unit_id] = [unit.move(direction, repeat=0, n=1)] # else if we have enough ice, we go back to the factory and dump it. elif unit.cargo.ice >= ice_threshold: - direction = direction_to(unit.pos, closest_factory_tile) + direction = direction_to(unit.pos, factory.pos) if adjacent_to_factory: if unit.power >= unit.action_queue_cost(game_state): actions[unit_id] = [unit.transfer(direction, 0, unit.cargo.ice, repeat=0, n=1)] @@ -128,6 +196,55 @@ def act(self, step: int, obs, remainingOverageTime: int = 60): move_cost = unit.move_cost(game_state, direction) if move_cost is not None and unit.power >= move_cost + unit.action_queue_cost(game_state): actions[unit_id] = [unit.move(direction, repeat=0, n=1)] + + # handle robots adding ore to factory + for unit_id, unit in self.robots_ore_factory[factory_id].items(): + adjacent_to_factory = norm(factory.pos - unit.pos, ord=np.inf) <= 1 + ore_threshold = 40 + # previous ore mining code + if adjacent_to_factory and unit.power < unit.unit_cfg.INIT_POWER: + actions[unit_id] = [unit.pickup(4, unit.unit_cfg.BATTERY_CAPACITY, repeat=0, n=1)] + # 4 means power + elif unit.cargo.ore < ore_threshold: + ore_tile_distances = norm(ore_tile_locations - unit.pos, ord=1, axis=1) + closest_ore_tile = ore_tile_locations[np.argmin(ore_tile_distances)] + if np.all(closest_ore_tile == unit.pos): + if unit.power >= unit.dig_cost(game_state) + unit.action_queue_cost(game_state): + actions[unit_id] = [unit.dig(repeat=0, n=1)] + else: + direction = direction_to(unit.pos, closest_ore_tile) + move_cost = unit.move_cost(game_state, direction) + if move_cost is not None and unit.power >= move_cost + unit.action_queue_cost(game_state): + actions[unit_id] = [unit.move(direction, repeat=0, n=1)] + # else if we have enough ore, we go back to the factory and dump it. + elif unit.cargo.ore >= ore_threshold: + direction = direction_to(unit.pos, factory.pos) + if adjacent_to_factory: + if unit.power >= unit.action_queue_cost(game_state): + actions[unit_id] = [unit.transfer(direction, 0, unit.cargo.ore, repeat=0, n=1)] + + else: + move_cost = unit.move_cost(game_state, direction) + if move_cost is not None and unit.power >= move_cost + unit.action_queue_cost(game_state): + actions[unit_id] = [unit.move(direction, repeat=0, n=1)] + + # handle factory action + n_lights = self.num_lights_ore_factory(factory_id) + self.num_lights_ice_factory(factory_id) + n_heavies = self.num_heavies_ore_factory(factory_id) + self.num_heavies_ice_factory(factory_id) + + # if factory can manage current water usage, then water + remaining_steps = self.env_cfg.max_episode_length - game_state.real_env_steps + if remaining_steps < 70: + if factory.water_cost(game_state) <= factory.cargo.water - remaining_steps: + actions[unit_id] = factory.water() + + else: # or build robots + if n_lights > n_heavies * 10 and factory.can_build_heavy(game_state): + actions[factory_id] = factory.build_heavy() + + elif n_lights <= n_heavies * 8 and factory.can_build_light(game_state): + actions[factory_id] = factory.build_light() + actions = stop_movement_collisions(obs, game_state, self.env_cfg, self.player, actions) @@ -149,4 +266,44 @@ def conv2d(a, f, pad='zero', n=1): a = np.pad(a, pad) subM = strd(a, shape = s, strides = a.strides * 2) a = np.einsum('ij,ijkl->kl', f, subM) - return a \ No newline at end of file + return a + + +def main(env, agents, steps): + # reset our env + obs, _ = env.reset() + np.random.seed(0) + + step = 0 + # Note that as the environment has two phases, we also keep track a value called + # `real_env_steps` in the environment state. The first phase ends once `real_env_steps` is 0 and used below + + # iterate until phase 1 ends + while env.state.real_env_steps < 0: + if step >= steps: break + actions = {} + for player in env.agents: + o = obs[player] + a = agents[player].early_setup(step, o) + actions[player] = a + step += 1 + obs, rewards, terminations, truncations, infos = env.step(actions) + dones = {k: terminations[k] or truncations[k] for k in terminations} + done = False + while not done: + if step >= steps: break + actions = {} + for player in env.agents: + o = obs[player] + a = agents[player].act(step, o) + actions[player] = a + step += 1 + obs, rewards, terminations, truncations, infos = env.step(actions) + dones = {k: terminations[k] or truncations[k] for k in terminations} + done = dones["player_0"] and dones["player_1"] + +if __name__=='__main__': + from luxai_s2.env import LuxAI_S2 + env = LuxAI_S2() # create the environment object + agents = {player: Agent(player, env.state.env_cfg) for player in ['player_0', 'player_1']} + main(env, agents, 100) \ No newline at end of file diff --git a/new_src/tutorial.ipynb b/new_src/tutorial.ipynb index 8cc9015..030721b 100644 --- a/new_src/tutorial.ipynb +++ b/new_src/tutorial.ipynb @@ -2,7 +2,7 @@ "cells": [ { "cell_type": "code", - "execution_count": 1, + "execution_count": 3, "metadata": {}, "outputs": [], "source": [ @@ -13,7 +13,7 @@ }, { "cell_type": "code", - "execution_count": 2, + "execution_count": 4, "metadata": {}, "outputs": [], "source": [ @@ -23,16 +23,16 @@ }, { "cell_type": "code", - "execution_count": 3, + "execution_count": 5, "metadata": {}, "outputs": [ { "data": { "text/plain": [ - "" + "" ] }, - "execution_count": 3, + "execution_count": 5, "metadata": {}, "output_type": "execute_result" }, @@ -54,37 +54,19 @@ }, { "cell_type": "code", - "execution_count": 4, + "execution_count": 6, "metadata": {}, "outputs": [], "source": [ "from lux.kit import obs_to_game_state, GameState, EnvConfig\n", "from luxai_s2.utils import animate\n", "from lux.utils import direction_to, my_turn_to_place_factory\n", - "import torch\n", - "class Agent():\n", - " def __init__(self, player: str, env_cfg: EnvConfig) -> None:\n", - " self.player = player\n", - " self.opp_player = \"player_1\" if self.player == \"player_0\" else \"player_0\"\n", - " np.random.seed(0)\n", - " self.env_cfg: EnvConfig = env_cfg\n", - " self.factory_score = None\n", - "\n", - " def early_setup(self, step: int, obs, remainingOverageTime: int = 60):\n", - " actions = dict()\n", - " # optionally convert observations to python objects with utility functions\n", - " game_state = obs_to_game_state(step, self.env_cfg, obs) \n", - " return actions\n", - "\n", - " def act(self, step: int, obs, remainingOverageTime: int = 60):\n", - " actions = dict()\n", - " game_state = obs_to_game_state(step, self.env_cfg, obs)\n", - " return actions" + "import torch" ] }, { "cell_type": "code", - "execution_count": 5, + "execution_count": 8, "metadata": {}, "outputs": [], "source": [ @@ -146,210 +128,149 @@ }, { "cell_type": "code", - "execution_count": 6, - "metadata": {}, - "outputs": [], - "source": [ - "# https://stackoverflow.com/questions/43086557/convolve2d-just-by-using-numpy\n", - "def conv2d(a, f, pad='zero', n=1):\n", - " if pad == 'zero':\n", - " pad = (f.shape[0] - 1) // 2\n", - "\n", - " strd = np.lib.stride_tricks.as_strided\n", - " a = np.pad(a, pad)\n", - " s = f.shape + tuple(np.subtract(a.shape, f.shape) + 1)\n", - " for i in range(n):\n", - " if i > 0:\n", - " a = np.pad(a, pad)\n", - " subM = strd(a, shape = s, strides = a.strides * 2)\n", - " a = np.einsum('ij,ijkl->kl', f, subM)\n", - " return a" - ] - }, - { - "cell_type": "code", - "execution_count": 7, - "metadata": {}, - "outputs": [], - "source": [ - "def average_kernel(size):\n", - " return np.ones((size, size)) / (size * size)" - ] - }, - { - "cell_type": "code", - "execution_count": 8, + "execution_count": 46, "metadata": {}, "outputs": [ { "data": { + "image/png": "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", "text/plain": [ - "array([[0.44444444, 0.66666667, 0.66666667, 0.66666667, 0.44444444],\n", - " [0.66666667, 1. , 1. , 1. , 0.66666667],\n", - " [0.66666667, 1. , 1. , 1. , 0.66666667],\n", - " [0.66666667, 1. , 1. , 1. , 0.66666667],\n", - " [0.44444444, 0.66666667, 0.66666667, 0.66666667, 0.44444444]])" + "
" ] }, - "execution_count": 8, "metadata": {}, - "output_type": "execute_result" - } - ], - "source": [ - "a = np.ones((5, 5))\n", - "k = average_kernel(3)\n", - "conv2d(a, k)" - ] - }, - { - "cell_type": "code", - "execution_count": 26, - "metadata": {}, - "outputs": [], - "source": [ - "def early_setup(self, step: int, obs, remainingOverageTime: int = 60):\n", - " if step == 0:\n", - " # bid 0 to not waste resources bidding and declare as the default faction\n", - " # you can bid -n to prefer going second or n to prefer going first in placement\n", - " return dict(faction=\"AlphaStrike\", bid=0)\n", - " else:\n", - " game_state = obs_to_game_state(step, self.env_cfg, obs)\n", - " # factory placement period\n", - " if self.factory_score is None:\n", - " map_size = self.env_cfg.map_size\n", - " self.factory_score = np.zeros((map_size, map_size))\n", - " self.factory_score += conv2d(game_state.board.rubble, average_kernel(5), n=3)\n", - " ice_tile_locations = np.argwhere(game_state.board.ice == 1)\n", - " all_locations = np.mgrid[:map_size, :map_size].swapaxes(0, 2).reshape(-1, 2)\n", - " distances = np.linalg.norm(np.expand_dims(all_locations, 1) - np.expand_dims(ice_tile_locations, 0), ord=1, axis=-1)\n", - " distances = np.min(distances, axis=-1)\n", - " distances = distances.reshape(map_size, map_size)\n", - " # distances[x][y] is the distance to the nearest ice tile \n", - " self.factory_score += distances\n", - " \n", - " # how much water and metal you have in your starting pool to give to new factories\n", - " water_left = game_state.teams[self.player].water\n", - " metal_left = game_state.teams[self.player].metal\n", - " \n", - " # how many factories you have left to place\n", - " factories_to_place = game_state.teams[self.player].factories_to_place\n", - " # whether it is your turn to place a factory\n", - " my_turn_to_place = my_turn_to_place_factory(game_state.teams[self.player].place_first, step)\n", - " if factories_to_place > 0 and my_turn_to_place:\n", - " # we will spawn our factory in a random location with 150 metal and water if it is our turn to place\n", - " factory_score = self.factory_score + (obs[\"board\"][\"valid_spawns_mask\"] == 0) * 1e9\n", - " spawn_loc = np.argmin(factory_score)\n", - " map_size = self.env_cfg.map_size\n", - " spawn_loc = np.array([spawn_loc // map_size, spawn_loc % map_size])\n", - " return dict(spawn=spawn_loc, metal=150, water=150)\n", - " return dict()\n", - "Agent.early_setup = early_setup" - ] - }, - { - "cell_type": "code", - "execution_count": 28, - "metadata": {}, - "outputs": [ + "output_type": "display_data" + }, { - "name": "stderr", - "output_type": "stream", - "text": [ - "OpenCV: FFMPEG: tag 0x30395056/'VP90' is not supported with codec id 167 and format 'webm / WebM'\n" - ] + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" }, { "data": { - "text/html": [ - "" - ], + "image/png": "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", "text/plain": [ - "" + "
" ] }, - "execution_count": 28, "metadata": {}, - "output_type": "execute_result" - } - ], - "source": [ - "# recreate our agents and run\n", - "agents = {player: Agent(player, env.state.env_cfg) for player in env.agents}\n", - "interact(env, agents, 15)" - ] - }, - { - "cell_type": "code", - "execution_count": 35, - "metadata": {}, - "outputs": [], - "source": [ - "def act(self, step: int, obs, remainingOverageTime: int = 60):\n", - " actions = dict()\n", - " game_state = obs_to_game_state(step, self.env_cfg, obs)\n", - " factories = game_state.factories[self.player]\n", - " factory_tiles, factory_units = [], []\n", - " for unit_id, factory in factories.items():\n", - " if factory.power >= self.env_cfg.ROBOTS[\"HEAVY\"].POWER_COST and \\\n", - " factory.cargo.metal >= self.env_cfg.ROBOTS[\"HEAVY\"].METAL_COST:\n", - " actions[unit_id] = factory.build_heavy()\n", - " factory_tiles += [factory.pos]\n", - " factory_units += [factory]\n", - " factory_tiles = np.array(factory_tiles)\n", - "\n", - " units = game_state.units[self.player]\n", - " ice_map = game_state.board.ice\n", - " ice_tile_locations = np.argwhere(ice_map == 1)\n", - " for unit_id, unit in units.items():\n", - " \n", - " # track the closest factory\n", - " closest_factory = None\n", - " adjacent_to_factory = False\n", - " if len(factory_tiles) > 0:\n", - " factory_distances = np.linalg.norm(factory_tiles - unit.pos, ord=1, axis=1)\n", - " closest_factory_tile = factory_tiles[np.argmin(factory_distances)]\n", - " closest_factory = factory_units[np.argmin(factory_distances)]\n", - " adjacent_to_factory = np.linalg.norm(closest_factory_tile - unit.pos, ord=1) == 0\n", - "\n", - " ice_threshold = 40\n", - " # previous ice mining code\n", - " if adjacent_to_factory and unit.power < unit.unit_cfg.INIT_POWER:\n", - " actions[unit_id] = [unit.pickup(4, unit.unit_cfg.BATTERY_CAPACITY, repeat=0, n=1)]\n", - " # 4 means power\n", - " elif unit.cargo.ice < ice_threshold:\n", - " ice_tile_distances = np.linalg.norm(ice_tile_locations - unit.pos, ord=1, axis=1)\n", - " closest_ice_tile = ice_tile_locations[np.argmin(ice_tile_distances)]\n", - " if np.all(closest_ice_tile == unit.pos):\n", - " if unit.power >= unit.dig_cost(game_state) + unit.action_queue_cost(game_state):\n", - " actions[unit_id] = [unit.dig(repeat=0, n=1)]\n", - " else:\n", - " direction = direction_to(unit.pos, closest_ice_tile)\n", - " move_cost = unit.move_cost(game_state, direction)\n", - " if move_cost is not None and unit.power >= move_cost + unit.action_queue_cost(game_state):\n", - " actions[unit_id] = [unit.move(direction, repeat=0, n=1)]\n", - " # else if we have enough ice, we go back to the factory and dump it.\n", - " elif unit.cargo.ice >= ice_threshold:\n", - " direction = direction_to(unit.pos, closest_factory_tile)\n", - " if adjacent_to_factory:\n", - " if unit.power >= unit.action_queue_cost(game_state):\n", - " actions[unit_id] = [unit.transfer(direction, 0, unit.cargo.ice, repeat=0, n=1)]\n", - " \n", - " else:\n", - " move_cost = unit.move_cost(game_state, direction)\n", - " if move_cost is not None and unit.power >= move_cost + unit.action_queue_cost(game_state):\n", - " actions[unit_id] = [unit.move(direction, repeat=0, n=1)]\n", - " return actions\n", - "Agent.act = act" - ] - }, - { - "cell_type": "code", - "execution_count": 37, - "metadata": {}, - "outputs": [ + "output_type": "display_data" + }, + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + }, + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + }, + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + }, + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + }, + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + }, + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + }, + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + }, + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + }, + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + }, + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + }, + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + }, { "name": "stderr", "output_type": "stream", @@ -360,7 +281,7 @@ { "data": { "text/html": [ - "