Struct RLTraining 

pub struct RLTraining<RLC: RLComponentsTypes> { /* private fields */ }

Available on crate feature rl only.

Structure to configure and launch reinforcement learning trainings.

Implementations

impl<B, E, EI, A> RLTraining<RLComponentsMarker<B, E, EI, A>>

where B: AutodiffBackend, E: Environment + 'static, EI: EnvironmentInit<E> + Send + 'static, A: PolicyLearner<B> + Send + 'static, A::TrainContext: ItemLazy + Clone + Send, A::InnerPolicy: Policy<B> + Send, <A::InnerPolicy as Policy<B>>::Observation: Batchable + Clone + Send, <A::InnerPolicy as Policy<B>>::ActionDistribution: Batchable + Clone + Send, <A::InnerPolicy as Policy<B>>::Action: Batchable + Clone + Send, <A::InnerPolicy as Policy<B>>::ActionContext: ItemLazy + Clone + Send + 'static, <A::InnerPolicy as Policy<B>>::PolicyState: Clone + Send, E::State: Into<<A::InnerPolicy as Policy<B>>::Observation> + Clone + Send + 'static, E::Action: From<<A::InnerPolicy as Policy<B>>::Action> + Into<<A::InnerPolicy as Policy<B>>::Action> + Clone + Send + 'static,

pub fn new(directory: impl AsRef<Path>, env_initializer: EI) -> Self

Creates a new runner for reinforcement learning.

Arguments

• directory - The directory to save the checkpoints.
• env_init - Specifies how to initialize the environment.

impl<RLC: RLComponentsTypes + 'static> RLTraining<RLC>

pub fn with_learning_strategy( self, learning_strategy: RLStrategies<RLC>, ) -> Self

Replace the default learning strategy (Off Policy learning) with the provided one.

Arguments

• training_strategy - The training strategy.

pub fn with_metric_logger<ML>(self, logger: ML) -> Self

where ML: MetricLogger + 'static,

Replace the default metric loggers with the provided ones.

Arguments

• logger - The training logger.

pub fn with_checkpointing_strategy<CS: CheckpointingStrategy + 'static>( self, strategy: CS, ) -> Self

Update the checkpointing_strategy.

pub fn renderer<MR>(self, renderer: MR) -> Self

where MR: MetricsRenderer + 'static,

Replace the default CLI renderer with a custom one.

Arguments

• renderer - The custom renderer.

pub fn metrics_train<Me: TrainMetricRegistration<RLC>>( self, metrics: Me, ) -> Self

Register numerical metrics for a training step of the agent.

pub fn text_metrics_train<Me: TrainTextMetricRegistration<RLC>>( self, metrics: Me, ) -> Self

Register textual metrics for a training step of the agent.

pub fn metrics_agent<Me: AgentMetricRegistration<RLC>>( self, metrics: Me, ) -> Self

Register numerical metrics for each action of the agent.

pub fn text_metrics_agent<Me: AgentTextMetricRegistration<RLC>>( self, metrics: Me, ) -> Self

Register textual metrics for each action of the agent.

pub fn metrics_episode<Me: EpisodeMetricRegistration<RLC>>( self, metrics: Me, ) -> Self

Register numerical metrics for a completed episode.

pub fn text_metrics_episode<Me: EpisodeTextMetricRegistration<RLC>>( self, metrics: Me, ) -> Self

Register textual metrics for a completed episode.

pub fn text_metric_train<Me: Metric + 'static>(self, metric: Me) -> Self

where <RLC::TrainingOutput as ItemLazy>::ItemSync: Adaptor<Me::Input>,

Register a textual metric for a training step.

pub fn metric_train<Me>(self, metric: Me) -> Self

where Me: Metric + Numeric + 'static, <RLC::TrainingOutput as ItemLazy>::ItemSync: Adaptor<Me::Input>,

Register a numeric metric for a training step.

pub fn text_metric_agent<Me: Metric + 'static>(self, metric: Me) -> Self

where <RLC::ActionContext as ItemLazy>::ItemSync: Adaptor<Me::Input>,

Register a textual metric for each action taken by the agent.

pub fn metric_agent<Me>(self, metric: Me) -> Self

where Me: Metric + Numeric + 'static, <RLC::ActionContext as ItemLazy>::ItemSync: Adaptor<Me::Input>,

Register a numeric metric for each action taken by the agent.

pub fn text_metric_episode<Me: Metric + 'static>(self, metric: Me) -> Self

where EpisodeSummary: Adaptor<Me::Input> + 'static,

Register a textual metric for a completed episode.

pub fn metric_episode<Me>(self, metric: Me) -> Self

where Me: Metric + Numeric + 'static, EpisodeSummary: Adaptor<Me::Input> + 'static,

Register a numeric metric for a completed episode.

pub fn num_steps(self, num_steps: usize) -> Self

The number of environment steps to train for.

pub fn checkpoint(self, checkpoint: usize) -> Self

The step from which the training must resume.

pub fn interrupter(&self) -> Interrupter

Provides a handle that can be used to interrupt training.

pub fn with_interrupter(self, interrupter: Interrupter) -> Self

Override the handle for stopping training with an externally provided handle

pub fn with_application_logger( self, logger: Option<Box<dyn ApplicationLoggerInstaller>>, ) -> Self

By default, Rust logs are captured and written into experiment.log. If disabled, standard Rust log handling will apply.

pub fn with_file_checkpointer<FR>(self, recorder: FR) -> Self

where FR: FileRecorder<RLC::Backend> + 'static + FileRecorder<<RLC::Backend as AutodiffBackend>::InnerBackend>,

Register a checkpointer that will save the environment runner’s policy and the PolicyLearner state to different files.

pub fn summary(self) -> Self

Enable the training summary report.

The summary will be displayed after .launch(), when the renderer is dropped.

pub fn launch(self, learner_agent: RLC::LearningAgent) -> RLResult<RLC::Policy>

where RLC::PolicyObs: SliceAccess<RLC::Backend>, RLC::PolicyAction: SliceAccess<RLC::Backend>,

Launch the training with the specified PolicyLearner on the specified environment.