复合空间¶

一个包含 :class:Space 实例的字典。

此空间中的元素是来自组成空间的元素的（有序）字典。

示例

>>> from gymnasium.spaces import Dict, Box, Discrete
>>> observation_space = Dict({"position": Box(-1, 1, shape=(2,)), "color": Discrete(3)}, seed=42)
>>> observation_space.sample()
{'color': 0, 'position': array([-0.3991573 ,  0.21649833], dtype=float32)}

使用嵌套字典：

>>> from gymnasium.spaces import Box, Dict, Discrete, MultiBinary, MultiDiscrete
>>> Dict(  
...     {
...         "ext_controller": MultiDiscrete([5, 2, 2]),
...         "inner_state": Dict(
...             {
...                 "charge": Discrete(100),
...                 "system_checks": MultiBinary(10),
...                 "job_status": Dict(
...                     {
...                         "task": Discrete(5),
...                         "progress": Box(low=0, high=100, shape=()),
...                     }
...                 ),
...             }
...         ),
...     }
... )

如果你想让复杂的观察或动作更具可读性，使用 :class:Dict 空间可能会很方便。通常情况下，将无法直接在学习代码中使用此空间的元素。然而，你可以通过使用 :class:gymnasium.wrappers.FlattenObservation 包装器轻松地将 :class:Dict 观察转换为扁平数组。类似的包装器可以实现来处理 :class:Dict 动作。

参数:

spaces – 空间的字典。这指定了 :class:Dict 空间的结构
seed – 可选地，您可以使用此参数来为构成 :class:Dict 空间的各个空间种子的随机数生成器（RNGs）。
**spaces_kwargs – 如果 spaces 是 None，你需要像上面描述的那样，将构成的空间作为关键字参数传递。

sample(mask: dict[str, Any] | None = None) → dict[str, Any][源代码]¶

从此空间生成一个随机样本。

样本是从组成空间中独立抽取的有序字典。

参数:: mask – 每个子空间的可选掩码，期望与空间相同的键
返回:: 一个字典，键相同，值从 :attr:self.spaces 中采样

seed(seed: int | dict[str, Any] | None = None) → dict[str, int][源代码]¶

为这个空间及其所有子空间播种PRNG。

根据种子的类型，子空间将以不同的方式播种。

None - 所有子空间将使用一个随机的初始种子
Int - 整数用于为 :class:Dict 空间播种，该空间用于为每个子空间生成种子值。警告，这并不能保证所有子空间都有唯一的种子，尽管这种情况非常不可能发生。
Dict - 每个子空间的种子字典，要求每个子空间都有一个种子键。这支持多个复合子空间的种子设定（Dict["space": Dict[...], ...] 对应 {"space": {...}, ...}）。

参数:: seed – 一个可选的整数或子空间键到整数的字典，用于为每个PRNG设置种子。更多详情请参见上文。
返回:: 子空间种子值的字典

class gymnasium.spaces.Tuple(spaces: Iterable[Space[Any]], seed: int | Sequence[int] | Generator | None = None)[源代码]¶

一个 :class:Space 实例的元组（更准确地说：笛卡尔积）。

此空间的元素是构成空间的元素的元组。

示例

>>> from gymnasium.spaces import Tuple, Box, Discrete
>>> observation_space = Tuple((Discrete(2), Box(-1, 1, shape=(2,))), seed=42)
>>> observation_space.sample()
(0, array([-0.3991573 ,  0.21649833], dtype=float32))

参数:

spaces (Iterable[Space]) – 参与笛卡尔积的空间。
seed – 可选地，您可以使用此参数来为 spaces 的随机数生成器 (RNGs) 设定种子，以确保采样的可重复性。

sample(mask: tuple[Any | None, ...] | None = None) → tuple[Any, ...][源代码]¶

在此空间内生成一个随机样本。

此方法从子空间中抽取独立样本。

参数:: mask – 每个子空间样本的可选掩码的可选元组，期望掩码数量与空间数量相同
返回:: 子空间的样本元组

seed(seed: int | tuple[int] | None = None) → tuple[int, ...][源代码]¶

