kaggle-environments 0.2.0__py3-none-any.whl → 1.20.0__py3-none-any.whl

kaggle_environments/envs/lux_ai_s3/test_agents/python/agent.py

@@ -0,0 +1,78 @@
+if __package__ == "":
+    from lux.utils import direction_to
+else:
+    from .lux.utils import direction_to
+import numpy as np
+
+
+class Agent:
+    def __init__(self, player: str, env_cfg) -> None:
+        self.player = player
+        self.opp_player = "player_1" if self.player == "player_0" else "player_0"
+        self.team_id = 0 if self.player == "player_0" else 1
+        self.opp_team_id = 1 if self.team_id == 0 else 0
+        np.random.seed(0)
+        self.env_cfg = env_cfg
+
+        self.relic_node_positions = []
+        self.discovered_relic_nodes_ids = set()
+        self.unit_explore_locations = dict()
+
+    def act(self, step: int, obs, remainingOverageTime: int = 60):
+        """implement this function to decide what actions to send to each available unit.
+
+        step is the current timestep number of the game starting from 0 going up to max_steps_in_match * match_count_per_episode - 1.
+        """
+        unit_mask = np.array(obs["units_mask"][self.team_id])  # shape (max_units, )
+        unit_positions = np.array(obs["units"]["position"][self.team_id])  # shape (max_units, 2)
+        unit_energys = np.array(obs["units"]["energy"][self.team_id])  # shape (max_units, 1)
+        observed_relic_node_positions = np.array(obs["relic_nodes"])  # shape (max_relic_nodes, 2)
+        observed_relic_nodes_mask = np.array(obs["relic_nodes_mask"])  # shape (max_relic_nodes, )
+        team_points = np.array(
+            obs["team_points"]
+        )  # points of each team, team_points[self.team_id] is the points of the your team
+
+        # ids of units you can control at this timestep
+        available_unit_ids = np.where(unit_mask)[0]
+        # visible relic nodes
+        visible_relic_node_ids = set(np.where(observed_relic_nodes_mask)[0])
+
+        actions = np.zeros((self.env_cfg["max_units"], 3), dtype=int)
+
+        # basic strategy here is simply to have some units randomly explore and some units collecting as much energy as possible
+        # and once a relic node is found, we send all units to move randomly around the first relic node to gain points
+        # and information about where relic nodes are found are saved for the next match
+
+        # save any new relic nodes that we discover for the rest of the game.
+        for id in visible_relic_node_ids:
+            if id not in self.discovered_relic_nodes_ids:
+                self.discovered_relic_nodes_ids.add(id)
+                self.relic_node_positions.append(observed_relic_node_positions[id])
+
+        # unit ids range from 0 to max_units - 1
+        for unit_id in available_unit_ids:
+            unit_pos = unit_positions[unit_id]
+            unit_energy = unit_energys[unit_id]
+            if len(self.relic_node_positions) > 0:
+                nearest_relic_node_position = self.relic_node_positions[0]
+                manhattan_distance = abs(unit_pos[0] - nearest_relic_node_position[0]) + abs(
+                    unit_pos[1] - nearest_relic_node_position[1]
+                )
+
+                # if close to the relic node we want to hover around it and hope to gain points
+                if manhattan_distance <= 4:
+                    random_direction = np.random.randint(0, 5)
+                    actions[unit_id] = [random_direction, 0, 0]
+                else:
+                    # otherwise we want to move towards the relic node
+                    actions[unit_id] = [direction_to(unit_pos, nearest_relic_node_position), 0, 0]
+            else:
+                # randomly explore by picking a random location on the map and moving there for about 20 steps
+                if step % 20 == 0 or unit_id not in self.unit_explore_locations:
+                    rand_loc = (
+                        np.random.randint(0, self.env_cfg["map_width"]),
+                        np.random.randint(0, self.env_cfg["map_height"]),
+                    )
+                    self.unit_explore_locations[unit_id] = rand_loc
+                actions[unit_id] = [direction_to(unit_pos, self.unit_explore_locations[unit_id]), 0, 0]
+        return actions

