Enum ark_api::ml::EpisodeState

#[repr(u32)]
pub enum EpisodeState {
    Running,
    Terminal,
    Interrupted,
    Initial,
}

Variants

Running

Episode is running.

Terminal

The episode has been terminated due to something the agent did.

The backend may use terminal masking for this state. In that case the agent will behave as if from this state it cannot receive any more rewards.

This state is useful if the agent for example has died or in some other way ended up in a non-recoverable state.

The agent will receive a ark_api::Response::EndOfEpisode when evaluating an observation with this state. This agent is considered removed from the simulation and you may not send in an observation with the same id again.

Interrupted

The episode has been terminated due to an external reason that the agent cannot control.

This is useful for things like timeouts that aren’t necessarily due to bad behavior of the agent. No terminal masking will be used in this case.

The agent will receive a ark_api::Response::EndOfEpisode when evaluating an observation with this state. This agent is considered removed from the simulation and you may not send in an observation with the same id again.

Initial

First frame of the episode.

The first observation that an agent sends to the engine must always be marked with this episode state.

Trait Implementations

impl CheckedBitPattern for EpisodeState

type Bits = u32

Self must have the same layout as the specified Bits except for the possible invalid bit patterns being checked during is_valid_bit_pattern.

fn is_valid_bit_pattern( bits: &<EpisodeState as CheckedBitPattern>::Bits ) -> bool

If this function returns true, then it must be valid to reinterpret bits as &Self.

impl Clone for EpisodeState

fn clone(&self) -> EpisodeState

Returns a copy of the value.

fn clone_from(&mut self, source: &Self)

Performs copy-assignment from source.

impl Debug for EpisodeState

fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error>

Formats the value using the given formatter.

impl Hash for EpisodeState

fn hash<__H>(&self, state: &mut __H)where __H: Hasher,

Feeds this value into the given Hasher.

fn hash_slice<H>(data: &[Self], state: &mut H)where H: Hasher, Self: Sized,

Feeds a slice of this type into the given Hasher.

impl PartialEq<EpisodeState> for EpisodeState

fn eq(&self, other: &EpisodeState) -> bool

This method tests for self and other values to be equal, and is used by ==.

fn ne(&self, other: &Rhs) -> bool

This method tests for !=. The default implementation is almost always sufficient, and should not be overridden without very good reason.

impl TryFrom<u32> for EpisodeState

type Error = TryFromPrimitiveError<EpisodeState>

The type returned in the event of a conversion error.

fn try_from( number: u32 ) -> Result<EpisodeState, TryFromPrimitiveError<EpisodeState>>

Performs the conversion.

impl TryFromPrimitive for EpisodeState

type Primitive = u32

const NAME: &'static str = "EpisodeState"

fn try_from_primitive( number: <EpisodeState as TryFromPrimitive>::Primitive ) -> Result<EpisodeState, TryFromPrimitiveError<EpisodeState>>

impl Copy for EpisodeState

impl Eq for EpisodeState

impl NoUninit for EpisodeState

impl StructuralEq for EpisodeState

impl StructuralPartialEq for EpisodeState