gaspersic/Gymnasium
1
0
Fork 0
mirror of https://github.com/Farama-Foundation/Gymnasium.git synced 2025-07-31 13:54:31 +00:00
Code Issues Packages Projects Releases Wiki Activity

Rename gymnasium as gym in docs (#24)

Browse Source
This commit is contained in:
Mark Towers
2022-09-19 21:14:09 +01:00
committed by GitHub
parent 5674a52d4c
commit c9056e37e1
68 changed files with 1134 additions and 1131 deletions
Download Patch File Download Diff File Expand all files Collapse all files

9
docs/api/vector.md
View File

@@ -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
{}

68
docs/api/wrappers.md
View File

@@ -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. |

13
docs/content/basic_usage.md
View File

@@ -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}

12
docs/content/environment_creation.md
View File

@@ -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], {}
```

116
docs/content/vectorising.md
View File

@@ -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')
```

18
docs/environments/atari/adventure.md
View File

@@ -12,12 +12,12 @@ firstpage:
This environment is part of the <a href='..'>Atari environments</a>. 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

34
docs/environments/atari/air_raid.md
View File

@@ -11,13 +11,13 @@ title: Air Raid
This environment is part of the <a href='..'>Atari environments</a>. 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

20
docs/environments/atari/alien.md
View File

@@ -11,13 +11,13 @@ title: Alien
This environment is part of the <a href='..'>Atari environments</a>. 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"

42
docs/environments/atari/amidar.md
View File

@@ -11,13 +11,13 @@ title: Amidar
This environment is part of the <a href='..'>Atari environments</a>. 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

36
docs/environments/atari/assault.md
View File

@@ -10,13 +10,13 @@ title: Assault
This environment is part of the <a href='..'>Atari environments</a>. 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"

40
docs/environments/atari/asterix.md
View File

@@ -10,13 +10,13 @@ title: Asterix
This environment is part of the <a href='..'>Atari environments</a>. 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"

28
docs/environments/atari/asteroids.md
View File

@@ -10,13 +10,13 @@ title: Asteroids
This environment is part of the <a href='..'>Atari environments</a>. 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

20
docs/environments/atari/atlantis.md
View File

@@ -11,13 +11,13 @@ title: Atlantis
This environment is part of the <a href='..'>Atari environments</a>. 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

20
docs/environments/atari/bank_heist.md
View File

@@ -10,13 +10,13 @@ title: Bank Heist
This environment is part of the <a href='..'>Atari environments</a>. 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

20
docs/environments/atari/battle_zone.md
View File

@@ -11,13 +11,13 @@ title: Battle Zone
This environment is part of the <a href='..'>Atari environments</a>. 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

20
docs/environments/atari/beam_rider.md
View File

@@ -17,13 +17,13 @@ grid:
This environment is part of the <a href='..'>Atari environments</a>. 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

20
docs/environments/atari/berzerk.md
View File

@@ -10,13 +10,13 @@ title: Berzerk
This environment is part of the <a href='..'>Atari environments</a>. 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

20
docs/environments/atari/bowling.md
View File

@@ -10,13 +10,13 @@ title: Bowling
This environment is part of the <a href='..'>Atari environments</a>. 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

20
docs/environments/atari/boxing.md
View File

@@ -10,13 +10,13 @@ title: Boxing
This environment is part of the <a href='..'>Atari environments</a>. 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

32
docs/environments/atari/breakout.md
View File

@@ -10,13 +10,13 @@ title: Breakout
This environment is part of the <a href='..'>Atari environments</a>. 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

20
docs/environments/atari/carnival.md
View File

@@ -10,13 +10,13 @@ title: Carnival
This environment is part of the <a href='..'>Atari environments</a>. 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

20
docs/environments/atari/centipede.md
View File

@@ -10,13 +10,13 @@ title: Centipede
This environment is part of the <a href='..'>Atari environments</a>. 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

20
docs/environments/atari/chopper_command.md
View File