kaggle_environments/envs/lux_ai_s3/test_agents/python/lux/kit.py

@@ -0,0 +1,31 @@
+import numpy as np
+
+
+def to_json(obj):
+    if isinstance(obj, np.ndarray):
+        return obj.tolist()
+    elif isinstance(obj, np.integer):
+        return int(obj)
+    elif isinstance(obj, np.floating):
+        return float(obj)
+    elif isinstance(obj, list) or isinstance(obj, tuple):
+        return [to_json(s) for s in obj]
+    elif isinstance(obj, dict):
+        out = {}
+        for k in obj:
+            out[k] = to_json(obj[k])
+        return out
+    else:
+        return obj
+
+
+def from_json(state):
+    if isinstance(state, list):
+        return np.array(state)
+    elif isinstance(state, dict):
+        out = {}
+        for k in state:
+            out[k] = from_json(state[k])
+        return out
+    else:
+        return state

kaggle_environments/envs/lux_ai_s3/test_agents/python/lux/utils.py

@@ -0,0 +1,17 @@
+# direction (0 = center, 1 = up, 2 = right, 3 = down, 4 = left)
+def direction_to(src, target):
+    ds = target - src
+    dx = ds[0]
+    dy = ds[1]
+    if dx == 0 and dy == 0:
+        return 0
+    if abs(dx) > abs(dy):
+        if dx > 0:
+            return 2
+        else:
+            return 4
+    else:
+        if dy > 0:
+            return 3
+        else:
+            return 1

kaggle_environments/envs/lux_ai_s3/test_agents/python/main.py

@@ -0,0 +1,66 @@
+import json
+from argparse import Namespace
+
+if __package__ == "":
+    from agent import Agent
+    from lux.kit import from_json
+else:
+    from .agent import Agent
+    from .lux.kit import from_json
+### DO NOT REMOVE THE FOLLOWING CODE ###
+agent_dict = dict()  # store potentially multiple dictionaries as kaggle imports code directly
+agent_prev_obs = dict()
+
+
+def agent_fn(observation, configurations):
+    """
+    agent definition for kaggle submission.
+    """
+    global agent_dict
+    obs = observation.obs
+    if type(obs) == str:
+        obs = json.loads(obs)
+    step = observation.step
+    player = observation.player
+    remainingOverageTime = observation.remainingOverageTime
+    if step == 0:
+        agent_dict[player] = Agent(player, configurations["env_cfg"])
+    agent = agent_dict[player]
+    actions = agent.act(step, from_json(obs), remainingOverageTime)
+    return dict(action=actions.tolist())
+
+
+if __name__ == "__main__":
+
+    def read_input():
+        """
+        Reads input from stdin
+        """
+        try:
+            return input()
+        except EOFError as eof:
+            raise SystemExit(eof)
+
+    step = 0
+    player_id = 0
+    env_cfg = None
+    i = 0
+    while True:
+        inputs = read_input()
+        raw_input = json.loads(inputs)
+        observation = Namespace(
+            **dict(
+                step=raw_input["step"],
+                obs=raw_input["obs"],
+                remainingOverageTime=raw_input["remainingOverageTime"],
+                player=raw_input["player"],
+                info=raw_input["info"],
+            )
+        )
+        if i == 0:
+            env_cfg = raw_input["info"]["env_cfg"]
+            player_id = raw_input["player"]
+        i += 1
+        actions = agent_fn(observation, dict(env_cfg=env_cfg))
+        # send actions to engine
+        print(json.dumps(actions))

kaggle_environments/envs/lux_ai_s3/test_lux.py

