Struct AgentTrainer

pub struct AgentTrainer<S>
where
    S: State,
{ /* private fields */ }

An AgentTrainer can be trained for using a certain Agent. After training, the AgentTrainer contains learned knowledge about the process, and can be queried for this. For example, you can ask the AgentTrainer the expected values of all possible actions in a given state.

Implementations

impl<S> AgentTrainer<S>

where S: State,

pub fn new() -> AgentTrainer<S>

Examples found in repository

src/examples/weightedcoin.rs (line 71)

fn main() {
    const TRIALS: i32 = 100000;
    let mut trainer = AgentTrainer::new();
    for trial in 0..TRIALS {
        let mut agent = CoinAgent {
            state: CoinState {
                balance: 1 + trial % 98,
            },
        };
        trainer.train(
            &mut agent,
            &QLearning::new(0.2, 1.0, 0.0),
            &mut SinkStates {},
            &RandomExploration::new(),
        );
    }

    println!("Balance\tBet\tQ-value");
    for balance in 1..TARGET {
        let state = CoinState { balance };
        let action = trainer.best_action(&state).unwrap();
        println!(
            "{}\t{}\t{}",
            balance,
            action.bet,
            trainer.expected_value(&state, &action).unwrap(),
        );
    }
}

src/examples/eucdist.rs (line 76)

fn main() {
    let initial_state = MyState {
        x: 0,
        y: 0,
        maxx: 21,
        maxy: 21,
    };
    let mut trainer = AgentTrainer::new();
    let mut agent = MyAgent {
        state: initial_state.clone(),
    };
    trainer.train(
        &mut agent,
        &QLearning::new(0.2, 0.01, 2.),
        &mut FixedIterations::new(100000),
        &RandomExploration::new(),
    );
    for j in 0..21 {
        for i in 0..21 {
            let entry: &HashMap<MyAction, f64> = trainer
                .expected_values(&MyState {
                    x: i,
                    y: j,
                    ..initial_state
                })
                .unwrap();
            let best_action = entry
                .iter()
                .max_by(|(_, v1), (_, v2)| v1.partial_cmp(v2).unwrap())
                .map(|(v, _)| v)
                .unwrap();
            match best_action {
                MyAction::Move { dx: -1, dy: 0 } => print!("<"),
                MyAction::Move { dx: 1, dy: 0 } => print!(">"),
                MyAction::Move { dx: 0, dy: -1 } => print!("^"),
                MyAction::Move { dx: 0, dy: 1 } => print!("v"),
                _ => unreachable!(),
            };
        }
        println!();
    }
}

pub fn expected_values(&self, state: &S) -> Option<&HashMap<S::A, f64>>

Fetches the learned values for the given state, by Action, or None if no value was learned.

Examples found in repository

src/examples/eucdist.rs (lines 89-93)

fn main() {
    let initial_state = MyState {
        x: 0,
        y: 0,
        maxx: 21,
        maxy: 21,
    };
    let mut trainer = AgentTrainer::new();
    let mut agent = MyAgent {
        state: initial_state.clone(),
    };
    trainer.train(
        &mut agent,
        &QLearning::new(0.2, 0.01, 2.),
        &mut FixedIterations::new(100000),
        &RandomExploration::new(),
    );
    for j in 0..21 {
        for i in 0..21 {
            let entry: &HashMap<MyAction, f64> = trainer
                .expected_values(&MyState {
                    x: i,
                    y: j,
                    ..initial_state
                })
                .unwrap();
            let best_action = entry
                .iter()
                .max_by(|(_, v1), (_, v2)| v1.partial_cmp(v2).unwrap())
                .map(|(v, _)| v)
                .unwrap();
            match best_action {
                MyAction::Move { dx: -1, dy: 0 } => print!("<"),
                MyAction::Move { dx: 1, dy: 0 } => print!(">"),
                MyAction::Move { dx: 0, dy: -1 } => print!("^"),
                MyAction::Move { dx: 0, dy: 1 } => print!("v"),
                _ => unreachable!(),
            };
        }
        println!();
    }
}

pub fn expected_value(&self, state: &S, action: &S::A) -> Option<f64>

Fetches the learned value for the given Action in the given State, or None if no value was learned.

Examples found in repository

src/examples/weightedcoin.rs (line 94)

