schola.scripts.ray.launch.RLlibArgs

class schola.scripts.ray.launch.RLlibArgs(enable_checkpoints: bool = False, checkpoint_dir: str = ‘./ckpt’, save_freq: int = 100000, name_prefix_override: str = None, export_onnx: bool = False, save_final_policy: bool = False, launch_unreal: bool = False, port: Optional[int] = None, unreal_path: Optional[str] = None, headless: bool = False, map: Optional[str] = None, fps: Optional[int] = None, disable_script: bool = False, timesteps: int = 3000, n_steps: int = 2048, learning_rate: float = 0.0003, mini_batch_size: int = 256, schola_verbosity: int = 0, rllib_verbosity: int = 1, resume_from: Optional[str] = None, fcnet_hiddens: List[int] = <factory>, activation: schola.scripts.common.ActivationFunctionEnum = <ActivationFunctionEnum.ReLU: ‘relu’>, num_cpus: Optional[int] = None, num_learners: Optional[int] = None, num_cpus_for_main_process: Optional[int] = None, num_gpus_per_learner: int = 0, num_cpus_per_learner: int = 1, num_gpus: Optional[int] = None)[source]

Bases: ScriptArgs

Methods

__init__([enable_checkpoints, …])

make_unreal_connection()

Create an Unreal Engine connection based on the script arguments.

Attributes

activation

checkpoint_dir

Enable saving checkpoints.

disable_script

Flag indicating if the autolaunch script setting in the Unreal Engine Schola Plugin should be disabled.

enable_checkpoints

Enable saving checkpoints

export_onnx

Whether to export the model to ONNX format instead of just saving a checkpoint.

fps

Fixed FPS to use when running standalone, if None no fixed timestep is used

headless

Flag indicating if the standalone Unreal Engine process should run in headless mode

launch_unreal

Flag indicating if the script should launch a standalone Unreal Engine process

learning_rate

map

Map to load when launching a standalone Unreal Engine process

mini_batch_size

n_steps

name_prefix_override

Override the name prefix for the checkpoint files (e.g. SAC, PPO, etc.).

num_cpus

num_cpus_for_main_process

num_cpus_per_learner

num_gpus

num_gpus_per_learner

num_learners

port

Port to connect to the Unreal Engine process, if None an open port will be automatically selected when running standalone.

resume_from

rllib_verbosity

save_final_policy

Whether to save the final policy after training is complete.

save_freq

Frequency with which to save checkpoints.

schola_verbosity

timesteps

unreal_path

Path to the Unreal Engine executable, when launching a standalone Unreal Engine process

fcnet_hiddens

Parameters:
  • enable_checkpoints (bool)

  • checkpoint_dir (str)

  • save_freq (int)

  • name_prefix_override (str)

  • export_onnx (bool)

  • save_final_policy (bool)

  • launch_unreal (bool)

  • port (int | None)

  • unreal_path (str | None)

  • headless (bool)

  • map (str | None)

  • fps (int | None)

  • disable_script (bool)

  • timesteps (int)

  • n_steps (int)

  • learning_rate (float)

  • mini_batch_size (int)

  • schola_verbosity (int)

  • rllib_verbosity (int)

  • resume_from (str | None)

  • fcnet_hiddens (List[int])

  • activation (ActivationFunctionEnum)

  • num_cpus (int | None)

  • num_learners (int | None)

  • num_cpus_for_main_process (int | None)

  • num_gpus_per_learner (int)

  • num_cpus_per_learner (int)

  • num_gpus (int | None)

__init__(enable_checkpoints=False, checkpoint_dir=’./ckpt’, save_freq=100000, name_prefix_override=None, export_onnx=False, save_final_policy=False, launch_unreal=False, port=None, unreal_path=None, headless=False, map=None, fps=None, disable_script=False, timesteps=3000, n_steps=2048, learning_rate=0.0003, mini_batch_size=256, schola_verbosity=0, rllib_verbosity=1, resume_from=None, fcnet_hiddens=<factory>, activation=ActivationFunctionEnum.ReLU, num_cpus=None, num_learners=None, num_cpus_for_main_process=None, num_gpus_per_learner=0, num_cpus_per_learner=1, num_gpus=None)
Parameters:
  • enable_checkpoints (bool)

  • checkpoint_dir (str)

  • save_freq (int)

  • name_prefix_override (str | None)

  • export_onnx (bool)

  • save_final_policy (bool)

  • launch_unreal (bool)

  • port (int | None)

  • unreal_path (str | None)

  • headless (bool)

  • map (str | None)

  • fps (int | None)

  • disable_script (bool)

  • timesteps (int)

  • n_steps (int)

  • learning_rate (float)

  • mini_batch_size (int)

  • schola_verbosity (int)

  • rllib_verbosity (int)

  • resume_from (str | None)

  • fcnet_hiddens (List[int])

  • activation (ActivationFunctionEnum)

  • num_cpus (int | None)

  • num_learners (int | None)

  • num_cpus_for_main_process (int | None)

  • num_gpus_per_learner (int)

  • num_cpus_per_learner (int)

  • num_gpus (int | None)

Return type:

None

activation: ActivationFunctionEnum = ‘relu’
fcnet_hiddens: List[int]
learning_rate: float = 0.0003
mini_batch_size: int = 256
n_steps: int = 2048
num_cpus: int | None = None
num_cpus_for_main_process: int | None = None
num_cpus_per_learner: int = 1
num_gpus: int | None = None
num_gpus_per_learner: int = 0
num_learners: int | None = None
resume_from: str | None = None
rllib_verbosity: int = 1
schola_verbosity: int = 0
timesteps: int = 3000

Related pages

  • Visit the Schola product page for download links and more information.

Looking for more documentation on GPUOpen?

AMD GPUOpen software blogs

Our handy software release blogs will help you make good use of our tools, SDKs, and effects, as well as sharing the latest features with new releases.

GPUOpen Manuals

Don’t miss our manual documentation! And if slide decks are what you’re after, you’ll find 100+ of our finest presentations here.

AMD GPUOpen Performance Guides

The home of great performance and optimization advice for AMD RDNA™ 2 GPUs, AMD Ryzen™ CPUs, and so much more.

Getting started: AMD GPUOpen software

New or fairly new to AMD’s tools, libraries, and effects? This is the best place to get started on GPUOpen!

AMD GPUOpen Getting Started Development and Performance

Looking for tips on getting started with developing and/or optimizing your game, whether on AMD hardware or generally? We’ve got you covered!

AMD GPUOpen Technical blogs

Browse our technical blogs, and find valuable advice on developing with AMD hardware, ray tracing, Vulkan®, DirectX®, Unreal Engine, and lots more.

Find out more about our software!

AMD GPUOpen Effects - AMD FidelityFX technologies

Create wonder. No black boxes. Meet the AMD FidelityFX SDK!

AMD GPUOpen Samples

Browse all our useful samples. Perfect for when you’re needing to get started, want to integrate one of our libraries, and much more.

AMD GPUOpen developer SDKs

Discover what our SDK technologies can offer you. Query hardware or software, manage memory, create rendering applications or machine learning, and much more!

AMD GPUOpen Developer Tools

Analyze, Optimize, Profile, Benchmark. We provide you with the developer tools you need to make sure your game is the best it can be!