env

Source code: tianshou/highlevel/env.py

---

class ContinuousEnvironments(env: Env, train_envs: BaseVectorEnv, test_envs: BaseVectorEnv)

Represents (vectorized) continuous environments.

static from_factory(factory_fn: Callable[[], Env], venv_type: VectorEnvType, num_training_envs: int, num_test_envs: int) → ContinuousEnvironments

Creates an instance from a factory function that creates a single instance.

Parameters:

• factory_fn – the factory for a single environment instance

• venv_type – the vector environment type to use for parallelization

• num_training_envs – the number of training environments to create

• num_test_envs – the number of test environments to create

Returns:

the instance

get_action_shape() → collections.abc.Sequence[int] | int

get_observation_shape() → int | collections.abc.Sequence[int]

get_type() → EnvType

info() → dict[str, Any]

class DiscreteEnvironments(env: Env, train_envs: BaseVectorEnv, test_envs: BaseVectorEnv)

Represents (vectorized) discrete environments.

static from_factory(factory_fn: Callable[[], Env], venv_type: VectorEnvType, num_training_envs: int, num_test_envs: int) → DiscreteEnvironments

Creates an instance from a factory function that creates a single instance.

Parameters:

• factory_fn – the factory for a single environment instance

• venv_type – the vector environment type to use for parallelization

• num_training_envs – the number of training environments to create

• num_test_envs – the number of test environments to create

Returns:

the instance

get_action_shape() → collections.abc.Sequence[int] | int

get_observation_shape() → int | collections.abc.Sequence[int]

get_type() → EnvType

class EnvFactory

abstract create_envs(num_training_envs: int, num_test_envs: int) → Environments

class EnvType(value, names=None, *, module=None, qualname=None, type=None, start=1, boundary=None)

Enumeration of environment types.

CONTINUOUS = 'continuous'

DISCRETE = 'discrete'

assert_continuous(requiring_entity: Any) → None

assert_discrete(requiring_entity: Any) → None

is_continuous() → bool

is_discrete() → bool

class Environments(env: Env, train_envs: BaseVectorEnv, test_envs: BaseVectorEnv)

Represents (vectorized) environments.

static from_factory_and_type(factory_fn: Callable[[], Env], env_type: EnvType, venv_type: VectorEnvType, num_training_envs: int, num_test_envs: int) → Environments

Creates a suitable subtype instance from a factory function that creates a single instance and the type of environment (continuous/discrete).

Parameters:

• factory_fn – the factory for a single environment instance

• env_type – the type of environments created by factory_fn

• venv_type – the vector environment type to use for parallelization

• num_training_envs – the number of training environments to create

• num_test_envs – the number of test environments to create

Returns:

the instance

abstract get_action_shape() → collections.abc.Sequence[int] | int

get_action_space() → Space

abstract get_observation_shape() → int | collections.abc.Sequence[int]

get_observation_space() → Space

abstract get_type() → EnvType

info() → dict[str, Any]

set_persistence(*p: Persistence) → None

Associates the given persistence handlers which may persist and restore environment-specific information.

Parameters:

p – persistence handlers

class VectorEnvType(value, names=None, *, module=None, qualname=None, type=None, start=1, boundary=None)

DUMMY = 'dummy'

Vectorized environment without parallelization; environments are processed sequentially

RAY = 'ray'

Parallelization based on the ray library

SUBPROC = 'subproc'

Parallelization based on subprocess

SUBPROC_SHARED_MEM = 'shmem'

Parallelization based on subprocess with shared memory

create_venv(factories: list[collections.abc.Callable[[], gymnasium.core.Env]]) → BaseVectorEnv