openrl.runners.common package

Submodules

openrl.runners.common.a2c_agent module

class openrl.runners.common.a2c_agent.A2CAgent(net: Optional[Union[torch.nn.modules.module.Module, openrl.modules.common.base_net.BaseNet]] = None, env: Union[gym.core.Env, str] = None, run_dir: Optional[str] = None, env_num: Optional[int] = None, rank: int = 0, world_size: int = 1, use_wandb: bool = False, use_tensorboard: bool = False, project_name: str = 'GAILAgent')

Bases: openrl.runners.common.ppo_agent.PPOAgent

train(total_time_steps: int, callback: Union[None, Callable, List[openrl.utils.callbacks.callbacks.BaseCallback], openrl.utils.callbacks.callbacks.BaseCallback] = None, train_algo_class: Type[openrl.algorithms.base_algorithm.BaseAlgorithm] = <class 'openrl.algorithms.a2c.A2CAlgorithm'>, logger: Optional[openrl.utils.logger.Logger] = None, driver_class: Type[openrl.drivers.base_driver.BaseDriver] = <class 'openrl.drivers.onpolicy_driver.OnPolicyDriver'>) → None

openrl.runners.common.base_agent module

class openrl.runners.common.base_agent.BaseAgent

Bases: abc.ABC

get_env() → Optional[openrl.envs.vec_env.base_venv.BaseVecEnv]

Returns the current environment (can be None if not defined).

Returns

The current environment

abstract load(path: Union[str, pathlib.Path, io.BufferedIOBase])

property logger: openrl.utils.logger.Logger

Getter for the logger object.

abstract save(path: Union[str, pathlib.Path, io.BufferedIOBase]) → None

openrl.runners.common.bc_agent module

class openrl.runners.common.bc_agent.BCAgent(net: Optional[Union[torch.nn.modules.module.Module, openrl.modules.common.base_net.BaseNet]] = None, env: Union[gym.core.Env, str] = None, run_dir: Optional[str] = None, env_num: Optional[int] = None, rank: int = 0, world_size: int = 1, use_wandb: bool = False, use_tensorboard: bool = False, project_name: str = 'GAILAgent')

Bases: openrl.runners.common.ppo_agent.PPOAgent

train(total_time_steps: int, callback: Union[None, Callable, List[openrl.utils.callbacks.callbacks.BaseCallback], openrl.utils.callbacks.callbacks.BaseCallback] = None, train_algo_class: Type[openrl.algorithms.base_algorithm.BaseAlgorithm] = <class 'openrl.algorithms.behavior_cloning.BCAlgorithm'>, logger: Optional[openrl.utils.logger.Logger] = None, driver_class: Type[openrl.drivers.base_driver.BaseDriver] = <class 'openrl.drivers.offline_driver.OfflineDriver'>) → None

openrl.runners.common.chat_agent module

class openrl.runners.common.chat_agent.Chat6BAgent(model, tokenizer, device=None)

Bases: openrl.runners.common.chat_agent.ChatAgent

chat(input: str, history: List[str])

classmethod load(agent_path: Union[str, pathlib.Path, io.BufferedIOBase], device='cuda:0') → openrl.runners.common.base_agent.SelfAgent

class openrl.runners.common.chat_agent.ChatAgent(model, tokenizer, device=None)

Bases: openrl.runners.common.base_agent.BaseAgent

chat(input: str, history: List[str])

classmethod load(agent_path: Union[str, pathlib.Path, io.BufferedIOBase], tokenizer: Optional[Union[str, pathlib.Path, io.BufferedIOBase]] = None, disable_cuda: Optional[bool] = True) → openrl.runners.common.base_agent.SelfAgent

save(path: Union[str, pathlib.Path, io.BufferedIOBase]) → None

openrl.runners.common.ddpg_agent module

class openrl.runners.common.ddpg_agent.DDPGAgent(net: Optional[torch.nn.modules.module.Module] = None, env: Union[gym.core.Env, str] = None, run_dir: Optional[str] = None, env_num: Optional[int] = None, rank: int = 0, world_size: int = 1, use_wandb: bool = False, use_tensorboard: bool = False)

Bases: openrl.runners.common.rl_agent.RLAgent

act(observation: Union[numpy.ndarray, Dict[str, numpy.ndarray]], deterministic: bool) → Tuple[numpy.ndarray, Optional[Tuple[numpy.ndarray, ...]]]

