synth-ai 0.2.6.dev1__py3-none-any.whl → 0.4.3__py3-none-any.whl

synth_ai/environments/examples/sokoban/engine_helpers/vendored/envs/room_utils.py

@@ -1,332 +0,0 @@
-import marshal
-import random
-
-import numpy as np
-
-
-def generate_room(
-    dim=(13, 13), p_change_directions=0.35, num_steps=25, num_boxes=3, tries=4, second_player=False
-):
-    """
-    Generates a Sokoban room, represented by an integer matrix. The elements are encoded as follows:
-    wall = 0
-    empty space = 1
-    box target = 2
-    box not on target = 3
-    box on target = 4
-    player = 5
-
-    :param dim:
-    :param p_change_directions:
-    :param num_steps:
-    :return: Numpy 2d Array
-    """
-    room_state = np.zeros(shape=dim)
-    room_structure = np.zeros(shape=dim)
-
-    # Some times rooms with a score == 0 are the only possibility.
-    # In these case, we try another model.
-    for t in range(tries):
-        room = room_topology_generation(dim, p_change_directions, num_steps)
-        room = place_boxes_and_player(room, num_boxes=num_boxes, second_player=second_player)
-
-        # Room fixed represents all not movable parts of the room
-        room_structure = np.copy(room)
-        room_structure[room_structure == 5] = 1
-
-        # Room structure represents the current state of the room including movable parts
-        room_state = room.copy()
-        room_state[room_state == 2] = 4
-
-        room_state, score, box_mapping = reverse_playing(room_state, room_structure)
-        room_state[room_state == 3] = 4
-
-        if score > 0:
-            break
-
-    if score == 0:
-        raise RuntimeWarning("Generated Model with score == 0")
-
-    return room_structure, room_state, box_mapping
-
-
-def room_topology_generation(dim=(10, 10), p_change_directions=0.35, num_steps=15):
-    """
-    Generate a room topology, which consits of empty floors and walls.
-
-    :param dim:
-    :param p_change_directions:
-    :param num_steps:
-    :return:
-    """
-    dim_x, dim_y = dim
-
-    # The ones in the mask represent all fields which will be set to floors
-    # during the random walk. The centered one will be placed over the current
-    # position of the walk.
-    masks = [
-        [[0, 0, 0], [1, 1, 1], [0, 0, 0]],
-        [[0, 1, 0], [0, 1, 0], [0, 1, 0]],
-        [[0, 0, 0], [1, 1, 0], [0, 1, 0]],
-        [[0, 0, 0], [1, 1, 0], [1, 1, 0]],
-        [[0, 0, 0], [0, 1, 1], [0, 1, 0]],
-    ]
-
-    # Possible directions during the walk
-    directions = [(1, 0), (0, 1), (-1, 0), (0, -1)]
-    direction = random.sample(directions, 1)[0]
-
-    # Starting position of random walk
-    position = np.array([random.randint(1, dim_x - 1), random.randint(1, dim_y - 1)])
-
-    level = np.zeros(dim, dtype=int)
-
-    for s in range(num_steps):
-        # Change direction randomly
-        if random.random() < p_change_directions:
-            direction = random.sample(directions, 1)[0]
-
-        # Update position
-        position = position + direction
-        position[0] = max(min(position[0], dim_x - 2), 1)
-        position[1] = max(min(position[1], dim_y - 2), 1)
-
-        # Apply mask
-        mask = random.sample(masks, 1)[0]
-        mask_start = position - 1
-        level[mask_start[0] : mask_start[0] + 3, mask_start[1] : mask_start[1] + 3] += mask
-
-    level[level > 0] = 1
-    level[:, [0, dim_y - 1]] = 0
-    level[[0, dim_x - 1], :] = 0
-
-    return level
-
-
-def place_boxes_and_player(room, num_boxes, second_player):
-    """
-    Places the player and the boxes into the floors in a room.
-
-    :param room:
-    :param num_boxes:
-    :return:
-    """
-    # Get all available positions
-    possible_positions = np.where(room == 1)
-    num_possible_positions = possible_positions[0].shape[0]
-    num_players = 2 if second_player else 1
-
-    if num_possible_positions <= num_boxes + num_players:
-        raise RuntimeError(
-            "Not enough free spots (#{}) to place {} player and {} boxes.".format(
-                num_possible_positions, num_players, num_boxes
-            )
-        )
-
-    # Place player(s)
-    ind = np.random.randint(num_possible_positions)
-    player_position = possible_positions[0][ind], possible_positions[1][ind]
-    room[player_position] = 5
-
-    if second_player:
-        ind = np.random.randint(num_possible_positions)
-        player_position = possible_positions[0][ind], possible_positions[1][ind]
-        room[player_position] = 5
-
-    # Place boxes
-    for n in range(num_boxes):
-        possible_positions = np.where(room == 1)
-        num_possible_positions = possible_positions[0].shape[0]
-
-        ind = np.random.randint(num_possible_positions)
-        box_position = possible_positions[0][ind], possible_positions[1][ind]
-        room[box_position] = 2
-
-    return room
-
-
-# Global variables used for reverse playing.
-explored_states = set()
-num_boxes = 0
-best_room_score = -1
-best_room = None
-best_box_mapping = None
-
-
-def reverse_playing(room_state, room_structure, search_depth=100):
-    """
-    This function plays Sokoban reverse in a way, such that the player can
-    move and pull boxes.
-    It ensures a solvable level with all boxes not being placed on a box target.
-    :param room_state:
-    :param room_structure:
-    :param search_depth:
-    :return: 2d array
-    """
-    global explored_states, num_boxes, best_room_score, best_room, best_box_mapping
-
-    # Box_Mapping is used to calculate the box displacement for every box
-    box_mapping = {}
-    box_locations = np.where(room_structure == 2)
-    num_boxes = len(box_locations[0])
-    for l in range(num_boxes):
-        box = (box_locations[0][l], box_locations[1][l])
-        box_mapping[box] = box
-
-    # explored_states globally stores the best room state and score found during search
-    explored_states = set()
-    best_room_score = -1
-    best_box_mapping = box_mapping
-    depth_first_search(
-        room_state, room_structure, box_mapping, box_swaps=0, last_pull=(-1, -1), ttl=300
-    )
-
-    return best_room, best_room_score, best_box_mapping
-
-
-def depth_first_search(
-    room_state, room_structure, box_mapping, box_swaps=0, last_pull=(-1, -1), ttl=300
-):
-    """
-    Searches through all possible states of the room.
-    This is a recursive function, which stops if the tll is reduced to 0 or
-    over 1.000.000 states have been explored.
-    :param room_state:
-    :param room_structure:
-    :param box_mapping:
-    :param box_swaps:
-    :param last_pull:
-    :param ttl:
-    :return:
-    """
-    global explored_states, num_boxes, best_room_score, best_room, best_box_mapping
-
-    ttl -= 1
-    if ttl <= 0 or len(explored_states) >= 300000:
-        return
-
-    state_tohash = marshal.dumps(room_state)
-
-    # Only search this state, if it not yet has been explored
-    if not (state_tohash in explored_states):
-        # Add current state and its score to explored states
-        room_score = box_swaps * box_displacement_score(box_mapping)
-        if np.where(room_state == 2)[0].shape[0] != num_boxes:
-            room_score = 0
-
-        if room_score > best_room_score:
-            best_room = room_state
-            best_room_score = room_score
-            best_box_mapping = box_mapping
-
-        explored_states.add(state_tohash)
-
-        for action in ACTION_LOOKUP.keys():
-            # The state and box mapping  need to be copied to ensure
-            # every action start from a similar state.
-            room_state_next = room_state.copy()
-            box_mapping_next = box_mapping.copy()
-
-            room_state_next, box_mapping_next, last_pull_next = reverse_move(
-                room_state_next, room_structure, box_mapping_next, last_pull, action
-            )
-
-            box_swaps_next = box_swaps
-            if last_pull_next != last_pull:
-                box_swaps_next += 1
-
-            depth_first_search(
-                room_state_next, room_structure, box_mapping_next, box_swaps_next, last_pull, ttl
-            )
-
-
-def reverse_move(room_state, room_structure, box_mapping, last_pull, action):
-    """
-    Perform reverse action. Where all actions in the range [0, 3] correspond to
-    push actions and the ones greater 3 are simmple move actions.
-    :param room_state:
-    :param room_structure:
-    :param box_mapping:
-    :param last_pull:
-    :param action:
-    :return:
-    """
-    player_position = np.where(room_state == 5)
-    player_position = np.array([player_position[0][0], player_position[1][0]])
-
-    change = CHANGE_COORDINATES[action % 4]
-    next_position = player_position + change
-
-    # Check if next position is an empty floor or an empty box target
-    if room_state[next_position[0], next_position[1]] in [1, 2]:
-        # Move player, independent of pull or move action.
-        room_state[player_position[0], player_position[1]] = room_structure[
-            player_position[0], player_position[1]
-        ]
-        room_state[next_position[0], next_position[1]] = 5
-
-        # In addition try to pull a box if the action is a pull action
-        if action < 4:
-            possible_box_location = change[0] * -1, change[1] * -1
-            possible_box_location += player_position
-
-            if room_state[possible_box_location[0], possible_box_location[1]] in [3, 4]:
-                # Perform pull of the adjacent box
-                room_state[player_position[0], player_position[1]] = 3
-                room_state[possible_box_location[0], possible_box_location[1]] = room_structure[
-                    possible_box_location[0], possible_box_location[1]
-                ]
-
-                # Update the box mapping
-                for k in box_mapping.keys():
-                    if box_mapping[k] == (possible_box_location[0], possible_box_location[1]):
-                        box_mapping[k] = (player_position[0], player_position[1])
-                        last_pull = k
-
-    return room_state, box_mapping, last_pull
-
-
-def box_displacement_score(box_mapping):
-    """
-    Calculates the sum of all Manhattan distances, between the boxes
-    and their origin box targets.
-    :param box_mapping:
-    :return:
-    """
-    score = 0
-
-    for box_target in box_mapping.keys():
-        box_location = np.array(box_mapping[box_target])
-        box_target = np.array(box_target)
-        dist = np.sum(np.abs(box_location - box_target))
-        score += dist
-
-    return score
-
-
-TYPE_LOOKUP = {
-    0: "wall",
-    1: "empty space",
-    2: "box target",
-    3: "box on target",
-    4: "box not on target",
-    5: "player",
-}
-
-ACTION_LOOKUP = {
-    0: "push up",
-    1: "push down",
-    2: "push left",
-    3: "push right",
-    4: "move up",
-    5: "move down",
-    6: "move left",
-    7: "move right",
-}
-
-# Moves are mapped to coordinate changes as follows
-# 0: Move up
-# 1: Move down
-# 2: Move left
-# 3: Move right
-CHANGE_COORDINATES = {0: (-1, 0), 1: (1, 0), 2: (0, -1), 3: (0, 1)}