fn main() {
    const TRIALS: i32 = 100000;
    let mut trainer = AgentTrainer::new();
    for trial in 0..TRIALS {
        let mut agent = CoinAgent {
            state: CoinState {
                balance: 1 + trial % 98,
            },
        };
        trainer.train(
            &mut agent,
            &QLearning::new(0.2, 1.0, 0.0),
            &mut SinkStates {},
            &RandomExploration::new(),
        );
    }

    println!("Balance\tBet\tQ-value");
    for balance in 1..TARGET {
        let state = CoinState { balance };
        let action = trainer.best_action(&state).unwrap();
        println!(
            "{}\t{}\t{}",
            balance,
            action.bet,
            trainer.expected_value(&state, &action).unwrap(),
        );
    }
}

pub fn export_learned_values(&self) -> HashMap<S, HashMap<S::A, f64>>

Returns a clone of the entire learned state to be saved or used elsewhere.

pub fn learned_values(&self) -> &HashMap<S, HashMap<S::A, f64>>

pub fn import_state(&mut self, q: HashMap<S, HashMap<S::A, f64>>)

Imports a state, completely replacing any learned progress

pub fn best_action(&self, state: &S) -> Option<S::A>

Returns the best action for the given State, or None if no values were learned.

Examples found in repository

src/examples/weightedcoin.rs (line 89)

fn main() {
    const TRIALS: i32 = 100000;
    let mut trainer = AgentTrainer::new();
    for trial in 0..TRIALS {
        let mut agent = CoinAgent {
            state: CoinState {
                balance: 1 + trial % 98,
            },
        };
        trainer.train(
            &mut agent,
            &QLearning::new(0.2, 1.0, 0.0),
            &mut SinkStates {},
            &RandomExploration::new(),
        );
    }

    println!("Balance\tBet\tQ-value");
    for balance in 1..TARGET {
        let state = CoinState { balance };
        let action = trainer.best_action(&state).unwrap();
        println!(
            "{}\t{}\t{}",
            balance,
            action.bet,
            trainer.expected_value(&state, &action).unwrap(),
        );
    }
}

pub fn train( &mut self, agent: &mut dyn Agent<S>, learning_strategy: &dyn LearningStrategy<S>, termination_strategy: &mut dyn TerminationStrategy<S>, exploration_strategy: &dyn ExplorationStrategy<S>, )

Trains this AgentTrainer using the given ExplorationStrategy, LearningStrategy and Agent until the TerminationStrategy decides to stop.

Examples found in repository

src/examples/weightedcoin.rs (lines 78-83)

fn main() {
    const TRIALS: i32 = 100000;
    let mut trainer = AgentTrainer::new();
    for trial in 0..TRIALS {
        let mut agent = CoinAgent {
            state: CoinState {
                balance: 1 + trial % 98,
            },
        };
        trainer.train(
            &mut agent,
            &QLearning::new(0.2, 1.0, 0.0),
            &mut SinkStates {},
            &RandomExploration::new(),
        );
    }

    println!("Balance\tBet\tQ-value");
    for balance in 1..TARGET {
        let state = CoinState { balance };
        let action = trainer.best_action(&state).unwrap();
        println!(
            "{}\t{}\t{}",
            balance,
            action.bet,
            trainer.expected_value(&state, &action).unwrap(),
        );
    }
}

src/examples/eucdist.rs (lines 80-85)

fn main() {
    let initial_state = MyState {
        x: 0,
        y: 0,
        maxx: 21,
        maxy: 21,
    };
    let mut trainer = AgentTrainer::new();
    let mut agent = MyAgent {
        state: initial_state.clone(),
    };
    trainer.train(
        &mut agent,
        &QLearning::new(0.2, 0.01, 2.),
        &mut FixedIterations::new(100000),
        &RandomExploration::new(),
    );
    for j in 0..21 {
        for i in 0..21 {
            let entry: &HashMap<MyAction, f64> = trainer
                .expected_values(&MyState {
                    x: i,
                    y: j,
                    ..initial_state
                })
                .unwrap();
            let best_action = entry
                .iter()
                .max_by(|(_, v1), (_, v2)| v1.partial_cmp(v2).unwrap())
                .map(|(v, _)| v)
                .unwrap();
            match best_action {
                MyAction::Move { dx: -1, dy: 0 } => print!("<"),
                MyAction::Move { dx: 1, dy: 0 } => print!(">"),
                MyAction::Move { dx: 0, dy: -1 } => print!("^"),
                MyAction::Move { dx: 0, dy: 1 } => print!("v"),
                _ => unreachable!(),
            };
        }
        println!();
    }
}

Trait Implementations

impl<S: State> Default for AgentTrainer<S>

fn default() -> Self

Returns the “default value” for a type.