train(total_time_steps: int, callback: Union[None, Callable, List[openrl.utils.callbacks.callbacks.BaseCallback], openrl.utils.callbacks.callbacks.BaseCallback] = None, train_algo_class: Type[openrl.algorithms.base_algorithm.BaseAlgorithm] = <class 'openrl.algorithms.ddpg.DDPGAlgorithm'>, logger: Optional[openrl.utils.logger.Logger] = None) → None

openrl.runners.common.dqn_agent module

class openrl.runners.common.dqn_agent.DQNAgent(net: Optional[torch.nn.modules.module.Module] = None, env: Union[gym.core.Env, str] = None, run_dir: Optional[str] = None, env_num: Optional[int] = None, rank: int = 0, world_size: int = 1, use_wandb: bool = False, use_tensorboard: bool = False)

Bases: openrl.runners.common.rl_agent.RLAgent

act(observation: Union[numpy.ndarray, Dict[str, numpy.ndarray]], deterministic: bool = True) → Tuple[numpy.ndarray, Optional[Tuple[numpy.ndarray, ...]]]

train(total_time_steps: int, callback: Union[None, Callable, List[openrl.utils.callbacks.callbacks.BaseCallback], openrl.utils.callbacks.callbacks.BaseCallback] = None, train_algo_class: Type[openrl.algorithms.base_algorithm.BaseAlgorithm] = <class 'openrl.algorithms.dqn.DQNAlgorithm'>, logger: Optional[openrl.utils.logger.Logger] = None) → None

openrl.runners.common.gail_agent module

class openrl.runners.common.gail_agent.GAILAgent(net: Optional[Union[torch.nn.modules.module.Module, openrl.modules.common.base_net.BaseNet]] = None, env: Union[gym.core.Env, str] = None, run_dir: Optional[str] = None, env_num: Optional[int] = None, rank: int = 0, world_size: int = 1, use_wandb: bool = False, use_tensorboard: bool = False, project_name: str = 'GAILAgent')

Bases: openrl.runners.common.ppo_agent.PPOAgent

train(total_time_steps: int, callback: Union[None, Callable, List[openrl.utils.callbacks.callbacks.BaseCallback], openrl.utils.callbacks.callbacks.BaseCallback] = None, train_algo_class: Type[openrl.algorithms.base_algorithm.BaseAlgorithm] = <class 'openrl.algorithms.gail.GAILAlgorithm'>, logger: Optional[openrl.utils.logger.Logger] = None) → None

openrl.runners.common.mat_agent module

class openrl.runners.common.mat_agent.MATAgent(net: Optional[Union[torch.nn.modules.module.Module, openrl.modules.common.base_net.BaseNet]] = None, env: Union[gym.core.Env, str] = None, run_dir: Optional[str] = None, env_num: Optional[int] = None, rank: int = 0, world_size: int = 1, use_wandb: bool = False, use_tensorboard: bool = False, project_name: str = 'PPOAgent')

Bases: openrl.runners.common.ppo_agent.PPOAgent

train(total_time_steps: int, train_algo_class: Type[openrl.algorithms.base_algorithm.BaseAlgorithm] = <class 'openrl.algorithms.mat.MATAlgorithm'>) → None

openrl.runners.common.ppo_agent module

class openrl.runners.common.ppo_agent.PPOAgent(net: Optional[Union[torch.nn.modules.module.Module, openrl.modules.common.base_net.BaseNet]] = None, env: Union[gym.core.Env, str] = None, run_dir: Optional[str] = None, env_num: Optional[int] = None, rank: int = 0, world_size: int = 1, use_wandb: bool = False, use_tensorboard: bool = False, project_name: str = 'PPOAgent')

Bases: openrl.runners.common.rl_agent.RLAgent

act(observation: Union[numpy.ndarray, Dict[str, numpy.ndarray]], info: Optional[List[Dict[str, Any]]] = None, deterministic: bool = True, episode_starts: Optional[numpy.ndarray] = None) → Tuple[numpy.ndarray, Optional[Tuple[numpy.ndarray, ...]]]

train(total_time_steps: int, callback: Union[None, Callable, List[openrl.utils.callbacks.callbacks.BaseCallback], openrl.utils.callbacks.callbacks.BaseCallback] = None, train_algo_class: Type[openrl.algorithms.base_algorithm.BaseAlgorithm] = <class 'openrl.algorithms.ppo.PPOAlgorithm'>, logger: Optional[openrl.utils.logger.Logger] = None, driver_class: Type[openrl.drivers.base_driver.BaseDriver] = <class 'openrl.drivers.onpolicy_driver.OnPolicyDriver'>) → None