synth_ai/environments/examples/sokoban/engine_helpers/vendored/envs/sokoban_env.py

@@ -1,306 +0,0 @@
-import gym
-import numpy as np
-from gym.spaces import Box
-from gym.spaces.discrete import Discrete
-from gym.utils import seeding
-
-from .render_utils import room_to_rgb, room_to_tiny_world_rgb
-from .room_utils import generate_room
-
-
-class SokobanEnv(gym.Env):
-    metadata = {
-        "render.modes": ["human", "rgb_array", "tiny_human", "tiny_rgb_array", "raw"],
-        "render_modes": ["human", "rgb_array", "tiny_human", "tiny_rgb_array", "raw"],
-    }
-
-    def __init__(
-        self, dim_room=(10, 10), max_steps=120, num_boxes=4, num_gen_steps=None, reset=True
-    ):
-        # General Configuration
-        self.dim_room = dim_room
-        if num_gen_steps == None:
-            self.num_gen_steps = int(1.7 * (dim_room[0] + dim_room[1]))
-        else:
-            self.num_gen_steps = num_gen_steps
-
-        self.num_boxes = num_boxes
-        self.boxes_on_target = 0
-
-        # Penalties and Rewards
-        self.penalty_for_step = -0.1
-        self.penalty_box_off_target = -1
-        self.reward_box_on_target = 1
-        self.reward_finished = 10
-        self.reward_last = 0
-
-        # Other Settings
-        self.viewer = None
-        self.max_steps = max_steps
-        self.action_space = Discrete(len(ACTION_LOOKUP))
-        screen_height, screen_width = (dim_room[0] * 16, dim_room[1] * 16)
-        self.observation_space = Box(
-            low=0, high=255, shape=(screen_height, screen_width, 3), dtype=np.uint8
-        )
-
-        if reset:
-            # Initialize Room
-            _ = self.reset()
-
-    def seed(self, seed=None):
-        self.np_random, seed = seeding.np_random(seed)
-        return [seed]
-
-    def step(self, action, observation_mode="rgb_array"):
-        assert action in ACTION_LOOKUP
-        assert observation_mode in ["rgb_array", "tiny_rgb_array", "raw"]
-
-        self.num_env_steps += 1
-
-        self.new_box_position = None
-        self.old_box_position = None
-
-        moved_box = False
-
-        if action == 0:
-            moved_player = False
-
-        # All push actions are in the range of [0, 3]
-        elif action < 5:
-            moved_player, moved_box = self._push(action)
-
-        else:
-            moved_player = self._move(action)
-
-        self._calc_reward()
-
-        done = self._check_if_done()
-
-        # Convert the observation to RGB frame
-        observation = self.render(mode=observation_mode)
-
-        info = {
-            "action.name": ACTION_LOOKUP[action],
-            "action.moved_player": moved_player,
-            "action.moved_box": moved_box,
-        }
-        if done:
-            info["maxsteps_used"] = self._check_if_maxsteps()
-            info["all_boxes_on_target"] = self._check_if_all_boxes_on_target()
-
-        return observation, self.reward_last, done, info
-
-    def _push(self, action):
-        """
-        Perform a push, if a box is adjacent in the right direction.
-        If no box, can be pushed, try to move.
-        :param action:
-        :return: Boolean, indicating a change of the room's state
-        """
-        change = CHANGE_COORDINATES[(action - 1) % 4]
-        new_position = self.player_position + change
-        current_position = self.player_position.copy()
-
-        # No push, if the push would get the box out of the room's grid
-        new_box_position = new_position + change
-        if (
-            new_box_position[0] >= self.room_state.shape[0]
-            or new_box_position[1] >= self.room_state.shape[1]
-        ):
-            return False, False
-
-        can_push_box = self.room_state[new_position[0], new_position[1]] in [3, 4]
-        can_push_box &= self.room_state[new_box_position[0], new_box_position[1]] in [1, 2]
-        if can_push_box:
-            self.new_box_position = tuple(new_box_position)
-            self.old_box_position = tuple(new_position)
-
-            # Move Player
-            self.player_position = new_position
-            self.room_state[(new_position[0], new_position[1])] = 5
-            self.room_state[current_position[0], current_position[1]] = self.room_fixed[
-                current_position[0], current_position[1]
-            ]
-
-            # Move Box
-            box_type = 4
-            if self.room_fixed[new_box_position[0], new_box_position[1]] == 2:
-                box_type = 3
-            self.room_state[new_box_position[0], new_box_position[1]] = box_type
-            return True, True
-
-        # Try to move if no box to push, available
-        else:
-            return self._move(action), False
-
-    def _move(self, action):
-        """
-        Moves the player to the next field, if it is not occupied.
-        :param action:
-        :return: Boolean, indicating a change of the room's state
-        """
-        change = CHANGE_COORDINATES[(action - 1) % 4]
-        new_position = self.player_position + change
-        current_position = self.player_position.copy()
-
-        # Move player if the field in the moving direction is either
-        # an empty field or an empty box target.
-        if self.room_state[new_position[0], new_position[1]] in [1, 2]:
-            self.player_position = new_position
-            self.room_state[(new_position[0], new_position[1])] = 5
-            self.room_state[current_position[0], current_position[1]] = self.room_fixed[
-                current_position[0], current_position[1]
-            ]
-
-            return True
-
-        return False
-
-    def _calc_reward(self):
-        """
-        Calculate Reward Based on
-        :return:
-        """
-        # Every step a small penalty is given, This ensures
-        # that short solutions have a higher reward.
-        self.reward_last = self.penalty_for_step
-
-        # count boxes off or on the target
-        empty_targets = self.room_state == 2
-        player_on_target = (self.room_fixed == 2) & (self.room_state == 5)
-        total_targets = empty_targets | player_on_target
-
-        current_boxes_on_target = self.num_boxes - np.where(total_targets)[0].shape[0]
-
-        # Add the reward if a box is pushed on the target and give a
-        # penalty if a box is pushed off the target.
-        if current_boxes_on_target > self.boxes_on_target:
-            self.reward_last += self.reward_box_on_target
-        elif current_boxes_on_target < self.boxes_on_target:
-            self.reward_last += self.penalty_box_off_target
-
-        game_won = self._check_if_all_boxes_on_target()
-        if game_won:
-            self.reward_last += self.reward_finished
-
-        self.boxes_on_target = current_boxes_on_target
-
-    def _check_if_done(self):
-        # Check if the game is over either through reaching the maximum number
-        # of available steps or by pushing all boxes on the targets.
-        return self._check_if_all_boxes_on_target() or self._check_if_maxsteps()
-
-    def _check_if_all_boxes_on_target(self):
-        empty_targets = self.room_state == 2
-        player_hiding_target = (self.room_fixed == 2) & (self.room_state == 5)
-        are_all_boxes_on_targets = np.where(empty_targets | player_hiding_target)[0].shape[0] == 0
-        return are_all_boxes_on_targets
-
-    def _check_if_maxsteps(self):
-        return self.max_steps == self.num_env_steps
-
-    def reset(
-        self,
-        second_player: bool = False,
-        render_mode: str = "rgb_array",
-        seed=None,
-        *,
-        max_attempts: int = 5,
-    ):
-        if seed is not None:
-            self.seed(seed)
-
-        for attempt in range(max_attempts):
-            try:
-                self.room_fixed, self.room_state, self.box_mapping = generate_room(
-                    dim=self.dim_room,
-                    num_steps=self.num_gen_steps,
-                    num_boxes=self.num_boxes,
-                    second_player=second_player,
-                )
-                break  # success
-            except (RuntimeError, RuntimeWarning) as e:
-                print(f"[SOKOBAN] {e}  – retry {attempt + 1}/{max_attempts}")
-                if attempt == max_attempts - 1:
-                    # fallback: trivial 3×3 room with player only
-                    self.room_fixed = np.pad(np.ones((1, 1), dtype=int), 1, constant_values=0)
-                    self.room_state = self.room_fixed.copy()
-                    self.room_state[1, 1] = 5
-                    self.box_mapping = {}
-
-        self.player_position = np.argwhere(self.room_state == 5)[0]
-        self.num_env_steps = 0
-        self.reward_last = 0
-        self.boxes_on_target = 0
-
-        return self.render(render_mode)
-
-    def render(self, mode="human", close=None, scale=1):
-        assert mode in RENDERING_MODES
-
-        img = self.get_image(mode, scale)
-
-        if "rgb_array" in mode:
-            return img
-
-        elif "human" in mode:
-            from gym.envs.classic_control import rendering
-
-            if self.viewer is None:
-                self.viewer = rendering.SimpleImageViewer()
-            self.viewer.imshow(img)
-            return self.viewer.isopen
-
-        elif "raw" in mode:
-            arr_walls = (self.room_fixed == 0).view(np.int8)
-            arr_goals = (self.room_fixed == 2).view(np.int8)
-            arr_boxes = ((self.room_state == 4) + (self.room_state == 3)).view(np.int8)
-            arr_player = (self.room_state == 5).view(np.int8)
-
-            return arr_walls, arr_goals, arr_boxes, arr_player
-
-        else:
-            super(SokobanEnv, self).render(mode=mode)  # just raise an exception
-
-    def get_image(self, mode, scale=1):
-        if mode.startswith("tiny_"):
-            img = room_to_tiny_world_rgb(self.room_state, self.room_fixed, scale=scale)
-        else:
-            img = room_to_rgb(self.room_state, self.room_fixed)
-
-        return img
-
-    def close(self):
-        if self.viewer is not None:
-            self.viewer.close()
-
-    def set_maxsteps(self, num_steps):
-        self.max_steps = num_steps
-
-    def get_action_lookup(self):
-        return ACTION_LOOKUP
-
-    def get_action_meanings(self):
-        return ACTION_LOOKUP
-
-
-ACTION_LOOKUP = {
-    0: "no operation",
-    1: "push up",
-    2: "push down",
-    3: "push left",
-    4: "push right",
-    5: "move up",
-    6: "move down",
-    7: "move left",
-    8: "move right",
-}
-
-# Moves are mapped to coordinate changes as follows
-# 0: Move up
-# 1: Move down
-# 2: Move left
-# 3: Move right
-CHANGE_COORDINATES = {0: (-1, 0), 1: (1, 0), 2: (0, -1), 3: (0, 1)}
-
-RENDERING_MODES = ["rgb_array", "human", "tiny_rgb_array", "tiny_human", "raw"]

