Struct ggpf::game::openai::Gym

pub struct Gym { /* fields omitted */ }

OpenAI Gym game instance.

Each instance is connected to a remote runner. This is because of Rust limitations somehow it's not possible to have both tensorflow and pyo3 in the same crate..

Methods

impl Gym

pub async fn new(__arg0: GymRunnerClient, game: String) -> Self

Given a connected client, build a game based on Gym.

Trait Implementations

impl Base for Gym

type Move = usize

The type for a Move.

fn possible_moves(&self) -> Vec<Self::Move>

Given the game state and turn, list possible actions to the current player. If the game has ended, no action should be available.

fn is_finished(&self) -> bool

Returns if the game has ended or not.

impl Clone for Gym

fn clone(&self) -> Gym

Returns a copy of the value.

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

Performs copy-assignment from source.

impl Debug for Gym

fn fmt(&self, f: &mut Formatter) -> Result

Formats the value using the given formatter.

impl Features for Gym

type StateDim = Ix3

Type dimension of the game state feature space.

type ActionDim = Ix1

Type dimension of the action feature space.

type Descriptor = (Vec<usize>, Ix3, Ix1)

Game features descriptor, that can be used to retrieve dimensions without having access to a game instance.

fn get_features(&self) -> Self::Descriptor

Obtain game descriptor.

fn state_dimension(descr: &Self::Descriptor) -> Self::StateDim

Deduce state shape from game descriptor.

fn action_dimension(descr: &Self::Descriptor) -> Self::ActionDim

Deduce action shape from game descriptor.

fn state_to_feature(&self, _pov: Self::Player) -> Array<f32, Self::StateDim>

Converts the game state to features (multi-dimensional array).

fn all_possible_moves(descr: &Self::Descriptor) -> Vec<Self::Move>

Returns action space

fn moves_to_feature(
    descr: &Self::Descriptor,
    moves: &HashMap<Self::Move, f32>
) -> Array<f32, Self::ActionDim>

Converts an action probability distribution to the action features.

fn all_feature_to_moves(
    _descr: &Self::Descriptor,
    features: &Array<f32, Self::ActionDim>
) -> HashMap<Self::Move, f32>

Converts a move distribution feature to the corresponding set of move probabilities, independently from the game state.

fn feature_to_moves(
    &self,
    features: &Array<f32, Self::ActionDim>
) -> HashMap<Self::Move, f32>

Converts a move distribution feature to the corresponding set of move probabilities, relative to the game state.

fn move_to_feature(
    descr: &Self::Descriptor,
    action: Self::Move
) -> Array<f32, Self::ActionDim>

Converts a single move to a one-hot feature encoding of the move.

impl Playable for Gym

fn play<'life0, 'life1, 'async_trait>(
    &'life0 mut self,
    action: &'life1 usize
) -> Pin<Box<dyn Future<Output = f32> + Send + 'async_trait>> where
    'life0: 'async_trait,
    'life1: 'async_trait,
    Self: 'async_trait, 

Mutates game state playing the given action. Yields a reward to the player.

#[must_use]fn random_move<'life0, 'async_trait>(
    &'life0 mut self
) -> Pin<Box<dyn Future<Output = (Self::Move, f32)> + Send + 'async_trait>> where
    'life0: 'async_trait,
    Self: Send + 'async_trait, 

Plays a random move. Yields a reward.

impl Singleplayer for Gym