@@ -0,0 +1,9 @@
+from kaggle_environments import make
+
+
+def xtest_lux_completes():
+    env = make("lux_ai_s3", debug=True)
+    env.run(["random_agent", "random_agent"])
+    json = env.toJSON()
+    assert json["name"] == "lux_ai_s3"
+    assert json["statuses"] == ["DONE", "DONE"]

kaggle_environments/envs/mab/agents.py

@@ -0,0 +1,12 @@
+import random
+
+
+def random_agent(observation, configuration):
+    return random.randrange(configuration.banditCount - 1)
+
+
+def round_robin_agent(observation, configuration):
+    return observation.step % configuration.banditCount
+
+
+agents = {"random": random_agent, "round_robin": round_robin_agent}

kaggle_environments/envs/mab/mab.js

@@ -0,0 +1,100 @@
+async function renderer(context) {
+    const {
+        act,
+        agents,
+        environment,
+        frame,
+        height = 400,
+        interactive,
+        isInteractive,
+        parent,
+        step,
+        update,
+        width = 400,
+    } = context;
+
+    // Common Dimensions.
+    const maxWidth = 960;
+    const maxHeight = 280;
+    const canvasSize = Math.min(height, width);
+    const unit = 8;
+    const offset = canvasSize > 400 ? canvasSize * 0.1 : unit / 2;
+    const cellSize = (canvasSize - offset * 2) / 3;
+
+    // Canvas Setup.
+    let canvas = parent.querySelector("canvas");
+    if (!canvas) {
+        canvas = document.createElement("canvas");
+        parent.appendChild(canvas);
+
+        if (interactive) {
+            canvas.addEventListener("click", evt => {
+                if (!isInteractive()) return;
+                const rect = evt.target.getBoundingClientRect();
+                const x = evt.clientX - rect.left - offset;
+                const y = evt.clientY - rect.top - offset;
+                act(Math.floor(x / cellSize) + Math.floor(y / cellSize) * 3);
+            });
+        }
+    }
+
+    canvas.style.cursor = isInteractive() ? "pointer" : "default";
+
+    // Canvas setup and reset.
+    let c = canvas.getContext("2d");
+    canvas.width = Math.min(maxWidth, width);
+    canvas.height = Math.min(maxHeight, height);
+    c.clearRect(0, 0, canvas.width, canvas.height);
+
+    // ------------------------------------------------------------------------------------//
+
+    if (step < environment.steps.length - 1) {
+        const state = environment.steps[step + 1]
+        const last_state = environment.steps[step]
+
+        const p1_move = state[0].observation.lastActions[0];
+        const p2_move = state[0].observation.lastActions[1];
+
+        const info = environment.info;
+        const player1_text = info?.TeamNames?.[0] || "Player 1";
+        const player2_text = info?.TeamNames?.[1] || "Player 2";
+
+        const ctx = canvas.getContext("2d");
+        const padding = 20;
+        const row_width = (Math.min(maxWidth, width) - padding * 2) / 3;
+        const label_x = padding;
+        const player1_x = padding + row_width;
+        const player2_x = padding + 2 * row_width;
+        const label_y = 40;
+        const sign_id_y = 80;
+        const result_y = 120;
+        const score_y = 160;
+
+        ctx.font = "30px sans-serif";
+        ctx.fillStyle = "#FFFFFF";
+
+        // Player Row
+        ctx.fillText(player1_text, player1_x, label_y)
+        ctx.fillText(player2_text, player2_x, label_y)
+
+        // Action Id Row
+        ctx.fillText("Action:", label_x, sign_id_y);
+        ctx.fillText(p1_move, player1_x, sign_id_y);
+        ctx.fillText(p2_move, player2_x, sign_id_y);
+
+        // Result Row
+        ctx.fillText("Result:", label_x, result_y);
+        if (state[0].reward - last_state[0].reward > 0) {
+            ctx.fillText("Win", player1_x, result_y);
+        }
+
+        if (state[1].reward - last_state[1].reward > 0) {
+            ctx.fillText("Win", player2_x, result_y);
+        }
+
+        // Reward Row
+        ctx.fillText("Reward:", label_x, score_y);
+        ctx.fillText(state[0].reward, player1_x, score_y);
+        ctx.fillText(state[1].reward, player2_x, score_y);
+    }
+}

