Skip to content

schola.core.spaces.box.BoxSpace

Class Definition

class schola.core.spaces.box.BoxSpace(low, high, shape=None)

Bases: Box, UnrealSpace

A Space representing a box in n-dimensional space.

See also:

  • gymnasium.spaces.Box – The gym space object that this class is analogous to
  • proto_spaces.BoxSpace – The protobuf representation of this space

Parameters

low

Type: Union[float, np.ndarray, List[float]]
The lower bounds of the box.

high

Type: Union[float, np.ndarray, List[float]]
The upper bounds of the box.

shape

Type: Tuple[int], optional
The shape of the space.

Attributes

shape

Type: Tuple[int]
The shape of the space. Has stricter type than gym.Space - never None.

is_np_flattenable

Checks whether this space can be flattened to aspaces.Box.

np_random

Lazily seed the PRNG since this is expensive and only needed if sampling from this space.

proto_space

Alias ofBoxSpace

Methods

__init__

__init__(low, high, shape=None)

Constructor of Box.

The argument low specifies the lower bound of each dimension and high specifies the upper bounds. I.e., the space that is constructed will be the product of the intervals [low[i], high[i]].

If low (or high) is a scalar, the lower bound (or upper bound, respectively) will be assumed to be this value across all dimensions.

Parameters:

  • low (SupportsFloat | np.ndarray) – Lower bounds of the intervals. If integer, must be at least -2**63
  • high (SupportsFloat | np.ndarray) – Upper bounds of the intervals. If integer, must be at most 2**63 - 2
  • shape (Optional[Sequence[int]]) – The shape is inferred from the shape of low or high np.ndarrays with low and high scalars defaulting to a shape of (1,)
  • dtype – The dtype of the elements of the space. If this is an integer type, the Box is essentially a discrete space
  • seed – Optionally, you can use this argument to seed the RNG that is used to sample from the space

Raises: ValueError – If no shape information is provided (shape is None, low is None and high is None) then a value error is raised.

contains

contains(x)

Return boolean specifying if x is a valid member of this space.

fill_proto

fill_proto(msg, values)

Convert a python representation of point in this space to a protobuf message. Mutates msg with the result.

Parameters:

  • msg (proto_points.FundamentalPoint) – The protobuf message to fill
  • value (Any) – The pythonic representation of the point

from_jsonable

from_jsonable(sample_n)

Convert a JSONable data type to a batch of samples from this space.

from_proto

@classmethod
from_proto(message)

Create a Space Object from a protobuf representation.

Parameters:

  • message (proto_space) – The protobuf message to convert

Returns: The Space subclass created from the protobuf message

Return type: UnrealSpace

is_bounded

is_bounded(manner="both")

Checks whether the box is bounded in some sense.

is_empty_definition

@classmethod
is_empty_definition(message)

Returns True iff this space has magnitude 0.

Parameters:

  • message (proto_space) – The protobuf message to check for emptiness

Returns: True iff the space is empty.

Return type: bool

merge

@classmethod
merge(*spaces)

Merge multiple BoxSpaces into a single space.

Parameters:

  • *spaces (List[BoxSpace]) – The spaces to merge

Returns: The merged space.

Return type: BoxSpace

Raises: TypeError – If any of the spaces are not BoxSpaces.

Example:

>>> merged_space = BoxSpace.merge(BoxSpace([0,0],[1,1]), BoxSpace([2,2],[3,3]))
>>> merged_space == BoxSpace([0, 0, 2, 2], [1, 1, 3, 3])
True

process_data

process_data(msg)

Convert a protobuf message corresponding to a point in this space to a pythonic representation.

Parameters:

  • msg (proto_points.FundamentalPoint) – The protobuf message to convert

Returns: The pythonic representation of the point.

Return type: np.ndarray

sample

sample(mask=None)

Generates a single random sample inside the Box.

seed

seed(seed=None)

Seed the PRNG of this space and possibly the PRNGs of subspaces.

to_jsonable

to_jsonable(sample_n)

Convert a batch of samples from this space to a JSONable data type.

to_normalized

to_normalized()

Normalize the bounds of the space to be between 0 and 1.

Returns: The normalized space. A modified version of the space this method is called on

Return type: BoxSpace

Example:

>>> space = BoxSpace([0, 0],[2, 2])
>>> space.to_normalized() == BoxSpace([0., 0.], [1., 1.])
True