@@ -10,13 +10,13 @@ title: Chopper Command
This environment is part of the <a href='..'>Atari environments</a>. 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

40
docs/environments/atari/crazy_climber.md
View File

@@ -10,13 +10,13 @@ title: Crazy Climber
This environment is part of the <a href='..'>Atari environments</a>. 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

18
docs/environments/atari/defender.md
View File

@@ -11,12 +11,12 @@ title: Defender
This environment is part of the <a href='..'>Atari environments</a>. 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

40
docs/environments/atari/demon_attack.md
View File

@@ -10,13 +10,13 @@ title: Demon Attack
This environment is part of the <a href='..'>Atari environments</a>. 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

40
docs/environments/atari/double_dunk.md
View File

@@ -10,13 +10,13 @@ title: Double Dunk
This environment is part of the <a href='..'>Atari environments</a>. 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

40
docs/environments/atari/elevator_action.md
View File

@@ -10,13 +10,13 @@ title: Elevator Action
This environment is part of the <a href='..'>Atari environments</a>. 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

40
docs/environments/atari/enduro.md
View File

@@ -10,13 +10,13 @@ title: Enduro
This environment is part of the <a href='..'>Atari environments</a>. 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

70
docs/environments/atari/fishing_derby.md
View File

@@ -10,13 +10,13 @@ title: FishingDerby
This environment is part of the <a href='..'>Atari environments</a>. 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.

61
docs/environments/atari/freeway.md
View File