kaggle_environments/envs/mab/mab.json

@@ -0,0 +1,74 @@
+{
+  "name": "mab",
+  "title": "Adversarial Multi-armed Bandit",
+  "description": "Adversarial Multi-armed Bandit",
+  "version": "1.0.0",
+  "agents": [2, 3, 4, 5, 6, 7, 8],
+  "configuration": {
+    "episodeSteps": 2000,
+    "actTimeout": 0.25,
+    "banditCount": {
+      "description": "Number of bandits available to choose from. Max action is this number -1.",
+      "type": "integer",
+      "minimum": 2,
+      "default": 100
+    },
+    "decayRate": {
+      "description": "Rate that reward chance threshold increases per step that a bandit is chosen by an agent.",
+      "type": "number",
+      "minimum": 0,
+      "default": 0.97
+    },
+    "sampleResolution": {
+      "description": "Maximum value that can be returned by a bandit.",
+      "type": "integer",
+      "minimum": 1,
+      "default": 100
+    }
+  },
+  "reward": {
+    "description": "The total reward each player has accumulated from the bandits across all steps.",
+    "type": "number",
+    "minimum": 0,
+    "default": 0
+  },
+  "observation": {
+    "remainingOverageTime": 60,
+    "agentIndex": {
+      "description": "The current agent's index within observation.lastActions.",
+      "type": "integer",
+      "defaults": [0, 1, 2, 3, 4, 5, 6, 7]
+    },
+    "reward": {
+      "description": "Current reward of the agent.",
+      "type": "number",
+      "minimum": 0,
+      "default": 0
+    },
+    "lastActions": {
+      "description": "Bandits chosen by each agent on the last step. None on the first step.",
+      "type": "array",
+      "shared": true,
+      "items": {
+        "type": "number",
+        "minimum": 0
+      },
+      "default": []
+    },
+    "thresholds": {
+      "description": "Probability values for each machine payout on this step. Hidden from agents at runtime.",
+      "type": "array",
+      "shared": true,
+      "hidden": true,
+      "items": {
+        "type": "number",
+        "minimum": 0
+      }
+    }
+  },
+  "action": {
+    "description": "Choice of bandit for the step (min bandit = 0, max bandit = configuration.banditCount - 1)",
+    "type": "integer",
+    "minimum": 0
+  }
+}

kaggle_environments/envs/mab/mab.py