openrl.runners.common.rl_agent module

class openrl.runners.common.rl_agent.RLAgent(net: Optional[Union[torch.nn.modules.module.Module, openrl.modules.common.base_net.BaseNet]] = None, env: Union[gym.core.Env, str] = None, run_dir: Optional[str] = None, env_num: Optional[int] = None, rank: int = 0, world_size: int = 1, use_wandb: bool = False, use_tensorboard: bool = False, project_name: str = 'RLAgent')

Bases: openrl.runners.common.base_agent.BaseAgent

abstract act(**kwargs) → None

load(path: Union[str, pathlib.Path, io.BufferedIOBase]) → None

load_policy(path: Union[str, pathlib.Path, io.BufferedIOBase]) → None

reset()

save(path: Union[str, pathlib.Path, io.BufferedIOBase]) → None

set_env(env: Union[gym.core.Env, str])

abstract train(total_time_steps: int, callback: Union[None, Callable, List[openrl.utils.callbacks.callbacks.BaseCallback], openrl.utils.callbacks.callbacks.BaseCallback] = None) → None

openrl.runners.common.sac_agent module

class openrl.runners.common.sac_agent.SACAgent(net: Optional[torch.nn.modules.module.Module] = None, env: Union[gym.core.Env, str] = None, run_dir: Optional[str] = None, env_num: Optional[int] = None, rank: int = 0, world_size: int = 1, use_wandb: bool = False, use_tensorboard: bool = False, project_name: str = 'SACAgent')

Bases: openrl.runners.common.rl_agent.RLAgent

act(observation: Union[numpy.ndarray, Dict[str, numpy.ndarray]], deterministic=True) → Tuple[numpy.ndarray, Optional[Tuple[numpy.ndarray, ...]]]

train(total_time_steps: int, callback: Union[None, Callable, List[openrl.utils.callbacks.callbacks.BaseCallback], openrl.utils.callbacks.callbacks.BaseCallback] = None, train_algo_class: Type[openrl.algorithms.base_algorithm.BaseAlgorithm] = <class 'openrl.algorithms.sac.SACAlgorithm'>, logger: Optional[openrl.utils.logger.Logger] = None, driver_class: Type[openrl.drivers.base_driver.BaseDriver] = <class 'openrl.drivers.offpolicy_driver.OffPolicyDriver'>) → None

openrl.runners.common.vdn_agent module

class openrl.runners.common.vdn_agent.VDNAgent(net: Optional[torch.nn.modules.module.Module] = None, env: Union[gym.core.Env, str] = None, run_dir: Optional[str] = None, env_num: Optional[int] = None, rank: int = 0, world_size: int = 1, use_wandb: bool = False, use_tensorboard: bool = False)

Bases: openrl.runners.common.rl_agent.RLAgent

act(observation: Union[numpy.ndarray, Dict[str, numpy.ndarray]], deterministic=None) → Tuple[numpy.ndarray, Optional[Tuple[numpy.ndarray, ...]]]

train(total_time_steps: int, callback: Union[None, Callable, List[openrl.utils.callbacks.callbacks.BaseCallback], openrl.utils.callbacks.callbacks.BaseCallback] = None, train_algo_class: Type[openrl.algorithms.base_algorithm.BaseAlgorithm] = <class 'openrl.algorithms.vdn.VDNAlgorithm'>, logger: Optional[openrl.utils.logger.Logger] = None) → None

Module contents

class openrl.runners.common.A2CAgent(net: Optional[Union[torch.nn.modules.module.Module, openrl.modules.common.base_net.BaseNet]] = None, env: Union[gym.core.Env, str] = None, run_dir: Optional[str] = None, env_num: Optional[int] = None, rank: int = 0, world_size: int = 1, use_wandb: bool = False, use_tensorboard: bool = False, project_name: str = 'GAILAgent')

Bases: openrl.runners.common.ppo_agent.PPOAgent

train(total_time_steps: int, callback: Union[None, Callable, List[openrl.utils.callbacks.callbacks.BaseCallback], openrl.utils.callbacks.callbacks.BaseCallback] = None, train_algo_class: Type[openrl.algorithms.base_algorithm.BaseAlgorithm] = <class 'openrl.algorithms.a2c.A2CAlgorithm'>, logger: Optional[openrl.utils.logger.Logger] = None, driver_class: Type[openrl.drivers.base_driver.BaseDriver] = <class 'openrl.drivers.onpolicy_driver.OnPolicyDriver'>) → None

