actor

Source code: tianshou/highlevel/module/actor.py

---

class ActorFactory

abstract create_module(envs: Environments, device: str | device) → BaseActor | Module

create_module_opt(envs: Environments, device: str | device, optim_factory: OptimizerFactory, lr: float) → ModuleOpt

Creates the actor module along with its optimizer for the given learning rate.

Parameters:

• envs – the environments

• device – the torch device

• optim_factory – the optimizer factory

• lr – the learning rate

Returns:

a container with the actor module and its optimizer

class ActorFactoryContinuous

Serves as a type bound for actor factories that are suitable for continuous action spaces.

class ActorFactoryContinuousDeterministicNet(hidden_sizes: ~collections.abc.Sequence[int], activation: type[~torch.nn.modules.module.Module] = <class 'torch.nn.modules.activation.ReLU'>)

create_module(envs: Environments, device: str | device) → BaseActor

class ActorFactoryContinuousGaussianNet(hidden_sizes: ~collections.abc.Sequence[int], unbounded: bool = True, conditioned_sigma: bool = False, activation: type[~torch.nn.modules.module.Module] = <class 'torch.nn.modules.activation.ReLU'>)

create_module(envs: Environments, device: str | device) → BaseActor

class ActorFactoryDefault(continuous_actor_type: ~tianshou.highlevel.module.actor.ContinuousActorType, hidden_sizes: ~collections.abc.Sequence[int] = (64, 64), hidden_activation: type[~torch.nn.modules.module.Module] = <class 'torch.nn.modules.activation.ReLU'>, continuous_unbounded: bool = False, continuous_conditioned_sigma: bool = False, discrete_softmax: bool = True)

An actor factory which, depending on the type of environment, creates a suitable MLP-based policy.

DEFAULT_HIDDEN_SIZES = (64, 64)

create_module(envs: Environments, device: str | device) → BaseActor

class ActorFactoryDiscreteNet(hidden_sizes: ~collections.abc.Sequence[int], softmax_output: bool = True, activation: type[~torch.nn.modules.module.Module] = <class 'torch.nn.modules.activation.ReLU'>)

create_module(envs: Environments, device: str | device) → BaseActor

class ActorFactoryTransientStorageDecorator(actor_factory: ActorFactory, actor_future: ActorFuture)

Wraps an actor factory, storing the most recently created actor instance such that it can be retrieved.

create_module(envs: Environments, device: str | device) → BaseActor | Module

class ActorFuture(actor: BaseActor | Module | None = None)

Container, which, in the future, will hold an actor instance.

actor: BaseActor | Module | None = None

class ActorFutureProviderProtocol(*args, **kwargs)

get_actor_future() → ActorFuture

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

DETERMINISTIC = 'deterministic'

GAUSSIAN = 'gaussian'

UNSUPPORTED = 'unsupported'

class IntermediateModuleFactoryFromActorFactory(actor_factory: ActorFactory)

create_intermediate_module(envs: Environments, device: str | device) → IntermediateModule