synth_ai/environments/examples/sokoban/engine_helpers/vendored/envs/sokoban_env_fixed_targets.py

@@ -1,67 +0,0 @@
-from gym.spaces import Box
-
-from .render_utils import room_to_rgb_FT, room_to_tiny_world_rgb_FT
-from .sokoban_env import SokobanEnv
-
-
-class FixedTargetsSokobanEnv(SokobanEnv):
-    def __init__(self, dim_room=(10, 10), max_steps=120, num_boxes=3, num_gen_steps=None):
-        super(FixedTargetsSokobanEnv, self).__init__(dim_room, max_steps, num_boxes, num_gen_steps)
-        screen_height, screen_width = (dim_room[0] * 16, dim_room[1] * 16)
-        self.observation_space = Box(low=0, high=255, shape=(screen_height, screen_width, 3))
-        self.boxes_are_on_target = [False] * num_boxes
-
-        _ = self.reset()
-
-    def get_image(self, mode, scale=1):
-        if mode.startswith("tiny_"):
-            img = room_to_tiny_world_rgb_FT(
-                self.room_state, self.box_mapping, self.room_fixed, scale=scale
-            )
-        else:
-            img = room_to_rgb_FT(self.room_state, self.box_mapping, self.room_fixed)
-
-        return img
-
-    def step(self, action, observation_mode="rgb_array"):
-        observation, self.reward_last, done, info = super(FixedTargetsSokobanEnv, self).step(
-            action, observation_mode
-        )
-
-        return observation, self.reward_last, done, info
-
-    def _calc_reward(self):
-        self._update_box_mapping()
-
-        # Every step a small penalty is given, This ensures
-        # that short solutions have a higher reward.
-        self.reward_last = self.penalty_for_step
-
-        for b in range(len(self.boxes_are_on_target)):
-            previous_state = self.boxes_are_on_target[b]
-
-            # Calculate new state
-            box_id = list(self.box_mapping.keys())[b]
-            new_state = self.box_mapping[box_id] == box_id
-
-            if previous_state and not new_state:
-                # Box was pushed of its target
-                self.reward_last += self.penalty_box_off_target
-            elif not previous_state and new_state:
-                # box was pushed on its target
-                self.reward_last += self.reward_box_on_target
-
-            self.boxes_are_on_target[b] = new_state
-
-    def _update_box_mapping(self):
-        if self.new_box_position is not None:
-            box_index = list(self.box_mapping.values()).index(self.old_box_position)
-            box_id = list(self.box_mapping.keys())[box_index]
-            self.box_mapping[box_id] = self.new_box_position
-
-    def _check_if_all_boxes_on_target(self):
-        for key in self.box_mapping.keys():
-            if not key == self.box_mapping[key]:
-                return False
-
-        return True