为这个空间及其所有子空间播种PRNG。

根据种子的类型，子空间将以不同的方式播种。

None - 所有子空间将使用一个随机的初始种子
Int - 整数用于为 :class:Tuple 空间设定种子，该空间用于为每个子空间生成种子值。警告：这不能保证所有子空间都有唯一的种子。
List - 用于初始化子空间的值。这允许初始化多个复合子空间 [42, 54, ...]。

参数:: seed – 一个可选的整数列表或整数，用于为（子）空间设定种子。
返回:: 所有子空间的种子值元组

class gymnasium.spaces.Sequence(space: Space[Any], seed: int | Generator | None = None, stack: bool = False)[源代码]¶

这个空间表示有限长度序列的集合。

此空间表示形式为 :math:(a_0, \dots, a_n) 的元组集合，其中 :math:a_i 属于在初始化时指定的某个空间，而整数 :math:n 不是固定的。

示例

>>> from gymnasium.spaces import Sequence, Box
>>> observation_space = Sequence(Box(0, 1), seed=0)
>>> observation_space.sample()
(array([0.6822636], dtype=float32), array([0.18933342], dtype=float32), array([0.19049619], dtype=float32))
>>> observation_space.sample()
(array([0.83506], dtype=float32), array([0.9053838], dtype=float32), array([0.5836242], dtype=float32), array([0.63214064], dtype=float32))

带有堆叠观测的示例

>>> observation_space = Sequence(Box(0, 1), stack=True, seed=0)
>>> observation_space.sample()
array([[0.6822636 ],
       [0.18933342],
       [0.19049619]], dtype=float32)

参数:

space – 此空间中序列的元素必须属于此空间。
seed – 可选地，您可以使用此参数来初始化用于从空间中采样的随机数生成器。
stack – 如果 True ，则生成的样本将被堆叠。

sample(mask: None | tuple[None | integer | ndarray[Any, dtype[integer]], Any] = None) → tuple[Any] | Any[源代码]¶

从此空间生成一个随机样本。

参数:: mask – 一个可选的掩码，用于（可选地）序列的长度和（可选地）序列中的值。如果你指定 mask，它应该是一个形式为 (length_mask, sample_mask) 的元组，其中 length_mask 可以是 * None 长度将从几何分布中随机抽取 * np.ndarray 的整数数组，在这种情况下，采样序列的长度从该数组中随机抽取。 * int 用于固定长度的样本元组 mask 的第二个元素 sample_mask 指定了一个掩码，该掩码在从基础空间采样元素时应用。掩码应用于每个特征空间样本。
返回:: 一个随机长度的元组，包含从 :attr:特征空间 中随机抽取的元素样本。

seed(seed: int | tuple[int, int] | None = None) → tuple[int, int][源代码]¶

初始化序列空间和特征空间的伪随机数生成器。

根据种子的类型，子空间将以不同的方式播种。

None - 所有子空间将使用一个随机的初始种子
Int - 整数用于为 :class:Sequence 空间播种，该空间用于为特征空间生成种子值。
Tuple of ints - 用于 :class:Sequence 和特征空间的元组。

参数:: seed – 一个可选的整数或整数元组，用于为PRNG设置种子。更多详情见上文。
返回:: 序列和特征空间的种子值元组

一个空间，表示为一系列 节点 通过 边 连接，根据邻接矩阵表示为一系列 边链接。

示例

>>> from gymnasium.spaces import Graph, Box, Discrete
>>> observation_space = Graph(node_space=Box(low=-100, high=100, shape=(3,)), edge_space=Discrete(3), seed=123)
>>> observation_space.sample(num_nodes=4, num_edges=8)
GraphInstance(nodes=array([[ 36.47037 , -89.235794, -55.928024],
       [-63.125637, -64.81882 ,  62.4189  ],
       [ 84.669   , -44.68512 ,  63.950912],
       [ 77.97854 ,   2.594091, -51.00708 ]], dtype=float32), edges=array([2, 0, 2, 1, 2, 0, 2, 1]), edge_links=array([[3, 0],
       [0, 0],
       [0, 1],
       [0, 2],
       [1, 0],
       [1, 0],
       [0, 1],
       [0, 2]], dtype=int32))