class openrl.runners.common.BCAgent(net: Optional[Union[torch.nn.modules.module.Module, openrl.modules.common.base_net.BaseNet]] = None, env: Union[gym.core.Env, str] = None, run_dir: Optional[str] = None, env_num: Optional[int] = None, rank: int = 0, world_size: int = 1, use_wandb: bool = False, use_tensorboard: bool = False, project_name: str = 'GAILAgent')

Bases: openrl.runners.common.ppo_agent.PPOAgent

train(total_time_steps: int, callback: Union[None, Callable, List[openrl.utils.callbacks.callbacks.BaseCallback], openrl.utils.callbacks.callbacks.BaseCallback] = None, train_algo_class: Type[openrl.algorithms.base_algorithm.BaseAlgorithm] = <class 'openrl.algorithms.behavior_cloning.BCAlgorithm'>, logger: Optional[openrl.utils.logger.Logger] = None, driver_class: Type[openrl.drivers.base_driver.BaseDriver] = <class 'openrl.drivers.offline_driver.OfflineDriver'>) → None

class openrl.runners.common.Chat6BAgent(model, tokenizer, device=None)

Bases: openrl.runners.common.chat_agent.ChatAgent

chat(input: str, history: List[str])

classmethod load(agent_path: Union[str, pathlib.Path, io.BufferedIOBase], device='cuda:0') → openrl.runners.common.base_agent.SelfAgent

class openrl.runners.common.ChatAgent(model, tokenizer, device=None)

Bases: openrl.runners.common.base_agent.BaseAgent

chat(input: str, history: List[str])

classmethod load(agent_path: Union[str, pathlib.Path, io.BufferedIOBase], tokenizer: Optional[Union[str, pathlib.Path, io.BufferedIOBase]] = None, disable_cuda: Optional[bool] = True) → openrl.runners.common.base_agent.SelfAgent

save(path: Union[str, pathlib.Path, io.BufferedIOBase]) → None

class openrl.runners.common.DDPGAgent(net: Optional[torch.nn.modules.module.Module] = None, env: Union[gym.core.Env, str] = None, run_dir: Optional[str] = None, env_num: Optional[int] = None, rank: int = 0, world_size: int = 1, use_wandb: bool = False, use_tensorboard: bool = False)

Bases: openrl.runners.common.rl_agent.RLAgent

act(observation: Union[numpy.ndarray, Dict[str, numpy.ndarray]], deterministic: bool) → Tuple[numpy.ndarray, Optional[Tuple[numpy.ndarray, ...]]]

train(total_time_steps: int, callback: Union[None, Callable, List[openrl.utils.callbacks.callbacks.BaseCallback], openrl.utils.callbacks.callbacks.BaseCallback] = None, train_algo_class: Type[openrl.algorithms.base_algorithm.BaseAlgorithm] = <class 'openrl.algorithms.ddpg.DDPGAlgorithm'>, logger: Optional[openrl.utils.logger.Logger] = None) → None

class openrl.runners.common.DQNAgent(net: Optional[torch.nn.modules.module.Module] = None, env: Union[gym.core.Env, str] = None, run_dir: Optional[str] = None, env_num: Optional[int] = None, rank: int = 0, world_size: int = 1, use_wandb: bool = False, use_tensorboard: bool = False)

Bases: openrl.runners.common.rl_agent.RLAgent

act(observation: Union[numpy.ndarray, Dict[str, numpy.ndarray]], deterministic: bool = True) → Tuple[numpy.ndarray, Optional[Tuple[numpy.ndarray, ...]]]

train(total_time_steps: int, callback: Union[None, Callable, List[openrl.utils.callbacks.callbacks.BaseCallback], openrl.utils.callbacks.callbacks.BaseCallback] = None, train_algo_class: Type[openrl.algorithms.base_algorithm.BaseAlgorithm] = <class 'openrl.algorithms.dqn.DQNAlgorithm'>, logger: Optional[openrl.utils.logger.Logger] = None) → None

class openrl.runners.common.GAILAgent(net: Optional[Union[torch.nn.modules.module.Module, openrl.modules.common.base_net.BaseNet]] = None, env: Union[gym.core.Env, str] = None, run_dir: Optional[str] = None, env_num: Optional[int] = None, rank: int = 0, world_size: int = 1, use_wandb: bool = False, use_tensorboard: bool = False, project_name: str = 'GAILAgent')

Bases: openrl.runners.common.ppo_agent.PPOAgent

