🥮 mooncakes.io

    moonrllab

    MoonRLLab is a discrete reinforcement-learning lab for MoonBit.

    moonbit
    reinforcement-learning
    q-learning
    sarsa
    gridworld
    Download zip
    Author
    Version
    0.1.1
    License
    Apache-2.0
    Repository
    Last updated
    2 months ago
    Downloads
    35

    No dependencies

    #MoonRLLab

    MoonRLLab is a reusable tabular reinforcement-learning toolkit for MoonBit.

    #Library quick start

    import { "liuzhiyug/moonrllab" }

    fn main {
      let report = @moonrllab.train_with_memory_logger(8, 40, 20260815)
      println(report.compact_line())
    }

    The checked executable equivalent is in examples/basic:

    moon run examples/basic

    The generic Trainer::train works through open Environment, Agent, Logger and Policy traits. Built-in examples cover GridWorld, CliffWalking, RandomWalk and a multi-armed bandit. See README.md for the full API and acceptance evidence.

    Agent

    source
    pub(open) trait Agent {
      fn reset_episode(Self) -> Unit
      fn choose_action(Self, Int) -> Int
      fn learn(Self, Transition, Int?) -> Unit
      fn epsilon(Self) -> Double
      fn q_report(Self, Int) -> String
    }

    Environment

    source
    pub(open) trait Environment {
      fn reset(Self) -> Int
      fn actions(Self) -> Array[Int]
      fn state_space(Self) -> Array[Int]
      fn step(Self, Int) -> Transition
      fn render(Self) -> String
    }

    Logger

    source
    pub(open) trait Logger {
      fn start_episode(Self, Int) -> Unit
      fn step(Self, Int, Int, Int, Double, Int, Bool, Int) -> Unit
      fn finish_episode(Self, EpisodeRecord) -> Unit
      fn finish(Self, TrainingReport) -> Unit
    }

    Policy

    source
    pub(open) trait Policy {
      fn choose_action(Self, Int, Array[Int], Array[Double]) -> Int
    }

    BanditEnv

    source
    pub struct BanditEnv {
      arms : Array[Double]
      rng : LcgRng
      pulls : Array[Int]
      total_reward : Double
    } derive(
    Debug    )

    A reproducible k-armed bandit. Rewards are bounded and generated from a deterministic pseudo-random stream, which makes it suitable for CI.

    BanditEnv::actions

    source
    fn BanditEnv::actions(self : BanditEnv) -> Array[Int]

    BanditEnv::arm_count

    source
    fn BanditEnv::arm_count(self : BanditEnv) -> Int

    BanditEnv::average_reward

    source
    fn BanditEnv::average_reward(self : BanditEnv) -> Double

    BanditEnv::best_arm

    source
    fn BanditEnv::best_arm(self : BanditEnv) -> Int

    BanditEnv::new

    source
    fn BanditEnv::new(means : Array[Double], seed : Int) -> BanditEnv

    BanditEnv::pull_count

    source
    fn BanditEnv::pull_count(self : BanditEnv, arm : Int) -> Int

    BanditEnv::render

    source
    fn BanditEnv::render(self : BanditEnv) -> String

    BanditEnv::reset

    source
    fn BanditEnv::reset(self : BanditEnv) -> Int

    BanditEnv::state_space

    source
    fn BanditEnv::state_space(_self : BanditEnv) -> Array[Int]

    BanditEnv::step

    source
    fn BanditEnv::step(self : BanditEnv, action : Int) -> Transition

    BanditPolicy

    source
    pub struct BanditPolicy {
      values : Array[Double]
      counts : Array[Int]
      schedule : EpsilonSchedule
      rng : LcgRng
    } derive(
    Debug    )

    BanditPolicy::choose

    source
    fn BanditPolicy::choose(self : BanditPolicy, step : Int) -> Int

    BanditPolicy::counts

    source
    fn BanditPolicy::counts(self : BanditPolicy) -> Array[Int]

    BanditPolicy::estimate

    source
    fn BanditPolicy::estimate(self : BanditPolicy, action : Int) -> Double

    BanditPolicy::new

    source
    fn BanditPolicy::new(arms : Int, schedule : EpsilonSchedule, seed : Int) -> BanditPolicy

    BanditPolicy::observe

    source
    fn BanditPolicy::observe(self : BanditPolicy, action : Int, reward : Double) -> Unit

    BenchmarkCase

    source
    pub struct BenchmarkCase {
      name : String
      description : String
      expected_states : Int
      expected_actions : Int
      max_steps : Int
    } derive(Eq, 
    Debug    )

    BenchmarkCase::bandit

    source

    BenchmarkCase::cliff_walking

    source
    fn BenchmarkCase::cliff_walking() -> BenchmarkCase

    BenchmarkCase::gridworld

    source
    fn BenchmarkCase::gridworld() -> BenchmarkCase

    BenchmarkCase::random_walk

    source
    fn BenchmarkCase::random_walk() -> BenchmarkCase

    BenchmarkResult

    source
    pub struct BenchmarkResult {
      name : String
      seed : Int
      episodes : Int
      rewards : Array[Double]
      steps : Array[Int]
      solved : Array[Bool]
    } derive(
    Debug    )

    Aggregated results for a fixed-seed benchmark.

    BenchmarkResult::new

    source
    fn BenchmarkResult::new(name : String, seed : Int, episodes : Int) -> BenchmarkResult

    BenchmarkResult::record

    source
    fn BenchmarkResult::record(self : BenchmarkResult, episode : Int, reward : Double, steps : Int, solved : Bool) -> Unit

    BenchmarkResult::reward_stats

    source
    fn BenchmarkResult::reward_stats(self : BenchmarkResult) -> RunningStats

    BenchmarkResult::solve_rate

    source
    fn BenchmarkResult::solve_rate(self : BenchmarkResult) -> Double

    BenchmarkResult::solved_count

    source
    fn BenchmarkResult::solved_count(self : BenchmarkResult) -> Int

    BenchmarkResult::step_stats

    source
    fn BenchmarkResult::step_stats(self : BenchmarkResult) -> RunningStats

    BenchmarkResult::summary

    source
    fn BenchmarkResult::summary(self : BenchmarkResult) -> String

    BenchmarkResult::tail_average

    source
    fn BenchmarkResult::tail_average(self : BenchmarkResult, window : Int) -> Double

    BenchmarkResult::to_csv

    source
    fn BenchmarkResult::to_csv(self : BenchmarkResult) -> String

    CliffWalkingEnv

    source
    pub struct CliffWalkingEnv {
      width : Int
      height : Int
      start_x : Int
      start_y : Int
      goal_x : Int
      goal_y : Int
      x : Int
      y : Int
      _last_stage : EpisodeStage
    } derive(
    Debug    )

    CliffWalkingEnv::actions

    source
    fn CliffWalkingEnv::actions(_self : CliffWalkingEnv) -> Array[Int]

    CliffWalkingEnv::new

    source

    CliffWalkingEnv::render

    source
    fn CliffWalkingEnv::render(self : CliffWalkingEnv) -> String

    CliffWalkingEnv::reset

    source
    fn CliffWalkingEnv::reset(self : CliffWalkingEnv) -> Int

    CliffWalkingEnv::state_space

    source
    fn CliffWalkingEnv::state_space(self : CliffWalkingEnv) -> Array[Int]

    CliffWalkingEnv::step

    source
    fn CliffWalkingEnv::step(self : CliffWalkingEnv, action : Int) -> Transition

    ConsoleLogger

    source
    pub struct ConsoleLogger {
      prefix : String
    } derive(
    Debug    )

    ConsoleLogger::new

    source
    fn ConsoleLogger::new(prefix : String) -> ConsoleLogger

    DoubleQLearningAgent

    source
    pub struct DoubleQLearningAgent {
      left : QTable
      right : QTable
      policy : EpsilonGreedyPolicy
      alpha : Double
      gamma : Double
      updates : Int
    } derive(
    Debug    )

    DoubleQLearningAgent::best_action

    source
    fn DoubleQLearningAgent::best_action(self : DoubleQLearningAgent, state : Int) -> Int

    DoubleQLearningAgent::choose_action

    source
    fn DoubleQLearningAgent::choose_action(self : DoubleQLearningAgent, state : Int) -> Int

    DoubleQLearningAgent::learn

    source
    fn DoubleQLearningAgent::learn(self : DoubleQLearningAgent, transition : Transition, update_left : Bool) -> Unit

    DoubleQLearningAgent::new

    source
    fn DoubleQLearningAgent::new(states : Array[Int], actions : Array[Int], policy : EpsilonGreedyPolicy, alpha : Double, gamma : Double) -> DoubleQLearningAgent

    DoubleQLearningAgent::update_count

    source
    fn DoubleQLearningAgent::update_count(self : DoubleQLearningAgent) -> Int

    DoubleQLearningAgent::value

    source
    fn DoubleQLearningAgent::value(self : DoubleQLearningAgent, state : Int, action : Int) -> Double

    EnvironmentAudit

    source
    pub struct EnvironmentAudit {
      states : Int
      actions : Int
      reset_state : Int
      invalid_action_state : Int
      render_nonempty : Bool
    } derive(Eq, 
    Debug    )

    EnvironmentAudit::bandit

    source

    EnvironmentAudit::cliff

    source

    EnvironmentAudit::gridworld

    source

    EnvironmentAudit::random_walk

    source
    fn EnvironmentAudit::random_walk() -> EnvironmentAudit

    EpisodeAccumulator

    source
    pub struct EpisodeAccumulator {
      reward : Double
      steps : Int
      last_state : Int
      solved : Bool
    } derive(
    Debug    )

    EpisodeAccumulator::finish

    source
    fn EpisodeAccumulator::finish(self : EpisodeAccumulator, episode : Int) -> EvaluationPoint

    EpisodeAccumulator::new

    source

    EpisodeAccumulator::observe

    source
    fn EpisodeAccumulator::observe(self : EpisodeAccumulator, transition : Transition) -> Unit

    EpisodeRecord

    source
    pub struct EpisodeRecord {
      episode : Int
      steps : Int
      reward : Double
      goal_reached : Bool
      final_state : Int
    } derive(Eq, 
    Debug    )

    EpisodeStage

    source
    type EpisodeStage derive(Eq, 
    Debug    )

    EpisodeTrace

    source
    pub struct EpisodeTrace {
      transitions : Array[Transition]
    } derive(
    Debug    )

    A transition trace retained until an episode finishes.

    EpisodeTrace::length

    source
    fn EpisodeTrace::length(self : EpisodeTrace) -> Int

    EpisodeTrace::new

    source

    EpisodeTrace::push

    source
    fn EpisodeTrace::push(self : EpisodeTrace, transition : Transition) -> Unit

    EpisodeTrace::returns

    source
    fn EpisodeTrace::returns(self : EpisodeTrace, gamma : Double) -> Array[Double]

    EpisodeTrace::total_reward

    source
    fn EpisodeTrace::total_reward(self : EpisodeTrace) -> Double

    EpsilonGreedyPolicy

    source
    pub struct EpsilonGreedyPolicy {
      epsilon : Double
      rng : LcgRng
    } derive(
    Debug    )

    EpsilonGreedyPolicy::choose_action

    source
    fn EpsilonGreedyPolicy::choose_action(self : EpsilonGreedyPolicy, _state : Int, actions : Array[Int], q_values : Array[Double]) -> Int

    EpsilonGreedyPolicy::new

    source
    fn EpsilonGreedyPolicy::new(epsilon : Double, seed : Int) -> EpsilonGreedyPolicy

    EpsilonSchedule

    source
    pub struct EpsilonSchedule {
      start : Double
      end : Double
      decay_steps : Int
    } derive(Eq, 
    Debug    )

    EpsilonSchedule::new

    source
    fn EpsilonSchedule::new(start : Double, end : Double, decay_steps : Int) -> EpsilonSchedule

    EpsilonSchedule::value

    source
    fn EpsilonSchedule::value(self : EpsilonSchedule, step : Int) -> Double

    EpsilonSchedule::values

    source
    fn EpsilonSchedule::values(self : EpsilonSchedule, count : Int) -> Array[Double]

    EvaluationConfig

    source
    pub struct EvaluationConfig {
      episodes : Int
      max_steps : Int
      seed : Int
      report_window : Int
    } derive(Eq, 
    Debug    )

    EvaluationConfig::new

    source
    fn EvaluationConfig::new(episodes : Int, max_steps : Int, seed : Int) -> EvaluationConfig

    EvaluationConfig::with_window

    source
    fn EvaluationConfig::with_window(self : EvaluationConfig, window : Int) -> EvaluationConfig

    EvaluationPoint

    source
    pub struct EvaluationPoint {
      episode : Int
      reward : Double
      steps : Int
      solved : Bool
    } derive(Eq, 
    Debug    )

    A single observation collected during an evaluation run.

    ExpectedSARSAAgent

    source
    pub struct ExpectedSARSAAgent {
      table : QTable
      policy : EpsilonGreedyPolicy
      alpha : Double
      gamma : Double
    } derive(
    Debug    )

    ExpectedSARSAAgent::choose_action

    source
    fn ExpectedSARSAAgent::choose_action(self : ExpectedSARSAAgent, state : Int) -> Int

    ExpectedSARSAAgent::epsilon

    source
    fn ExpectedSARSAAgent::epsilon(self : ExpectedSARSAAgent) -> Double

    ExpectedSARSAAgent::learn

    source
    fn ExpectedSARSAAgent::learn(self : ExpectedSARSAAgent, transition : Transition, _next_action : Int?) -> Unit

    ExpectedSARSAAgent::new

    source
    fn ExpectedSARSAAgent::new(states : Array[Int], actions : Array[Int], policy : EpsilonGreedyPolicy, alpha : Double, gamma : Double) -> ExpectedSARSAAgent

    ExpectedSARSAAgent::q_report

    source
    fn ExpectedSARSAAgent::q_report(self : ExpectedSARSAAgent, state : Int) -> String

    ExpectedSARSAAgent::reset_episode

    source
    fn ExpectedSARSAAgent::reset_episode(_self : ExpectedSARSAAgent) -> Unit

    ExperimentSummary

    source
    pub struct ExperimentSummary {
      name : String
      result : BenchmarkResult
      notes : String
    } derive(
    Debug    )

    ExperimentSummary::report

    source
    fn ExperimentSummary::report(self : ExperimentSummary) -> String

    GridWorldEnv

    source
    pub struct GridWorldEnv {
      width : Int
      height : Int
      start_x : Int
      start_y : Int
      goal_x : Int
      goal_y : Int
      x : Int
      y : Int
      _last_stage : EpisodeStage
    } derive(
    Debug    )

    GridWorldEnv::actions

    source
    fn GridWorldEnv::actions(_self : GridWorldEnv) -> Array[Int]

    GridWorldEnv::new

    source

    GridWorldEnv::render

    source
    fn GridWorldEnv::render(self : GridWorldEnv) -> String

    GridWorldEnv::state_space

    source
    fn GridWorldEnv::state_space(self : GridWorldEnv) -> Array[Int]

    GridWorldEnv::step

    source
    fn GridWorldEnv::step(self : GridWorldEnv, action : Int) -> Transition

    LcgRng

    source

    LearningRateSchedule

    source
    pub struct LearningRateSchedule {
      initial : Double
      minimum : Double
      decay : Double
    } derive(Eq, 
    Debug    )

    LearningRateSchedule::new

    source
    fn LearningRateSchedule::new(initial : Double, minimum : Double, decay : Double) -> LearningRateSchedule

    LearningRateSchedule::value

    source
    fn LearningRateSchedule::value(self : LearningRateSchedule, step : Int) -> Double

    MemoryLogger

    source
    pub struct MemoryLogger {
      started : Int
      transitions : Int
      finished : Int
      last_report : TrainingReport?
    } derive(
    Debug    )

    A silent logger for library and CI consumers that need structured results without writing progress lines to stdout.

    MemoryLogger::finished_count

    source
    fn MemoryLogger::finished_count(self : MemoryLogger) -> Int

    MemoryLogger::new

    source

    MemoryLogger::started_count

    source
    fn MemoryLogger::started_count(self : MemoryLogger) -> Int

    MemoryLogger::transition_count

    source
    fn MemoryLogger::transition_count(self : MemoryLogger) -> Int

    MonteCarloAgent

    source
    pub struct MonteCarloAgent {
      table : QTable
      policy : EpsilonGreedyPolicy
      alpha : Double
      gamma : Double
      visits : Array[Int]
    } derive(
    Debug    )

    MonteCarloAgent::choose_action

    source
    fn MonteCarloAgent::choose_action(self : MonteCarloAgent, state : Int) -> Int

    MonteCarloAgent::learn_episode

    source
    fn MonteCarloAgent::learn_episode(self : MonteCarloAgent, trace : EpisodeTrace) -> Unit

    MonteCarloAgent::new

    source
    fn MonteCarloAgent::new(states : Array[Int], actions : Array[Int], policy : EpsilonGreedyPolicy, alpha : Double, gamma : Double) -> MonteCarloAgent

    MonteCarloAgent::q_value

    source
    fn MonteCarloAgent::q_value(self : MonteCarloAgent, state : Int, action : Int) -> Double

    MonteCarloAgent::visit_count

    source
    fn MonteCarloAgent::visit_count(self : MonteCarloAgent, state : Int, action : Int) -> Int

    PolicyEvaluation

    source
    pub struct PolicyEvaluation {
      values : Array[Double]
      residual : Double
      iterations : Int
      stable : Bool
    } derive(
    Debug    )

    PolicyEvaluation::value

    source
    fn PolicyEvaluation::value(self : PolicyEvaluation, state : Int) -> Double

    QLearningAgent

    source
    pub struct QLearningAgent {
      table : QTable
      policy : EpsilonGreedyPolicy
      alpha : Double
      gamma : Double
    } derive(
    Debug    )

    QLearningAgent::choose_action

    source
    fn QLearningAgent::choose_action(self : QLearningAgent, state : Int) -> Int

    QLearningAgent::epsilon

    source
    fn QLearningAgent::epsilon(self : QLearningAgent) -> Double

    QLearningAgent::learn

    source
    fn QLearningAgent::learn(self : QLearningAgent, transition : Transition, _next_action : Int?) -> Unit

    QLearningAgent::new

    source
    fn QLearningAgent::new(states : Array[Int], actions : Array[Int], policy : EpsilonGreedyPolicy, alpha : Double, gamma : Double) -> QLearningAgent

    QLearningAgent::q_report

    source
    fn QLearningAgent::q_report(self : QLearningAgent, state : Int) -> String

    QLearningAgent::q_value

    source
    fn QLearningAgent::q_value(self : QLearningAgent, state : Int, action : Int) -> Double

    QLearningAgent::reset_episode

    source
    fn QLearningAgent::reset_episode(_self : QLearningAgent) -> Unit

    QLearningAgent::set_q_value

    source
    fn QLearningAgent::set_q_value(self : QLearningAgent, state : Int, action : Int, value : Double) -> Unit

    QTable

    source

    RandomWalkEnv

    source
    pub struct RandomWalkEnv {
      width : Int
      start : Int
      left_terminal : Int
      right_terminal : Int
      position : Int
      rng : LcgRng
    } derive(
    Debug    )

    A small non-terminal random-walk benchmark used for value-estimation tests.

    RandomWalkEnv::actions

    source
    fn RandomWalkEnv::actions(_self : RandomWalkEnv) -> Array[Int]

    RandomWalkEnv::new

    source
    fn RandomWalkEnv::new(width : Int, seed : Int) -> RandomWalkEnv

    RandomWalkEnv::render

    source
    fn RandomWalkEnv::render(self : RandomWalkEnv) -> String

    RandomWalkEnv::reset

    source
    fn RandomWalkEnv::reset(self : RandomWalkEnv) -> Int

    RandomWalkEnv::state_space

    source
    fn RandomWalkEnv::state_space(self : RandomWalkEnv) -> Array[Int]

    RandomWalkEnv::step

    source
    fn RandomWalkEnv::step(self : RandomWalkEnv, action : Int) -> Transition

    ReplayBuffer

    source
    pub struct ReplayBuffer {
      capacity : Int
      items : Array[ReplayItem]
      cursor : Int
    } derive(
    Debug    )

    ReplayBuffer::at

    source
    fn ReplayBuffer::at(self : ReplayBuffer, index : Int) -> ReplayItem?

    ReplayBuffer::is_full

    source
    fn ReplayBuffer::is_full(self : ReplayBuffer) -> Bool

    ReplayBuffer::length

    source
    fn ReplayBuffer::length(self : ReplayBuffer) -> Int

    ReplayBuffer::mean_reward

    source
    fn ReplayBuffer::mean_reward(self : ReplayBuffer) -> Double

    ReplayBuffer::new

    source
    fn ReplayBuffer::new(capacity : Int) -> ReplayBuffer

    ReplayBuffer::priorities

    source
    fn ReplayBuffer::priorities(self : ReplayBuffer) -> Array[Double]

    ReplayBuffer::push

    source
    fn ReplayBuffer::push(self : ReplayBuffer, transition : Transition, priority : Double) -> Unit

    ReplayItem

    source
    pub struct ReplayItem {
      transition : Transition
      priority : Double
    } derive(
    Debug    )

    ReportTable

    source
    pub struct ReportTable {
      headers : Array[String]
      rows : Array[Array[String]]
    } derive(
    Debug    )

    ReportTable::add_row

    source
    fn ReportTable::add_row(self : ReportTable, row : Array[String]) -> Unit

    ReportTable::column_count

    source
    fn ReportTable::column_count(self : ReportTable) -> Int

    ReportTable::new

    source
    fn ReportTable::new(headers : Array[String]) -> ReportTable

    ReportTable::row_count

    source
    fn ReportTable::row_count(self : ReportTable) -> Int

    ReportTable::to_csv

    source
    fn ReportTable::to_csv(self : ReportTable) -> String

    ReportTable::to_markdown

    source
    fn ReportTable::to_markdown(self : ReportTable) -> String

    ReportTable::valid_shape

    source
    fn ReportTable::valid_shape(self : ReportTable) -> Bool

    RunningStats

    source
    pub struct RunningStats {
      count : Int
      mean : Double
      m2 : Double
      minimum : Double
      maximum : Double
    } derive(
    Debug    )

    Online statistics with numerically stable mean and variance updates.

    RunningStats::average

    source
    fn RunningStats::average(self : RunningStats) -> Double

    RunningStats::new

    source

    RunningStats::push

    source
    fn RunningStats::push(self : RunningStats, value : Double) -> Unit

    RunningStats::standard_error

    source
    fn RunningStats::standard_error(self : RunningStats) -> Double

    RunningStats::summary

    source
    fn RunningStats::summary(self : RunningStats) -> String

    RunningStats::variance

    source
    fn RunningStats::variance(self : RunningStats) -> Double

    SARSAAgent

    source
    pub struct SARSAAgent {
      table : QTable
      policy : EpsilonGreedyPolicy
      alpha : Double
      gamma : Double
    } derive(
    Debug    )

    impl Agent for SARSAAgent

    SARSAAgent::choose_action

    source
    fn SARSAAgent::choose_action(self : SARSAAgent, state : Int) -> Int

    SARSAAgent::epsilon

    source
    fn SARSAAgent::epsilon(self : SARSAAgent) -> Double

    SARSAAgent::learn

    source
    fn SARSAAgent::learn(self : SARSAAgent, transition : Transition, next_action : Int?) -> Unit

    SARSAAgent::new

    source
    fn SARSAAgent::new(states : Array[Int], actions : Array[Int], policy : EpsilonGreedyPolicy, alpha : Double, gamma : Double) -> SARSAAgent

    SARSAAgent::q_report

    source
    fn SARSAAgent::q_report(self : SARSAAgent, state : Int) -> String

    SARSAAgent::reset_episode

    source
    fn SARSAAgent::reset_episode(_self : SARSAAgent) -> Unit

    Scorecard

    source
    pub struct Scorecard {
      name : String
      expected : Double
      observed : Double
      tolerance : Double
    } derive(Eq, 
    Debug    )

    Scorecard::error

    source
    fn Scorecard::error(self : Scorecard) -> Double

    Scorecard::new

    source
    fn Scorecard::new(name : String, expected : Double, observed : Double, tolerance : Double) -> Scorecard

    Scorecard::passed

    source
    fn Scorecard::passed(self : Scorecard) -> Bool

    Scorecard::text

    source
    fn Scorecard::text(self : Scorecard) -> String

    ScorecardSet

    source
    pub struct ScorecardSet {
      items : Array[Scorecard]
    } derive(
    Debug    )

    ScorecardSet::add

    source
    fn ScorecardSet::add(self : ScorecardSet, score : Scorecard) -> Unit

    ScorecardSet::failed_count

    source
    fn ScorecardSet::failed_count(self : ScorecardSet) -> Int

    ScorecardSet::new

    source

    ScorecardSet::passed

    source
    fn ScorecardSet::passed(self : ScorecardSet) -> Bool

    ScorecardSet::to_text

    source
    fn ScorecardSet::to_text(self : ScorecardSet) -> String

    SeedBank

    source
    pub struct SeedBank {
      seeds : Array[Int]
    } derive(Eq, 
    Debug    )

    SeedBank::at

    source
    fn SeedBank::at(self : SeedBank, index : Int) -> Int?

    SeedBank::csv

    source
    fn SeedBank::csv(self : SeedBank) -> String

    SeedBank::distinct

    source
    fn SeedBank::distinct(self : SeedBank) -> Bool

    SeedBank::length

    source
    fn SeedBank::length(self : SeedBank) -> Int

    SeedBank::new

    source
    fn SeedBank::new(first : Int, count : Int) -> SeedBank

    Trainer

    source
    pub struct Trainer {
      episodes : Int
      max_steps : Int
    } derive(
    Debug    )

    Trainer::new

    source
    fn Trainer::new(episodes : Int, max_steps : Int) -> Trainer

    Trainer::train

    source
    fn[Env : Environment, Ag : Agent, Log : Logger] Trainer::train(self : Trainer, env : Env, agent : Ag, logger : Log) -> TrainingReport

    A trait-driven training entry point. The agent receives the next action as an optional hint: SARSA uses it, while Q-learning ignores it. This keeps the episode loop independent of a concrete environment or agent type.

    Trainer::train_q_learning

    source
    fn Trainer::train_q_learning(self : Trainer, env : GridWorldEnv, agent : QLearningAgent, logger : ConsoleLogger) -> TrainingReport

    Trainer::train_sarsa

    source
    fn Trainer::train_sarsa(self : Trainer, env : GridWorldEnv, agent : SARSAAgent, logger : ConsoleLogger) -> TrainingReport

    TrainingReport

    source
    pub struct TrainingReport {
      label : String
      episodes : Int
      rewards : Array[Double]
      steps : Array[Int]
      goal_hits : Int
      final_epsilon : Double
    } derive(
    Debug    )

    TrainingReport::compact_line

    source
    fn TrainingReport::compact_line(self : TrainingReport) -> String

    TrainingReport::episode_count

    source
    fn TrainingReport::episode_count(self : TrainingReport) -> Int

    TrainingReport::final_epsilon_value

    source
    fn TrainingReport::final_epsilon_value(self : TrainingReport) -> Double

    TrainingReport::goal_count

    source
    fn TrainingReport::goal_count(self : TrainingReport) -> Int

    TrainingReport::reward_at

    source
    fn TrainingReport::reward_at(self : TrainingReport, episode : Int) -> Double

    TrainingReport::steps_at

    source
    fn TrainingReport::steps_at(self : TrainingReport, episode : Int) -> Int

    Transition

    source
    pub struct Transition {
      state : Int
      action : Int
      reward : Double
      next_state : Int
      done : Bool
      step : Int
    } derive(Eq, 
    Debug    )

    Transition::action

    source
    fn Transition::action(self : Transition) -> Int

    Transition::done

    source
    fn Transition::done(self : Transition) -> Bool

    Transition::new

    source
    fn Transition::new(state : Int, action : Int, reward : Double, next_state : Int, done : Bool, step : Int) -> Transition

    Transition::next_state

    source
    fn Transition::next_state(self : Transition) -> Int

    Transition::reward

    source
    fn Transition::reward(self : Transition) -> Double

    Transition::state

    source
    fn Transition::state(self : Transition) -> Int

    Transition::step_index

    source
    fn Transition::step_index(self : Transition) -> Int

    ValidationFinding

    source
    pub struct ValidationFinding {
      rule : String
      severity : ValidationSeverity
      message : String
    } derive(Eq, 
    Debug    )

    ValidationReport

    source
    pub struct ValidationReport {
      findings : Array[ValidationFinding]
      passed : Int
      notices : Int
      failures : Int
    } derive(
    Debug    )

    ValidationReport::add

    source
    fn ValidationReport::add(self : ValidationReport, finding : ValidationFinding) -> Unit

    ValidationReport::finding_count

    source
    fn ValidationReport::finding_count(self : ValidationReport) -> Int

    ValidationReport::new

    source

    ValidationReport::ok

    source
    fn ValidationReport::ok(self : ValidationReport) -> Bool

    ValidationReport::summary

    source
    fn ValidationReport::summary(self : ValidationReport) -> String

    ValidationReport::to_text

    source
    fn ValidationReport::to_text(self : ValidationReport) -> String

    ValidationSeverity

    source
    pub enum ValidationSeverity {
      Pass
      Notice
      Failure
    } derive(Eq, 
    Debug    )

    ValueIterationResult

    source
    pub struct ValueIterationResult {
      values : Array[Double]
      policy : Array[Int]
      iterations : Int
      converged : Bool
      residual : Double
    } derive(
    Debug    )

    A value-iteration result that can be inspected independently of a learner.

    ValueIterationResult::action

    source
    fn ValueIterationResult::action(self : ValueIterationResult, state : Int) -> Int

    ValueIterationResult::greedy_path

    source
    fn ValueIterationResult::greedy_path(self : ValueIterationResult, start : Int, goal : Int, limit : Int) -> Array[Int]

    ValueIterationResult::value

    source
    fn ValueIterationResult::value(self : ValueIterationResult, state : Int) -> Double

    acceptance_evidence

    source
    fn acceptance_evidence() -> Array[String]

    action_map_text

    source
    fn action_map_text(actions : Array[Int]) -> String

    all_environment_audits

    source
    fn all_environment_audits() -> String

    audit_score

    source
    fn audit_score(audit : EnvironmentAudit, expected_states : Int, expected_actions : Int) -> ScorecardSet

    benchmark_catalog

    source
    fn benchmark_catalog() -> String

    benchmark_manifest

    source
    fn benchmark_manifest() -> String

    boundary_probe

    source
    fn boundary_probe() -> String

    clipped

    source
    fn clipped(value : Double, lower : Double, upper : Double) -> Double

    compact_result_line

    source
    fn compact_result_line(result : BenchmarkResult) -> String

    compact_results

    source
    fn compact_results(results : Array[BenchmarkResult]) -> String

    compare_results_table

    source
    fn compare_results_table(results : Array[BenchmarkResult]) -> ReportTable

    compare_training_reports

    source
    fn compare_training_reports(left : TrainingReport, right : TrainingReport) -> String

    confidence_interval

    source
    fn confidence_interval(values : Array[Double]) -> String

    csv_escape

    source
    fn csv_escape(value : String) -> String

    discounted_return

    source
    fn discounted_return(rewards : Array[Double], gamma : Double) -> Double

    discounted_returns

    source
    fn discounted_returns(rewards : Array[Double], gamma : Double) -> Array[Double]

    evaluate_grid_policy

    source
    fn evaluate_grid_policy(policy : Array[Int], goal : Int, gamma : Double, limit : Int) -> PolicyEvaluation

    full_benchmark_report

    source
    fn full_benchmark_report(config : EvaluationConfig) -> String

    greedy_action_map

    source
    fn greedy_action_map(agent : QLearningAgent, state_count : Int) -> Array[Int]

    gridworld_value_iteration

    source
    fn gridworld_value_iteration(width : Int, height : Int, goal : Int, gamma : Double, tolerance : Double, limit : Int) -> ValueIterationResult

    Compute an optimal bounded policy for a rectangular navigation task.

    join_lines

    source
    fn join_lines(lines : Array[String]) -> String

    linear_interpolate

    source
    fn linear_interpolate(left : Double, right : Double, ratio : Double) -> Double

    markdown_escape

    source
    fn markdown_escape(value : String) -> String

    merge_reward_series

    source
    fn merge_reward_series(left : Array[Double], right : Array[Double]) -> Array[Double]

    moving_average

    source
    fn moving_average(values : Array[Double], window : Int) -> Array[Double]

    normalize_returns

    source
    fn normalize_returns(values : Array[Double]) -> Array[Double]

    percentile

    source
    fn percentile(values : Array[Double], ratio : Double) -> Double

    performance_budget

    source
    fn performance_budget(episodes : Int, max_steps : Int) -> Int

    policy_agreement

    source
    fn policy_agreement(left : ValueIterationResult, right : ValueIterationResult) -> Double

    policy_histogram

    source
    fn policy_histogram(policy : Array[Int], action_count : Int) -> Array[Int]

    project_name

    source
    fn project_name() -> String

    MoonRLLab is a compact reinforcement-learning lab for discrete problems.

    The project focuses on a small but extensible tabular stack:
    • environments expose a finite state space and legal actions
    • policies choose actions with epsilon-greedy exploration
    • agents implement Q-learning and SARSA updates
    • the trainer produces a readable episode report

    project_self_check

    source
    fn project_self_check(config : EvaluationConfig) -> String

    q_table_snapshot

    source
    fn q_table_snapshot(agent : QLearningAgent, states : Int, actions : Int) -> String

    quality_text

    source
    fn quality_text(result : BenchmarkResult) -> String

    regret

    source
    fn regret(optimal : Double, actual : Array[Double]) -> Array[Double]

    release_checklist_text

    source
    fn release_checklist_text() -> String

    report_contract

    source
    fn report_contract() -> String

    fn report_footer() -> String

    report_header

    source
    fn report_header(title : String, seed : Int) -> String

    report_quality

    source
    fn report_quality(result : BenchmarkResult) -> ScorecardSet

    report_sections

    source
    fn report_sections(config : EvaluationConfig) -> Array[String]

    report_sections_text

    source
    fn report_sections_text(config : EvaluationConfig) -> String

    report_table_from_result

    source
    fn report_table_from_result(result : BenchmarkResult) -> ReportTable

    report_table_from_stats

    source
    fn report_table_from_stats(result : BenchmarkResult) -> ReportTable

    report_version

    source
    fn report_version() -> String

    reproducibility_signature

    source
    fn reproducibility_signature(config : EvaluationConfig) -> String

    result_digest

    source
    fn result_digest(result : BenchmarkResult) -> String

    result_episode_ids

    source
    fn result_episode_ids(result : BenchmarkResult) -> Array[Int]

    result_has_consistent_ids

    source
    fn result_has_consistent_ids(result : BenchmarkResult) -> Bool

    result_has_learning_signal

    source
    fn result_has_learning_signal(result : BenchmarkResult) -> Bool

    result_health

    source
    fn result_health(result : BenchmarkResult) -> String

    result_is_nontrivial

    source
    fn result_is_nontrivial(result : BenchmarkResult) -> Bool

    result_range

    source
    fn result_range(result : BenchmarkResult) -> String

    reward_ceiling

    source
    fn reward_ceiling(values : Array[Double]) -> Double

    reward_floor

    source
    fn reward_floor(values : Array[Double]) -> Double

    risk_flags

    source
    fn risk_flags() -> Array[String]

    run_bandit_benchmark

    source
    fn run_bandit_benchmark(config : EvaluationConfig) -> ExperimentSummary

    run_cliff_benchmark

    source
    fn run_cliff_benchmark(episodes : Int, seed : Int) -> ExperimentSummary

    run_demo

    source
    fn run_demo() -> TrainingReport

    run_gridworld_benchmark

    source
    fn run_gridworld_benchmark(episodes : Int, seed : Int) -> ExperimentSummary

    run_random_walk_benchmark

    source
    fn run_random_walk_benchmark(config : EvaluationConfig) -> ExperimentSummary

    run_sarsa_demo

    source
    fn run_sarsa_demo() -> TrainingReport

    run_standard_reports

    source
    fn run_standard_reports(config : EvaluationConfig) -> String

    seed_sensitivity

    source
    fn seed_sensitivity(episodes : Int) -> String

    solved_prefix

    source
    fn solved_prefix(values : Array[Bool]) -> Int

    source_scale_estimate

    source
    fn source_scale_estimate() -> String

    stable_mean

    source
    fn stable_mean(values : Array[Double]) -> Double

    stable_sum

    source
    fn stable_sum(values : Array[Double]) -> Double

    standard_benchmarks

    source
    fn standard_benchmarks() -> Array[BenchmarkCase]

    suite_summary

    source
    fn suite_summary(config : EvaluationConfig) -> String

    table_is_empty

    source
    fn table_is_empty(table : ReportTable) -> Bool

    table_last_row

    source
    fn table_last_row(table : ReportTable) -> Array[String]?

    table_preview

    source
    fn table_preview(table : ReportTable, limit : Int) -> String

    train_cliff_qlearning_generic

    source
    fn train_cliff_qlearning_generic(episodes : Int, max_steps : Int, seed : Int) -> TrainingReport

    train_gridworld_expected_sarsa_generic

    source
    fn train_gridworld_expected_sarsa_generic(episodes : Int, max_steps : Int, seed : Int) -> TrainingReport

    train_gridworld_qlearning_generic

    source
    fn train_gridworld_qlearning_generic(episodes : Int, max_steps : Int, seed : Int) -> TrainingReport

    train_gridworld_sarsa_generic

    source
    fn train_gridworld_sarsa_generic(episodes : Int, max_steps : Int, seed : Int) -> TrainingReport

    train_with_memory_logger

    source
    fn train_with_memory_logger(episodes : Int, max_steps : Int, seed : Int) -> TrainingReport

    trend

    source
    fn trend(values : Array[Double]) -> Double

    tutorial_blurb

    source
    fn tutorial_blurb() -> String

    validate_cliff

    source
    fn validate_cliff(env : CliffWalkingEnv) -> ValidationReport

    validate_config

    source
    fn validate_config(config : EvaluationConfig) -> ValidationReport

    validate_gridworld

    source
    fn validate_gridworld(env : GridWorldEnv) -> ValidationReport

    validate_planner

    source
    fn validate_planner(result : ValueIterationResult) -> ValidationReport

    validate_policy

    source
    fn validate_policy(policy : Array[Int], action_count : Int) -> ValidationReport

    validate_replay

    source
    fn validate_replay(buffer : ReplayBuffer) -> ValidationReport

    validate_result

    source
    fn validate_result(result : BenchmarkResult) -> ValidationReport

    validate_schedule

    source
    fn validate_schedule(schedule : EpsilonSchedule, samples : Int) -> ValidationReport

    value_error

    source
    fn value_error(left : Array[Double], right : Array[Double]) -> Double

    Source Files

    Powered by MoonBit

    Site sourceReport issueModulesSkillsBuild queueStatistics

    © 2026 mooncakes.io