@@ -10,13 +10,13 @@ title: Freeway
This environment is part of the <a href='..'>Atari environments</a>. 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` |

71
docs/environments/atari/frostbite.md
View File

@@ -10,13 +10,13 @@ title: Frostbite
This environment is part of the <a href='..'>Atari environments</a>. 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.

71
docs/environments/atari/gopher.md
View File

@@ -10,13 +10,13 @@ title: Gopher
This environment is part of the <a href='..'>Atari environments</a>. 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.

71
docs/environments/atari/gravitar.md
View File

@@ -10,13 +10,13 @@ title: Gravitar
This environment is part of the <a href='..'>Atari environments</a>. 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.

18
docs/environments/atari/hero.md
View File

@@ -11,12 +11,12 @@ title: Hero
This environment is part of the <a href='..'>Atari environments</a>. 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

20
docs/environments/atari/ice_hockey.md
View File

@@ -10,13 +10,13 @@ title: IceHockey
This environment is part of the <a href='..'>Atari environments</a>. 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

74
docs/environments/atari/index.md
View File

@@ -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

20
docs/environments/atari/jamesbond.md
View File

@@ -10,13 +10,13 @@ title: Jamesbond
This environment is part of the <a href='..'>Atari environments</a>. 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

53
docs/environments/atari/journey_escape.md
View File

@@ -10,13 +10,13 @@ title: JourneyEscape
This environment is part of the <a href='..'>Atari environments</a>. 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

20
docs/environments/atari/kangaroo.md
View File

@@ -10,13 +10,13 @@ title: Kangaroo
This environment is part of the <a href='..'>Atari environments</a>. 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

20
docs/environments/atari/krull.md
View File

@@ -10,13 +10,13 @@ title: Krull
This environment is part of the <a href='..'>Atari environments</a>. 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

52
docs/environments/atari/kung_fu_master.md
View File

@@ -10,13 +10,13 @@ title: Kung Fu Master
This environment is part of the <a href='..'>Atari environments</a>. 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

20
docs/environments/atari/montezuma_revenge.md
View File

@@ -10,13 +10,13 @@ title: Montezuma Revenge
This environment is part of the <a href='..'>Atari environments</a>. 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

40
docs/environments/atari/ms_pacman.md
View File

@@ -10,13 +10,13 @@ title: Ms Pacman
This environment is part of the <a href='..'>Atari environments</a>. 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

34
docs/environments/atari/name_this_game.md
View File

@@ -10,13 +10,13 @@ title: Name This Game
This environment is part of the <a href='..'>Atari environments</a>. 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

38
docs/environments/atari/phoenix.md
View File

@@ -10,13 +10,13 @@ title: Phoenix
This environment is part of the <a href='..'>Atari environments</a>. 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

20
docs/environments/atari/pitfall.md
View File

@@ -10,13 +10,13 @@ title: Pitfall
This environment is part of the <a href='..'>Atari environments</a>. 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

34
docs/environments/atari/pong.md
View File

@@ -10,13 +10,13 @@ title: Pong
This environment is part of the <a href='..'>Atari environments</a>. 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

36
docs/environments/atari/pooyan.md
View File

@@ -10,13 +10,13 @@ title: Pooyan
This environment is part of the <a href='..'>Atari environments</a>. 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

20
docs/environments/atari/private_eye.md
View File

@@ -10,13 +10,13 @@ title: PrivateEye
This environment is part of the <a href='..'>Atari environments</a>. 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

36
docs/environments/atari/qbert.md
View File

@@ -10,13 +10,13 @@ title: Qbert
This environment is part of the <a href='..'>Atari environments</a>. 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

30
docs/environments/atari/riverraid.md
View File

@@ -10,13 +10,13 @@ title: Riverraid
This environment is part of the <a href='..'>Atari environments</a>. 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

32
docs/environments/atari/road_runner.md
View File

@@ -10,13 +10,13 @@ title: Road Runner
This environment is part of the <a href='..'>Atari environments</a>. 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

20
docs/environments/atari/robotank.md
View File

@@ -10,13 +10,13 @@ title: Robot Tank
This environment is part of the <a href='..'>Atari environments</a>. 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

20
docs/environments/atari/seaquest.md
View File

@@ -10,13 +10,13 @@ title: Seaquest
This environment is part of the <a href='..'>Atari environments</a>. 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

28
docs/environments/atari/skiing.md
View File

@@ -10,13 +10,13 @@ title: Skiing
This environment is part of the <a href='..'>Atari environments</a>. 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

20
docs/environments/atari/solaris.md
View File

@@ -10,13 +10,13 @@ title: Solaris
This environment is part of the <a href='..'>Atari environments</a>. 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

34
docs/environments/atari/space_invaders.md
View File

@@ -10,13 +10,13 @@ title: SpaceInvaders
This environment is part of the <a href='..'>Atari environments</a>. 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

36
docs/environments/atari/star_gunner.md
View File

@@ -10,13 +10,13 @@ title: StarGunner
This environment is part of the <a href='..'>Atari environments</a>. 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

20
docs/environments/atari/tennis.md
View File

@@ -10,13 +10,13 @@ title: Tennis
This environment is part of the <a href='..'>Atari environments</a>. 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

42
docs/environments/atari/time_pilot.md
View File

@@ -10,13 +10,13 @@ title: TimePilot
This environment is part of the <a href='..'>Atari environments</a>. 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.

38
docs/environments/atari/tutankham.md
View File

@@ -10,13 +10,13 @@ title: Tutankham
This environment is part of the <a href='..'>Atari environments</a>. 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

34
docs/environments/atari/up_n_down.md
View File

@@ -10,13 +10,13 @@ title: Up n' Down
This environment is part of the <a href='..'>Atari environments</a>. 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

20
docs/environments/atari/venture.md
View File

@@ -10,13 +10,13 @@ title: Venture
This environment is part of the <a href='..'>Atari environments</a>. 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

40
docs/environments/atari/video_pinball.md
View File

@@ -10,13 +10,13 @@ title: Video Pinball
This environment is part of the <a href='..'>Atari environments</a>. 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

42
docs/environments/atari/wizard_of_wor.md
View File

@@ -10,13 +10,13 @@ title: Wizard of Wor
This environment is part of the <a href='..'>Atari environments</a>. 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

20
docs/environments/atari/zaxxon.md
View File

@@ -11,13 +11,13 @@ lastpage:
This environment is part of the <a href='..'>Atari environments</a>. 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

4
docs/index.md
View File

@@ -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