train(total_time_steps: int, callback: Union[None, Callable, List[openrl.utils.callbacks.callbacks.BaseCallback], openrl.utils.callbacks.callbacks.BaseCallback] = None, train_algo_class: Type[openrl.algorithms.base_algorithm.BaseAlgorithm] = <class 'openrl.algorithms.gail.GAILAlgorithm'>, logger: Optional[openrl.utils.logger.Logger] = None) → None

class openrl.runners.common.MATAgent(net: Optional[Union[torch.nn.modules.module.Module, openrl.modules.common.base_net.BaseNet]] = None, env: Union[gym.core.Env, str] = None, run_dir: Optional[str] = None, env_num: Optional[int] = None, rank: int = 0, world_size: int = 1, use_wandb: bool = False, use_tensorboard: bool = False, project_name: str = 'PPOAgent')

Bases: openrl.runners.common.ppo_agent.PPOAgent

train(total_time_steps: int, train_algo_class: Type[openrl.algorithms.base_algorithm.BaseAlgorithm] = <class 'openrl.algorithms.mat.MATAlgorithm'>) → None

class openrl.runners.common.PPOAgent(net: Optional[Union[torch.nn.modules.module.Module, openrl.modules.common.base_net.BaseNet]] = None, env: Union[gym.core.Env, str] = None, run_dir: Optional[str] = None, env_num: Optional[int] = None, rank: int = 0, world_size: int = 1, use_wandb: bool = False, use_tensorboard: bool = False, project_name: str = 'PPOAgent')

Bases: openrl.runners.common.rl_agent.RLAgent

act(observation: Union[numpy.ndarray, Dict[str, numpy.ndarray]], info: Optional[List[Dict[str, Any]]] = None, deterministic: bool = True, episode_starts: Optional[numpy.ndarray] = None) → Tuple[numpy.ndarray, Optional[Tuple[numpy.ndarray, ...]]]

train(total_time_steps: int, callback: Union[None, Callable, List[openrl.utils.callbacks.callbacks.BaseCallback], openrl.utils.callbacks.callbacks.BaseCallback] = None, train_algo_class: Type[openrl.algorithms.base_algorithm.BaseAlgorithm] = <class 'openrl.algorithms.ppo.PPOAlgorithm'>, logger: Optional[openrl.utils.logger.Logger] = None, driver_class: Type[openrl.drivers.base_driver.BaseDriver] = <class 'openrl.drivers.onpolicy_driver.OnPolicyDriver'>) → None

class openrl.runners.common.SACAgent(net: Optional[torch.nn.modules.module.Module] = None, env: Union[gym.core.Env, str] = None, run_dir: Optional[str] = None, env_num: Optional[int] = None, rank: int = 0, world_size: int = 1, use_wandb: bool = False, use_tensorboard: bool = False, project_name: str = 'SACAgent')

Bases: openrl.runners.common.rl_agent.RLAgent

act(observation: Union[numpy.ndarray, Dict[str, numpy.ndarray]], deterministic=True) → Tuple[numpy.ndarray, Optional[Tuple[numpy.ndarray, ...]]]

train(total_time_steps: int, callback: Union[None, Callable, List[openrl.utils.callbacks.callbacks.BaseCallback], openrl.utils.callbacks.callbacks.BaseCallback] = None, train_algo_class: Type[openrl.algorithms.base_algorithm.BaseAlgorithm] = <class 'openrl.algorithms.sac.SACAlgorithm'>, logger: Optional[openrl.utils.logger.Logger] = None, driver_class: Type[openrl.drivers.base_driver.BaseDriver] = <class 'openrl.drivers.offpolicy_driver.OffPolicyDriver'>) → None

class openrl.runners.common.VDNAgent(net: Optional[torch.nn.modules.module.Module] = None, env: Union[gym.core.Env, str] = None, run_dir: Optional[str] = None, env_num: Optional[int] = None, rank: int = 0, world_size: int = 1, use_wandb: bool = False, use_tensorboard: bool = False)

Bases: openrl.runners.common.rl_agent.RLAgent

act(observation: Union[numpy.ndarray, Dict[str, numpy.ndarray]], deterministic=None) → Tuple[numpy.ndarray, Optional[Tuple[numpy.ndarray, ...]]]

train(total_time_steps: int, callback: Union[None, Callable, List[openrl.utils.callbacks.callbacks.BaseCallback], openrl.utils.callbacks.callbacks.BaseCallback] = None, train_algo_class: Type[openrl.algorithms.base_algorithm.BaseAlgorithm] = <class 'openrl.algorithms.vdn.VDNAlgorithm'>, logger: Optional[openrl.utils.logger.Logger] = None) → None