Struct RLTraining 

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

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 as PolicyLearner<B>>::TrainContext: ItemLazy + Clone + Send, <A as PolicyLearner<B>>::InnerPolicy: Policy<B> + Send, <<A as PolicyLearner<B>>::InnerPolicy as Policy<B>>::Observation: Batchable + Clone + Send, <<A as PolicyLearner<B>>::InnerPolicy as Policy<B>>::ActionDistribution: Batchable + Clone + Send, <<A as PolicyLearner<B>>::InnerPolicy as Policy<B>>::Action: Batchable + Clone + Send, <<A as PolicyLearner<B>>::InnerPolicy as Policy<B>>::ActionContext: ItemLazy + Clone + Send + 'static, <<A as PolicyLearner<B>>::InnerPolicy as Policy<B>>::PolicyState: Clone + Send, <E as Environment>::State: Into<<<A as PolicyLearner<B>>::InnerPolicy as Policy<B>>::Observation> + Clone + Send + 'static, <E as Environment>::Action: From<<<A as PolicyLearner<B>>::InnerPolicy as Policy<B>>::Action> + Into<<<A as PolicyLearner<B>>::InnerPolicy as Policy<B>>::Action> + Clone + Send + 'static,

pub fn new( directory: impl AsRef<Path>, env_initializer: EI, ) -> RLTraining<RLComponentsMarker<B, E, EI, A>>

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> RLTraining<RLC>

where RLC: RLComponentsTypes + 'static,

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

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) -> RLTraining<RLC>

where ML: MetricLogger + 'static,

Replace the default metric loggers with the provided ones.

Arguments

• logger - The training logger.

pub fn with_checkpointing_strategy<CS>(self, strategy: CS) -> RLTraining<RLC>

where CS: CheckpointingStrategy + 'static,

Update the checkpointing_strategy.

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

where MR: MetricsRenderer + 'static,

Replace the default CLI renderer with a custom one.

Arguments

• renderer - The custom renderer.

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

where Me: TrainMetricRegistration<RLC>,

Register numerical metrics for a training step of the agent.

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

where Me: TrainTextMetricRegistration<RLC>,

Register textual metrics for a training step of the agent.

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

where Me: AgentMetricRegistration<RLC>,

Register numerical metrics for each action of the agent.

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

where Me: AgentTextMetricRegistration<RLC>,

Register textual metrics for each action of the agent.

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

where Me: EpisodeMetricRegistration<RLC>,

Register numerical metrics for a completed episode.

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

where Me: EpisodeTextMetricRegistration<RLC>,

Register textual metrics for a completed episode.

pub fn text_metric_train<Me>(self, metric: Me) -> RLTraining<RLC>

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

Register a textual metric for a training step.

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

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

Register a numeric metric for a training step.

pub fn text_metric_agent<Me>(self, metric: Me) -> RLTraining<RLC>

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

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

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

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

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

pub fn text_metric_episode<Me>(self, metric: Me) -> RLTraining<RLC>

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

Register a textual metric for a completed episode.

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

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

Register a numeric metric for a completed episode.

pub fn num_steps(self, num_steps: usize) -> RLTraining<RLC>

The number of environment steps to train for.

pub fn checkpoint(self, checkpoint: usize) -> RLTraining<RLC>

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) -> RLTraining<RLC>

Override the handle for stopping training with an externally provided handle

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

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) -> RLTraining<RLC>

where FR: FileRecorder<<RLC as RLComponentsTypes>::Backend> + 'static + FileRecorder<<<RLC as RLComponentsTypes>::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) -> RLTraining<RLC>

Enable the training summary report.

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

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

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

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