参数:

node_space (Union[Box, Discrete]) – 节点特征的空间。
edge_space (Union[None, Box, Discrete]) – 边缘特征的空间。
seed – 可选地，您可以使用此参数来初始化用于从空间中采样的随机数生成器。

生成一个单一样本图，节点数在 1 到 10 之间，从图中采样。

参数:

mask – 一个可选的节点和边掩码元组，这仅在离散空间中可能（Box空间不支持样本掩码）。如果没有提供 num_edges，那么 edge_mask 将与边数相乘。
num_nodes – 将要采样的节点数量，默认是 10 个节点
num_edges – 可选的边数，否则，一个介于 0 和 :math:num_nodes^2 之间的随机数

返回:

一个具有属性 .nodes、.edges 和 .edge_links 的 :class:GraphInstance。

seed(seed: int | tuple[int, int] | tuple[int, int, int] | None = None) → tuple[int, int] | tuple[int, int, int][源代码]¶

为这个空间和节点/边子空间的PRNG播种。

根据种子的类型，子空间将以不同的方式播种。

None - 根、节点和边空间的PRNG是随机初始化的
Int - 整数用于为 :class:Graph 空间播种，该空间用于为节点和边子空间生成种子值。
Tuple[int, int] - 用特定值为 :class:Graph 和节点子空间设定种子。仅当边子空间未指定时。
Tuple[int, int, int] - 使用特定值为 :class:Graph 、节点和边子空间播种。

参数:: seed – 此空间和节点/边子空间的可选整数或整数元组。有关更多详细信息，请参见上文。
返回:: 一个由两个或三个整数组成的元组，取决于是否指定了边缘子空间。

class gymnasium.spaces.OneOf(spaces: Iterable[Space[Any]], seed: int | Sequence[int] | Generator | None = None)[源代码]¶

一个独占的元组（更准确地说：直接和）的 :class:空间 实例。

此空间中的元素是构成空间之一的元素。

示例

>>> from gymnasium.spaces import OneOf, Box, Discrete
>>> observation_space = OneOf((Discrete(2), Box(-1, 1, shape=(2,))), seed=123)
>>> observation_space.sample()  # the first element is the space index (Box in this case) and the second element is the sample from Box
(0, 0)
>>> observation_space.sample()  # this time the Discrete space was sampled as index=0
(1, array([-0.00711833, -0.7257502 ], dtype=float32))
>>> observation_space[0]
Discrete(2)
>>> observation_space[1]
Box(-1.0, 1.0, (2,), float32)
>>> len(observation_space)
2

参数:

spaces (Iterable[Space]) – 参与笛卡尔积的空间。
seed – 可选地，您可以使用此参数来为 spaces 的随机数生成器 (RNGs) 设定种子，以确保采样的可重复性。

sample(mask: tuple[Any | None, ...] | None = None) → tuple[int, Any][源代码]¶

在此空间内生成一个随机样本。

此方法从子空间中抽取独立样本。

参数:: mask – 每个子空间样本的可选掩码的可选元组，期望掩码数量与空间数量相同
返回:: 子空间的样本元组

seed(seed: int | tuple[int, ...] | None = None) → tuple[int, ...][源代码]¶

为这个空间及其所有子空间播种PRNG。

根据种子的类型，子空间将以不同的方式播种。

None - 所有子空间将使用一个随机的初始种子
Int - 整数用于为 :class:Tuple 空间设定种子，该空间用于为每个子空间生成种子值。警告：这不能保证所有子空间都有唯一的种子。
Tuple[int, ...] - 用于种子子空间的值，第一个值种子OneOf，后续值种子子空间。这允许种子多个复合子空间 [42, 54, ...]。

参数:: seed – 一个可选的整数或整数的元组，用于为 OneOf 空间及其子空间设定种子。更多详情请参见上文。
返回:: 用于为 OneOf 空间及其子空间设定种子的整数元组