diff --git a/docs/api/vector.md b/docs/api/vector.md index 345957f7c..408a9b164 100644 --- a/docs/api/vector.md +++ b/docs/api/vector.md @@ -54,7 +54,8 @@ title: Vector ``` ```python ->>> envs = gymnasium.vector.make("CartPole-v1", num_envs=3) +>>> import gymnasium as gym +>>> envs = gym.vector.make("CartPole-v1", num_envs=3) >>> envs.reset() (array([[-0.02240574, -0.03439831, -0.03904812, 0.02810693], [ 0.01586068, 0.01929009, 0.02394426, 0.04016077], @@ -68,10 +69,10 @@ title: Vector ``` ```python ->>> envs = gymnasium.vector.make("CartPole-v1", num_envs=3) +>>> envs = gym.vector.make("CartPole-v1", num_envs=3) >>> envs.reset() >>> actions = np.array([1, 0, 1]) ->>> observations, rewards, dones, infos = envs.step(actions) +>>> observations, rewards, terminated, truncated, infos = envs.step(actions) >>> observations array([[ 0.00122802, 0.16228443, 0.02521779, -0.23700266], @@ -80,7 +81,7 @@ array([[ 0.00122802, 0.16228443, 0.02521779, -0.23700266], dtype=float32) >>> rewards array([1., 1., 1.]) ->>> dones +>>> terminated array([False, False, False]) >>> infos {} diff --git a/docs/api/wrappers.md b/docs/api/wrappers.md index 6dbb8edee..05f4a1f0f 100644 --- a/docs/api/wrappers.md +++ b/docs/api/wrappers.md @@ -12,9 +12,9 @@ also be chained to combine their effects. Most environments that are generated v In order to wrap an environment, you must first initialize a base environment. Then you can pass this environment along with (possibly optional) parameters to the wrapper's constructor: ```python ->>> import gymnasium +>>> import gymnasium as gym >>> from gymnasium.wrappers import RescaleAction ->>> base_env = gymnasium.make("BipedalWalker-v3") +>>> base_env = gym.make("BipedalWalker-v3") >>> base_env.action_space Box([-1. -1. -1. -1.], [1. 1. 1. 1.], (4,), float32) >>> wrapped_env = RescaleAction(base_env, min_action=0, max_action=1) @@ -64,7 +64,7 @@ Let's say you have an environment with action space of type `Box`, but you would only like to use a finite subset of actions. Then, you might want to implement the following wrapper ```python -class DiscreteActions(gymnasium.ActionWrapper): +class DiscreteActions(gym.ActionWrapper): def __init__(self, env, disc_to_cont): super().__init__(env) self.disc_to_cont = disc_to_cont @@ -74,7 +74,7 @@ class DiscreteActions(gymnasium.ActionWrapper): return self.disc_to_cont[act] if __name__ == "__main__": - env = gymnasium.make("LunarLanderContinuous-v2") + env = gym.make("LunarLanderContinuous-v2") wrapped_env = DiscreteActions(env, [np.array([1,0]), np.array([-1,0]), np.array([0,1]), np.array([0,-1])]) print(wrapped_env.action_space) #Discrete(4) @@ -95,7 +95,7 @@ the position of the target relative to the agent, i.e. `observation["target_posi For this, you could implement an observation wrapper like this: ```python -class RelativePosition(gymnasium.ObservationWrapper): +class RelativePosition(gym.ObservationWrapper): def __init__(self, env): super().__init__(env) self.observation_space = Box(shape=(2,), low=-np.inf, high=np.inf) @@ -117,7 +117,7 @@ Let us look at an example: Sometimes (especially when we do not have control ove to a range to gain some numerical stability. To do that, we could, for instance, implement the following wrapper: ```python -class ClipReward(gymnasium.RewardWrapper): +class ClipReward(gym.RewardWrapper): def __init__(self, env, min_reward, max_reward): super().__init__(env) self.min_reward = min_reward @@ -137,7 +137,7 @@ When calling step causes `self.env.step()` to return `done=True`, and the return format of `self.step()` is as follows: ```python -new_obs, terminal_reward, terminal_done, info +new_obs, terminal_reward, terminated, truncated, info ``` `new_obs` is the first observation after calling `self.env.reset()`, @@ -145,7 +145,7 @@ new_obs, terminal_reward, terminal_done, info `terminal_reward` is the reward after calling `self.env.step()`, prior to calling `self.env.reset()` -`terminal_done` is always `True` +`terminated or truncated` is always `True` `info` is a dict containing all the keys from the info dict returned by the call to `self.env.reset()`, with additional keys `terminal_observation` @@ -156,7 +156,7 @@ to `self.env.step()`. If `done` is not true when `self.env.step()` is called, `self.step()` returns ```python -obs, reward, done, info +obs, reward, terminated, truncated, info ``` as normal. @@ -164,12 +164,12 @@ as normal. The AutoResetWrapper is not applied by default when calling `gymnasium.make()`, but can be applied by setting the optional `autoreset` argument to `True`: ```python - env = gymnasium.make("CartPole-v1", autoreset=True) + env = gym.make("CartPole-v1", autoreset=True) ``` The AutoResetWrapper can also be applied using its constructor: ```python - env = gymnasium.make("CartPole-v1") + env = gym.make("CartPole-v1") env = AutoResetWrapper(env) ``` @@ -204,7 +204,7 @@ initialization of the environment. However, *Reacher* does not allow you to do t of the reward are returned in `info`, so let us build a wrapper for Reacher that allows us to weight those terms: ```python -class ReacherRewardWrapper(gymnasium.Wrapper): +class ReacherRewardWrapper(gym.Wrapper): def __init__(self, env, reward_dist_weight, reward_ctrl_weight): super().__init__(env) self.reward_dist_weight = reward_dist_weight @@ -225,25 +225,25 @@ It is *not* sufficient to use a `RewardWrapper` in this case! ## Available Wrappers -| Name | Type | Arguments | Description | -|---------------------------|--------------------------|--------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------|--------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------| -| `AtariPreprocessing` | `gymnasium.Wrapper` | `env: gymnasium.Env`, `noop_max: int = 30`, `frame_skip: int = 4`, `screen_size: int = 84`, `terminal_on_life_loss: bool = False`, `grayscale_obs: bool = True`, `grayscale_newaxis: bool = False`, `scale_obs: bool = False` | Implements the best practices from Machado et al. (2018), "Revisiting the Arcade Learning Environment: Evaluation Protocols and Open Problems for General Agents" but will be deprecated soon. | -| `AutoResetWrapper` | `gymnasium.Wrapper` | `env` | The wrapped environment will automatically reset when the done state is reached. Make sure you read the documentation before using this wrapper!| -| `ClipAction` | `gymnasium.ActionWrapper` | `env` | Clip the continuous action to the valid bound specified by the environment's `action_space` | -| `FilterObservation` | `gymnasium.ObservationWrapper` | `env`, `filter_keys=None` | If you have an environment that returns dictionaries as observations, but you would like to only keep a subset of the entries, you can use this wrapper. `filter_keys` should be an iterable that contains the keys that are kept in the new observation. If it is `None`, all keys will be kept and the wrapper has no effect. | -| `FlattenObservation` | `gymnasium.ObservationWrapper` | `env` | Observation wrapper that flattens the observation | -| `FrameStack` | `gymnasium.ObservationWrapper` | `env`, `num_stack`, `lz4_compress=False` | Observation wrapper that stacks the observations in a rolling manner. For example, if the number of stacks is 4, then the returned observation contains the most recent 4 observations. Observations will be objects of type `LazyFrames`. This object can be cast to a numpy array via `np.asarray(obs)`. You can also access single frames or slices via the usual `__getitem__` syntax. If `lz4_compress` is set to true, the `LazyFrames` object will compress the frames internally (losslessly). The first observation (i.e. the one returned by `reset`) will consist of `num_stack` repitions of the first frame. | -| `GrayScaleObservation` | `gymnasium.ObservationWrapper` | `env`, `keep_dim=False` | Convert the image observation from RGB to gray scale. By default, the resulting observation will be 2-dimensional. If `keep_dim` is set to true, a singleton dimension will be added (i.e. the observations are of shape AxBx1). | -| `NormalizeReward` | `gymnasium.Wrapper` | `env`, `gamma=0.99`, `epsilon=1e-8` | This wrapper will normalize immediate rewards s.t. their exponential moving average has a fixed variance. `epsilon` is a stability parameter and `gamma` is the discount factor that is used in the exponential moving average. The exponential moving average will have variance `(1 - gamma)**2`. The scaling depends on past trajectories and rewards will not be scaled correctly if the wrapper was newly instantiated or the policy was changed recently. | -| `NormalizeObservation` | `gymnasium.Wrapper` | `env`, `epsilon=1e-8` | This wrapper will normalize observations s.t. each coordinate is centered with unit variance. The normalization depends on past trajectories and observations will not be normalized correctly if the wrapper was newly instantiated or the policy was changed recently. `epsilon` is a stability parameter that is used when scaling the observations. | -| `OrderEnforcing` | `gymnasium.Wrapper` | `env` | This will produce an error if `step` is called before an initial `reset` | -| `PixelObservationWrapper` | `gymnasium.ObservationWrapper` | `env`, `pixels_only=True`, `render_kwargs=None`, `pixel_keys=("pixels",)` | Augment observations by pixel values obtained via `render`. You can specify whether the original observations should be discarded entirely or be augmented by setting `pixels_only`. Also, you can provide keyword arguments for `render`. | -| `RecordEpisodeStatistics` | `gymnasium.Wrapper` | `env`, `deque_size=100` | This will keep track of cumulative rewards and episode lengths. At the end of an episode, the statistics of the episode will be added to `info`. Moreover, the rewards and episode lengths are stored in buffers that can be accessed via `wrapped_env.return_queue` and `wrapped_env.length_queue` respectively. The size of these buffers can be set via `deque_size`. | -| `RecordVideo` | `gymnasium.Wrapper` | `env`, `video_folder: str`, `episode_trigger: Callable[[int], bool] = None`, `step_trigger: Callable[[int], bool] = None`, `video_length: int = 0`, `name_prefix: str = "rl-video"` | This wrapper will record videos of rollouts. The results will be saved in the folder specified via `video_folder`. You can specify a prefix for the filenames via `name_prefix`. Usually, you only want to record the environment intermittently, say every hundreth episode. To allow this, you can pass `episode_trigger` or `step_trigger`. At most one of these should be passed. These functions will accept an episode index or step index, respectively. They should return a boolean that indicates whether a recording should be started at this point. If neither `episode_trigger`, nor `step_trigger` is passed, a default `episode_trigger` will be used. By default, the recording will be stopped once a done signal has been emitted by the environment. However, you can also create recordings of fixed length (possibly spanning several episodes) by passing a strictly positive value for `video_length`. | -| `RescaleAction` | `gymnasium.ActionWrapper` | `env`, `min_action`, `max_action` | Rescales the continuous action space of the environment to a range \[`min_action`, `max_action`], where `min_action` and `max_action` are numpy arrays or floats. | -| `ResizeObservation` | `gymnasium.ObservationWrapper` | `env`, `shape` | This wrapper works on environments with image observations (or more generally observations of shape AxBxC) and resizes the observation to the shape given by the tuple `shape`. The argument `shape` may also be an integer. In that case, the observation is scaled to a square of sidelength `shape` | -| `TimeAwareObservation` | `gymnasium.ObservationWrapper` | `env` | Augment the observation with current time step in the trajectory (by appending it to the observation). This can be useful to ensure that things stay Markov. Currently it only works with one-dimensional observation spaces. | -| `TimeLimit` | `gymnasium.Wrapper` | `env`, `max_episode_steps=None` | Probably the most useful wrapper in Gymnasium. This wrapper will emit a done signal if the specified number of steps is exceeded in an episode. In order to be able to distinguish termination and truncation, you need to check `info`. If it does not contain the key `"TimeLimit.truncated"`, the environment did not reach the timelimit. Otherwise, `info["TimeLimit.truncated"]` will be true if the episode was terminated because of the time limit. | -| `TransformObservation` | `gymnasium.ObservationWrapper` | `env`, `f` | This wrapper will apply `f` to observations | -| `TransformReward` | `gymnasium.RewardWrapper` | `env`, `f` | This wrapper will apply `f` to rewards | -| `VectorListInfo` | `gymnasium.Wrapper` | `env` | This wrapper will convert the info of a vectorized environment from the `dict` format to a `list` of dictionaries where the _i-th_ dictionary contains info of the _i-th_ environment. If using other wrappers that perform operation on info like `RecordEpisodeStatistics`, this need to be the outermost wrapper. | +| Name | Type | Arguments | Description | +|---------------------------|--------------------------------|-------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------|--------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------| +| `AtariPreprocessing` | `gymnasium.Wrapper` | `env: gymnasium.Env`, `noop_max: int = 30`, `frame_skip: int = 4`, `screen_size: int = 84`, `terminal_on_life_loss: bool = False`, `grayscale_obs: bool = True`, `grayscale_newaxis: bool = False`, `scale_obs: bool = False` | Implements the best practices from Machado et al. (2018), "Revisiting the Arcade Learning Environment: Evaluation Protocols and Open Problems for General Agents" but will be deprecated soon. | +| `AutoResetWrapper` | `gymnasium.Wrapper` | `env` | The wrapped environment will automatically reset when the done state is reached. Make sure you read the documentation before using this wrapper! | +| `ClipAction` | `gymnasium.ActionWrapper` | `env` | Clip the continuous action to the valid bound specified by the environment's `action_space` | +| `FilterObservation` | `gymnasium.ObservationWrapper` | `env`, `filter_keys=None` | If you have an environment that returns dictionaries as observations, but you would like to only keep a subset of the entries, you can use this wrapper. `filter_keys` should be an iterable that contains the keys that are kept in the new observation. If it is `None`, all keys will be kept and the wrapper has no effect. | +| `FlattenObservation` | `gymnasium.ObservationWrapper` | `env` | Observation wrapper that flattens the observation | +| `FrameStack` | `gymnasium.ObservationWrapper` | `env`, `num_stack`, `lz4_compress=False` | Observation wrapper that stacks the observations in a rolling manner. For example, if the number of stacks is 4, then the returned observation contains the most recent 4 observations. Observations will be objects of type `LazyFrames`. This object can be cast to a numpy array via `np.asarray(obs)`. You can also access single frames or slices via the usual `__getitem__` syntax. If `lz4_compress` is set to true, the `LazyFrames` object will compress the frames internally (losslessly). The first observation (i.e. the one returned by `reset`) will consist of `num_stack` repitions of the first frame. | +| `GrayScaleObservation` | `gymnasium.ObservationWrapper` | `env`, `keep_dim=False` | Convert the image observation from RGB to gray scale. By default, the resulting observation will be 2-dimensional. If `keep_dim` is set to true, a singleton dimension will be added (i.e. the observations are of shape AxBx1). | +| `NormalizeReward` | `gymnasium.Wrapper` | `env`, `gamma=0.99`, `epsilon=1e-8` | This wrapper will normalize immediate rewards s.t. their exponential moving average has a fixed variance. `epsilon` is a stability parameter and `gamma` is the discount factor that is used in the exponential moving average. The exponential moving average will have variance `(1 - gamma)**2`. The scaling depends on past trajectories and rewards will not be scaled correctly if the wrapper was newly instantiated or the policy was changed recently. | +| `NormalizeObservation` | `gymnasium.Wrapper` | `env`, `epsilon=1e-8` | This wrapper will normalize observations s.t. each coordinate is centered with unit variance. The normalization depends on past trajectories and observations will not be normalized correctly if the wrapper was newly instantiated or the policy was changed recently. `epsilon` is a stability parameter that is used when scaling the observations. | +| `OrderEnforcing` | `gymnasium.Wrapper` | `env` | This will produce an error if `step` is called before an initial `reset` | +| `PixelObservationWrapper` | `gymnasium.ObservationWrapper` | `env`, `pixels_only=True`, `render_kwargs=None`, `pixel_keys=("pixels",)` | Augment observations by pixel values obtained via `render`. You can specify whether the original observations should be discarded entirely or be augmented by setting `pixels_only`. Also, you can provide keyword arguments for `render`. | +| `RecordEpisodeStatistics` | `gymnasium.Wrapper` | `env`, `deque_size=100` | This will keep track of cumulative rewards and episode lengths. At the end of an episode, the statistics of the episode will be added to `info`. Moreover, the rewards and episode lengths are stored in buffers that can be accessed via `wrapped_env.return_queue` and `wrapped_env.length_queue` respectively. The size of these buffers can be set via `deque_size`. | +| `RecordVideo` | `gymnasium.Wrapper` | `env`, `video_folder: str`, `episode_trigger: Callable[[int], bool] = None`, `step_trigger: Callable[[int], bool] = None`, `video_length: int = 0`, `name_prefix: str = "rl-video"` | This wrapper will record videos of rollouts. The results will be saved in the folder specified via `video_folder`. You can specify a prefix for the filenames via `name_prefix`. Usually, you only want to record the environment intermittently, say every hundreth episode. To allow this, you can pass `episode_trigger` or `step_trigger`. At most one of these should be passed. These functions will accept an episode index or step index, respectively. They should return a boolean that indicates whether a recording should be started at this point. If neither `episode_trigger`, nor `step_trigger` is passed, a default `episode_trigger` will be used. By default, the recording will be stopped once a done signal has been emitted by the environment. However, you can also create recordings of fixed length (possibly spanning several episodes) by passing a strictly positive value for `video_length`. | +| `RescaleAction` | `gymnasium.ActionWrapper` | `env`, `min_action`, `max_action` | Rescales the continuous action space of the environment to a range \[`min_action`, `max_action`], where `min_action` and `max_action` are numpy arrays or floats. | +| `ResizeObservation` | `gymnasium.ObservationWrapper` | `env`, `shape` | This wrapper works on environments with image observations (or more generally observations of shape AxBxC) and resizes the observation to the shape given by the tuple `shape`. The argument `shape` may also be an integer. In that case, the observation is scaled to a square of sidelength `shape` | +| `TimeAwareObservation` | `gymnasium.ObservationWrapper` | `env` | Augment the observation with current time step in the trajectory (by appending it to the observation). This can be useful to ensure that things stay Markov. Currently it only works with one-dimensional observation spaces. | +| `TimeLimit` | `gymnasium.Wrapper` | `env`, `max_episode_steps=None` | Probably the most useful wrapper in Gymnasium. This wrapper will emit a done signal if the specified number of steps is exceeded in an episode. In order to be able to distinguish termination and truncation, you need to check `info`. If it does not contain the key `"TimeLimit.truncated"`, the environment did not reach the timelimit. Otherwise, `info["TimeLimit.truncated"]` will be true if the episode was terminated because of the time limit. | +| `TransformObservation` | `gymnasium.ObservationWrapper` | `env`, `f` | This wrapper will apply `f` to observations | +| `TransformReward` | `gymnasium.RewardWrapper` | `env`, `f` | This wrapper will apply `f` to rewards | +| `VectorListInfo` | `gymnasium.Wrapper` | `env` | This wrapper will convert the info of a vectorized environment from the `dict` format to a `list` of dictionaries where the _i-th_ dictionary contains info of the _i-th_ environment. If using other wrappers that perform operation on info like `RecordEpisodeStatistics`, this need to be the outermost wrapper. | diff --git a/docs/content/basic_usage.md b/docs/content/basic_usage.md index 2eb5762f0..61f513eb4 100644 --- a/docs/content/basic_usage.md +++ b/docs/content/basic_usage.md @@ -10,8 +10,8 @@ firstpage: Initializing environments is very easy in Gymnasium and can be done via: ```python -import gymnasium -env = gymnasium.make('CartPole-v0') +import gymnasium as gym +env = gym.make('CartPole-v0') ``` ## Interacting with the Environment @@ -46,14 +46,15 @@ Let's see what the agent-environment loop looks like in Gymnasium. This example will run an instance of `LunarLander-v2` environment for 1000 timesteps. Since we pass `render_mode="human"`, you should see a window pop up rendering the environment. ```python -import gymnasium -env = gymnasium.make("LunarLander-v2", render_mode="human") +import gymnasium as gym +env = gym.make("LunarLander-v2", render_mode="human") env.action_space.seed(42) observation, info = env.reset(seed=42) for _ in range(1000): - observation, reward, terminated, truncated, info = env.step(env.action_space.sample()) + action = env.action_space.sample() + observation, reward, terminated, truncated, info = env.step(action) if terminated or truncated: observation, info = env.reset() @@ -201,7 +202,7 @@ For example, if pressing the keys `w` and `space` at the same time is supposed t ``` As a more complete example, let's say we wish to play with `CartPole-v0` using our left and right arrow keys. The code would be as follows: ```python -import gymnasium +import gymnasium as gym import pygame from gymnasium.utils.play import play mapping = {(pygame.K_LEFT,): 0, (pygame.K_RIGHT,): 1} diff --git a/docs/content/environment_creation.md b/docs/content/environment_creation.md index cfd2be172..216052aa4 100644 --- a/docs/content/environment_creation.md +++ b/docs/content/environment_creation.md @@ -69,13 +69,13 @@ may look like ` {"agent": array([1, 0]), "target": array([0, 3])}`. Since we have 4 actions in our environment ("right", "up", "left", "down"), we will use `Discrete(4)` as an action space. Here is the declaration of `GridWorldEnv` and the implementation of `__init__`: ```python -import gymnasium +import gymnasium as gym from gymnasium import spaces import pygame import numpy as np -class GridWorldEnv(gymnasium.Env): +class GridWorldEnv(gym.Env): metadata = {"render_modes": ["human", "rgb_array"], "render_fps": 4} def __init__(self, render_mode=None, size=5): @@ -354,14 +354,14 @@ After you have installed your package locally with `pip install -e gym-examples` ```python import gym_examples -env = gymnasium.make('gym_examples/GridWorld-v0') +env = gym.make('gym_examples/GridWorld-v0') ``` You can also pass keyword arguments of your environment's constructor to `gymnasium.make` to customize the environment. In our case, we could do: ```python -env = gymnasium.make('gym_examples/GridWorld-v0', size=10) +env = gym.make('gym_examples/GridWorld-v0', size=10) ``` Sometimes, you may find it more convenient to skip registration and call the environment's @@ -382,7 +382,7 @@ a wrapper on top of environment instances to flatten observations into a single import gym_examples from gymnasium.wrappers import FlattenObservation -env = gymnasium.make('gym_examples/GridWorld-v0') +env = gym.make('gym_examples/GridWorld-v0') wrapped_env = FlattenObservation(env) print(wrapped_env.reset()) # E.g. [3 0 3 3], {} ``` @@ -396,7 +396,7 @@ a wrapper that does this job. This wrapper is also available in gym-examples: import gym_examples from gym_examples.wrappers import RelativePosition -env = gymnasium.make('gym_examples/GridWorld-v0') +env = gym.make('gym_examples/GridWorld-v0') wrapped_env = RelativePosition(env) print(wrapped_env.reset()) # E.g. [-3 3], {} ``` diff --git a/docs/content/vectorising.md b/docs/content/vectorising.md index 2814fc7d2..cd5d99d10 100644 --- a/docs/content/vectorising.md +++ b/docs/content/vectorising.md @@ -19,10 +19,11 @@ Similar to `gymnasium.make`, you can run a vectorized version of a registered en The following example runs 3 copies of the ``CartPole-v1`` environment in parallel, taking as input a vector of 3 binary actions (one for each copy of the environment), and returning an array of 3 observations stacked along the first dimension, with an array of rewards returned by each copy, and an array of booleans indicating if the episode in each parallel environment has ended. ```python ->>> envs = gymnasium.vector.make("CartPole-v1", num_envs=3) +>>> import gymnasium as gym +>>> envs = gym.vector.make("CartPole-v1", num_envs=3) >>> envs.reset() >>> actions = np.array([1, 0, 1]) ->>> observations, rewards, dones, infos = envs.step(actions) +>>> observations, rewards, terminated, truncated, infos = envs.step(actions) >>> observations array([[ 0.00122802, 0.16228443, 0.02521779, -0.23700266], @@ -31,7 +32,7 @@ array([[ 0.00122802, 0.16228443, 0.02521779, -0.23700266], dtype=float32) >>> rewards array([1., 1., 1.]) ->>> dones +>>> terminated array([False, False, False]) >>> infos {} @@ -48,25 +49,25 @@ The function `gymnasium.vector.make` is meant to be used only in basic cases (e. To create a vectorized environment that runs multiple environment copies, you can wrap your parallel environments inside `gymnasium.vector.SyncVectorEnv` (for sequential execution), or `gymnasium.vector.AsyncVectorEnv` (for parallel execution, with [multiprocessing](https://docs.python.org/3/library/multiprocessing.html)). These vectorized environments take as input a list of callables specifying how the copies are created. ```python ->>> envs = gymnasium.vector.AsyncVectorEnv([ -... lambda: gymnasium.make("CartPole-v1"), -... lambda: gymnasium.make("CartPole-v1"), -... lambda: gymnasium.make("CartPole-v1") +>>> envs = gym.vector.AsyncVectorEnv([ +... lambda: gym.make("CartPole-v1"), +... lambda: gym.make("CartPole-v1"), +... lambda: gym.make("CartPole-v1") ... ]) ``` Alternatively, to create a vectorized environment of multiple copies of the same registered environment, you can use the function `gymnasium.vector.make()`. ```python ->>> envs = gymnasium.vector.make("CartPole-v1", num_envs=3) # Equivalent +>>> envs = gym.vector.make("CartPole-v1", num_envs=3) # Equivalent ``` To enable automatic batching of actions and observations, all of the environment copies must share the same `action_space` and `observation_space`. However, all of the parallel environments are not required to be exact copies of one another. For example, you can run 2 instances of ``Pendulum-v0`` with different values for gravity in a vectorized environment with: ```python ->>> env = gymnasium.vector.AsyncVectorEnv([ -... lambda: gymnasium.make("Pendulum-v0", g=9.81), -... lambda: gymnasium.make("Pendulum-v0", g=1.62) +>>> env = gym.vector.AsyncVectorEnv([ +... lambda: gym.make("Pendulum-v0", g=9.81), +... lambda: gym.make("Pendulum-v0", g=1.62) ... ]) ``` @@ -76,14 +77,14 @@ When using `AsyncVectorEnv` with either the ``spawn`` or ``forkserver`` start me ```python if __name__ == "__main__": - envs = gymnasium.vector.make("CartPole-v1", num_envs=3, context="spawn") + envs = gym.vector.make("CartPole-v1", num_envs=3, context="spawn") ``` ### Working with vectorized environments While standard Gymnasium environments take a single action and return a single observation (with a reward, and boolean indicating termination), vectorized environments take a *batch of actions* as input, and return a *batch of observations*, together with an array of rewards and booleans indicating if the episode ended in each environment copy. ```python ->>> envs = gymnasium.vector.make("CartPole-v1", num_envs=3) +>>> envs = gym.vector.make("CartPole-v1", num_envs=3) >>> envs.reset() (array([[-0.02792548, -0.04423395, 0.00026012, 0.04486719], [-0.04906582, 0.02779809, 0.02881928, -0.04467649], @@ -91,7 +92,7 @@ While standard Gymnasium environments take a single action and return a single o dtype=float32), {}) >>> actions = np.array([1, 0, 1]) ->>> observations, rewards, dones, infos = envs.step(actions) +>>> observations, rewards, terminated, truncated, infos = envs.step(actions) >>> observations array([[ 0.00187507, 0.18986781, -0.03168437, -0.301252 ], @@ -100,7 +101,7 @@ array([[ 0.00187507, 0.18986781, -0.03168437, -0.301252 ], dtype=float32) >>> rewards array([1., 1., 1.]) ->>> dones +>>> terminated array([False, False, False]) >>> infos {} @@ -109,15 +110,15 @@ array([False, False, False]) Vectorized environments are compatible with any environment, regardless of the action and observation spaces (e.g. container spaces like `gymnasium.spaces.Dict`, or any arbitrarily nested spaces). In particular, vectorized environments can automatically batch the observations returned by `VectorEnv.reset` and `VectorEnv.step` for any standard Gymnasium `Space` (e.g. `gymnasium.spaces.Box`, `gymnasium.spaces.Discrete`, `gymnasium.spaces.Dict`, or any nested structure thereof). Similarly, vectorized environments can take batches of actions from any standard Gymnasium `Space`. ```python ->>> class DictEnv(gymnasium.Env): -... observation_space = gymnasium.spaces.Dict({ -... "position": gymnasium.spaces.Box(-1., 1., (3,), np.float32), -... "velocity": gymnasium.spaces.Box(-1., 1., (2,), np.float32) +>>> class DictEnv(gym.Env): +... observation_space = gym.spaces.Dict({ +... "position": gym.spaces.Box(-1., 1., (3,), np.float32), +... "velocity": gym.spaces.Box(-1., 1., (2,), np.float32) ... }) -... action_space = gymnasium.spaces.Dict({ -... "fire": gymnasium.spaces.Discrete(2), -... "jump": gymnasium.spaces.Discrete(2), -... "acceleration": gymnasium.spaces.Box(-1., 1., (2,), np.float32) +... action_space = gym.spaces.Dict({ +... "fire": gym.spaces.Discrete(2), +... "jump": gym.spaces.Discrete(2), +... "acceleration": gym.spaces.Box(-1., 1., (2,), np.float32) ... }) ... ... def reset(self): @@ -125,9 +126,9 @@ Vectorized environments are compatible with any environment, regardless of the a ... ... def step(self, action): ... observation = self.observation_space.sample() -... return (observation, 0., False, {}) +... return observation, 0., False, False, {} ->>> envs = gymnasium.vector.AsyncVectorEnv([lambda: DictEnv()] * 3) +>>> envs = gym.vector.AsyncVectorEnv([lambda: DictEnv()] * 3) >>> envs.observation_space Dict(position:Box(-1.0, 1.0, (3, 3), float32), velocity:Box(-1.0, 1.0, (3, 2), float32)) >>> envs.action_space @@ -139,7 +140,7 @@ Dict(fire:MultiDiscrete([2 2 2]), jump:MultiDiscrete([2 2 2]), acceleration:Box( ... "jump": np.array([0, 1, 0]), ... "acceleration": np.random.uniform(-1., 1., size=(3, 2)) ... } ->>> observations, rewards, dones, infos = envs.step(actions) +>>> observations, rewards, terminated, truncated, infos = envs.step(actions) >>> observations {"position": array([[-0.5337036 , 0.7439302 , 0.41748118], [ 0.9373266 , -0.5780453 , 0.8987405 ], @@ -152,13 +153,13 @@ Dict(fire:MultiDiscrete([2 2 2]), jump:MultiDiscrete([2 2 2]), acceleration:Box( The environment copies inside a vectorized environment automatically call `gymnasium.Env.reset` at the end of an episode. In the following example, the episode of the 3rd copy ends after 2 steps (the agent fell in a hole), and the paralle environment gets reset (observation ``0``). ```python ->>> envs = gymnasium.vector.make("FrozenLake-v1", num_envs=3, is_slippery=False) +>>> envs = gym.vector.make("FrozenLake-v1", num_envs=3, is_slippery=False) >>> envs.reset() (array([0, 0, 0]), {'prob': array([1, 1, 1]), '_prob': array([ True, True, True])}) ->>> observations, rewards, dones, infos = envs.step(np.array([1, 2, 2])) ->>> observations, rewards, dones, infos = envs.step(np.array([1, 2, 1])) +>>> observations, rewards, terminated, truncated, infos = envs.step(np.array([1, 2, 2])) +>>> observations, rewards, terminated, truncated, infos = envs.step(np.array([1, 2, 1])) ->>> dones +>>> terminated array([False, False, True]) >>> observations array([8, 2, 0]) @@ -170,22 +171,23 @@ If the _dtype_ of the returned info is whether `int`, `float`, `bool` or any _dt ```python ->>> envs = gymnasium.vector.make("CartPole-v1", num_envs=3) +>>> envs = gym.vector.make("CartPole-v1", num_envs=3) >>> observations, infos = envs.reset() >>> actions = np.array([1, 0, 1]) ->>> observations, rewards, dones, infos = envs.step(actions) +>>> observations, rewards, terminated, truncated, infos = envs.step(actions) +>>> dones = np.logical_or(terminated, truncated) >>> while not any(dones): -... observations, rewards, dones, infos = envs.step(actions) +... observations, rewards, terminated, truncated, infos = envs.step(actions) >>> print(dones) [False, True, False] >>> print(infos) -{'terminal_observation': array([None, +{'final_observation': array([None, array([-0.11350546, -1.8090094 , 0.23710881, 2.8017728 ], dtype=float32), - None], dtype=object), '_terminal_observation': array([False, True, False])} + None], dtype=object), '_final_observation': array([False, True, False])} ``` @@ -193,7 +195,7 @@ If the _dtype_ of the returned info is whether `int`, `float`, `bool` or any _dt Like any Gymnasium environment, vectorized environments contain the two properties `VectorEnv.observation_space` and `VectorEnv.action_space` to specify the observation and action spaces of the environments. Since vectorized environments operate on multiple environment copies, where the actions taken and observations returned by all of the copies are batched together, the observation and action *spaces* are batched as well so that the input actions are valid elements of `VectorEnv.action_space`, and the observations are valid elements of `VectorEnv.observation_space`. ```python ->>> envs = gymnasium.vector.make("CartPole-v1", num_envs=3) +>>> envs = gym.vector.make("CartPole-v1", num_envs=3) >>> envs.observation_space Box([[-4.8 ...]], [[4.8 ...]], (3, 4), float32) >>> envs.action_space @@ -203,9 +205,9 @@ MultiDiscrete([2 2 2]) In order to appropriately batch the observations and actions in vectorized environments, the observation and action spaces of all of the copies are required to be identical. ```python ->>> envs = gymnasium.vector.AsyncVectorEnv([ -... lambda: gymnasium.make("CartPole-v1"), -... lambda: gymnasium.make("MountainCar-v0") +>>> envs = gym.vector.AsyncVectorEnv([ +... lambda: gym.make("CartPole-v1"), +... lambda: gym.make("MountainCar-v0") ... ]) RuntimeError: Some environments have an observation space different from `Box([-4.8 ...], [4.8 ...], (4,), float32)`. In order to batch observations, the observation spaces from all environments must be equal. @@ -213,7 +215,7 @@ In order to batch observations, the observation spaces from all environments mus However, sometimes it may be handy to have access to the observation and action spaces of a particular copy, and not the batched spaces. You can access those with the properties `VectorEnv.single_observation_space` and `VectorEnv.single_action_space` of the vectorized environment. ```python ->>> envs = gymnasium.vector.make("CartPole-v1", num_envs=3) +>>> envs = gym.vector.make("CartPole-v1", num_envs=3) >>> envs.single_observation_space Box([-4.8 ...], [4.8 ...], (4,), float32) >>> envs.single_action_space @@ -229,14 +231,14 @@ This is convenient, for example, if you instantiate a policy. In the following e ... logits = np.dot(observations, weights) ... return softmax(logits, axis=1) ->>> envs = gymnasium.vector.make("CartPole-v1", num_envs=3) +>>> envs = gym.vector.make("CartPole-v1", num_envs=3) >>> weights = np.random.randn( ... flatdim(envs.single_observation_space), ... envs.single_action_space.n ... ) >>> observations, infos = envs.reset() >>> actions = policy(weights, observations).argmax(axis=1) ->>> observations, rewards, dones, infos = envs.step(actions) +>>> observations, rewards, terminated, truncated, infos = envs.step(actions) ``` ## Intermediate Usage @@ -245,14 +247,14 @@ This is convenient, for example, if you instantiate a policy. In the following e `AsyncVectorEnv` runs each environment copy inside an individual process. At each call to `AsyncVectorEnv.reset` or `AsyncVectorEnv.step`, the observations of all of the parallel environments are sent back to the main process. To avoid expensive transfers of data between processes, especially with large observations (e.g. images), `AsyncVectorEnv` uses a shared memory by default (``shared_memory=True``) that processes can write to and read from at minimal cost. This can increase the throughout of the vectorized environment. ```python ->>> env_fns = [lambda: gymnasium.make("BreakoutNoFrameskip-v4")] * 5 +>>> env_fns = [lambda: gym.make("BreakoutNoFrameskip-v4")] * 5 ->>> envs = gymnasium.vector.AsyncVectorEnv(env_fns, shared_memory=False) +>>> envs = gym.vector.AsyncVectorEnv(env_fns, shared_memory=False) >>> envs.reset() >>> %timeit envs.step(envs.action_space.sample()) 2.23 ms ± 136 µs per loop (mean ± std. dev. of 7 runs, 100 loops each) ->>> envs = gymnasium.vector.AsyncVectorEnv(env_fns, shared_memory=True) +>>> envs = gym.vector.AsyncVectorEnv(env_fns, shared_memory=True) >>> envs.reset() >>> %timeit envs.step(envs.action_space.sample()) 1.36 ms ± 15.4 µs per loop (mean ± std. dev. of 7 runs, 1000 loops each) @@ -262,9 +264,9 @@ This is convenient, for example, if you instantiate a policy. In the following e Because sometimes things may not go as planned, the exceptions raised in any given environment copy are re-raised in the vectorized environment, even when the copy run in parallel with `AsyncVectorEnv`. This way, you can choose how to handle these exceptions yourself (with ``try ... except``). ```python ->>> class ErrorEnv(gymnasium.Env): -... observation_space = gymnasium.spaces.Box(-1., 1., (2,), np.float32) -... action_space = gymnasium.spaces.Discrete(2) +>>> class ErrorEnv(gym.Env): +... observation_space = gym.spaces.Box(-1., 1., (2,), np.float32) +... action_space = gym.spaces.Discrete(2) ... ... def reset(self): ... return np.zeros((2,), dtype=np.float32), {} @@ -273,11 +275,11 @@ Because sometimes things may not go as planned, the exceptions raised in any giv ... if action == 1: ... raise ValueError("An error occurred.") ... observation = self.observation_space.sample() -... return (observation, 0., False, {}) +... return observation, 0., False, False, {} >>> envs = gymnasium.vector.AsyncVectorEnv([lambda: ErrorEnv()] * 3) >>> observations, infos = envs.reset() ->>> observations, rewards, dones, infos = envs.step(np.array([0, 0, 1])) +>>> observations, rewards, terminated, truncated, infos = envs.step(np.array([0, 0, 1])) ERROR: Received the following error from Worker-2: ValueError: An error occurred. ERROR: Shutting down Worker-2. ERROR: Raising the last exception back to the main process. @@ -292,7 +294,7 @@ Vectorized environments will batch actions and observations if they are elements In the following example, we create a new environment `SMILESEnv`, whose observations are strings representing the [SMILES](https://en.wikipedia.org/wiki/Simplified_molecular-input_line-entry_system) notation of a molecular structure, with a custom observation space `SMILES`. The observations returned by the vectorized environment are contained in a tuple of strings. ```python ->>> class SMILES(gymnasium.Space): +>>> class SMILES(gym.Space): ... def __init__(self, symbols): ... super().__init__() ... self.symbols = symbols @@ -300,9 +302,9 @@ In the following example, we create a new environment `SMILESEnv`, whose observa ... def __eq__(self, other): ... return self.symbols == other.symbols ->>> class SMILESEnv(gymnasium.Env): +>>> class SMILESEnv(gym.Env): ... observation_space = SMILES("][()CO=") -... action_space = gymnasium.spaces.Discrete(7) +... action_space = gym.spaces.Discrete(7) ... ... def reset(self): ... self._state = "[" @@ -310,15 +312,15 @@ In the following example, we create a new environment `SMILESEnv`, whose observa ... ... def step(self, action): ... self._state += self.observation_space.symbols[action] -... reward = done = (action == 0) -... return (self._state, float(reward), done, {}) +... reward = terminated = (action == 0) +... return self._state, float(reward), terminated, False, {} ->>> envs = gymnasium.vector.AsyncVectorEnv( +>>> envs = gym.vector.AsyncVectorEnv( ... [lambda: SMILESEnv()] * 3, ... shared_memory=False ... ) >>> envs.reset() ->>> observations, rewards, dones, infos = envs.step(np.array([2, 5, 4])) +>>> observations, rewards, terminated, truncated, infos = envs.step(np.array([2, 5, 4])) >>> observations ('[(', '[O', '[C') ``` diff --git a/docs/environments/atari/adventure.md b/docs/environments/atari/adventure.md index 5e059bc0a..f6caca768 100644 --- a/docs/environments/atari/adventure.md +++ b/docs/environments/atari/adventure.md @@ -12,12 +12,12 @@ firstpage: This environment is part of the Atari environments. Please read that page first for general information. -| | | -|-------------------|--------------------------------| -| Action Space | Discrete(18) | -| Observation Space | (250, 160, 3) | -| Observation High | 255 | -| Observation Low | 0 | +| | | +|-------------------|--------------------------------------| +| Action Space | Discrete(18) | +| Observation Space | (250, 160, 3) | +| Observation High | 255 | +| Observation Low | 0 | | Import | `gymnasium.make("ALE/Adventure-v5")` | ### Description @@ -60,9 +60,9 @@ The various ways to configure the environment are described in detail in the art It is possible to specify various flavors of the environment via the keyword arguments `difficulty` and `mode`. A flavor is a combination of a game mode and a difficulty setting. -| Environment | Valid Modes | Valid Difficulties | Default Mode | -|------------------|-------------------------------------------------|----------------------|----------------| -| Adventure | `[0, 1, 2]` | `[0, ..., 3]` | `0` | +| Environment | Valid Modes | Valid Difficulties | Default Mode | +|-------------|-------------|--------------------|--------------| +| Adventure | `[0, 1, 2]` | `[0, ..., 3]` | `0` | You may use the suffix "-ram" to switch to the RAM observation space. In v0 and v4, the suffixes "Deterministic" and "NoFrameskip" are available. These are no longer supported in v5. In order to obtain equivalent behavior, pass keyword arguments to `gymnasium.make` as outlined in diff --git a/docs/environments/atari/air_raid.md b/docs/environments/atari/air_raid.md index d0331d4ab..32dd78c51 100644 --- a/docs/environments/atari/air_raid.md +++ b/docs/environments/atari/air_raid.md @@ -11,13 +11,13 @@ title: Air Raid This environment is part of the Atari environments. Please read that page first for general information. -| | | -|---|---| -| Action Space | Discrete(18) | -| Observation Space | (250, 160, 3) | -| Observation High | 255 | -| Observation Low | 0 | -| Import | `gymnasium.make("ALE/AirRaid-v5")` | +| | | +|-------------------|------------------------------------| +| Action Space | Discrete(18) | +| Observation Space | (250, 160, 3) | +| Observation High | 255 | +| Observation Low | 0 | +| Import | `gymnasium.make("ALE/AirRaid-v5")` | ### Description You control a ship that can move sideways. You must protect two buildings (one on the right and one on the left side of the screen) from @@ -30,14 +30,14 @@ number of actions (those that are meaningful in this game) are available. The re on the flavor of the environment (the combination of `mode` and `difficulty`). The reduced action space for the default flavor looks like this: -| Num | Action | -|-----|------------------------| -| 0 | NOOP | -| 1 | FIRE | -| 2 | RIGHT | -| 3 | LEFT | +| Num | Action | +|-----|-----------| +| 0 | NOOP | +| 1 | FIRE | +| 2 | RIGHT | +| 3 | LEFT | | 4 | RIGHTFIRE | -| 5 | LEFTFIRE | +| 5 | LEFTFIRE | ### Observations @@ -68,9 +68,9 @@ The various ways to configure the environment are described in detail in the art It is possible to specify various flavors of the environment via the keyword arguments `difficulty` and `mode`. A flavor is a combination of a game mode and a difficulty setting. -| Environment | Valid Modes | Valid Difficulties | Default Mode | -|------------------|-------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------|--------------------|--------------| -| AirRaid | `[1, ..., 8]` | `[0]` | `1` | +| Environment | Valid Modes | Valid Difficulties | Default Mode | +|-------------|---------------|--------------------|--------------| +| AirRaid | `[1, ..., 8]` | `[0]` | `1` | You may use the suffix "-ram" to switch to the RAM observation space. In v0 and v4, the suffixes "Deterministic" and "NoFrameskip" are available. These are no longer supported in v5. In order to obtain equivalent behavior, pass keyword arguments to `gymnasium.make` as outlined in diff --git a/docs/environments/atari/alien.md b/docs/environments/atari/alien.md index 798ce543b..26b8fcc7f 100644 --- a/docs/environments/atari/alien.md +++ b/docs/environments/atari/alien.md @@ -11,13 +11,13 @@ title: Alien This environment is part of the Atari environments. Please read that page first for general information. -| | | -|---|---| -| Action Space | Discrete(18) | -| Observation Space | (210, 160, 3) | -| Observation High | 255 | -| Observation Low | 0 | -| Import | `gymnasium.make("ALE/Alien-v5")` | +| | | +|-------------------|----------------------------------| +| Action Space | Discrete(18) | +| Observation Space | (210, 160, 3) | +| Observation High | 255 | +| Observation Low | 0 | +| Import | `gymnasium.make("ALE/Alien-v5")` | ### Description You are stuck in a maze-like space ship with three aliens. You goal is to destroy their eggs that are scattered @@ -65,9 +65,9 @@ The various ways to configure the environment are described in detail in the art It is possible to specify various flavors of the environment via the keyword arguments `difficulty` and `mode`. A flavor is a combination of a game mode and a difficulty setting. -| Environment | Valid Modes | Valid Difficulties | Default Mode | -|------------------|-------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------|--------------------|--------------| -| Alien | `[0, ..., 3]` | `[0, ..., 3]` | `0` | +| Environment | Valid Modes | Valid Difficulties | Default Mode | +|-------------|---------------|--------------------|--------------| +| Alien | `[0, ..., 3]` | `[0, ..., 3]` | `0` | You may use the suffix "-ram" to switch to the RAM observation space. In v0 and v4, the suffixes "Deterministic" and "NoFrameskip" diff --git a/docs/environments/atari/amidar.md b/docs/environments/atari/amidar.md index 1916d6c5d..150517593 100644 --- a/docs/environments/atari/amidar.md +++ b/docs/environments/atari/amidar.md @@ -11,13 +11,13 @@ title: Amidar This environment is part of the Atari environments. Please read that page first for general information. -| | | -|---|---| -| Action Space | Discrete(18) | -| Observation Space | (210, 160, 3) | -| Observation High | 255 | -| Observation Low | 0 | -| Import | `gymnasium.make("ALE/Amidar-v5")` | +| | | +|-------------------|-----------------------------------| +| Action Space | Discrete(18) | +| Observation Space | (210, 160, 3) | +| Observation High | 255 | +| Observation Low | 0 | +| Import | `gymnasium.make("ALE/Amidar-v5")` | ### Description This game is similar to Pac-Man: You are trying to visit all places on a 2-dimensional grid while simultaneously avoiding @@ -32,18 +32,18 @@ on the flavor of the environment (the combination of `mode` and `difficulty`). T flavor looks like this: -| Num | Action | -|-----|------------------------| -| 0 | NOOP | -| 1 | FIRE | -| 2 | UP | -| 3 | RIGHT | -| 4 | LEFT | -| 5 | DOWN | -| 6 | UPFIRE | +| Num | Action | +|-----|-----------| +| 0 | NOOP | +| 1 | FIRE | +| 2 | UP | +| 3 | RIGHT | +| 4 | LEFT | +| 5 | DOWN | +| 6 | UPFIRE | | 7 | RIGHTFIRE | -| 8 | LEFTFIRE | -| 9 | DOWNFIRE | +| 8 | LEFTFIRE | +| 9 | DOWNFIRE | ### Observations By default, the environment returns the RGB image that is displayed to human players as an observation. However, it is @@ -78,9 +78,9 @@ The various ways to configure the environment are described in detail in the art It is possible to specify various flavors of the environment via the keyword arguments `difficulty` and `mode`. A flavor is a combination of a game mode and a difficulty setting. -| Environment | Valid Modes | Valid Difficulties | Default Mode | -|------------------|-------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------|--------------------|--------------| -| Amidar | `[0]` | `[0, 3]` | `0` | +| Environment | Valid Modes | Valid Difficulties | Default Mode | +|-------------|-------------|--------------------|--------------| +| Amidar | `[0]` | `[0, 3]` | `0` | You may use the suffix "-ram" to switch to the RAM observation space. In v0 and v4, the suffixes "Deterministic" and "NoFrameskip" are available. These are no longer supported in v5. In order to obtain equivalent behavior, pass keyword arguments to `gymnasium.make` as outlined in diff --git a/docs/environments/atari/assault.md b/docs/environments/atari/assault.md index 3b7862fb1..c8263cf3b 100644 --- a/docs/environments/atari/assault.md +++ b/docs/environments/atari/assault.md @@ -10,13 +10,13 @@ title: Assault This environment is part of the Atari environments. Please read that page first for general information. -| | | -|---|---| -| Action Space | Discrete(18) | -| Observation Space | (210, 160, 3) | -| Observation High | 255 | -| Observation Low | 0 | -| Import | `gymnasium.make("ALE/Assault-v5")` | +| | | +|-------------------|------------------------------------| +| Action Space | Discrete(18) | +| Observation Space | (210, 160, 3) | +| Observation High | 255 | +| Observation Low | 0 | +| Import | `gymnasium.make("ALE/Assault-v5")` | ### Description You control a vehicle that can move sideways. A big mother ship circles overhead and continually deploys smaller drones. @@ -29,15 +29,15 @@ number of actions (those that are meaningful in this game) are available. The re on the flavor of the environment (the combination of `mode` and `difficulty`). The reduced action space for the default flavor looks like this: -| Num | Action | -|-----|------------------------| -| 0 | NOOP | -| 1 | FIRE | -| 2 | UP | -| 3 | RIGHT | -| 4 | LEFT | +| Num | Action | +|-----|-----------| +| 0 | NOOP | +| 1 | FIRE | +| 2 | UP | +| 3 | RIGHT | +| 4 | LEFT | | 5 | RIGHTFIRE | -| 6 | LEFTFIRE | +| 6 | LEFTFIRE | ### Observations By default, the environment returns the RGB image that is displayed to human players as an observation. However, it is @@ -65,9 +65,9 @@ env = gymnasium.make("ALE/Assault-v5") The various ways to configure the environment are described in detail in the article on Atari environments. -| Environment | Valid Modes | Valid Difficulties | Default Mode | -|------------------|-------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------|--------------------|--------------| -| Assault | `[0]` | `[0]` | `0` | +| Environment | Valid Modes | Valid Difficulties | Default Mode | +|-------------|-------------|--------------------|--------------| +| Assault | `[0]` | `[0]` | `0` | You may use the suffix "-ram" to switch to the RAM observation space. In v0 and v4, the suffixes "Deterministic" and "NoFrameskip" diff --git a/docs/environments/atari/asterix.md b/docs/environments/atari/asterix.md index 5fcfd08d2..be138b463 100644 --- a/docs/environments/atari/asterix.md +++ b/docs/environments/atari/asterix.md @@ -10,13 +10,13 @@ title: Asterix This environment is part of the Atari environments. Please read that page first for general information. -| | | -|---|---| -| Action Space | Discrete(18) | -| Observation Space | (210, 160, 3) | -| Observation High | 255 | -| Observation Low | 0 | -| Import | `gymnasium.make("ALE/Asterix-v5")` | +| | | +|-------------------|------------------------------------| +| Action Space | Discrete(18) | +| Observation Space | (210, 160, 3) | +| Observation High | 255 | +| Observation Low | 0 | +| Import | `gymnasium.make("ALE/Asterix-v5")` | ### Description You are Asterix and can move horizontally (continuously) and vertically (discretely). Objects @@ -33,17 +33,17 @@ number of actions (those that are meaningful in this game) are available. The re on the flavor of the environment (the combination of `mode` and `difficulty`). The reduced action space for the default flavor looks like this: -| Num | Action | -|-----|------------------------| -| 0 | NOOP | -| 1 | UP | -| 2 | RIGHT | -| 3 | LEFT | -| 4 | DOWN | -| 5 | UPRIGHT | -| 6 | UPLEFT | +| Num | Action | +|-----|-----------| +| 0 | NOOP | +| 1 | UP | +| 2 | RIGHT | +| 3 | LEFT | +| 4 | DOWN | +| 5 | UPRIGHT | +| 6 | UPLEFT | | 7 | DOWNRIGHT | -| 8 | DOWNLEFT | +| 8 | DOWNLEFT | ### Observations By default, the environment returns the RGB image that is displayed to human players as an observation. However, it is @@ -74,9 +74,9 @@ env = gymnasium.make("ALE/Asterix-v5") The various ways to configure the environment are described in detail in the article on Atari environments. -| Environment | Valid Modes | Valid Difficulties | Default Mode | -|------------------|-------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------|--------------------|--------------| -| Asterix | `[0]` | `[0]` | `0` | +| Environment | Valid Modes | Valid Difficulties | Default Mode | +|-------------|-------------|--------------------|--------------| +| Asterix | `[0]` | `[0]` | `0` | You may use the suffix "-ram" to switch to the RAM observation space. In v0 and v4, the suffixes "Deterministic" and "NoFrameskip" diff --git a/docs/environments/atari/asteroids.md b/docs/environments/atari/asteroids.md index 53300094d..0a32736a2 100644 --- a/docs/environments/atari/asteroids.md +++ b/docs/environments/atari/asteroids.md @@ -10,13 +10,13 @@ title: Asteroids This environment is part of the Atari environments. Please read that page first for general information. -| | | -|---|---| -| Action Space | Discrete(18) | -| Observation Space | (210, 160, 3) | -| Observation High | 255 | -| Observation Low | 0 | -| Import | `gymnasium.make("ALE/Asteroids-v5")` | +| | | +|-------------------|--------------------------------------| +| Action Space | Discrete(18) | +| Observation Space | (210, 160, 3) | +| Observation High | 255 | +| Observation Low | 0 | +| Import | `gymnasium.make("ALE/Asteroids-v5")` | ### Description This is a well-known arcade game: You control a spaceship in an asteroid field and must break up asteroids by shooting @@ -43,10 +43,10 @@ flavor looks like this: | 7 | UPLEFT | | 8 | UPFIRE | | 9 | RIGHTFIRE | -| 10 | LEFTFIRE | -| 11 | DOWNFIRE | -| 12 | UPRIGHTFIRE | -| 13 | UPLEFTFIRE | +| 10 | LEFTFIRE | +| 11 | DOWNFIRE | +| 12 | UPRIGHTFIRE | +| 13 | UPLEFTFIRE | @@ -83,9 +83,9 @@ The various ways to configure the environment are described in detail in the art It is possible to specify various flavors of the environment via the keyword arguments `difficulty` and `mode`. A flavor is a combination of a game mode and a difficulty setting. -| Environment | Valid Modes | Valid Difficulties | Default Mode | -|------------------|-------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------|--------------------|--------------| -| Asteroids | `[0, ..., 31, 128]` | `[0, 3]` | `0` | +| Environment | Valid Modes | Valid Difficulties | Default Mode | +|-------------|---------------------|--------------------|--------------| +| Asteroids | `[0, ..., 31, 128]` | `[0, 3]` | `0` | You may use the suffix "-ram" to switch to the RAM observation space. In v0 and v4, the suffixes "Deterministic" and "NoFrameskip" are available. These are no longer supported in v5. In order to obtain equivalent behavior, pass keyword arguments to `gymnasium.make` as outlined in diff --git a/docs/environments/atari/atlantis.md b/docs/environments/atari/atlantis.md index a83336b02..9f821bc5e 100644 --- a/docs/environments/atari/atlantis.md +++ b/docs/environments/atari/atlantis.md @@ -11,13 +11,13 @@ title: Atlantis This environment is part of the Atari environments. Please read that page first for general information. -| | | -|---|---| -| Action Space | Discrete(18) | -| Observation Space | (210, 160, 3) | -| Observation High | 255 | -| Observation Low | 0 | -| Import | `gymnasium.make("ALE/Atlantis-v5")` | +| | | +|-------------------|-------------------------------------| +| Action Space | Discrete(18) | +| Observation Space | (210, 160, 3) | +| Observation High | 255 | +| Observation Low | 0 | +| Import | `gymnasium.make("ALE/Atlantis-v5")` | ### Description Your job is to defend the submerged city of Atlantis. Your enemies slowly descend towards the city and you must @@ -74,9 +74,9 @@ The various ways to configure the environment are described in detail in the art It is possible to specify various flavors of the environment via the keyword arguments `difficulty` and `mode`. A flavor is a combination of a game mode and a difficulty setting. -| Environment | Valid Modes | Valid Difficulties | Default Mode | -|------------------|-------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------|--------------------|--------------| -| Atlantis | `[0, ..., 3]` | `[0]` | `0` | +| Environment | Valid Modes | Valid Difficulties | Default Mode | +|-------------|---------------|--------------------|--------------| +| Atlantis | `[0, ..., 3]` | `[0]` | `0` | You may use the suffix "-ram" to switch to the RAM observation space. In v0 and v4, the suffixes "Deterministic" and "NoFrameskip" are available. These are no longer supported in v5. In order to obtain equivalent behavior, pass keyword arguments to `gymnasium.make` as outlined in diff --git a/docs/environments/atari/bank_heist.md b/docs/environments/atari/bank_heist.md index d83f83ebd..bc998bae4 100644 --- a/docs/environments/atari/bank_heist.md +++ b/docs/environments/atari/bank_heist.md @@ -10,13 +10,13 @@ title: Bank Heist This environment is part of the Atari environments. Please read that page first for general information. -| | | -|---|---| -| Action Space | Discrete(18) | -| Observation Space | (210, 160, 3) | -| Observation High | 255 | -| Observation Low | 0 | -| Import | `gymnasium.make("ALE/BankHeist-v5")` | +| | | +|-------------------|--------------------------------------| +| Action Space | Discrete(18) | +| Observation Space | (210, 160, 3) | +| Observation High | 255 | +| Observation Low | 0 | +| Import | `gymnasium.make("ALE/BankHeist-v5")` | ### Description You are a bank robber and (naturally) want to rob as many banks as possible. You control your getaway car and must @@ -65,9 +65,9 @@ The various ways to configure the environment are described in detail in the art It is possible to specify various flavors of the environment via the keyword arguments `difficulty` and `mode`. A flavor is a combination of a game mode and a difficulty setting. -| Environment | Valid Modes | Valid Difficulties | Default Mode | -|------------------|-------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------|--------------------|--------------| -| BankHeist | `[0, 4, 8, 12, 16, 20, 24, 28]` | `[0, ..., 3]` | `0` | +| Environment | Valid Modes | Valid Difficulties | Default Mode | +|-------------|---------------------------------|--------------------|--------------| +| BankHeist | `[0, 4, 8, 12, 16, 20, 24, 28]` | `[0, ..., 3]` | `0` | You may use the suffix "-ram" to switch to the RAM observation space. In v0 and v4, the suffixes "Deterministic" and "NoFrameskip" are available. These are no longer supported in v5. In order to obtain equivalent behavior, pass keyword arguments to `gymnasium.make` as outlined in diff --git a/docs/environments/atari/battle_zone.md b/docs/environments/atari/battle_zone.md index b4a23f88d..6cc291b5f 100644 --- a/docs/environments/atari/battle_zone.md +++ b/docs/environments/atari/battle_zone.md @@ -11,13 +11,13 @@ title: Battle Zone This environment is part of the Atari environments. Please read that page first for general information. -| | | -|---|---| -| Action Space | Discrete(18) | -| Observation Space | (210, 160, 3) | -| Observation High | 255 | -| Observation Low | 0 | -| Import | `gymnasium.make("ALE/BattleZone-v5")` | +| | | +|-------------------|---------------------------------------| +| Action Space | Discrete(18) | +| Observation Space | (210, 160, 3) | +| Observation High | 255 | +| Observation Low | 0 | +| Import | `gymnasium.make("ALE/BattleZone-v5")` | ### Description You control a tank and must destroy enemy vehicles. This game is played in a first-person perspective and creates @@ -65,9 +65,9 @@ The various ways to configure the environment are described in detail in the art It is possible to specify various flavors of the environment via the keyword arguments `difficulty` and `mode`. A flavor is a combination of a game mode and a difficulty setting. -| Environment | Valid Modes | Valid Difficulties | Default Mode | -|------------------|-------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------|--------------------|--------------| -| BattleZone | `[1, 2, 3]` | `[0]` | `1` | +| Environment | Valid Modes | Valid Difficulties | Default Mode | +|-------------|-------------|--------------------|--------------| +| BattleZone | `[1, 2, 3]` | `[0]` | `1` | You may use the suffix "-ram" to switch to the RAM observation space. In v0 and v4, the suffixes "Deterministic" and "NoFrameskip" are available. These are no longer supported in v5. In order to obtain equivalent behavior, pass keyword arguments to `gymnasium.make` as outlined in diff --git a/docs/environments/atari/beam_rider.md b/docs/environments/atari/beam_rider.md index 10734f65e..aa7a5cf28 100644 --- a/docs/environments/atari/beam_rider.md +++ b/docs/environments/atari/beam_rider.md @@ -17,13 +17,13 @@ grid: This environment is part of the Atari environments. Please read that page first for general information. -| | | -|---|---| -| Action Space | Discrete(18) | -| Observation Space | (210, 160, 3) | -| Observation High | 255 | -| Observation Low | 0 | -| Import | `gymnasium.make("ALE/BeamRider-v5")` | +| | | +|-------------------|--------------------------------------| +| Action Space | Discrete(18) | +| Observation Space | (210, 160, 3) | +| Observation High | 255 | +| Observation Low | 0 | +| Import | `gymnasium.make("ALE/BeamRider-v5")` | ### Description You control a space-ship that travels forward at a constant speed. You can only steer it sideways between discrete @@ -84,9 +84,9 @@ The various ways to configure the environment are described in detail in the art It is possible to specify various flavors of the environment via the keyword arguments `difficulty` and `mode`. A flavor is a combination of a game mode and a difficulty setting. -| Environment | Valid Modes | Valid Difficulties | Default Mode | -|------------------|-------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------|--------------------|--------------| -| BeamRider | `[0]` | `[0, 1]` | `0` | +| Environment | Valid Modes | Valid Difficulties | Default Mode | +|-------------|-------------|--------------------|--------------| +| BeamRider | `[0]` | `[0, 1]` | `0` | You may use the suffix "-ram" to switch to the RAM observation space. In v0 and v4, the suffixes "Deterministic" and "NoFrameskip" are available. These are no longer supported in v5. In order to obtain equivalent behavior, pass keyword arguments to `gymnasium.make` as outlined in diff --git a/docs/environments/atari/berzerk.md b/docs/environments/atari/berzerk.md index 85e28100d..75d4141c9 100644 --- a/docs/environments/atari/berzerk.md +++ b/docs/environments/atari/berzerk.md @@ -10,13 +10,13 @@ title: Berzerk This environment is part of the Atari environments. Please read that page first for general information. -| | | -|---|---| -| Action Space | Discrete(18) | -| Observation Space | (210, 160, 3) | -| Observation High | 255 | -| Observation Low | 0 | -| Import | `gymnasium.make("ALE/Berzerk-v5")` | +| | | +|-------------------|------------------------------------| +| Action Space | Discrete(18) | +| Observation Space | (210, 160, 3) | +| Observation High | 255 | +| Observation Low | 0 | +| Import | `gymnasium.make("ALE/Berzerk-v5")` | ### Description You are stuck in a maze with evil robots. You must destroy them and avoid touching the walls of the maze, as this will kill you. You may be awarded extra lives after scoring a sufficient number of points, depending on the game mode. @@ -62,9 +62,9 @@ The various ways to configure the environment are described in detail in the art It is possible to specify various flavors of the environment via the keyword arguments `difficulty` and `mode`. A flavor is a combination of a game mode and a difficulty setting. -| Environment | Valid Modes | Valid Difficulties | Default Mode | -|------------------|-------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------|--------------------|--------------| -| Berzerk | `[1, ..., 9, 16, 17, 18]` | `[0]` | `1` | +| Environment | Valid Modes | Valid Difficulties | Default Mode | +|-------------|---------------------------|--------------------|--------------| +| Berzerk | `[1, ..., 9, 16, 17, 18]` | `[0]` | `1` | You may use the suffix "-ram" to switch to the RAM observation space. In v0 and v4, the suffixes "Deterministic" and "NoFrameskip" are available. These are no longer supported in v5. In order to obtain equivalent behavior, pass keyword arguments to `gymnasium.make` as outlined in diff --git a/docs/environments/atari/bowling.md b/docs/environments/atari/bowling.md index 07103a9aa..64626dc10 100644 --- a/docs/environments/atari/bowling.md +++ b/docs/environments/atari/bowling.md @@ -10,13 +10,13 @@ title: Bowling This environment is part of the Atari environments. Please read that page first for general information. -| | | -|---|---| -| Action Space | Discrete(18) | -| Observation Space | (210, 160, 3) | -| Observation High | 255 | -| Observation Low | 0 | -| Import | `gymnasium.make("ALE/Bowling-v5")` | +| | | +|-------------------|------------------------------------| +| Action Space | Discrete(18) | +| Observation Space | (210, 160, 3) | +| Observation High | 255 | +| Observation Low | 0 | +| Import | `gymnasium.make("ALE/Bowling-v5")` | ### Description Your goal is to score as many points as possible in the game of Bowling. A game consists of 10 frames and you have two @@ -76,9 +76,9 @@ The various ways to configure the environment are described in detail in the art It is possible to specify various flavors of the environment via the keyword arguments `difficulty` and `mode`. A flavor is a combination of a game mode and a difficulty setting. -| Environment | Valid Modes | Valid Difficulties | Default Mode | -|------------------|-------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------|--------------------|--------------| -| Bowling | `[0, 2, 4]` | `[0, 1]` | `0` | +| Environment | Valid Modes | Valid Difficulties | Default Mode | +|-------------|-------------|--------------------|--------------| +| Bowling | `[0, 2, 4]` | `[0, 1]` | `0` | You may use the suffix "-ram" to switch to the RAM observation space. In v0 and v4, the suffixes "Deterministic" and "NoFrameskip" are available. These are no longer supported in v5. In order to obtain equivalent behavior, pass keyword arguments to `gymnasium.make` as outlined in diff --git a/docs/environments/atari/boxing.md b/docs/environments/atari/boxing.md index 046afca12..a41d705e2 100644 --- a/docs/environments/atari/boxing.md +++ b/docs/environments/atari/boxing.md @@ -10,13 +10,13 @@ title: Boxing This environment is part of the Atari environments. Please read that page first for general information. -| | | -|---|---| -| Action Space | Discrete(18) | -| Observation Space | (210, 160, 3) | -| Observation High | 255 | -| Observation Low | 0 | -| Import | `gymnasium.make("ALE/Boxing-v5")` | +| | | +|-------------------|-----------------------------------| +| Action Space | Discrete(18) | +| Observation Space | (210, 160, 3) | +| Observation High | 255 | +| Observation Low | 0 | +| Import | `gymnasium.make("ALE/Boxing-v5")` | ### Description You fight an opponent in a boxing ring. You score points for hitting the opponent. If you score 100 points, your opponent is @@ -61,9 +61,9 @@ The various ways to configure the environment are described in detail in the art It is possible to specify various flavors of the environment via the keyword arguments `difficulty` and `mode`. A flavor is a combination of a game mode and a difficulty setting. -| Environment | Valid Modes | Valid Difficulties | Default Mode | -|------------------|-------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------|--------------------|--------------| -| Boxing | `[0]` | `[0, ..., 3]` | `0` | +| Environment | Valid Modes | Valid Difficulties | Default Mode | +|-------------|-------------|--------------------|--------------| +| Boxing | `[0]` | `[0, ..., 3]` | `0` | You may use the suffix "-ram" to switch to the RAM observation space. In v0 and v4, the suffixes "Deterministic" and "NoFrameskip" are available. These are no longer supported in v5. In order to obtain equivalent behavior, pass keyword arguments to `gymnasium.make` as outlined in diff --git a/docs/environments/atari/breakout.md b/docs/environments/atari/breakout.md index a66ba2225..d4285a0c2 100644 --- a/docs/environments/atari/breakout.md +++ b/docs/environments/atari/breakout.md @@ -10,13 +10,13 @@ title: Breakout This environment is part of the Atari environments. Please read that page first for general information. -| | | -|---|---| -| Action Space | Discrete(18) | -| Observation Space | (210, 160, 3) | -| Observation High | 255 | -| Observation Low | 0 | -| Import | `gymnasium.make("ALE/Breakout-v5")` | +| | | +|-------------------|-------------------------------------| +| Action Space | Discrete(18) | +| Observation Space | (210, 160, 3) | +| Observation High | 255 | +| Observation Low | 0 | +| Import | `gymnasium.make("ALE/Breakout-v5")` | ### Description Another famous Atari game. The dynamics are similar to pong: You move a paddle and hit the ball in a brick wall at the @@ -31,12 +31,12 @@ number of actions (those that are meaningful in this game) are available. The re on the flavor of the environment (the combination of `mode` and `difficulty`). The reduced action space for the default flavor looks like this: -| Num | Action | -|-----|------------------------| -| 0 | NOOP | -| 1 | FIRE | -| 2 | RIGHT | -| 3 | LEFT | +| Num | Action | +|-----|--------| +| 0 | NOOP | +| 1 | FIRE | +| 2 | RIGHT | +| 3 | LEFT | ### Observations By default, the environment returns the RGB image that is displayed to human players as an observation. However, it is @@ -71,9 +71,9 @@ The various ways to configure the environment are described in detail in the art It is possible to specify various flavors of the environment via the keyword arguments `difficulty` and `mode`. A flavor is a combination of a game mode and a difficulty setting. -| Environment | Valid Modes | Valid Difficulties | Default Mode | -|------------------|-------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------|--------------------|--------------| -| Breakout | `[0, 4, 8, 12, 16, 20, 24, 28, 32, 36, 40, 44]` | `[0, 1]` | `0` | +| Environment | Valid Modes | Valid Difficulties | Default Mode | +|-------------|-------------------------------------------------|--------------------|--------------| +| Breakout | `[0, 4, 8, 12, 16, 20, 24, 28, 32, 36, 40, 44]` | `[0, 1]` | `0` | You may use the suffix "-ram" to switch to the RAM observation space. In v0 and v4, the suffixes "Deterministic" and "NoFrameskip" are available. These are no longer supported in v5. In order to obtain equivalent behavior, pass keyword arguments to `gymnasium.make` as outlined in diff --git a/docs/environments/atari/carnival.md b/docs/environments/atari/carnival.md index 4aed37d9b..1f2f3a059 100644 --- a/docs/environments/atari/carnival.md +++ b/docs/environments/atari/carnival.md @@ -10,13 +10,13 @@ title: Carnival This environment is part of the Atari environments. Please read that page first for general information. -| | | -|---|---| -| Action Space | Discrete(18) | -| Observation Space | (214, 160, 3) | -| Observation High | 255 | -| Observation Low | 0 | -| Import | `gymnasium.make("ALE/Carnival-v5")` | +| | | +|-------------------|-------------------------------------| +| Action Space | Discrete(18) | +| Observation Space | (214, 160, 3) | +| Observation High | 255 | +| Observation Low | 0 | +| Import | `gymnasium.make("ALE/Carnival-v5")` | ### Description This is a "shoot 'em up" game. Targets move horizontally across the screen and you must shoot them. You are @@ -75,9 +75,9 @@ The various ways to configure the environment are described in detail in the art It is possible to specify various flavors of the environment via the keyword arguments `difficulty` and `mode`. A flavor is a combination of a game mode and a difficulty setting. -| Environment | Valid Modes | Valid Difficulties | Default Mode | -|------------------|-------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------|--------------------|--------------| -| Carnival | `[0]` | `[0]` | `0` | +| Environment | Valid Modes | Valid Difficulties | Default Mode | +|-------------|-------------|--------------------|--------------| +| Carnival | `[0]` | `[0]` | `0` | You may use the suffix "-ram" to switch to the RAM observation space. In v0 and v4, the suffixes "Deterministic" and "NoFrameskip" are available. These are no longer supported in v5. In order to obtain equivalent behavior, pass keyword arguments to `gymnasium.make` as outlined in diff --git a/docs/environments/atari/centipede.md b/docs/environments/atari/centipede.md index 0b6af67cc..45e91629d 100644 --- a/docs/environments/atari/centipede.md +++ b/docs/environments/atari/centipede.md @@ -10,13 +10,13 @@ title: Centipede This environment is part of the Atari environments. Please read that page first for general information. -| | | -|---|---| -| Action Space | Discrete(18) | -| Observation Space | (210, 160, 3) | -| Observation High | 255 | -| Observation Low | 0 | -| Import | `gymnasium.make("ALE/Centipede-v5")` | +| | | +|-------------------|--------------------------------------| +| Action Space | Discrete(18) | +| Observation Space | (210, 160, 3) | +| Observation High | 255 | +| Observation Low | 0 | +| Import | `gymnasium.make("ALE/Centipede-v5")` | ### Description You are an elf and must use your magic wands to fend off spiders, fleas and centipedes. Your goal is to protect mushrooms in @@ -66,9 +66,9 @@ The various ways to configure the environment are described in detail in the art It is possible to specify various flavors of the environment via the keyword arguments `difficulty` and `mode`. A flavor is a combination of a game mode and a difficulty setting. -| Environment | Valid Modes | Valid Difficulties | Default Mode | -|------------------|-------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------|--------------------|--------------| -| Centipede | `[22, 86]` | `[0]` | `22` | +| Environment | Valid Modes | Valid Difficulties | Default Mode | +|-------------|-------------|--------------------|--------------| +| Centipede | `[22, 86]` | `[0]` | `22` | You may use the suffix "-ram" to switch to the RAM observation space. In v0 and v4, the suffixes "Deterministic" and "Noframeskip" are available. These are no longer supported in v5. In order to obtain equivalent behavior, pass keyword arguments to `gymnasium.make` as outlined in diff --git a/docs/environments/atari/chopper_command.md b/docs/environments/atari/chopper_command.md index 1ffea7b1c..c0ebd6a11 100644 --- a/docs/environments/atari/chopper_command.md +++ b/docs/environments/atari/chopper_command.md @@ -10,13 +10,13 @@ title: Chopper Command This environment is part of the Atari environments. Please read that page first for general information. -| | | -|---|---| -| Action Space | Discrete(18) | -| Observation Space | (210, 160, 3) | -| Observation High | 255 | -| Observation Low | 0 | -| Import | `gymnasium.make("ALE/ChopperCommand-v5")` | +| | | +|-------------------|-------------------------------------------| +| Action Space | Discrete(18) | +| Observation Space | (210, 160, 3) | +| Observation High | 255 | +| Observation Low | 0 | +| Import | `gymnasium.make("ALE/ChopperCommand-v5")` | ### Description You control a helicopter and must protect truck convoys. To that end, you need to shoot down enemy aircraft. @@ -63,9 +63,9 @@ The various ways to configure the environment are described in detail in the art It is possible to specify various flavors of the environment via the keyword arguments `difficulty` and `mode`. A flavor is a combination of a game mode and a difficulty setting. -| Environment | Valid Modes | Valid Difficulties | Default Mode | -|------------------|-------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------|--------------------|--------------| -| ChopperCommand | `[0, 2]` | `[0, 1]` | `0` | +| Environment | Valid Modes | Valid Difficulties | Default Mode | +|----------------|-------------|--------------------|--------------| +| ChopperCommand | `[0, 2]` | `[0, 1]` | `0` | You may use the suffix "-ram" to switch to the RAM observation space. In v0 and v4, the suffixes "Deterministic" and "Noframeskip" are available. These are no longer supported in v5. In order to obtain equivalent behavior, pass keyword arguments to `gymnasium.make` as outlined in diff --git a/docs/environments/atari/crazy_climber.md b/docs/environments/atari/crazy_climber.md index f4c95ec22..bf66cf509 100644 --- a/docs/environments/atari/crazy_climber.md +++ b/docs/environments/atari/crazy_climber.md @@ -10,13 +10,13 @@ title: Crazy Climber This environment is part of the Atari environments. Please read that page first for general information. -| | | -|---|---| -| Action Space | Discrete(18) | -| Observation Space | (250, 160, 3) | -| Observation High | 255 | -| Observation Low | 0 | -| Import | `gymnasium.make("ALE/CrazyClimber-v5")` | +| | | +|-------------------|-----------------------------------------| +| Action Space | Discrete(18) | +| Observation Space | (250, 160, 3) | +| Observation High | 255 | +| Observation Low | 0 | +| Import | `gymnasium.make("ALE/CrazyClimber-v5")` | ### Description You are a climber trying to reach the top of four builidings, while avoiding obstacles like closing @@ -35,17 +35,17 @@ number of actions (those that are meaningful in this game) are available. The re on the flavor of the environment (the combination of `mode` and `difficulty`). The reduced action space for the default flavor looks like this: -| Num | Action | -|-----|------------------------| -| 0 | NOOP | -| 1 | UP | -| 2 | RIGHT | -| 3 | LEFT | -| 4 | DOWN | -| 5 | UPRIGHT | -| 6 | UPLEFT | +| Num | Action | +|-----|-----------| +| 0 | NOOP | +| 1 | UP | +| 2 | RIGHT | +| 3 | LEFT | +| 4 | DOWN | +| 5 | UPRIGHT | +| 6 | UPLEFT | | 7 | DOWNRIGHT | -| 8 | DOWNLEFT | +| 8 | DOWNLEFT | ### Observations By default, the environment returns the RGB image that is displayed to human players as an observation. However, it is @@ -78,9 +78,9 @@ The various ways to configure the environment are described in detail in the art It is possible to specify various flavors of the environment via the keyword arguments `difficulty` and `mode`. A flavor is a combination of a game mode and a difficulty setting. -| Environment | Valid Modes | Valid Difficulties | Default Mode | -|------------------|-------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------|--------------------|--------------| -| CrazyClimber | `[0, ..., 3]` | `[0, 1]` | `0` | +| Environment | Valid Modes | Valid Difficulties | Default Mode | +|--------------|---------------|--------------------|--------------| +| CrazyClimber | `[0, ..., 3]` | `[0, 1]` | `0` | You may use the suffix "-ram" to switch to the RAM observation space. In v0 and v4, the suffixes "Deterministic" and "Noframeskip" are available. These are no longer supported in v5. In order to obtain equivalent behavior, pass keyword arguments to `gymnasium.make` as outlined in diff --git a/docs/environments/atari/defender.md b/docs/environments/atari/defender.md index 3dd1fb7ee..615f2a463 100644 --- a/docs/environments/atari/defender.md +++ b/docs/environments/atari/defender.md @@ -11,12 +11,12 @@ title: Defender This environment is part of the Atari environments. Please read that page first for general information. -| | | -|-------------------|-------------------------------| -| Action Space | Discrete(18) | -| Observation Space | (210, 160, 3) | -| Observation High | 255 | -| Observation Low | 0 | +| | | +|-------------------|-------------------------------------| +| Action Space | Discrete(18) | +| Observation Space | (210, 160, 3) | +| Observation High | 255 | +| Observation Low | 0 | | Import | `gymnasium.make("ALE/Defender-v5")` | ### Description @@ -66,9 +66,9 @@ The various ways to configure the environment are described in detail in the art It is possible to specify various flavors of the environment via the keyword arguments `difficulty` and `mode`. A flavor is a combination of a game mode and a difficulty setting. -| Environment | Valid Modes | Valid Difficulties | Default Mode | -|------------------|-------------------|--------------------|---------------| -| Defender | `[1, ..., 9, 16]` | `[0, 1]` | `1` | +| Environment | Valid Modes | Valid Difficulties | Default Mode | +|-------------|-------------------|--------------------|--------------| +| Defender | `[1, ..., 9, 16]` | `[0, 1]` | `1` | You may use the suffix "-ram" to switch to the RAM observation space. In v0 and v4, the suffixes "Deterministic" and "NoFrameskip" are available. These are no longer supported in v5. In order to obtain equivalent behavior, pass keyword arguments to `gymnasium.make` as outlined in diff --git a/docs/environments/atari/demon_attack.md b/docs/environments/atari/demon_attack.md index f74e8b940..b1590d367 100644 --- a/docs/environments/atari/demon_attack.md +++ b/docs/environments/atari/demon_attack.md @@ -10,13 +10,13 @@ title: Demon Attack This environment is part of the Atari environments. Please read that page first for general information. -| | | -|---|---| -| Action Space | Discrete(18) | -| Observation Space | (210, 160, 3) | -| Observation High | 255 | -| Observation Low | 0 | -| Import | `gymnasium.make("ALE/DemonAttack-v5")` | +| | | +|-------------------|----------------------------------------| +| Action Space | Discrete(18) | +| Observation Space | (210, 160, 3) | +| Observation High | 255 | +| Observation Low | 0 | +| Import | `gymnasium.make("ALE/DemonAttack-v5")` | ### Description You are facing waves of demons in the ice planet of Krybor. Points are accumulated by destroying @@ -34,17 +34,17 @@ number of actions (those that are meaningful in this game) are available. The re on the flavor of the environment (the combination of `mode` and `difficulty`). The reduced action space for the default flavor looks like this: -| Num | Action | -|-----|------------------------| -| 0 | NOOP | -| 1 | UP | -| 2 | RIGHT | -| 3 | LEFT | -| 4 | DOWN | -| 5 | UPRIGHT | -| 6 | UPLEFT | +| Num | Action | +|-----|-----------| +| 0 | NOOP | +| 1 | UP | +| 2 | RIGHT | +| 3 | LEFT | +| 4 | DOWN | +| 5 | UPRIGHT | +| 6 | UPLEFT | | 7 | DOWNRIGHT | -| 8 | DOWNLEFT | +| 8 | DOWNLEFT | ### Observations By default, the environment returns the RGB image that is displayed to human players as an observation. However, it is @@ -79,9 +79,9 @@ The various ways to configure the environment are described in detail in the art It is possible to specify various flavors of the environment via the keyword arguments `difficulty` and `mode`. A flavor is a combination of a game mode and a difficulty setting. -| Environment | Valid Modes | Valid Difficulties | Default Mode | -|------------------|-------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------|--------------------|--------------| -| DemonAttack | `[1, 3, 5, 7]` | `[0, 1]` | `1` | +| Environment | Valid Modes | Valid Difficulties | Default Mode | +|-------------|----------------|--------------------|--------------| +| DemonAttack | `[1, 3, 5, 7]` | `[0, 1]` | `1` | You may use the suffix "-ram" to switch to the RAM observation space. In v0 and v4, the suffixes "Deterministic" and "Noframeskip" are available. These are no longer supported in v5. In order to obtain equivalent behavior, pass keyword arguments to `gymnasium.make` as outlined in diff --git a/docs/environments/atari/double_dunk.md b/docs/environments/atari/double_dunk.md index bea4a03d4..d6666146b 100644 --- a/docs/environments/atari/double_dunk.md +++ b/docs/environments/atari/double_dunk.md @@ -10,13 +10,13 @@ title: Double Dunk This environment is part of the Atari environments. Please read that page first for general information. -| | | -|---|---| -| Action Space | Discrete(18) | -| Observation Space | (250, 160, 3) | -| Observation High | 255 | -| Observation Low | 0 | -| Import | `gymnasium.make("ALE/DoubleDunk-v5")` | +| | | +|-------------------|---------------------------------------| +| Action Space | Discrete(18) | +| Observation Space | (250, 160, 3) | +| Observation High | 255 | +| Observation Low | 0 | +| Import | `gymnasium.make("ALE/DoubleDunk-v5")` | ### Description You are playing a 2v2 game of basketball. At the start of each possession, you select between a set @@ -32,17 +32,17 @@ number of actions (those that are meaningful in this game) are available. The re on the flavor of the environment (the combination of `mode` and `difficulty`). The reduced action space for the default flavor looks like this: -| Num | Action | -|-----|------------------------| -| 0 | NOOP | -| 1 | UP | -| 2 | RIGHT | -| 3 | LEFT | -| 4 | DOWN | -| 5 | UPRIGHT | -| 6 | UPLEFT | +| Num | Action | +|-----|-----------| +| 0 | NOOP | +| 1 | UP | +| 2 | RIGHT | +| 3 | LEFT | +| 4 | DOWN | +| 5 | UPRIGHT | +| 6 | UPLEFT | | 7 | DOWNRIGHT | -| 8 | DOWNLEFT | +| 8 | DOWNLEFT | ### Observations By default, the environment returns the RGB image that is displayed to human players as an observation. However, it is @@ -77,9 +77,9 @@ The various ways to configure the environment are described in detail in the art It is possible to specify various flavors of the environment via the keyword arguments `difficulty` and `mode`. A flavor is a combination of a game mode and a difficulty setting. -| Environment | Valid Modes | Valid Difficulties | Default Mode | -|------------------|-------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------|--------------------|--------------| -| DoubleDunk | `[0, ..., 15]` | `[0]` | `0` | +| Environment | Valid Modes | Valid Difficulties | Default Mode | +|-------------|----------------|--------------------|--------------| +| DoubleDunk | `[0, ..., 15]` | `[0]` | `0` | You may use the suffix "-ram" to switch to the RAM observation space. In v0 and v4, the suffixes "Deterministic" and "Noframeskip" are available. These are no longer supported in v5. In order to obtain equivalent behavior, pass keyword arguments to `gymnasium.make` as outlined in diff --git a/docs/environments/atari/elevator_action.md b/docs/environments/atari/elevator_action.md index 6d693e12e..d0b99b148 100644 --- a/docs/environments/atari/elevator_action.md +++ b/docs/environments/atari/elevator_action.md @@ -10,13 +10,13 @@ title: Elevator Action This environment is part of the Atari environments. Please read that page first for general information. -| | | -|---|---| -| Action Space | Discrete(18) | -| Observation Space | (250, 160, 3) | -| Observation High | 255 | -| Observation Low | 0 | -| Import | `gymnasium.make("ALE/ElevatorAction-v5")` | +| | | +|-------------------|-------------------------------------------| +| Action Space | Discrete(18) | +| Observation Space | (250, 160, 3) | +| Observation High | 255 | +| Observation Low | 0 | +| Import | `gymnasium.make("ALE/ElevatorAction-v5")` | ### Description You are a secret agent that must retrieve some secret documents and reach the ground level of a @@ -35,17 +35,17 @@ number of actions (those that are meaningful in this game) are available. The re on the flavor of the environment (the combination of `mode` and `difficulty`). The reduced action space for the default flavor looks like this: -| Num | Action | -|-----|------------------------| -| 0 | NOOP | -| 1 | UP | -| 2 | RIGHT | -| 3 | LEFT | -| 4 | DOWN | -| 5 | UPRIGHT | -| 6 | UPLEFT | +| Num | Action | +|-----|-----------| +| 0 | NOOP | +| 1 | UP | +| 2 | RIGHT | +| 3 | LEFT | +| 4 | DOWN | +| 5 | UPRIGHT | +| 6 | UPLEFT | | 7 | DOWNRIGHT | -| 8 | DOWNLEFT | +| 8 | DOWNLEFT | ### Observations By default, the environment returns the RGB image that is displayed to human players as an observation. However, it is @@ -80,9 +80,9 @@ The various ways to configure the environment are described in detail in the art It is possible to specify various flavors of the environment via the keyword arguments `difficulty` and `mode`. A flavor is a combination of a game mode and a difficulty setting. -| Environment | Valid Modes | Valid Difficulties | Default Mode | -|------------------|-------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------|--------------------|--------------| -| ElevatorAction | `[0]` | `[0]` | `0` | +| Environment | Valid Modes | Valid Difficulties | Default Mode | +|----------------|-------------|--------------------|--------------| +| ElevatorAction | `[0]` | `[0]` | `0` | You may use the suffix "-ram" to switch to the RAM observation space. In v0 and v4, the suffixes "Deterministic" and "Noframeskip" are available. These are no longer supported in v5. In order to obtain equivalent behavior, pass keyword arguments to `gymnasium.make` as outlined in diff --git a/docs/environments/atari/enduro.md b/docs/environments/atari/enduro.md index 5faf4a7f8..e8f57b81c 100644 --- a/docs/environments/atari/enduro.md +++ b/docs/environments/atari/enduro.md @@ -10,13 +10,13 @@ title: Enduro This environment is part of the Atari environments. Please read that page first for general information. -| | | -|---|---| -| Action Space | Discrete(18) | -| Observation Space | (250, 160, 3) | -| Observation High | 255 | -| Observation Low | 0 | -| Import | `gymnasium.make("ALE/Enduro-v5")` | +| | | +|-------------------|-----------------------------------| +| Action Space | Discrete(18) | +| Observation Space | (250, 160, 3) | +| Observation High | 255 | +| Observation Low | 0 | +| Import | `gymnasium.make("ALE/Enduro-v5")` | ### Description You are a racer in the National Enduro, a long-distance endurance race. You must overtake a certain @@ -32,17 +32,17 @@ number of actions (those that are meaningful in this game) are available. The re on the flavor of the environment (the combination of `mode` and `difficulty`). The reduced action space for the default flavor looks like this: -| Num | Action | -|-----|------------------------| -| 0 | NOOP | -| 1 | UP | -| 2 | RIGHT | -| 3 | LEFT | -| 4 | DOWN | -| 5 | UPRIGHT | -| 6 | UPLEFT | +| Num | Action | +|-----|-----------| +| 0 | NOOP | +| 1 | UP | +| 2 | RIGHT | +| 3 | LEFT | +| 4 | DOWN | +| 5 | UPRIGHT | +| 6 | UPLEFT | | 7 | DOWNRIGHT | -| 8 | DOWNLEFT | +| 8 | DOWNLEFT | ### Observations By default, the environment returns the RGB image that is displayed to human players as an observation. However, it is @@ -75,9 +75,9 @@ The various ways to configure the environment are described in detail in the art It is possible to specify various flavors of the environment via the keyword arguments `difficulty` and `mode`. A flavor is a combination of a game mode and a difficulty setting. -| Environment | Valid Modes | Valid Difficulties | Default Mode | -|------------------|-------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------|--------------------|--------------| -| Enduro | `[0]` | `[0]` | `0` | +| Environment | Valid Modes | Valid Difficulties | Default Mode | +|-------------|-------------|--------------------|--------------| +| Enduro | `[0]` | `[0]` | `0` | You may use the suffix "-ram" to switch to the RAM observation space. In v0 and v4, the suffixes "Deterministic" and "Noframeskip" are available. These are no longer supported in v5. In order to obtain equivalent behavior, pass keyword arguments to `gymnasium.make` as outlined in diff --git a/docs/environments/atari/fishing_derby.md b/docs/environments/atari/fishing_derby.md index 3ce8aab8c..3e8a31431 100644 --- a/docs/environments/atari/fishing_derby.md +++ b/docs/environments/atari/fishing_derby.md @@ -10,13 +10,13 @@ title: FishingDerby This environment is part of the Atari environments. Please read that page first for general information. -| | | -|---|---| -| Action Space | Discrete(18) | -| Observation Space | (210, 160, 3) | -| Observation High | 255 | -| Observation Low | 0 | -| Import | `gymnasium.make("ALE/FishingDerby-v5")` | +| | | +|-------------------|-----------------------------------------| +| Action Space | Discrete(18) | +| Observation Space | (210, 160, 3) | +| Observation High | 255 | +| Observation Low | 0 | +| Import | `gymnasium.make("ALE/FishingDerby-v5")` | ### Description your objective is to catch more sunfish than your opponent. But it's not just between you and the other fisherman, as a big, black shark is lurking just below the surface, waiting to steal your catch! Detailed documentation can be found on [the AtariAge page](https://atariage.com/manual_html_page.php?SoftwareLabelID=182). @@ -30,26 +30,26 @@ Atari environments are simulated via the Arcade Learning Environment (ALE) [[1]] ### Action Space The action space a subset of the following discrete set of legal actions: -| Num | Action | -|-----|------------------------| -| 0 | NOOP | -| 1 | FIRE | -| 2 | UP | -| 3 | RIGHT | -| 4 | LEFT | -| 5 | DOWN | -| 6 | UPRIGHT | -| 7 | UPLEFT | -| 8 | DOWNRIGHT | -| 9 | DOWNLEFT | -| 10 | UPFIRE | -| 11 | RIGHTFIRE | -| 12 | LEFTFIRE | -| 13 | DOWNFIRE | -| 14 | UPRIGHTFIRE | -| 15 | UPLEFTFIRE | -| 16 | DOWNRIGHTFIRE | -| 17 | DOWNLEFTFIRE | +| Num | Action | +|-----|---------------| +| 0 | NOOP | +| 1 | FIRE | +| 2 | UP | +| 3 | RIGHT | +| 4 | LEFT | +| 5 | DOWN | +| 6 | UPRIGHT | +| 7 | UPLEFT | +| 8 | DOWNRIGHT | +| 9 | DOWNLEFT | +| 10 | UPFIRE | +| 11 | RIGHTFIRE | +| 12 | LEFTFIRE | +| 13 | DOWNFIRE | +| 14 | UPRIGHTFIRE | +| 15 | UPLEFTFIRE | +| 16 | DOWNRIGHTFIRE | +| 17 | DOWNLEFTFIRE | If you use v0 or v4 and the environment is initialized via `make`, the action space will usually be much smaller since most legal actions don't have any effect. Thus, the enumeration of the actions will differ. The action space can be expanded to the full @@ -84,10 +84,10 @@ env = gymnasium.make("ALE/FishingDerby-v5") ``` The various ways to configure the environment are described in detail in the article on Atari environments. -| Environment | Valid Modes | Valid Difficulties | Default Mode | -|------------------|-------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------|--------------------|--------------| -| FishingDerby | `[0]` | `[0, ..., 3]` | `0` | +| Environment | Valid Modes | Valid Difficulties | Default Mode | +|--------------|-------------|--------------------|--------------| +| FishingDerby | `[0]` | `[0, ..., 3]` | `0` | You may use the suffix "-ram" to switch to the RAM observation space. In v0 and v4, the suffixes "Deterministic" and "NoFrameskip" @@ -99,11 +99,11 @@ The versions v0 and v4 are not contained in the "ALE" namespace. I.e. they are i A thorough discussion of the intricate differences between the versions and configurations can be found in the general article on Atari environments. -|Version|`frameskip=`|`repeat_action_probability=`|`full_action_space=`| -| ----- | --------- | ------------------------- | ---------| -|v0 |`(2, 5,)` |`0.25` |`False` | -|v4 |`(2, 5,)` |`0.0` |`False` | -|v5 |`5` |`0.25` |`True` | +| Version | `frameskip=` | `repeat_action_probability=` | `full_action_space=` | +|---------|--------------|------------------------------|----------------------| +| v0 | `(2, 5,)` | `0.25` | `False` | +| v4 | `(2, 5,)` | `0.0` | `False` | +| v5 | `5` | `0.25` | `True` | > Version v5 follows the best practices outlined in [[2]](#2). Thus, it is recommended to transition to v5 and > customize the environment using the arguments above, if necessary. diff --git a/docs/environments/atari/freeway.md b/docs/environments/atari/freeway.md index 7fd31e326..5ec4fe4fc 100644 --- a/docs/environments/atari/freeway.md +++ b/docs/environments/atari/freeway.md @@ -10,13 +10,13 @@ title: Freeway This environment is part of the Atari environments. Please read that page first for general information. -| | | -|---|---| -| Action Space | Discrete(18) | -| Observation Space | (210, 160, 3) | -| Observation High | 255 | -| Observation Low | 0 | -| Import | `gymnasium.make("ALE/Freeway-v5")` | +| | | +|-------------------|------------------------------------| +| Action Space | Discrete(18) | +| Observation Space | (210, 160, 3) | +| Observation High | 255 | +| Observation Low | 0 | +| Import | `gymnasium.make("ALE/Freeway-v5")` | ### Description your objective is to guide your chicken across lane after lane of busy rush hour traffic. You receive a point for every chicken that makes it to the top of the screen after crossing all the lanes of traffic. Detailed documentation can be found on [the AtariAge page](https://atariage.com/manual_thumbs.php?SoftwareLabelID=192). @@ -30,26 +30,26 @@ Atari environments are simulated via the Arcade Learning Environment (ALE) [[1]] ### Action Space The action space a subset of the following discrete set of legal actions: -| Num | Action | -|-----|------------------------| -| 0 | NOOP | -| 1 | FIRE | -| 2 | UP | -| 3 | RIGHT | -| 4 | LEFT | -| 5 | DOWN | -| 6 | UPRIGHT | -| 7 | UPLEFT | -| 8 | DOWNRIGHT | -| 9 | DOWNLEFT | -| 10 | UPFIRE | -| 11 | RIGHTFIRE | -| 12 | LEFTFIRE | -| 13 | DOWNFIRE | -| 14 | UPRIGHTFIRE | -| 15 | UPLEFTFIRE | -| 16 | DOWNRIGHTFIRE | -| 17 | DOWNLEFTFIRE | +| Num | Action | +|-----|---------------| +| 0 | NOOP | +| 1 | FIRE | +| 2 | UP | +| 3 | RIGHT | +| 4 | LEFT | +| 5 | DOWN | +| 6 | UPRIGHT | +| 7 | UPLEFT | +| 8 | DOWNRIGHT | +| 9 | DOWNLEFT | +| 10 | UPFIRE | +| 11 | RIGHTFIRE | +| 12 | LEFTFIRE | +| 13 | DOWNFIRE | +| 14 | UPRIGHTFIRE | +| 15 | UPLEFTFIRE | +| 16 | DOWNRIGHTFIRE | +| 17 | DOWNLEFTFIRE | If you use v0 or v4 and the environment is initialized via `make`, the action space will usually be much smaller since most legal actions don't have any effect. Thus, the enumeration of the actions will differ. The action space can be expanded to the full @@ -84,9 +84,10 @@ env = gymnasium.make("ALE/Freeway-v5") ``` The various ways to configure the environment are described in detail in the article on Atari environments. -| Environment | Valid Modes | Valid Difficulties | Default Mode | -|------------------|-------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------|--------------------|--------------| -| Freeway | `[0, ..., 7]` | `[0, 1]` | `0` | + +| Environment | Valid Modes | Valid Difficulties | Default Mode | +|-------------|---------------|--------------------|--------------| +| Freeway | `[0, ..., 7]` | `[0, 1]` | `0` | diff --git a/docs/environments/atari/frostbite.md b/docs/environments/atari/frostbite.md index 7734fd543..4de74296f 100644 --- a/docs/environments/atari/frostbite.md +++ b/docs/environments/atari/frostbite.md @@ -10,13 +10,13 @@ title: Frostbite This environment is part of the Atari environments. Please read that page first for general information. -| | | -|---|---| -| Action Space | Discrete(18) | -| Observation Space | (210, 160, 3) | -| Observation High | 255 | -| Observation Low | 0 | -| Import | `gymnasium.make("ALE/Frostbite-v5")` | +| | | +|-------------------|--------------------------------------| +| Action Space | Discrete(18) | +| Observation Space | (210, 160, 3) | +| Observation High | 255 | +| Observation Low | 0 | +| Import | `gymnasium.make("ALE/Frostbite-v5")` | ### Description In Frostbite, the player controls "Frostbite Bailey" who hops back and forth across across an Arctic river, changing the color of the ice blocks from white to blue. Each time he does so, a block is added to his igloo. [the AtariAge page](https://atariage.com/manual_html_page.php?SoftwareLabelID=199). @@ -30,26 +30,26 @@ Atari environments are simulated via the Arcade Learning Environment (ALE) [[1]] ### Action Space The action space a subset of the following discrete set of legal actions: -| Num | Action | -|-----|------------------------| -| 0 | NOOP | -| 1 | FIRE | -| 2 | UP | -| 3 | RIGHT | -| 4 | LEFT | -| 5 | DOWN | -| 6 | UPRIGHT | -| 7 | UPLEFT | -| 8 | DOWNRIGHT | -| 9 | DOWNLEFT | -| 10 | UPFIRE | -| 11 | RIGHTFIRE | -| 12 | LEFTFIRE | -| 13 | DOWNFIRE | -| 14 | UPRIGHTFIRE | -| 15 | UPLEFTFIRE | -| 16 | DOWNRIGHTFIRE | -| 17 | DOWNLEFTFIRE | +| Num | Action | +|-----|---------------| +| 0 | NOOP | +| 1 | FIRE | +| 2 | UP | +| 3 | RIGHT | +| 4 | LEFT | +| 5 | DOWN | +| 6 | UPRIGHT | +| 7 | UPLEFT | +| 8 | DOWNRIGHT | +| 9 | DOWNLEFT | +| 10 | UPFIRE | +| 11 | RIGHTFIRE | +| 12 | LEFTFIRE | +| 13 | DOWNFIRE | +| 14 | UPRIGHTFIRE | +| 15 | UPLEFTFIRE | +| 16 | DOWNRIGHTFIRE | +| 17 | DOWNLEFTFIRE | If you use v0 or v4 and the environment is initialized via `make`, the action space will usually be much smaller since most legal actions don't have any effect. Thus, the enumeration of the actions will differ. The action space can be expanded to the full @@ -84,9 +84,10 @@ env = gymnasium.make("ALE/Frostbite-v5") ``` The various ways to configure the environment are described in detail in the article on Atari environments. -| Environment | Valid Modes | Valid Difficulties | Default Mode | -|------------------|-------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------|--------------------|--------------| -| Frostbite | `[0, 2]` | `[0]` | `0` | + +| Environment | Valid Modes | Valid Difficulties | Default Mode | +|-------------|-------------|--------------------|--------------| +| Frostbite | `[0, 2]` | `[0]` | `0` | @@ -99,11 +100,11 @@ The versions v0 and v4 are not contained in the "ALE" namespace. I.e. they are i A thorough discussion of the intricate differences between the versions and configurations can be found in the general article on Atari environments. -|Version|`frameskip=`|`repeat_action_probability=`|`full_action_space=`| -| ----- | --------- | ------------------------- | ---------| -|v0 |`(2, 5,)` |`0.25` |`False` | -|v4 |`(2, 5,)` |`0.0` |`False` | -|v5 |`5` |`0.25` |`True` | +| Version | `frameskip=` | `repeat_action_probability=` | `full_action_space=` | +|---------|--------------|------------------------------|----------------------| +| v0 | `(2, 5,)` | `0.25` | `False` | +| v4 | `(2, 5,)` | `0.0` | `False` | +| v5 | `5` | `0.25` | `True` | > Version v5 follows the best practices outlined in [[2]](#2). Thus, it is recommended to transition to v5 and > customize the environment using the arguments above, if necessary. diff --git a/docs/environments/atari/gopher.md b/docs/environments/atari/gopher.md index a1bf80cd7..ac7017b05 100644 --- a/docs/environments/atari/gopher.md +++ b/docs/environments/atari/gopher.md @@ -10,13 +10,13 @@ title: Gopher This environment is part of the Atari environments. Please read that page first for general information. -| | | -|---|---| -| Action Space | Discrete(18) | -| Observation Space | (210, 160, 3) | -| Observation High | 255 | -| Observation Low | 0 | -| Import | `gymnasium.make("ALE/Gopher-v5")` | +| | | +|-------------------|-----------------------------------| +| Action Space | Discrete(18) | +| Observation Space | (210, 160, 3) | +| Observation High | 255 | +| Observation Low | 0 | +| Import | `gymnasium.make("ALE/Gopher-v5")` | ### Description The player controls a shovel-wielding farmer who protects a crop of three carrots from a gopher. [the AtariAge page](https://atariage.com/manual_html_page.php?SoftwareLabelID=218). @@ -30,26 +30,26 @@ Atari environments are simulated via the Arcade Learning Environment (ALE) [[1]] ### Action Space The action space a subset of the following discrete set of legal actions: -| Num | Action | -|-----|------------------------| -| 0 | NOOP | -| 1 | FIRE | -| 2 | UP | -| 3 | RIGHT | -| 4 | LEFT | -| 5 | DOWN | -| 6 | UPRIGHT | -| 7 | UPLEFT | -| 8 | DOWNRIGHT | -| 9 | DOWNLEFT | -| 10 | UPFIRE | -| 11 | RIGHTFIRE | -| 12 | LEFTFIRE | -| 13 | DOWNFIRE | -| 14 | UPRIGHTFIRE | -| 15 | UPLEFTFIRE | -| 16 | DOWNRIGHTFIRE | -| 17 | DOWNLEFTFIRE | +| Num | Action | +|-----|---------------| +| 0 | NOOP | +| 1 | FIRE | +| 2 | UP | +| 3 | RIGHT | +| 4 | LEFT | +| 5 | DOWN | +| 6 | UPRIGHT | +| 7 | UPLEFT | +| 8 | DOWNRIGHT | +| 9 | DOWNLEFT | +| 10 | UPFIRE | +| 11 | RIGHTFIRE | +| 12 | LEFTFIRE | +| 13 | DOWNFIRE | +| 14 | UPRIGHTFIRE | +| 15 | UPLEFTFIRE | +| 16 | DOWNRIGHTFIRE | +| 17 | DOWNLEFTFIRE | If you use v0 or v4 and the environment is initialized via `make`, the action space will usually be much smaller since most legal actions don't have any effect. Thus, the enumeration of the actions will differ. The action space can be expanded to the full @@ -84,9 +84,10 @@ env = gymnasium.make("ALE/Gopher-v5") ``` The various ways to configure the environment are described in detail in the article on Atari environments. -| Environment | Valid Modes | Valid Difficulties | Default Mode | -|------------------|-------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------|--------------------|--------------| -| Gopher | `[0, 2]` | `[0, 1]` | `0` | + +| Environment | Valid Modes | Valid Difficulties | Default Mode | +|-------------|-------------|--------------------|--------------| +| Gopher | `[0, 2]` | `[0, 1]` | `0` | @@ -99,11 +100,11 @@ The versions v0 and v4 are not contained in the "ALE" namespace. I.e. they are i A thorough discussion of the intricate differences between the versions and configurations can be found in the general article on Atari environments. -|Version|`frameskip=`|`repeat_action_probability=`|`full_action_space=`| -| ----- | --------- | ------------------------- | ---------| -|v0 |`(2, 5,)` |`0.25` |`False` | -|v4 |`(2, 5,)` |`0.0` |`False` | -|v5 |`5` |`0.25` |`True` | +| Version | `frameskip=` | `repeat_action_probability=` | `full_action_space=` | +|---------|--------------|------------------------------|----------------------| +| v0 | `(2, 5,)` | `0.25` | `False` | +| v4 | `(2, 5,)` | `0.0` | `False` | +| v5 | `5` | `0.25` | `True` | > Version v5 follows the best practices outlined in [[2]](#2). Thus, it is recommended to transition to v5 and > customize the environment using the arguments above, if necessary. diff --git a/docs/environments/atari/gravitar.md b/docs/environments/atari/gravitar.md index 8b5039ba5..b00073308 100644 --- a/docs/environments/atari/gravitar.md +++ b/docs/environments/atari/gravitar.md @@ -10,13 +10,13 @@ title: Gravitar This environment is part of the Atari environments. Please read that page first for general information. -| | | -|---|---| -| Action Space | Discrete(18) | -| Observation Space | (210, 160, 3) | -| Observation High | 255 | -| Observation Low | 0 | -| Import | `gymnasium.make("ALE/Gravitar-v5")` | +| | | +|-------------------|-------------------------------------| +| Action Space | Discrete(18) | +| Observation Space | (210, 160, 3) | +| Observation High | 255 | +| Observation Low | 0 | +| Import | `gymnasium.make("ALE/Gravitar-v5")` | ### Description The player controls a small blue spacecraft. The game starts in a fictional solar system with several planets to explore. If the player moves his ship into a planet, he will be taken to a side-view landscape. Player has to destroy red bunkers [the AtariAge page](https://atariage.com/manual_html_page.php?SoftwareLabelID=223). @@ -30,26 +30,26 @@ Atari environments are simulated via the Arcade Learning Environment (ALE) [[1]] ### Action Space The action space a subset of the following discrete set of legal actions: -| Num | Action | -|-----|------------------------| -| 0 | NOOP | -| 1 | FIRE | -| 2 | UP | -| 3 | RIGHT | -| 4 | LEFT | -| 5 | DOWN | -| 6 | UPRIGHT | -| 7 | UPLEFT | -| 8 | DOWNRIGHT | -| 9 | DOWNLEFT | -| 10 | UPFIRE | -| 11 | RIGHTFIRE | -| 12 | LEFTFIRE | -| 13 | DOWNFIRE | -| 14 | UPRIGHTFIRE | -| 15 | UPLEFTFIRE | -| 16 | DOWNRIGHTFIRE | -| 17 | DOWNLEFTFIRE | +| Num | Action | +|-----|---------------| +| 0 | NOOP | +| 1 | FIRE | +| 2 | UP | +| 3 | RIGHT | +| 4 | LEFT | +| 5 | DOWN | +| 6 | UPRIGHT | +| 7 | UPLEFT | +| 8 | DOWNRIGHT | +| 9 | DOWNLEFT | +| 10 | UPFIRE | +| 11 | RIGHTFIRE | +| 12 | LEFTFIRE | +| 13 | DOWNFIRE | +| 14 | UPRIGHTFIRE | +| 15 | UPLEFTFIRE | +| 16 | DOWNRIGHTFIRE | +| 17 | DOWNLEFTFIRE | If you use v0 or v4 and the environment is initialized via `make`, the action space will usually be much smaller since most legal actions don't have any effect. Thus, the enumeration of the actions will differ. The action space can be expanded to the full @@ -84,9 +84,10 @@ env = gymnasium.make("ALE/Gravitar-v5") ``` The various ways to configure the environment are described in detail in the article on Atari environments. -| Environment | Valid Modes | Valid Difficulties | Default Mode | -|------------------|-------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------|--------------------|--------------| -| Gravitar | `[0, ..., 4]` | `[0]` | `0` | + +| Environment | Valid Modes | Valid Difficulties | Default Mode | +|-------------|---------------|--------------------|--------------| +| Gravitar | `[0, ..., 4]` | `[0]` | `0` | @@ -99,11 +100,11 @@ The versions v0 and v4 are not contained in the "ALE" namespace. I.e. they are i A thorough discussion of the intricate differences between the versions and configurations can be found in the general article on Atari environments. -|Version|`frameskip=`|`repeat_action_probability=`|`full_action_space=`| -| ----- | --------- | ------------------------- | ---------| -|v0 |`(2, 5,)` |`0.25` |`False` | -|v4 |`(2, 5,)` |`0.0` |`False` | -|v5 |`5` |`0.25` |`True` | +| Version | `frameskip=` | `repeat_action_probability=` | `full_action_space=` | +|---------|--------------|------------------------------|----------------------| +| v0 | `(2, 5,)` | `0.25` | `False` | +| v4 | `(2, 5,)` | `0.0` | `False` | +| v5 | `5` | `0.25` | `True` | > Version v5 follows the best practices outlined in [[2]](#2). Thus, it is recommended to transition to v5 and > customize the environment using the arguments above, if necessary. diff --git a/docs/environments/atari/hero.md b/docs/environments/atari/hero.md index c0832bcbc..f58878ff5 100644 --- a/docs/environments/atari/hero.md +++ b/docs/environments/atari/hero.md @@ -11,12 +11,12 @@ title: Hero This environment is part of the Atari environments. Please read that page first for general information. -| | | -|-------------------|---------------------------| -| Action Space | Discrete(18) | -| Observation Space | (210, 160, 3) | -| Observation High | 255 | -| Observation Low | 0 | +| | | +|-------------------|---------------------------------| +| Action Space | Discrete(18) | +| Observation Space | (210, 160, 3) | +| Observation High | 255 | +| Observation Low | 0 | | Import | `gymnasium.make("ALE/Hero-v5")` | ### Description @@ -67,9 +67,9 @@ The various ways to configure the environment are described in detail in the art It is possible to specify various flavors of the environment via the keyword arguments `difficulty` and `mode`. A flavor is a combination of a game mode and a difficulty setting. -| Environment | Valid Modes | Valid Difficulties | Default Mode | -|------------------|--------------------------|--------------------|---------------| -| Hero | `[0, ..., 4]` | `[0]` | `0` | +| Environment | Valid Modes | Valid Difficulties | Default Mode | +|-------------|---------------|--------------------|--------------| +| Hero | `[0, ..., 4]` | `[0]` | `0` | You may use the suffix "-ram" to switch to the RAM observation space. In v0 and v4, the suffixes "Deterministic" and "NoFrameskip" are available. These are no longer supported in v5. In order to obtain equivalent behavior, pass keyword arguments to `gymnasium.make` as outlined in diff --git a/docs/environments/atari/ice_hockey.md b/docs/environments/atari/ice_hockey.md index cb488b344..c9f0b7115 100644 --- a/docs/environments/atari/ice_hockey.md +++ b/docs/environments/atari/ice_hockey.md @@ -10,13 +10,13 @@ title: IceHockey This environment is part of the Atari environments. Please read that page first for general information. -| | | -|---|---| -| Action Space | Discrete(18) | -| Observation Space | (210, 160, 3) | -| Observation High | 255 | -| Observation Low | 0 | -| Import | `gymnasium.make("ALE/IceHockey-v5")` | +| | | +|-------------------|--------------------------------------| +| Action Space | Discrete(18) | +| Observation Space | (210, 160, 3) | +| Observation High | 255 | +| Observation Low | 0 | +| Import | `gymnasium.make("ALE/IceHockey-v5")` | ### Description Your goal is to score as many points as possible in a standard game of Ice Hockey over a 3-minute time period. The ball is usually called "the puck". @@ -64,9 +64,9 @@ The various ways to configure the environment are described in detail in the art It is possible to specify various flavors of the environment via the keyword arguments `difficulty` and `mode`. A flavor is a combination of a game mode and a difficulty setting. -| Environment | Valid Modes | Valid Difficulties | Default Mode | -|------------------|-------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------|--------------------|--------------| -| IceHockey | `[0, 2]` | `[0, ..., 3]` | `0` | +| Environment | Valid Modes | Valid Difficulties | Default Mode | +|-------------|-------------|--------------------|--------------| +| IceHockey | `[0, 2]` | `[0, ..., 3]` | `0` | You may use the suffix "-ram" to switch to the RAM observation space. In v0 and v4, the suffixes "Deterministic" and "NoFrameskip" are available. These are no longer supported in v5. In order to obtain equivalent behavior, pass keyword arguments to `gymnasium.make` as outlined in diff --git a/docs/environments/atari/index.md b/docs/environments/atari/index.md index 990b59925..ab8680a4c 100644 --- a/docs/environments/atari/index.md +++ b/docs/environments/atari/index.md @@ -83,26 +83,26 @@ Atari environments are simulated via the Arcade Learning Environment (ALE) [[1]] The action space a subset of the following discrete set of legal actions: -| Num | Action | -|-----|------------------------| -| 0 | NOOP | -| 1 | FIRE | -| 2 | UP | -| 3 | RIGHT | -| 4 | LEFT | -| 5 | DOWN | -| 6 | UPRIGHT | -| 7 | UPLEFT | -| 8 | DOWNRIGHT | -| 9 | DOWNLEFT | -| 10 | UPFIRE | -| 11 | RIGHTFIRE | -| 12 | LEFTFIRE | -| 13 | DOWNFIRE | -| 14 | UPRIGHTFIRE | -| 15 | UPLEFTFIRE | -| 16 | DOWNRIGHTFIRE | -| 17 | DOWNLEFTFIRE | +| Num | Action | +|-----|---------------| +| 0 | NOOP | +| 1 | FIRE | +| 2 | UP | +| 3 | RIGHT | +| 4 | LEFT | +| 5 | DOWN | +| 6 | UPRIGHT | +| 7 | UPLEFT | +| 8 | DOWNRIGHT | +| 9 | DOWNLEFT | +| 10 | UPFIRE | +| 11 | RIGHTFIRE | +| 12 | LEFTFIRE | +| 13 | DOWNFIRE | +| 14 | UPRIGHTFIRE | +| 15 | UPLEFTFIRE | +| 16 | DOWNRIGHTFIRE | +| 17 | DOWNLEFTFIRE | If you use v0 or v4 and the environment is initialized via `make`, the action space will usually be much smaller since most legal actions don't have any effect. Thus, the enumeration of the actions will differ. The action space can be expanded to the full @@ -168,11 +168,11 @@ action space will be reduced to a subset. All Atari games are available in three versions. They differ in the default settings of the arguments above. The differences are listed in the following table: -|Version|`frameskip=`|`repeat_action_probability=`|`full_action_space=`| -| ----- | --------- | ------------------------- | ---------| -|v0 |`(2, 5,)` |`0.25` |`False` | -|v4 |`(2, 5,)` |`0.0` |`False` | -|v5 |`5` |`0.25` |`True` | +| Version | `frameskip=` | `repeat_action_probability=` | `full_action_space=` | +|---------|--------------|------------------------------|----------------------| +| v0 | `(2, 5,)` | `0.25` | `False` | +| v4 | `(2, 5,)` | `0.0` | `False` | +| v5 | `5` | `0.25` | `True` | > Version v5 follows the best practices outlined in [[2]](#2). Thus, it is recommended to transition to v5 and > customize the environment using the arguments above, if necessary. @@ -180,23 +180,23 @@ The differences are listed in the following table: For each Atari game, several different configurations are registered in Gymnasium. The naming schemes are analogous for v0 and v4. Let us take a look at all variations of Amidar-v0 that are registered with gymnasium: -|Name |`obs_type=`|`frameskip=`|`repeat_action_probability=`|`full_action_space=`| -| ---------------------------- | -------- | --------- | ------------------------- | ----------------- | -|Amidar-v0 |`"rgb"` |`(2, 5,)` |`0.25` |`False` | -|AmidarDeterministic-v0 |`"rgb"` |`4` |`0.0` |`False` | -|AmidarNoframeskip-v0 |`"rgb"` |`1` |`0.25` |`False` | -|Amidar-ram-v0 |`"ram"` |`(2, 5,)` |`0.25` |`False` | -|Amidar-ramDeterministic-v0 |`"ram"` |`4` |`0.0` |`False` | -|Amidar-ramNoframeskip-v0 |`"ram"` |`1` |`0.25` |`False` | +| Name | `obs_type=` | `frameskip=` | `repeat_action_probability=` | `full_action_space=` | +|----------------------------|-------------|--------------|------------------------------|----------------------| +| Amidar-v0 | `"rgb"` | `(2, 5,)` | `0.25` | `False` | +| AmidarDeterministic-v0 | `"rgb"` | `4` | `0.0` | `False` | +| AmidarNoframeskip-v0 | `"rgb"` | `1` | `0.25` | `False` | +| Amidar-ram-v0 | `"ram"` | `(2, 5,)` | `0.25` | `False` | +| Amidar-ramDeterministic-v0 | `"ram"` | `4` | `0.0` | `False` | +| Amidar-ramNoframeskip-v0 | `"ram"` | `1` | `0.25` | `False` | Things change in v5: The suffixes "Deterministic" and "NoFrameskip" are no longer available. Instead, you must specify the environment configuration via arguments passed to `gymnasium.make`. Moreover, the v5 environments are in the "ALE" namespace. The suffix "-ram" is still available. Thus, we get the following table: -|Name |`obs_type=`|`frameskip=`|`repeat_action_probability=`|`full_action_space=`| -| ---------------------------- | -------- | --------- | ------------------------- | ----------------- | -|ALE/Amidar-v5 |`"rgb"` |`5` |`0.25` |`True` | -|ALE/Amidar-ram-v5 |`"ram"` |`5` |`0.25` |`True` | +| Name | `obs_type=` | `frameskip=` | `repeat_action_probability=` | `full_action_space=` | +|-------------------|-------------|--------------|------------------------------|----------------------| +| ALE/Amidar-v5 | `"rgb"` | `5` | `0.25` | `True` | +| ALE/Amidar-ram-v5 | `"ram"` | `5` | `0.25` | `True` | ### Flavors Some games allow the user to set a difficulty level and a game mode. Different modes/difficulties may have different diff --git a/docs/environments/atari/jamesbond.md b/docs/environments/atari/jamesbond.md index 103ea6aa5..d1d1190b3 100644 --- a/docs/environments/atari/jamesbond.md +++ b/docs/environments/atari/jamesbond.md @@ -10,13 +10,13 @@ title: Jamesbond This environment is part of the Atari environments. Please read that page first for general information. -| | | -|---|---| -| Action Space | Discrete(18) | -| Observation Space | (210, 160, 3) | -| Observation High | 255 | -| Observation Low | 0 | -| Import | `gymnasium.make("ALE/Jamesbond-v5")` | +| | | +|-------------------|--------------------------------------| +| Action Space | Discrete(18) | +| Observation Space | (210, 160, 3) | +| Observation High | 255 | +| Observation Low | 0 | +| Import | `gymnasium.make("ALE/Jamesbond-v5")` | ### Description Your mission is to control Mr. Bond's specially designed multipurpose craft to complete a variety of missions. @@ -65,9 +65,9 @@ The various ways to configure the environment are described in detail in the art It is possible to specify various flavors of the environment via the keyword arguments `difficulty` and `mode`. A flavor is a combination of a game mode and a difficulty setting. -| Environment | Valid Modes | Valid Difficulties | Default Mode | -|------------------|-------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------|--------------------|--------------| -| Jamesbond | `[0, 1]` | `[0]` | `0` | +| Environment | Valid Modes | Valid Difficulties | Default Mode | +|-------------|-------------|--------------------|--------------| +| Jamesbond | `[0, 1]` | `[0]` | `0` | You may use the suffix "-ram" to switch to the RAM observation space. In v0 and v4, the suffixes "Deterministic" and "NoFrameskip" are available. These are no longer supported in v5. In order to obtain equivalent behavior, pass keyword arguments to `gymnasium.make` as outlined in diff --git a/docs/environments/atari/journey_escape.md b/docs/environments/atari/journey_escape.md index dcdb14e66..816818e90 100644 --- a/docs/environments/atari/journey_escape.md +++ b/docs/environments/atari/journey_escape.md @@ -10,13 +10,13 @@ title: JourneyEscape This environment is part of the Atari environments. Please read that page first for general information. -| | | -|---|---| -| Action Space | Discrete(18) | -| Observation Space | (210, 160, 3) | -| Observation High | 255 | -| Observation Low | 0 | -| Import | `gymnasium.make("ALE/JourneyEscape-v5")` | +| | | +|-------------------|------------------------------------------| +| Action Space | Discrete(18) | +| Observation Space | (210, 160, 3) | +| Observation High | 255 | +| Observation Low | 0 | +| Import | `gymnasium.make("ALE/JourneyEscape-v5")` | ### Description You must lead all 5 members of JOURNEY through waves of pesky characters and backstage obstacles to the Scarab Escape Vehicle before time runs out. @@ -30,27 +30,24 @@ number of actions (those that are meaningful in this game) are available. The re on the flavor of the environment (the combination of `mode` and `difficulty`). The reduced action space for the default flavor looks like this: -| Num | Action | -|-----|------------------------| -| 0 | NOOP | -| 2 | UP | -| 3 | RIGHT | -| 4 | LEFT | -| 5 | DOWN | -| 6 | UPRIGHT | -| 7 | UPLEFT | -| 8 | DOWNRIGHT | -| 9 | DOWNLEFT | -| 11 | RIGHTFIRE | -| 12 | LEFTFIRE | -| 13 | DOWNFIRE | -| 14 | UPRIGHTFIRE | -| 15 | UPLEFTFIRE | -| 16 | DOWNRIGHTFIRE | -| 17 | DOWNLEFTFIRE | - - - +| Num | Action | +|-----|---------------| +| 0 | NOOP | +| 2 | UP | +| 3 | RIGHT | +| 4 | LEFT | +| 5 | DOWN | +| 6 | UPRIGHT | +| 7 | UPLEFT | +| 8 | DOWNRIGHT | +| 9 | DOWNLEFT | +| 11 | RIGHTFIRE | +| 12 | LEFTFIRE | +| 13 | DOWNFIRE | +| 14 | UPRIGHTFIRE | +| 15 | UPLEFTFIRE | +| 16 | DOWNRIGHTFIRE | +| 17 | DOWNLEFTFIRE | ### Observations By default, the environment returns the RGB image that is displayed to human players as an observation. However, it is diff --git a/docs/environments/atari/kangaroo.md b/docs/environments/atari/kangaroo.md index 9fd36b4ee..c54af55d4 100644 --- a/docs/environments/atari/kangaroo.md +++ b/docs/environments/atari/kangaroo.md @@ -10,13 +10,13 @@ title: Kangaroo This environment is part of the Atari environments. Please read that page first for general information. -| | | -|---|---| -| Action Space | Discrete(18) | -| Observation Space | (210, 160, 3) | -| Observation High | 255 | -| Observation Low | 0 | -| Import | `gymnasium.make("ALE/Kangaroo-v5")` | +| | | +|-------------------|-------------------------------------| +| Action Space | Discrete(18) | +| Observation Space | (210, 160, 3) | +| Observation High | 255 | +| Observation Low | 0 | +| Import | `gymnasium.make("ALE/Kangaroo-v5")` | ### Description The object of the game is to score as many points as you can while controlling Mother Kangaroo to rescue her precious baby. You start the game with three lives. @@ -63,9 +63,9 @@ The various ways to configure the environment are described in detail in the art It is possible to specify various flavors of the environment via the keyword arguments `difficulty` and `mode`. A flavor is a combination of a game mode and a difficulty setting. -| Environment | Valid Modes | Valid Difficulties | Default Mode | -|------------------|-------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------|--------------------|--------------| -| Kangaroo | `[0, 1]` | `[0]` | `0` | +| Environment | Valid Modes | Valid Difficulties | Default Mode | +|-------------|-------------|--------------------|--------------| +| Kangaroo | `[0, 1]` | `[0]` | `0` | You may use the suffix "-ram" to switch to the RAM observation space. In v0 and v4, the suffixes "Deterministic" and "NoFrameskip" are available. These are no longer supported in v5. In order to obtain equivalent behavior, pass keyword arguments to `gymnasium.make` as outlined in diff --git a/docs/environments/atari/krull.md b/docs/environments/atari/krull.md index 40c85cfee..25af2f6aa 100644 --- a/docs/environments/atari/krull.md +++ b/docs/environments/atari/krull.md @@ -10,13 +10,13 @@ title: Krull This environment is part of the Atari environments. Please read that page first for general information. -| | | -|---|---| -| Action Space | Discrete(18) | -| Observation Space | (210, 160, 3) | -| Observation High | 255 | -| Observation Low | 0 | -| Import | `gymnasium.make("ALE/Krull-v5")` | +| | | +|-------------------|----------------------------------| +| Action Space | Discrete(18) | +| Observation Space | (210, 160, 3) | +| Observation High | 255 | +| Observation Low | 0 | +| Import | `gymnasium.make("ALE/Krull-v5")` | ### Description Your mission is to find and enter the Beast's Black Fortress, rescue Princess Lyssa, and destroy the Beast. @@ -63,9 +63,9 @@ The various ways to configure the environment are described in detail in the art It is possible to specify various flavors of the environment via the keyword arguments `difficulty` and `mode`. A flavor is a combination of a game mode and a difficulty setting. -| Environment | Valid Modes | Valid Difficulties | Default Mode | -|------------------|-------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------|--------------------|--------------| -| Krull | `[0]` | `[0]` | `0` | +| Environment | Valid Modes | Valid Difficulties | Default Mode | +|-------------|-------------|--------------------|--------------| +| Krull | `[0]` | `[0]` | `0` | You may use the suffix "-ram" to switch to the RAM observation space. In v0 and v4, the suffixes "Deterministic" and "NoFrameskip" are available. These are no longer supported in v5. In order to obtain equivalent behavior, pass keyword arguments to `gymnasium.make` as outlined in diff --git a/docs/environments/atari/kung_fu_master.md b/docs/environments/atari/kung_fu_master.md index 3cd270b10..12c90ddb9 100644 --- a/docs/environments/atari/kung_fu_master.md +++ b/docs/environments/atari/kung_fu_master.md @@ -10,13 +10,13 @@ title: Kung Fu Master This environment is part of the Atari environments. Please read that page first for general information. -| | | -|---|---| -| Action Space | Discrete(18) | -| Observation Space | (210, 160, 3) | -| Observation High | 255 | -| Observation Low | 0 | -| Import | `gymnasium.make("ALE/KungFuMaster-v5")` | +| | | +|-------------------|-----------------------------------------| +| Action Space | Discrete(18) | +| Observation Space | (210, 160, 3) | +| Observation High | 255 | +| Observation Low | 0 | +| Import | `gymnasium.make("ALE/KungFuMaster-v5")` | ### Description You are a Kung-Fu Master fighting your way through the Evil Wizard's temple. Your goal is to rescue Princess Victoria, defeating various enemies along the way. Detailed documentation can be found on [the AtariAge page](https://atariage.com/manual_thumbs.php?SoftwareLabelID=268). @@ -24,22 +24,22 @@ You are a Kung-Fu Master fighting your way through the Evil Wizard's temple. You ### Actions By default, all actions that can be performed on an Atari 2600 are available in this environment. However, if you use v0 or v4 or specify full_action_space=False during initialization, only a reduced number of actions (those that are meaningful in this game) are available. The reduced action space may depend on the flavor of the environment (the combination of mode and difficulty). The reduced action space for the default flavor looks like this: -| Num | Action | -|-----|------------------------| -| 0 | NOOP | -| 1 | UP | -| 2 | RIGHT | -| 3 | LEFT | -| 4 | DOWN | -| 5 | DOWNRIGHT | -| 6 | DOWNLEFT | -| 7 | RIGHTFIRE | -| 8 | LEFTFIRE | -| 9 | DOWNFIRE | -| 10 | UPRIGHTFIRE | -| 11 | UPLEFTFIRE | -| 12 | DOWNRIGHTFIRE | -| 13 | DOWNLEFTFIRE | +| Num | Action | +|-----|---------------| +| 0 | NOOP | +| 1 | UP | +| 2 | RIGHT | +| 3 | LEFT | +| 4 | DOWN | +| 5 | DOWNRIGHT | +| 6 | DOWNLEFT | +| 7 | RIGHTFIRE | +| 8 | LEFTFIRE | +| 9 | DOWNFIRE | +| 10 | UPRIGHTFIRE | +| 11 | UPLEFTFIRE | +| 12 | DOWNRIGHTFIRE | +| 13 | DOWNLEFTFIRE | ### Observations By default, the environment returns the RGB image that is displayed to human players as an observation. However, it is @@ -67,9 +67,9 @@ env = gymnasium.make("ALE/KungFuMaster-v5") The various ways to configure the environment are described in detail in the article on Atari environments. -| Environment | Valid Modes | Valid Difficulties | Default Mode | -|------------------|-------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------|--------------------|--------------| -| KungFuMaster | `[0]` | `[0]` | `0` | +| Environment | Valid Modes | Valid Difficulties | Default Mode | +|--------------|-------------|--------------------|--------------| +| KungFuMaster | `[0]` | `[0]` | `0` | You may use the suffix "-ram" to switch to the RAM observation space. In v0 and v4, the suffixes "Deterministic" and "Noframeskip" are available. These are no longer supported in v5. In order to obtain equivalent behavior, pass keyword arguments to `gymnasium.make` as outlined in diff --git a/docs/environments/atari/montezuma_revenge.md b/docs/environments/atari/montezuma_revenge.md index ca0a937e4..4b584f7c9 100644 --- a/docs/environments/atari/montezuma_revenge.md +++ b/docs/environments/atari/montezuma_revenge.md @@ -10,13 +10,13 @@ title: Montezuma Revenge This environment is part of the Atari environments. Please read that page first for general information. -| | | -|---|---| -| Action Space | Discrete(18) | -| Observation Space | (210, 160, 3) | -| Observation High | 255 | -| Observation Low | 0 | -| Import | `gymnasium.make("ALE/MontezumaRevenge-v5")` | +| | | +|-------------------|---------------------------------------------| +| Action Space | Discrete(18) | +| Observation Space | (210, 160, 3) | +| Observation High | 255 | +| Observation Low | 0 | +| Import | `gymnasium.make("ALE/MontezumaRevenge-v5")` | ### Description Your goal is to acquire Montezuma's treasure by making your way through a maze of chambers within the emperor's fortress. You must avoid deadly creatures while collecting valuables and tools which can help you escape with the treasure. Detailed documentation can be found on [the AtariAge page](https://atariage.com/manual_html_page.php?SoftwareLabelID=310). @@ -52,9 +52,9 @@ env = gymnasium.make("ALE/MontezumaRevenge-v5") The various ways to configure the environment are described in detail in the article on Atari environments. -| Environment | Valid Modes | Valid Difficulties | Default Mode | -|------------------|-------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------|--------------------|--------------| -| MontezumaRevenge | `[0]` | `[0]` | `0` | +| Environment | Valid Modes | Valid Difficulties | Default Mode | +|------------------|-------------|--------------------|--------------| +| MontezumaRevenge | `[0]` | `[0]` | `0` | You may use the suffix "-ram" to switch to the RAM observation space. In v0 and v4, the suffixes "Deterministic" and "Noframeskip" are available. These are no longer supported in v5. In order to obtain equivalent behavior, pass keyword arguments to `gymnasium.make` as outlined in diff --git a/docs/environments/atari/ms_pacman.md b/docs/environments/atari/ms_pacman.md index 20814c8bf..8a6808c87 100644 --- a/docs/environments/atari/ms_pacman.md +++ b/docs/environments/atari/ms_pacman.md @@ -10,13 +10,13 @@ title: Ms Pacman This environment is part of the Atari environments. Please read that page first for general information. -| | | -|---|---| -| Action Space | Discrete(18) | -| Observation Space | (210, 160, 3) | -| Observation High | 255 | -| Observation Low | 0 | -| Import | `gymnasium.make("ALE/MsPacman-v5")` | +| | | +|-------------------|-------------------------------------| +| Action Space | Discrete(18) | +| Observation Space | (210, 160, 3) | +| Observation High | 255 | +| Observation Low | 0 | +| Import | `gymnasium.make("ALE/MsPacman-v5")` | ### Description Your goal is to collect all of the pellets on the screen while avoiding the ghosts. @@ -24,17 +24,17 @@ Your goal is to collect all of the pellets on the screen while avoiding the ghos ### Actions By default, all actions that can be performed on an Atari 2600 are available in this environment. However, if you use v0 or v4 or specify full_action_space=False during initialization, only a reduced number of actions (those that are meaningful in this game) are available. The reduced action space may depend on the flavor of the environment (the combination of mode and difficulty). The reduced action space for the default flavor looks like this: -| Num | Action | -|-----|------------------------| -| 0 | NOOP | -| 1 | UP | -| 2 | RIGHT | -| 3 | LEFT | -| 4 | DOWN | -| 5 | UPRIGHT | -| 6 | UPLEFT | +| Num | Action | +|-----|-----------| +| 0 | NOOP | +| 1 | UP | +| 2 | RIGHT | +| 3 | LEFT | +| 4 | DOWN | +| 5 | UPRIGHT | +| 6 | UPLEFT | | 7 | DOWNRIGHT | -| 8 | DOWNLEFT | +| 8 | DOWNLEFT | ### Observations By default, the environment returns the RGB image that is displayed to human players as an observation. However, it is @@ -62,9 +62,9 @@ env = gymnasium.make("ALE/MsPacman-v5") The various ways to configure the environment are described in detail in the article on Atari environments. -| Environment | Valid Modes | Valid Difficulties | Default Mode | -|------------------|-------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------|--------------------|--------------| -| MsPacman | `[0, ..., 3]` | `[0]` | `0` | +| Environment | Valid Modes | Valid Difficulties | Default Mode | +|-------------|---------------|--------------------|--------------| +| MsPacman | `[0, ..., 3]` | `[0]` | `0` | You may use the suffix "-ram" to switch to the RAM observation space. In v0 and v4, the suffixes "Deterministic" and "Noframeskip" are available. These are no longer supported in v5. In order to obtain equivalent behavior, pass keyword arguments to `gymnasium.make` as outlined in diff --git a/docs/environments/atari/name_this_game.md b/docs/environments/atari/name_this_game.md index 92ecad376..230c7a877 100644 --- a/docs/environments/atari/name_this_game.md +++ b/docs/environments/atari/name_this_game.md @@ -10,13 +10,13 @@ title: Name This Game This environment is part of the Atari environments. Please read that page first for general information. -| | | -|---|---| -| Action Space | Discrete(18) | -| Observation Space | (210, 160, 3) | -| Observation High | 255 | -| Observation Low | 0 | -| Import | `gymnasium.make("ALE/NameThisGame-v5")` | +| | | +|-------------------|-----------------------------------------| +| Action Space | Discrete(18) | +| Observation Space | (210, 160, 3) | +| Observation High | 255 | +| Observation Low | 0 | +| Import | `gymnasium.make("ALE/NameThisGame-v5")` | ### Description Your goal is to defend the treasure that you have discovered. You must fight off a shark and an octopus while keeping an eye on your oxygen supply. Detailed documentation can be found on [the AtariAge page](https://atariage.com/manual_html_page.php?SoftwareLabelID=323). @@ -24,14 +24,14 @@ Your goal is to defend the treasure that you have discovered. You must fight off ### Actions By default, all actions that can be performed on an Atari 2600 are available in this environment. However, if you use v0 or v4 or specify full_action_space=False during initialization, only a reduced number of actions (those that are meaningful in this game) are available. The reduced action space may depend on the flavor of the environment (the combination of mode and difficulty). The reduced action space for the default flavor looks like this: -| Num | Action | -|-----|------------------------| -| 0 | NOOP | -| 1 | FIRE | -| 2 | RIGHT | -| 3 | LEFT | +| Num | Action | +|-----|-----------| +| 0 | NOOP | +| 1 | FIRE | +| 2 | RIGHT | +| 3 | LEFT | | 4 | RIGHTFIRE | -| 5 | LEFTFIRE | +| 5 | LEFTFIRE | ### Observations @@ -60,9 +60,9 @@ env = gymnasium.make("ALE/NameThisGame-v5") The various ways to configure the environment are described in detail in the article on Atari environments. -| Environment | Valid Modes | Valid Difficulties | Default Mode | -|------------------|-------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------|--------------------|--------------| -| NameThisGame | `[8, 24, 40]` | `[0, 1]` | `8` | +| Environment | Valid Modes | Valid Difficulties | Default Mode | +|--------------|---------------|--------------------|--------------| +| NameThisGame | `[8, 24, 40]` | `[0, 1]` | `8` | You may use the suffix "-ram" to switch to the RAM observation space. In v0 and v4, the suffixes "Deterministic" and "Noframeskip" are available. These are no longer supported in v5. In order to obtain equivalent behavior, pass keyword arguments to `gymnasium.make` as outlined in diff --git a/docs/environments/atari/phoenix.md b/docs/environments/atari/phoenix.md index 6063ed3f0..30b15a602 100644 --- a/docs/environments/atari/phoenix.md +++ b/docs/environments/atari/phoenix.md @@ -10,13 +10,13 @@ title: Phoenix This environment is part of the Atari environments. Please read that page first for general information. -| | | -|---|---| -| Action Space | Discrete(18) | -| Observation Space | (210, 160, 3) | -| Observation High | 255 | -| Observation Low | 0 | -| Import | `gymnasium.make("ALE/Phoenix-v5")` | +| | | +|-------------------|------------------------------------| +| Action Space | Discrete(18) | +| Observation Space | (210, 160, 3) | +| Observation High | 255 | +| Observation Low | 0 | +| Import | `gymnasium.make("ALE/Phoenix-v5")` | ### Description Your goal is to reach and shoot the alien pilot. On your way there, you must eliminate waves of war birds while avoiding their bombs. Detailed documentation can be found on [the AtariAge page](https://atariage.com/manual_thumbs.php?SoftwareLabelID=355). @@ -24,16 +24,16 @@ Your goal is to reach and shoot the alien pilot. On your way there, you must eli ### Actions By default, all actions that can be performed on an Atari 2600 are available in this environment. However, if you use v0 or v4 or specify full_action_space=False during initialization, only a reduced number of actions (those that are meaningful in this game) are available. The reduced action space may depend on the flavor of the environment (the combination of mode and difficulty). The reduced action space for the default flavor looks like this: -| Num | Action | -|-----|------------------------| -| 0 | NOOP | -| 1 | FIRE | -| 2 | RIGHT | -| 3 | LEFT | -| 4 | DOWN | +| Num | Action | +|-----|-----------| +| 0 | NOOP | +| 1 | FIRE | +| 2 | RIGHT | +| 3 | LEFT | +| 4 | DOWN | | 5 | RIGHTFIRE | -| 6 | LEFTFIRE | -| 7 | DOWNFIRE | +| 6 | LEFTFIRE | +| 7 | DOWNFIRE | ### Observations By default, the environment returns the RGB image that is displayed to human players as an observation. However, it is @@ -61,9 +61,9 @@ env = gymnasium.make("ALE/Phoenix-v5") The various ways to configure the environment are described in detail in the article on Atari environments. -| Environment | Valid Modes | Valid Difficulties | Default Mode | -|------------------|-------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------|--------------------|--------------| -| Phoenix | `[0]` | `[0]` | `0` | +| Environment | Valid Modes | Valid Difficulties | Default Mode | +|-------------|-------------|--------------------|--------------| +| Phoenix | `[0]` | `[0]` | `0` | You may use the suffix "-ram" to switch to the RAM observation space. In v0 and v4, the suffixes "Deterministic" and "Noframeskip" are available. These are no longer supported in v5. In order to obtain equivalent behavior, pass keyword arguments to `gymnasium.make` as outlined in diff --git a/docs/environments/atari/pitfall.md b/docs/environments/atari/pitfall.md index ab5d60afd..28507b04f 100644 --- a/docs/environments/atari/pitfall.md +++ b/docs/environments/atari/pitfall.md @@ -10,13 +10,13 @@ title: Pitfall This environment is part of the Atari environments. Please read that page first for general information. -| | | -|---|---| -| Action Space | Discrete(18) | -| Observation Space | (210, 160, 3) | -| Observation High | 255 | -| Observation Low | 0 | -| Import | `gymnasium.make("ALE/Pitfall-v5")` | +| | | +|-------------------|------------------------------------| +| Action Space | Discrete(18) | +| Observation Space | (210, 160, 3) | +| Observation High | 255 | +| Observation Low | 0 | +| Import | `gymnasium.make("ALE/Pitfall-v5")` | ### Description You control Pitfall Harry and are tasked with collecting all the treasures in a jungle within 20 minutes. You have three lives. The game is over if you collect all the treasures or if you die or if the time runs out. @@ -58,9 +58,9 @@ The various ways to configure the environment are described in detail in the art It is possible to specify various flavors of the environment via the keyword arguments `difficulty` and `mode`. A flavor is a combination of a game mode and a difficulty setting. -| Environment | Valid Modes | Valid Difficulties | Default Mode | -|------------------|-------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------|--------------------|--------------| -| Pitfall | `[0]` | `[0]` | `0` | +| Environment | Valid Modes | Valid Difficulties | Default Mode | +|-------------|-------------|--------------------|--------------| +| Pitfall | `[0]` | `[0]` | `0` | You may use the suffix "-ram" to switch to the RAM observation space. In v0 and v4, the suffixes "Deterministic" and "NoFrameskip" are available. These are no longer supported in v5. In order to obtain equivalent behavior, pass keyword arguments to `gymnasium.make` as outlined in diff --git a/docs/environments/atari/pong.md b/docs/environments/atari/pong.md index 8788d5448..e80087e4d 100644 --- a/docs/environments/atari/pong.md +++ b/docs/environments/atari/pong.md @@ -10,13 +10,13 @@ title: Pong This environment is part of the Atari environments. Please read that page first for general information. -| | | -|---|---| -| Action Space | Discrete(18) | -| Observation Space | (210, 160, 3) | -| Observation High | 255 | -| Observation Low | 0 | -| Import | `gymnasium.make("ALE/Pong-v5")` | +| | | +|-------------------|---------------------------------| +| Action Space | Discrete(18) | +| Observation Space | (210, 160, 3) | +| Observation High | 255 | +| Observation Low | 0 | +| Import | `gymnasium.make("ALE/Pong-v5")` | ### Description You control the right paddle, you compete against the left paddle controlled by the computer. You each try to keep deflecting the ball away from your goal and into your opponent's goal. @@ -28,14 +28,14 @@ However, if you use v0 or v4 or specify `full_action_space=False` during initial number of actions (those that are meaningful in this game) are available. The reduced action space may depend on the flavor of the environment (the combination of `mode` and `difficulty`). The reduced action space for the default flavor looks like this: -| Num | Action | -|-----|------------------------| -| 0 | NOOP | -| 1 | FIRE | -| 2 | RIGHT | -| 3 | LEFT | +| Num | Action | +|-----|-----------| +| 0 | NOOP | +| 1 | FIRE | +| 2 | RIGHT | +| 3 | LEFT | | 4 | RIGHTFIRE | -| 5 | LEFTFIRE | +| 5 | LEFTFIRE | @@ -70,9 +70,9 @@ The various ways to configure the environment are described in detail in the art It is possible to specify various flavors of the environment via the keyword arguments `difficulty` and `mode`. A flavor is a combination of a game mode and a difficulty setting. -| Environment | Valid Modes | Valid Difficulties | Default Mode | -|------------------|-------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------|--------------------|--------------| -| Pong | `[0, 1]` | `[0, ..., 3]` | `0` | +| Environment | Valid Modes | Valid Difficulties | Default Mode | +|-------------|-------------|--------------------|--------------| +| Pong | `[0, 1]` | `[0, ..., 3]` | `0` | You may use the suffix "-ram" to switch to the RAM observation space. In v0 and v4, the suffixes "Deterministic" and "NoFrameskip" are available. These are no longer supported in v5. In order to obtain equivalent behavior, pass keyword arguments to `gymnasium.make` as outlined in diff --git a/docs/environments/atari/pooyan.md b/docs/environments/atari/pooyan.md index fbc41bd98..71e4c377c 100644 --- a/docs/environments/atari/pooyan.md +++ b/docs/environments/atari/pooyan.md @@ -10,13 +10,13 @@ title: Pooyan This environment is part of the Atari environments. Please read that page first for general information. -| | | -|---|---| -| Action Space | Discrete(18) | -| Observation Space | (210, 160, 3) | -| Observation High | 255 | -| Observation Low | 0 | -| Import | `gymnasium.make("ALE/Pooyan-v5")` | +| | | +|-------------------|-----------------------------------| +| Action Space | Discrete(18) | +| Observation Space | (210, 160, 3) | +| Observation High | 255 | +| Observation Low | 0 | +| Import | `gymnasium.make("ALE/Pooyan-v5")` | ### Description @@ -29,17 +29,15 @@ However, if you use v0 or v4 or specify `full_action_space=False` during initial number of actions (those that are meaningful in this game) are available. The reduced action space may depend on the flavor of the environment (the combination of `mode` and `difficulty`). The reduced action space for the default flavor looks like this: -| Num | Action | -|-----|------------------------| -| 0 | NOOP | -| 1 | FIRE | -| 2 | UP | -| 3 | DOWN | -| 4 | UPFIRE | +| Num | Action | +|-----|----------| +| 0 | NOOP | +| 1 | FIRE | +| 2 | UP | +| 3 | DOWN | +| 4 | UPFIRE | | 5 | DOWNFIRE | - - ### Observations By default, the environment returns the RGB image that is displayed to human players as an observation. However, it is possible to observe - The 128 Bytes of RAM of the console @@ -71,9 +69,9 @@ The various ways to configure the environment are described in detail in the art It is possible to specify various flavors of the environment via the keyword arguments `difficulty` and `mode`. A flavor is a combination of a game mode and a difficulty setting. -| Environment | Valid Modes | Valid Difficulties | Default Mode | -|------------------|-------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------|--------------------|--------------| -| Pooyan | `[10, 30, 50, 70]` | `[0]` | `10` | +| Environment | Valid Modes | Valid Difficulties | Default Mode | +|-------------|--------------------|--------------------|--------------| +| Pooyan | `[10, 30, 50, 70]` | `[0]` | `10` | You may use the suffix "-ram" to switch to the RAM observation space. In v0 and v4, the suffixes "Deterministic" and "NoFrameskip" are available. These are no longer supported in v5. In order to obtain equivalent behavior, pass keyword arguments to `gymnasium.make` as outlined in diff --git a/docs/environments/atari/private_eye.md b/docs/environments/atari/private_eye.md index ba6d1620e..85863a925 100644 --- a/docs/environments/atari/private_eye.md +++ b/docs/environments/atari/private_eye.md @@ -10,13 +10,13 @@ title: PrivateEye This environment is part of the Atari environments. Please read that page first for general information. -| | | -|---|---| -| Action Space | Discrete(18) | -| Observation Space | (210, 160, 3) | -| Observation High | 255 | -| Observation Low | 0 | -| Import | `gymnasium.make("ALE/PrivateEye-v5")` | +| | | +|-------------------|---------------------------------------| +| Action Space | Discrete(18) | +| Observation Space | (210, 160, 3) | +| Observation High | 255 | +| Observation Low | 0 | +| Import | `gymnasium.make("ALE/PrivateEye-v5")` | ### Description You control the French Private Eye Pierre Touche. Navigate the city streets, parks, secret passages, dead-ends and one-ways in search of the ringleader, Henri Le Fiend and his gang. You also need to find evidence and stolen goods that are scattered about. There are five cases, complete each case before its statute of limitations expires. @@ -58,9 +58,9 @@ The various ways to configure the environment are described in detail in the art It is possible to specify various flavors of the environment via the keyword arguments `difficulty` and `mode`. A flavor is a combination of a game mode and a difficulty setting. -| Environment | Valid Modes | Valid Difficulties | Default Mode | -|------------------|-------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------|--------------------|--------------| -| PrivateEye | `[0, ..., 4]` | `[0, ..., 3]` | `0` | +| Environment | Valid Modes | Valid Difficulties | Default Mode | +|-------------|---------------|--------------------|--------------| +| PrivateEye | `[0, ..., 4]` | `[0, ..., 3]` | `0` | You may use the suffix "-ram" to switch to the RAM observation space. In v0 and v4, the suffixes "Deterministic" and "NoFrameskip" are available. These are no longer supported in v5. In order to obtain equivalent behavior, pass keyword arguments to `gymnasium.make` as outlined in diff --git a/docs/environments/atari/qbert.md b/docs/environments/atari/qbert.md index 84f898b5f..0a3d1292b 100644 --- a/docs/environments/atari/qbert.md +++ b/docs/environments/atari/qbert.md @@ -10,13 +10,13 @@ title: Qbert This environment is part of the Atari environments. Please read that page first for general information. -| | | -|---|---| -| Action Space | Discrete(18) | -| Observation Space | (210, 160, 3) | -| Observation High | 255 | -| Observation Low | 0 | -| Import | `gymnasium.make("ALE/Qbert-v5")` | +| | | +|-------------------|----------------------------------| +| Action Space | Discrete(18) | +| Observation Space | (210, 160, 3) | +| Observation High | 255 | +| Observation Low | 0 | +| Import | `gymnasium.make("ALE/Qbert-v5")` | ### Description You are Q*bert. Your goal is to change the color of all the cubes on the pyramid to the pyramid's 'destination' color. To do this, you must hop on each cube on the pyramid one at a time while avoiding nasty creatures that lurk there. @@ -28,14 +28,14 @@ However, if you use v0 or v4 or specify `full_action_space=False` during initial number of actions (those that are meaningful in this game) are available. The reduced action space may depend on the flavor of the environment (the combination of `mode` and `difficulty`). The reduced action space for the default flavor looks like this: -| Num | Action | -|-----|------------------------| -| 0 | NOOP | -| 1 | FIRE | -| 2 | UP | -| 3 | RIGHT | -| 4 | LEFT | -| 5 | DOWN | +| Num | Action | +|-----|--------| +| 0 | NOOP | +| 1 | FIRE | +| 2 | UP | +| 3 | RIGHT | +| 4 | LEFT | +| 5 | DOWN | ### Observations @@ -69,9 +69,9 @@ The various ways to configure the environment are described in detail in the art It is possible to specify various flavors of the environment via the keyword arguments `difficulty` and `mode`. A flavor is a combination of a game mode and a difficulty setting. -| Environment | Valid Modes | Valid Difficulties | Default Mode | -|------------------|-------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------|--------------------|--------------| -| Qbert | `[0]` | `[0, 1]` | `0` | +| Environment | Valid Modes | Valid Difficulties | Default Mode | +|-------------|-------------|--------------------|--------------| +| Qbert | `[0]` | `[0, 1]` | `0` | You may use the suffix "-ram" to switch to the RAM observation space. In v0 and v4, the suffixes "Deterministic" and "NoFrameskip" are available. These are no longer supported in v5. In order to obtain equivalent behavior, pass keyword arguments to `gymnasium.make` as outlined in diff --git a/docs/environments/atari/riverraid.md b/docs/environments/atari/riverraid.md index 4d79de80c..25d509bb6 100644 --- a/docs/environments/atari/riverraid.md +++ b/docs/environments/atari/riverraid.md @@ -10,13 +10,13 @@ title: Riverraid This environment is part of the Atari environments. Please read that page first for general information. -| | | -|---|---| -| Action Space | Discrete(18) | -| Observation Space | (210, 160, 3) | -| Observation High | 255 | -| Observation Low | 0 | -| Import | `gymnasium.make("ALE/Riverraid-v5")` | +| | | +|-------------------|--------------------------------------| +| Action Space | Discrete(18) | +| Observation Space | (210, 160, 3) | +| Observation High | 255 | +| Observation Low | 0 | +| Import | `gymnasium.make("ALE/Riverraid-v5")` | ### Description You control a jet that flies over a river: you can move it sideways and fire missiles to destroy enemy objects. Each time an enemy object is destroyed you score points (i.e. rewards). @@ -55,11 +55,11 @@ Score points are your only reward. You get score points each time you destroy an | Enemy Object | Score Points | |--------------|--------------| -| Tanker | 30| -| Helicopter | 60| -| Fuel Depot | 80| -| Jet | 100| -| Bridge | 500| +| Tanker | 30 | +| Helicopter | 60 | +| Fuel Depot | 80 | +| Jet | 100 | +| Bridge | 500 | For a more detailed documentation, see [the AtariAge page](https://atariage.com/manual_html_page.php?SoftwareLabelID=409). @@ -73,9 +73,9 @@ The various ways to configure the environment are described in detail in the art It is possible to specify various flavors of the environment via the keyword arguments `difficulty` and `mode`. A flavor is a combination of a game mode and a difficulty setting. -| Environment | Valid Modes | Valid Difficulties | Default Mode | -|------------------|-----------|--------------------|--------------| -| Riverraid | `[0]` | `[0,1]` | `0` | +| Environment | Valid Modes | Valid Difficulties | Default Mode | +|-------------|-------------|--------------------|--------------| +| Riverraid | `[0]` | `[0,1]` | `0` | You may use the suffix "-ram" to switch to the RAM observation space. In v0 and v4, the suffixes "Deterministic" and "NoFrameskip" are available. These are no longer supported in v5. In order to obtain equivalent behavior, pass keyword arguments to `gymnasium.make` as outlined in diff --git a/docs/environments/atari/road_runner.md b/docs/environments/atari/road_runner.md index 4d487fa1f..6275a294e 100644 --- a/docs/environments/atari/road_runner.md +++ b/docs/environments/atari/road_runner.md @@ -10,13 +10,13 @@ title: Road Runner This environment is part of the Atari environments. Please read that page first for general information. -| | | -|---|---| -| Action Space | Discrete(18) | -| Observation Space | (210, 160, 3) | -| Observation High | 255 | -| Observation Low | 0 | -| Import | `gymnasium.make("ALE/RoadRunner-v0")` | +| | | +|-------------------|---------------------------------------| +| Action Space | Discrete(18) | +| Observation Space | (210, 160, 3) | +| Observation High | 255 | +| Observation Low | 0 | +| Import | `gymnasium.make("ALE/RoadRunner-v0")` | ### Description You control the Road Runner(TM) in a race; you can control the direction to run in and times to jumps. @@ -56,12 +56,12 @@ via `gymnasium.make`. ### Rewards Score points are your only reward. You get score points each time you: -|actions |points| -|-----------------------------------------------------------|-----| -|eat a pile of birdseed |100 | -|eat steel shot |100 | -|get the coyote hit by a mine (cannonball, rock, etc.) |200 | -|get the coyote hit by a truck |1000 | +| actions | points | +|-------------------------------------------------------|--------| +| eat a pile of birdseed | 100 | +| eat steel shot | 100 | +| get the coyote hit by a mine (cannonball, rock, etc.) | 200 | +| get the coyote hit by a truck | 1000 | For a more detailed documentation, see [the AtariAge page](https://atariage.com/manual_html_page.php?SoftwareLabelID=412). @@ -75,9 +75,9 @@ The various ways to configure the environment are described in detail in the art It is possible to specify various flavors of the environment via the keyword arguments `difficulty` and `mode`. A flavor is a combination of a game mode and a difficulty setting. -| Environment | Valid Modes | Valid Difficulties | Default Mode | -|------------------------|------|----------|--------------| -| RoadRunner | `[0]`| `[0]` | `0` | +| Environment | Valid Modes | Valid Difficulties | Default Mode | +|-------------|-------------|--------------------|--------------| +| RoadRunner | `[0]` | `[0]` | `0` | You may use the suffix "-ram" to switch to the RAM observation space. In v0 and v4, the suffixes "Deterministic" and "NoFrameskip" are available. These are no longer supported in v5. In order to obtain equivalent behavior, pass keyword arguments to `gymnasium.make` as outlined in diff --git a/docs/environments/atari/robotank.md b/docs/environments/atari/robotank.md index 0179de9e1..833f51059 100644 --- a/docs/environments/atari/robotank.md +++ b/docs/environments/atari/robotank.md @@ -10,13 +10,13 @@ title: Robot Tank This environment is part of the Atari environments. Please read that page first for general information. -| | | -|---|---| -| Action Space | Discrete(18) | -| Observation Space | (210, 160, 3) | -| Observation High | 255 | -| Observation Low | 0 | -| Import | `gymnasium.make("ALE/Robotank-v0")` | +| | | +|-------------------|-------------------------------------| +| Action Space | Discrete(18) | +| Observation Space | (210, 160, 3) | +| Observation High | 255 | +| Observation Low | 0 | +| Import | `gymnasium.make("ALE/Robotank-v0")` | ### Description You control your Robot Tanks to destroy enemies and avoid enemy fire. @@ -74,9 +74,9 @@ The various ways to configure the environment are described in detail in the art It is possible to specify various flavors of the environment via the keyword arguments `difficulty` and `mode`. A flavor is a combination of a game mode and a difficulty setting. -| Environment | Valid Modes | Valid Difficulties | Default Mode | -|------------------|-------------------------|--------------------|--------------| -| Robotank | `[0]` | `[0]` | `0` | +| Environment | Valid Modes | Valid Difficulties | Default Mode | +|-------------|-------------|--------------------|--------------| +| Robotank | `[0]` | `[0]` | `0` | You may use the suffix "-ram" to switch to the RAM observation space. In v0 and v4, the suffixes "Deterministic" and "NoFrameskip" are available. These are no longer supported in v5. In order to obtain equivalent behavior, pass keyword arguments to `gymnasium.make` as outlined in diff --git a/docs/environments/atari/seaquest.md b/docs/environments/atari/seaquest.md index b5d63c8af..87043e151 100644 --- a/docs/environments/atari/seaquest.md +++ b/docs/environments/atari/seaquest.md @@ -10,13 +10,13 @@ title: Seaquest This environment is part of the Atari environments. Please read that page first for general information. -| | | -|---|---| -| Action Space | Discrete(18) | -| Observation Space | (210, 160, 3) | -| Observation High | 255 | -| Observation Low | 0 | -| Import | `gymnasium.make("ALE/Seaquest-v0")` | +| | | +|-------------------|-------------------------------------| +| Action Space | Discrete(18) | +| Observation Space | (210, 160, 3) | +| Observation High | 255 | +| Observation Low | 0 | +| Import | `gymnasium.make("ALE/Seaquest-v0")` | ### Description You control a sub able to move in all directions and fire torpedoes. @@ -84,9 +84,9 @@ The various ways to configure the environment are described in detail in the art It is possible to specify various flavors of the environment via the keyword arguments `difficulty` and `mode`. A flavor is a combination of a game mode and a difficulty setting. -| Environment | Valid Modes | Valid Difficulties | Default Mode | -|------------------|------------------------------|---------------|--------------| -| Seaquest | `[0]` | `[0, 1]` | `0` | +| Environment | Valid Modes | Valid Difficulties | Default Mode | +|-------------|-------------|--------------------|--------------| +| Seaquest | `[0]` | `[0, 1]` | `0` | You may use the suffix "-ram" to switch to the RAM observation space. In v0 and v4, the suffixes "Deterministic" and "NoFrameskip" are available. These are no longer supported in v5. In order to obtain equivalent behavior, pass keyword arguments to `gymnasium.make` as outlined in diff --git a/docs/environments/atari/skiing.md b/docs/environments/atari/skiing.md index 3c048ac3f..391022515 100644 --- a/docs/environments/atari/skiing.md +++ b/docs/environments/atari/skiing.md @@ -10,13 +10,13 @@ title: Skiing This environment is part of the Atari environments. Please read that page first for general information. -| | | -|---|---| -| Action Space | Discrete(18) | -| Observation Space | (210, 160, 3) | -| Observation High | 255 | -| Observation Low | 0 | -| Import | `gymnasium.make("ALE/Skiing-v0")` | +| | | +|-------------------|-----------------------------------| +| Action Space | Discrete(18) | +| Observation Space | (210, 160, 3) | +| Observation High | 255 | +| Observation Low | 0 | +| Import | `gymnasium.make("ALE/Skiing-v0")` | ### Description You control a skier who can move sideways. @@ -37,10 +37,10 @@ on the flavor of the environment (the combination of `mode` and `difficulty`). T flavor looks like this: | Num | Action | -|-----|------| -| 0 | NOOP | -| 1 | RIGHT | -| 2 | LEFT | +|-----|--------| +| 0 | NOOP | +| 1 | RIGHT | +| 2 | LEFT | ### Observations By default, the environment returns the RGB image that is displayed to human players as an observation. However, it is @@ -75,9 +75,9 @@ The various ways to configure the environment are described in detail in the art It is possible to specify various flavors of the environment via the keyword arguments `difficulty` and `mode`. A flavor is a combination of a game mode and a difficulty setting. -| Environment | Valid Modes | Valid Difficulties | Default Mode | -|------------------|------------------------------|---------------|--------------| -| Skiing | `[0]` | `[0]` | `0` | +| Environment | Valid Modes | Valid Difficulties | Default Mode | +|-------------|-------------|--------------------|--------------| +| Skiing | `[0]` | `[0]` | `0` | You may use the suffix "-ram" to switch to the RAM observation space. In v0 and v4, the suffixes "Deterministic" and "NoFrameskip" are available. These are no longer supported in v5. In order to obtain equivalent behavior, pass keyword arguments to `gymnasium.make` as outlined in diff --git a/docs/environments/atari/solaris.md b/docs/environments/atari/solaris.md index 420822a14..170b5c9bf 100644 --- a/docs/environments/atari/solaris.md +++ b/docs/environments/atari/solaris.md @@ -10,13 +10,13 @@ title: Solaris This environment is part of the Atari environments. Please read that page first for general information. -| | | -|---|---| -| Action Space | Discrete(18) | -| Observation Space | (210, 160, 3) | -| Observation High | 255 | -| Observation Low | 0 | -| Import | `gymnasium.make("ALE/Solaris-v5")` | +| | | +|-------------------|------------------------------------| +| Action Space | Discrete(18) | +| Observation Space | (210, 160, 3) | +| Observation High | 255 | +| Observation Low | 0 | +| Import | `gymnasium.make("ALE/Solaris-v5")` | ### Description You control a spaceship. Blast enemies before they can blast you. You can warp to different sectors. You have to defend Federation planets, and destroy Zylon forces. Keep track of your fuel, if you run out you lose a life. Warp to a Federation planet to refuel. The game ends if all your ships are destroyed or if you reach the Solaris planet. Detailed documentation can be found on [the AtariAge page](https://atariage.com/manual_html_page.php?SoftwareLabelID=450) @@ -56,9 +56,9 @@ The various ways to configure the environment are described in detail in the art It is possible to specify various flavors of the environment via the keyword arguments `difficulty` and `mode`. A flavor is a combination of a game mode and a difficulty setting. -| Environment | Valid Modes | Valid Difficulties | Default Mode | -|------------------|-------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------|--------------------|--------------| -| Solaris | `[0]` | `[0]` | `0` | +| Environment | Valid Modes | Valid Difficulties | Default Mode | +|-------------|-------------|--------------------|--------------| +| Solaris | `[0]` | `[0]` | `0` | You may use the suffix "-ram" to switch to the RAM observation space. In v0 and v4, the suffixes "Deterministic" and "NoFrameskip" are available. These are no longer supported in v5. In order to obtain equivalent behavior, pass keyword arguments to `gymnasium.make` as outlined in diff --git a/docs/environments/atari/space_invaders.md b/docs/environments/atari/space_invaders.md index 646ed36c8..990662673 100644 --- a/docs/environments/atari/space_invaders.md +++ b/docs/environments/atari/space_invaders.md @@ -10,13 +10,13 @@ title: SpaceInvaders This environment is part of the Atari environments. Please read that page first for general information. -| | | -|---|---| -| Action Space | Discrete(18) | -| Observation Space | (210, 160, 3) | -| Observation High | 255 | -| Observation Low | 0 | -| Import | `gymnasium.make("ALE/SpaceInvaders-v5")` | +| | | +|-------------------|------------------------------------------| +| Action Space | Discrete(18) | +| Observation Space | (210, 160, 3) | +| Observation High | 255 | +| Observation Low | 0 | +| Import | `gymnasium.make("ALE/SpaceInvaders-v5")` | ### Description @@ -28,14 +28,14 @@ However, if you use v0 or v4 or specify `full_action_space=False` during initial number of actions (those that are meaningful in this game) are available. The reduced action space may depend on the flavor of the environment (the combination of `mode` and `difficulty`). The reduced action space for the default flavor looks like this: -| Num | Action | -|-----|------------------------| -| 0 | NOOP | -| 1 | FIRE | -| 2 | RIGHT | -| 3 | LEFT | +| Num | Action | +|-----|-----------| +| 0 | NOOP | +| 1 | FIRE | +| 2 | RIGHT | +| 3 | LEFT | | 4 | RIGHTFIRE | -| 5 | LEFTFIRE | +| 5 | LEFTFIRE | ### Observations @@ -69,9 +69,9 @@ The various ways to configure the environment are described in detail in the art It is possible to specify various flavors of the environment via the keyword arguments `difficulty` and `mode`. A flavor is a combination of a game mode and a difficulty setting. -| Environment | Valid Modes | Valid Difficulties | Default Mode | -|------------------|-------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------|--------------------|--------------| -| SpaceInvaders | `[0, ..., 15]` | `[0, 1]` | `0` | +| Environment | Valid Modes | Valid Difficulties | Default Mode | +|---------------|----------------|--------------------|--------------| +| SpaceInvaders | `[0, ..., 15]` | `[0, 1]` | `0` | You may use the suffix "-ram" to switch to the RAM observation space. In v0 and v4, the suffixes "Deterministic" and "NoFrameskip" are available. These are no longer supported in v5. In order to obtain equivalent behavior, pass keyword arguments to `gymnasium.make` as outlined in diff --git a/docs/environments/atari/star_gunner.md b/docs/environments/atari/star_gunner.md index 8267d2877..9e79ee051 100644 --- a/docs/environments/atari/star_gunner.md +++ b/docs/environments/atari/star_gunner.md @@ -10,13 +10,13 @@ title: StarGunner This environment is part of the Atari environments. Please read that page first for general information. -| | | -|---|---| -| Action Space | Discrete(18) | -| Observation Space | (210, 160, 3) | -| Observation High | 255 | -| Observation Low | 0 | -| Import | `gymnasium.make("ALE/StarGunner-v5")` | +| | | +|-------------------|---------------------------------------| +| Action Space | Discrete(18) | +| Observation Space | (210, 160, 3) | +| Observation High | 255 | +| Observation Low | 0 | +| Import | `gymnasium.make("ALE/StarGunner-v5")` | ### Description @@ -28,14 +28,14 @@ However, if you use v0 or v4 or specify `full_action_space=False` during initial number of actions (those that are meaningful in this game) are available. The reduced action space may depend on the flavor of the environment (the combination of `mode` and `difficulty`). The reduced action space for the default flavor looks like this: -| Num | Action | -|-----|------------------------| -| 0 | NOOP | -| 1 | FIRE | -| 2 | UP | -| 3 | RIGHT | -| 4 | LEFT | -| 5 | DOWN | +| Num | Action | +|-----|--------| +| 0 | NOOP | +| 1 | FIRE | +| 2 | UP | +| 3 | RIGHT | +| 4 | LEFT | +| 5 | DOWN | ### Observations @@ -70,9 +70,9 @@ The various ways to configure the environment are described in detail in the art It is possible to specify various flavors of the environment via the keyword arguments `difficulty` and `mode`. A flavor is a combination of a game mode and a difficulty setting. -| Environment | Valid Modes | Valid Difficulties | Default Mode | -|------------------|-------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------|--------------------|--------------| -| StarGunner | `[0, ..., 3]` | `[0]` | `0` | +| Environment | Valid Modes | Valid Difficulties | Default Mode | +|-------------|---------------|--------------------|--------------| +| StarGunner | `[0, ..., 3]` | `[0]` | `0` | You may use the suffix "-ram" to switch to the RAM observation space. In v0 and v4, the suffixes "Deterministic" and "NoFrameskip" are available. These are no longer supported in v5. In order to obtain equivalent behavior, pass keyword arguments to `gymnasium.make` as outlined in diff --git a/docs/environments/atari/tennis.md b/docs/environments/atari/tennis.md index bb635d7f3..cd99bb8a5 100644 --- a/docs/environments/atari/tennis.md +++ b/docs/environments/atari/tennis.md @@ -10,13 +10,13 @@ title: Tennis This environment is part of the Atari environments. Please read that page first for general information. -| | | -|---|---| -| Action Space | Discrete(18) | -| Observation Space | (210, 160, 3) | -| Observation High | 255 | -| Observation Low | 0 | -| Import | `gymnasium.make("ALE/Tennis-v5")` | +| | | +|-------------------|-----------------------------------| +| Action Space | Discrete(18) | +| Observation Space | (210, 160, 3) | +| Observation High | 255 | +| Observation Low | 0 | +| Import | `gymnasium.make("ALE/Tennis-v5")` | ### Description @@ -59,9 +59,9 @@ The various ways to configure the environment are described in detail in the art It is possible to specify various flavors of the environment via the keyword arguments `difficulty` and `mode`. A flavor is a combination of a game mode and a difficulty setting. -| Environment | Valid Modes | Valid Difficulties | Default Mode | -|------------------|-------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------|--------------------|--------------| -| Tennis | `[0, 2]` | `[0, ..., 3]` | `0` | +| Environment | Valid Modes | Valid Difficulties | Default Mode | +|-------------|-------------|--------------------|--------------| +| Tennis | `[0, 2]` | `[0, ..., 3]` | `0` | You may use the suffix "-ram" to switch to the RAM observation space. In v0 and v4, the suffixes "Deterministic" and "NoFrameskip" are available. These are no longer supported in v5. In order to obtain equivalent behavior, pass keyword arguments to `gymnasium.make` as outlined in diff --git a/docs/environments/atari/time_pilot.md b/docs/environments/atari/time_pilot.md index 48c63d906..5533df106 100644 --- a/docs/environments/atari/time_pilot.md +++ b/docs/environments/atari/time_pilot.md @@ -10,13 +10,13 @@ title: TimePilot This environment is part of the Atari environments. Please read that page first for general information. -| | | -|---|---| -| Action Space | Discrete(18) | -| Observation Space | (210, 160, 3) | -| Observation High | 255 | -| Observation Low | 0 | -| Import | `gymnasium.make("ALE/TimePilot-v5")` | +| | | +|-------------------|--------------------------------------| +| Action Space | Discrete(18) | +| Observation Space | (210, 160, 3) | +| Observation High | 255 | +| Observation Low | 0 | +| Import | `gymnasium.make("ALE/TimePilot-v5")` | ### Description @@ -28,18 +28,18 @@ However, if you use v0 or v4 or specify `full_action_space=False` during initial number of actions (those that are meaningful in this game) are available. The reduced action space may depend on the flavor of the environment (the combination of `mode` and `difficulty`). The reduced action space for the default flavor looks like this: -| Num | Action | -|-----|------------------------| -| 0 | NOOP | -| 1 | FIRE | -| 2 | UP | -| 3 | RIGHT | -| 4 | LEFT | -| 5 | DOWN | -| 6 | UPFIRE | +| Num | Action | +|-----|-----------| +| 0 | NOOP | +| 1 | FIRE | +| 2 | UP | +| 3 | RIGHT | +| 4 | LEFT | +| 5 | DOWN | +| 6 | UPFIRE | | 7 | RIGHTFIRE | -| 8 | LEFTFIRE | -| 9 | DOWNFIRE | +| 8 | LEFTFIRE | +| 9 | DOWNFIRE | ### Observations @@ -75,9 +75,9 @@ The various ways to configure the environment are described in detail in the art It is possible to specify various flavors of the environment via the keyword arguments `difficulty` and `mode`. A flavor is a combination of a game mode and a difficulty setting. -| Environment | Valid Modes | Valid Difficulties | Default Mode | -|------------------|-------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------|--------------------|--------------| -| TimePilot | `[0]` | `[0, 1, 2]` | `0` | +| Environment | Valid Modes | Valid Difficulties | Default Mode | +|-------------|-------------|--------------------|--------------| +| TimePilot | `[0]` | `[0, 1, 2]` | `0` | You may use the suffix "-ram" to switch to the RAM observation space. In v0 and v4, the suffixes "Deterministic" and "NoFrameskip" are available. These are no longer supported in v5. In order to obtain equivalent behavior, pass keyword arguments to `gymnasium.make` as outlined in the general article on Atari environments. diff --git a/docs/environments/atari/tutankham.md b/docs/environments/atari/tutankham.md index dabeaef5d..ca17f3910 100644 --- a/docs/environments/atari/tutankham.md +++ b/docs/environments/atari/tutankham.md @@ -10,13 +10,13 @@ title: Tutankham This environment is part of the Atari environments. Please read that page first for general information. -| | | -|---|---| -| Action Space | Discrete(18) | -| Observation Space | (210, 160, 3) | -| Observation High | 255 | -| Observation Low | 0 | -| Import | `gymnasium.make("ALE/Tutankham-v5")` | +| | | +|-------------------|--------------------------------------| +| Action Space | Discrete(18) | +| Observation Space | (210, 160, 3) | +| Observation High | 255 | +| Observation Low | 0 | +| Import | `gymnasium.make("ALE/Tutankham-v5")` | ### Description Your goal is to rack up points by finding treasures in the mazes of the tomb while eliminating its guardians. Detailed documentation can be found on [the AtariAge page](https://atariage.com/manual_thumbs.php?SoftwareLabelID=572). @@ -24,16 +24,16 @@ Your goal is to rack up points by finding treasures in the mazes of the tomb whi ### Actions By default, all actions that can be performed on an Atari 2600 are available in this environment. However, if you use v0 or v4 or specify full_action_space=False during initialization, only a reduced number of actions (those that are meaningful in this game) are available. The reduced action space may depend on the flavor of the environment (the combination of mode and difficulty). The reduced action space for the default flavor looks like this: -| Num | Action | -|-----|------------------------| -| 0 | NOOP | -| 1 | UP | -| 2 | RIGHT | -| 3 | LEFT | -| 4 | DOWN | -| 5 | UPFIRE | +| Num | Action | +|-----|-----------| +| 0 | NOOP | +| 1 | UP | +| 2 | RIGHT | +| 3 | LEFT | +| 4 | DOWN | +| 5 | UPFIRE | | 6 | RIGHTFIRE | -| 7 | LEFTFIRE | +| 7 | LEFTFIRE | ### Observations By default, the environment returns the RGB image that is displayed to human players as an observation. However, it is @@ -61,9 +61,9 @@ env = gymnasium.make("ALE/Tutankham-v5") The various ways to configure the environment are described in detail in the article on Atari environments. -| Environment | Valid Modes | Valid Difficulties | Default Mode | -|------------------|-------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------|--------------------|--------------| -| Tutankham | `[0]` | `[0]` | `0` | +| Environment | Valid Modes | Valid Difficulties | Default Mode | +|-------------|-------------|--------------------|--------------| +| Tutankham | `[0]` | `[0]` | `0` | You may use the suffix "-ram" to switch to the RAM observation space. In v0 and v4, the suffixes "Deterministic" and "Noframeskip" are available. These are no longer supported in v5. In order to obtain equivalent behavior, pass keyword arguments to `gymnasium.make` as outlined in diff --git a/docs/environments/atari/up_n_down.md b/docs/environments/atari/up_n_down.md index bf5376581..9454349e6 100644 --- a/docs/environments/atari/up_n_down.md +++ b/docs/environments/atari/up_n_down.md @@ -10,13 +10,13 @@ title: Up n' Down This environment is part of the Atari environments. Please read that page first for general information. -| | | -|---|---| -| Action Space | Discrete(18) | -| Observation Space | (210, 160, 3) | -| Observation High | 255 | -| Observation Low | 0 | -| Import | `gymnasium.make("ALE/UpNDown-v5")` | +| | | +|-------------------|------------------------------------| +| Action Space | Discrete(18) | +| Observation Space | (210, 160, 3) | +| Observation High | 255 | +| Observation Low | 0 | +| Import | `gymnasium.make("ALE/UpNDown-v5")` | ### Description Your goal is to steer your baja bugger to collect prizes and eliminate opponents. Detailed documentation can be found on [the AtariAge page](https://atariage.com/manual_html_page.php?SoftwareLabelID=574). @@ -24,13 +24,13 @@ Your goal is to steer your baja bugger to collect prizes and eliminate opponents ### Actions By default, all actions that can be performed on an Atari 2600 are available in this environment. However, if you use v0 or v4 or specify full_action_space=False during initialization, only a reduced number of actions (those that are meaningful in this game) are available. The reduced action space may depend on the flavor of the environment (the combination of mode and difficulty). The reduced action space for the default flavor looks like this: -| Num | Action | -|-----|------------------------| -| 0 | NOOP | -| 1 | FIRE | -| 2 | UP | -| 3 | DOWN | -| 4 | UPFIRE | +| Num | Action | +|-----|----------| +| 0 | NOOP | +| 1 | FIRE | +| 2 | UP | +| 3 | DOWN | +| 4 | UPFIRE | | 5 | DOWNFIRE | ### Observations @@ -60,9 +60,9 @@ The various ways to configure the environment are described in detail in the art It is possible to specify various flavors of the environment via the keyword arguments `difficulty` and `mode`. A flavor is a combination of a game mode and a difficulty setting. -| Environment | Valid Modes | Valid Difficulties | Default Mode | -|------------------|-------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------|--------------------|--------------| -| UpNDown | `[0]` | `[0, ..., 3]` | `0` | +| Environment | Valid Modes | Valid Difficulties | Default Mode | +|-------------|-------------|--------------------|--------------| +| UpNDown | `[0]` | `[0, ..., 3]` | `0` | You may use the suffix "-ram" to switch to the RAM observation space. In v0 and v4, the suffixes "Deterministic" and "Noframeskip" are available. These are no longer supported in v5. In order to obtain equivalent behavior, pass keyword arguments to `gymnasium.make` as outlined in diff --git a/docs/environments/atari/venture.md b/docs/environments/atari/venture.md index 970c56fa9..8beb523ef 100644 --- a/docs/environments/atari/venture.md +++ b/docs/environments/atari/venture.md @@ -10,13 +10,13 @@ title: Venture This environment is part of the Atari environments. Please read that page first for general information. -| | | -|---|---| -| Action Space | Discrete(18) | -| Observation Space | (210, 160, 3) | -| Observation High | 255 | -| Observation Low | 0 | -| Import | `gymnasium.make("ALE/Venture-v5")` | +| | | +|-------------------|------------------------------------| +| Action Space | Discrete(18) | +| Observation Space | (210, 160, 3) | +| Observation High | 255 | +| Observation Low | 0 | +| Import | `gymnasium.make("ALE/Venture-v5")` | ### Description Your goal is to capture the treasure in every chamber of the dungeon while eliminating the monsters. Detailed documentation can be found on [the AtariAge page](https://atariage.com/manual_html_page.php?SoftwareLabelID=576). @@ -52,9 +52,9 @@ The various ways to configure the environment are described in detail in the art It is possible to specify various flavors of the environment via the keyword arguments `difficulty` and `mode`. A flavor is a combination of a game mode and a difficulty setting. -| Environment | Valid Modes | Valid Difficulties | Default Mode | -|------------------|-------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------|--------------------|--------------| -| Venture | `[0]` | `[0, ..., 3]` | `0` | +| Environment | Valid Modes | Valid Difficulties | Default Mode | +|-------------|-------------|--------------------|--------------| +| Venture | `[0]` | `[0, ..., 3]` | `0` | You may use the suffix "-ram" to switch to the RAM observation space. In v0 and v4, the suffixes "Deterministic" and "Noframeskip" are available. These are no longer supported in v5. In order to obtain equivalent behavior, pass keyword arguments to `gymnasium.make` as outlined in diff --git a/docs/environments/atari/video_pinball.md b/docs/environments/atari/video_pinball.md index e1364d905..e588a1ff0 100644 --- a/docs/environments/atari/video_pinball.md +++ b/docs/environments/atari/video_pinball.md @@ -10,13 +10,13 @@ title: Video Pinball This environment is part of the Atari environments. Please read that page first for general information. -| | | -|---|---| -| Action Space | Discrete(18) | -| Observation Space | (210, 160, 3) | -| Observation High | 255 | -| Observation Low | 0 | -| Import | `gymnasium.make("ALE/VideoPinball-v5")` | +| | | +|-------------------|-----------------------------------------| +| Action Space | Discrete(18) | +| Observation Space | (210, 160, 3) | +| Observation High | 255 | +| Observation Low | 0 | +| Import | `gymnasium.make("ALE/VideoPinball-v5")` | ### Description Your goal is to keep the ball in play as long as possible and to score as many points as possible. Detailed documentation can be found on [the AtariAge page](https://atariage.com/manual_html_page.php?SoftwareLabelID=588). @@ -24,17 +24,17 @@ Your goal is to keep the ball in play as long as possible and to score as many p ### Actions By default, all actions that can be performed on an Atari 2600 are available in this environment. However, if you use v0 or v4 or specify full_action_space=False during initialization, only a reduced number of actions (those that are meaningful in this game) are available. The reduced action space may depend on the flavor of the environment (the combination of mode and difficulty). The reduced action space for the default flavor looks like this: -| Num | Action | -|-----|------------------------| -| 0 | NOOP | -| 1 | FIRE | -| 2 | UP | -| 3 | RIGHT | -| 4 | LEFT | -| 5 | DOWN | -| 6 | UPFIRE | +| Num | Action | +|-----|-----------| +| 0 | NOOP | +| 1 | FIRE | +| 2 | UP | +| 3 | RIGHT | +| 4 | LEFT | +| 5 | DOWN | +| 6 | UPFIRE | | 7 | RIGHTFIRE | -| 8 | LEFTFIRE | +| 8 | LEFTFIRE | ### Observations By default, the environment returns the RGB image that is displayed to human players as an observation. However, it is @@ -64,9 +64,9 @@ The various ways to configure the environment are described in detail in the art It is possible to specify various flavors of the environment via the keyword arguments `difficulty` and `mode`. A flavor is a combination of a game mode and a difficulty setting. -| Environment | Valid Modes | Valid Difficulties | Default Mode | -|------------------|-------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------|--------------------|--------------| -| VideoPinball | `[0, ..., 2]` | `[0, 1]` | `0` | +| Environment | Valid Modes | Valid Difficulties | Default Mode | +|--------------|---------------|--------------------|--------------| +| VideoPinball | `[0, ..., 2]` | `[0, 1]` | `0` | You may use the suffix "-ram" to switch to the RAM observation space. In v0 and v4, the suffixes "Deterministic" and "Noframeskip" are available. These are no longer supported in v5. In order to obtain equivalent behavior, pass keyword arguments to `gymnasium.make` as outlined in diff --git a/docs/environments/atari/wizard_of_wor.md b/docs/environments/atari/wizard_of_wor.md index 05e189b8a..91a828ea4 100644 --- a/docs/environments/atari/wizard_of_wor.md +++ b/docs/environments/atari/wizard_of_wor.md @@ -10,13 +10,13 @@ title: Wizard of Wor This environment is part of the Atari environments. Please read that page first for general information. -| | | -|---|---| -| Action Space | Discrete(18) | -| Observation Space | (210, 160, 3) | -| Observation High | 255 | -| Observation Low | 0 | -| Import | `gymnasium.make("ALE/WizardOfWor-v5")` | +| | | +|-------------------|----------------------------------------| +| Action Space | Discrete(18) | +| Observation Space | (210, 160, 3) | +| Observation High | 255 | +| Observation Low | 0 | +| Import | `gymnasium.make("ALE/WizardOfWor-v5")` | ### Description Your goal is to beat the Wizard using your laser and radar scanner. Detailed documentation can be found on [the AtariAge page](https://atariage.com/manual_html_page.php?SoftwareLabelID=598). @@ -24,18 +24,18 @@ Your goal is to beat the Wizard using your laser and radar scanner. Detailed doc ### Actions By default, all actions that can be performed on an Atari 2600 are available in this environment. However, if you use v0 or v4 or specify full_action_space=False during initialization, only a reduced number of actions (those that are meaningful in this game) are available. The reduced action space may depend on the flavor of the environment (the combination of mode and difficulty). The reduced action space for the default flavor looks like this: -| Num | Action | -|-----|------------------------| -| 0 | NOOP | -| 1 | FIRE | -| 2 | UP | -| 3 | RIGHT | -| 4 | LEFT | -| 5 | DOWN | -| 6 | UPFIRE | +| Num | Action | +|-----|-----------| +| 0 | NOOP | +| 1 | FIRE | +| 2 | UP | +| 3 | RIGHT | +| 4 | LEFT | +| 5 | DOWN | +| 6 | UPFIRE | | 7 | RIGHTFIRE | -| 8 | LEFTFIRE | -| 9 | DOWNFIRE | +| 8 | LEFTFIRE | +| 9 | DOWNFIRE | ### Observations By default, the environment returns the RGB image that is displayed to human players as an observation. However, it is @@ -65,9 +65,9 @@ The various ways to configure the environment are described in detail in the art It is possible to specify various flavors of the environment via the keyword arguments `difficulty` and `mode`. A flavor is a combination of a game mode and a difficulty setting. -| Environment | Valid Modes | Valid Difficulties | Default Mode | -|------------------|-------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------|--------------------|--------------| -| VideoPinball | `[0]` | `[0, 1]` | `0` | +| Environment | Valid Modes | Valid Difficulties | Default Mode | +|--------------|-------------|--------------------|--------------| +| VideoPinball | `[0]` | `[0, 1]` | `0` | You may use the suffix "-ram" to switch to the RAM observation space. In v0 and v4, the suffixes "Deterministic" and "Noframeskip" are available. These are no longer supported in v5. In order to obtain equivalent behavior, pass keyword arguments to `gymnasium.make` as outlined in diff --git a/docs/environments/atari/zaxxon.md b/docs/environments/atari/zaxxon.md index ac1e52c99..411209006 100644 --- a/docs/environments/atari/zaxxon.md +++ b/docs/environments/atari/zaxxon.md @@ -11,13 +11,13 @@ lastpage: This environment is part of the Atari environments. Please read that page first for general information. -| | | -|---|---| -| Action Space | Discrete(18) | -| Observation Space | (210, 160, 3) | -| Observation High | 255 | -| Observation Low | 0 | -| Import | `gymnasium.make("ALE/Zaxxon-v5")` | +| | | +|-------------------|-----------------------------------| +| Action Space | Discrete(18) | +| Observation Space | (210, 160, 3) | +| Observation High | 255 | +| Observation Low | 0 | +| Import | `gymnasium.make("ALE/Zaxxon-v5")` | ### Description Your goal is to stop the evil robot Zaxxon and its armies from enslaving the galaxy by piloting your fighter and shooting enemies. Detailed documentation can be found on [the AtariAge page](https://atariage.com/manual_html_page.php?SoftwareLabelID=606). @@ -51,9 +51,9 @@ env = gymnasium.make("ALE/Zaxxon-v5") The various ways to configure the environment are described in detail in the article on Atari environments. -| Environment | Valid Modes | Valid Difficulties | Default Mode | -|------------------|-------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------|--------------------|--------------| -| Zaxxon | `[0]` | `[0]` | `0` | +| Environment | Valid Modes | Valid Difficulties | Default Mode | +|-------------|-------------|--------------------|--------------| +| Zaxxon | `[0]` | `[0]` | `0` | You may use the suffix "-ram" to switch to the RAM observation space. In v0 and v4, the suffixes "Deterministic" and "Noframeskip" are available. These are no longer supported in v5. In order to obtain equivalent behavior, pass keyword arguments to `gymnasium.make` as outlined in diff --git a/docs/index.md b/docs/index.md index 7f0c60cd5..227e331e2 100644 --- a/docs/index.md +++ b/docs/index.md @@ -16,8 +16,8 @@ lastpage: ```{code-block} python -import gymnasium -env = gymnasium.make("LunarLander-v2", render_mode="human") +import gymnasium as gym +env = gym.make("LunarLander-v2", render_mode="human") observation, info = env.reset(seed=42) for _ in range(1000): action = policy(observation) # User-defined policy function