@@ -0,0 +1,146 @@
+import json
+from os import path
+from random import SystemRandom
+from typing import List
+
+import kaggle_environments.helpers
+
+from .agents import agents as all_agents
+
+
+class Observation(kaggle_environments.helpers.Observation):
+    @property
+    def agent_index(self) -> float:
+        """The current agent's index within observation.last_actions."""
+        return self["agentIndex"]
+
+    """This provides bindings for the observation type described at https://github.com/Kaggle/kaggle-environments/blob/master/kaggle_environments/envs/mab/mab.json"""
+
+    @property
+    def last_actions(self) -> List[int]:
+        """Bandit chosen by opponent last step. None on the first step."""
+        return self["lastActions"]
+
+    @last_actions.setter
+    def last_actions(self, value):
+        self["lastActions"] = value
+
+    @property
+    def reward(self) -> float:
+        """Current reward of the agent."""
+        return self["reward"]
+
+    @reward.setter
+    def reward(self, value):
+        self["reward"] = value
+
+    @property
+    def thresholds(self) -> List[float]:
+        """Probability values for each machine payout on this step. This value is None at agent runtime."""
+        return self["thresholds"] if "thresholds" in self else None
+
+    @thresholds.setter
+    def thresholds(self, value):
+        self["thresholds"] = value
+
+
+class Configuration(kaggle_environments.helpers.Configuration):
+    """This provides bindings for the configuration type described at https://github.com/Kaggle/kaggle-environments/blob/master/kaggle_environments/envs/mab/mab.json"""
+
+    @property
+    def bandit_count(self) -> int:
+        """Number of bandits available to choose from. Max action is this number -1."""
+        return self["banditCount"]
+
+    @property
+    def decay_rate(self) -> float:
+        """Rate that reward chance threshold increases per step that a bandit is chosen by an agent."""
+        return self["decayRate"]
+
+    @property
+    def sample_resolution(self) -> int:
+        """Maximum value that can be returned by a bandit."""
+        return self["sampleResolution"]
+
+
+# SystemRandom is used to provide stronger randoms than builtin twister
+random = SystemRandom()
+
+
+def interpreter(agents, env):
+    configuration = Configuration(env.configuration)
+    shared_agent = agents[0]
+    # Assign shared_agent.observation so that changes that we make to the shared observation are propagated back to the agent state.
+    shared_agent.observation = shared_observation = Observation(shared_agent.observation)
+
+    def sample():
+        """Obtain a value between 0 and sampleResolution to check against a bandit threshold."""
+        return random.randint(0, configuration.sample_resolution)
+
+    if env.done:
+        # Initialize thresholds
+        shared_observation.last_actions = None
+        shared_observation.thresholds = [sample() for _ in range(configuration.bandit_count)]
+        return agents
+
+    # Provide actions in the next observation so agents can monitor opponents.
+    shared_observation.last_actions = [agent.action for agent in agents]
+    thresholds = shared_observation.thresholds
+
+    for agent in agents:
+        if (
+            agent.action is not None
+            and isinstance(agent.action, int)
+            and 0 <= agent.action < configuration.bandit_count
+        ):
+            # If the sample is less than the threshold the agent gains reward, otherwise nothing
+            agent.reward += 1 if sample() < thresholds[agent.action] else 0
+            agent.observation.reward = agent.reward
+        else:
+            agent.status = "INVALID"
+            agent.reward = -1
+
+    initial_thresholds = env.steps[0][0].observation.thresholds
+    action_histogram = kaggle_environments.helpers.histogram(shared_observation.last_actions)
+
+    for index, threshold in enumerate(thresholds):
+        # Every time a threshold is selected it is multiplied by (decay_rate) for each agent that selected it.
+        # When a threshold is not selected it is reduced by (decay_rate) ^ 0 (i.e. no recovery).
+        action_count = action_histogram[index] if index in action_histogram else 0
+        update_rate = (configuration.decay_rate) ** action_count
+        thresholds[index] = min(threshold * update_rate, initial_thresholds[index])
+
+    active_agents = [agent for agent in agents if agent.status == "ACTIVE" or agent.status == "INACTIVE"]
+
+    if len(active_agents) <= 1:
+        for agent in active_agents:
+            agent.status = "DONE"
+
+    return agents
+
+
+def renderer(steps, env):
+    rounds_played = len(env.steps)
+    board = ""
+
+    for i in range(1, rounds_played):
+        actions = [agent.action for agent in steps[i]]
+        rewards = [agent.reward for agent in steps[i]]
+        board += f"Round {i} Actions: {actions}, Rewards: {rewards}\n"
+
+    return board
+
+
+dir_path = path.dirname(__file__)
+json_path = path.abspath(path.join(dir_path, "mab.json"))
+with open(json_path) as json_file:
+    specification = json.load(json_file)
+
+
+def html_renderer():
+    js_path = path.abspath(path.join(dir_path, "mab.js"))
+    with open(js_path, encoding="utf-8") as js_file:
+        return js_file.read()
+
+
+agents = all_agents