🥮 mooncakes.io

    moon-online-models

    A native MoonBit toolkit for online learning, sparse and dense models, streaming features, evaluation, monitoring, serving, and reproducible model lifecycle workflows.

    machine-learning
    regression
    online-learning
    incremental-learning
    classification
    streaming-data
    model-monitoring
    moonbit
    Download zip
    Author
    Version
    0.2.3
    License
    Apache-2.0
    Repository
    Last updated
    2 months ago
    Downloads
    40

    No dependencies

    #moon-online-models

    moon-online-models is a native MoonBit toolkit for machine learning on streaming data. It provides online models, incremental feature processing, evaluation metrics, monitoring utilities, and deployment primitives for use cases such as CTR prediction, risk scoring, device telemetry, ranking, and real-time forecasting.

    The library is designed for event-by-event updates, bounded state, explicit validation, deterministic experiments, and compilation to MoonBit-supported targets.

    #Core capabilities

    #Online learning

    • RLS, SGD/FTRL logistic regression, Adagrad, ridge, Huber, and quantile regression.
    • Softmax regression, Gaussian and Bernoulli Naive Bayes, online k-means, kernel models, PCA, factorization, tree stumps, ensembles, and time-series models.
    • Epsilon-greedy, UCB, softmax, posterior, and contextual bandits with deterministic exploration and online reward evaluation.

    #Streaming data and features

    • Dense and sparse vectors with dimension-safe operations.
    • Feature hashing, categorical encoding, CSV parsing, feature crosses, and polynomial features.
    • Online joins, rolling windows, reservoirs, stratified sampling, bootstrap counters, schema validation, and bounded feature storage.
    • Typed data contracts, missing-value policies, idempotency ledgers, online graph/co-occurrence models, and user-item recommendation primitives.

    #Evaluation and reliability

    • Exact and histogram AUC, calibration, regression, ranking, CTR, and confusion-matrix metrics.
    • Conformal intervals, drift detection, fairness diagnostics, cost-sensitive thresholds, gradient guards, and prediction guards.
    • Snapshots with checksums, model registries, deployment state transitions, canary experiments, serving batchers, alerts, error budgets, audit trails, data lineage, privacy budgets, and reproducibility manifests.
    • Model routing with health-aware fallbacks and score caches, Holt-Winters and intermittent-demand forecasts, adaptive histograms, streaming stump ensembles, and reliability/conformal calibration monitors.

    #Quick start

    Add the package to a MoonBit project:

    moon add phjphj676/moon-online-models

    Create and update a dense online classifier:

    let model = @moon-online-models.AdagradLogisticRegression::new(
      3,
      learning_rate=0.1,
    )
    model.update([1.0, 0.0, 0.2], 1.0)
    model.update([0.0, 1.0, -0.2], 0.0)
    let probability = model.predict([1.0, 0.0, 0.2])

    Use sparse hashed features for high-cardinality event data:

    let hasher = @moon-online-models.FeatureHasher::new(1_000_000)
    let features = hasher.encode(["country=CN", "device=mobile", "slot=home"])
    let model = @moon-online-models.SparseAdagradClassifier::new(1_000_000)
    model.update(features, 1.0)
    let probability = model.predict(features)

    #CLI and reproducible commands

    The repository includes a native benchmark command under cmd/benchmark and a PowerShell wrapper under benchmarks/run.ps1.

    moon version --all
moon update
moon check --target all
moon test --target all
moon run --target native cmd/benchmark

    On Windows, the wrapper records the benchmark wall-clock time:

    .\benchmarks\run.ps1

    Formatting and generated-interface checks:

    moon fmt && git diff --exit-code
moon info && git diff --exit-code

    #Architecture

    moon-online-models/
├── *.mbt                       Core models and streaming primitives
├── production_extensions_test.mbt Boundary and behavior coverage
├── cmd/benchmark/              Native reproducible benchmark command
├── benchmarks/                 Runner, methodology, and measured results
└── .github/workflows/          Cross-platform checks and package publishing

    The root package is dependency-light and uses MoonBit core packages for math and JSON support. Algorithms expose explicit counters, reset operations, and dimension-safe boundaries so they can be embedded in long-running streams.

    #Benchmark

    The benchmark trains an AdagradLogisticRegression model on 20,000 deterministic events and reports update count, exact AUC, final weight norm, and a stable weight checksum. The latest measured reference is maintained in benchmarks/RESULTS.md; elapsed time is hardware- and runtime-dependent.

    #Tests

    The black-box suite covers empty inputs, dimension mismatches, out-of-range indices, non-finite values, sparse features, CSV quoting, metric degeneracy, bounded capacities, drift detection, feature storage, serving, deployment, audit logging, and cost-sensitive decisions.

    Run all configured targets with:

    moon test --target all

    #CI

    GitHub Actions installs the current stable MoonBit toolchain and checks Ubuntu, macOS, and Windows. Each job runs moon version --all, moon update, moon check --target all, moon test --target all, moon fmt, and moon info. The publishing workflow is manual and runs the same prepublish checks before calling moon publish.

    #Package and license

    OnlineLearner

    source
    pub trait OnlineLearner {
      fn update(Self, Array[Double], Double) -> Unit
      fn predict(Self, Array[Double]) -> Double
    }

    A trait for online learning models that can be incrementally updated.

    Snapshot

    source
    pub trait Snapshot {
      fn to_bytes(Self) -> Bytes
      fn from_bytes(Self, Bytes) -> Bool
    }

    A trait for models that support saving and loading state.

    AdagradLinearRegression

    source
    pub struct AdagradLinearRegression {
      weights : Array[Double]
      accumulator : Array[Double]
      learning_rate : Double
      epsilon : Double
      l2 : Double
      steps : Int
    }

    A linear regressor with Adagrad updates, useful when labels are continuous and the stream has heterogeneous feature scales.

    AdagradLinearRegression::dimension

    source

    AdagradLinearRegression::loss

    source
    fn AdagradLinearRegression::loss(self : AdagradLinearRegression, features : Array[Double], label : Double) -> Double

    AdagradLinearRegression::new

    source
    fn AdagradLinearRegression::new(dimension : Int, learning_rate? : Double, epsilon? : Double, l2? : Double) -> AdagradLinearRegression

    AdagradLinearRegression::predict

    source
    fn AdagradLinearRegression::predict(self : AdagradLinearRegression, features : Array[Double]) -> Double

    AdagradLinearRegression::reset

    source

    AdagradLinearRegression::residual

    source
    fn AdagradLinearRegression::residual(self : AdagradLinearRegression, features : Array[Double], label : Double) -> Double

    AdagradLinearRegression::steps

    source

    AdagradLinearRegression::update

    source
    fn AdagradLinearRegression::update(self : AdagradLinearRegression, features : Array[Double], label : Double) -> Unit

    AdagradLinearRegression::weights

    source

    AdagradLogisticRegression

    source
    pub struct AdagradLogisticRegression {
      weights : Array[Double]
      accumulator : Array[Double]
      learning_rate : Double
      epsilon : Double
      l1 : Double
      l2 : Double
      steps : Int
      seen : Double
    }

    Online binary classifier trained with Adagrad and optional elastic-net regularization. It is a practical dense counterpart to FTRL for streams where feature values are dense but their scales change over time.

    AdagradLogisticRegression::accumulator

    source
    fn AdagradLogisticRegression::accumulator(self : AdagradLogisticRegression) -> Array[Double]

    AdagradLogisticRegression::dimension

    source

    AdagradLogisticRegression::feature_importance

    source
    fn AdagradLogisticRegression::feature_importance(self : AdagradLogisticRegression) -> Array[Double]

    AdagradLogisticRegression::logit

    source
    fn AdagradLogisticRegression::logit(self : AdagradLogisticRegression, features : Array[Double]) -> Double

    AdagradLogisticRegression::loss

    source
    fn AdagradLogisticRegression::loss(self : AdagradLogisticRegression, features : Array[Double], label : Double) -> Double

    AdagradLogisticRegression::new

    source
    fn AdagradLogisticRegression::new(dimension : Int, learning_rate? : Double, epsilon? : Double, l1? : Double, l2? : Double) -> AdagradLogisticRegression

    AdagradLogisticRegression::predict

    source
    fn AdagradLogisticRegression::predict(self : AdagradLogisticRegression, features : Array[Double]) -> Double

    AdagradLogisticRegression::predict_label

    source
    fn AdagradLogisticRegression::predict_label(self : AdagradLogisticRegression, features : Array[Double], threshold? : Double) -> Double

    AdagradLogisticRegression::regularization

    source
    fn AdagradLogisticRegression::regularization(self : AdagradLogisticRegression) -> Double

    AdagradLogisticRegression::reset

    source

    AdagradLogisticRegression::seen

    source

    AdagradLogisticRegression::sparsity

    source
    fn AdagradLogisticRegression::sparsity(self : AdagradLogisticRegression, tolerance? : Double) -> Double

    AdagradLogisticRegression::steps

    source

    AdagradLogisticRegression::update

    source
    fn AdagradLogisticRegression::update(self : AdagradLogisticRegression, features : Array[Double], label : Double) -> Unit

    AdagradLogisticRegression::update_weighted

    source
    fn AdagradLogisticRegression::update_weighted(self : AdagradLogisticRegression, features : Array[Double], label : Double, sample_weight : Double) -> Unit

    AdagradLogisticRegression::weights

    source

    AdagradOptimizer

    source
    pub struct AdagradOptimizer {
      learning_rate : Double
      epsilon : Double
      schedule : LearningRateSchedule
      accumulator : Array[Double]
      clipper : GradientClipper
      step_count : Int
      statistics : OptimizerStatistics
    }

    AdagradOptimizer::accumulated

    source
    fn AdagradOptimizer::accumulated(self : AdagradOptimizer) -> Array[Double]

    AdagradOptimizer::apply

    source
    fn AdagradOptimizer::apply(self : AdagradOptimizer, parameters : Array[Double], gradients : Array[Double]) -> Unit

    AdagradOptimizer::dimension

    source
    fn AdagradOptimizer::dimension(self : AdagradOptimizer) -> Int

    AdagradOptimizer::new

    source
    fn AdagradOptimizer::new(dimension : Int, learning_rate? : Double, epsilon? : Double, schedule? : LearningRateSchedule, clipper? : GradientClipper) -> AdagradOptimizer

    AdagradOptimizer::rate

    source
    fn AdagradOptimizer::rate(self : AdagradOptimizer) -> Double

    AdagradOptimizer::reset

    source
    fn AdagradOptimizer::reset(self : AdagradOptimizer) -> Unit

    AdagradOptimizer::statistics

    source

    AdagradOptimizer::step_count

    source
    fn AdagradOptimizer::step_count(self : AdagradOptimizer) -> Int

    AdagradOptimizer::update

    source
    fn AdagradOptimizer::update(self : AdagradOptimizer, gradients : Array[Double]) -> Array[Double]

    AdamOptimizer

    source
    pub struct AdamOptimizer {
      learning_rate : Double
      beta1 : Double
      beta2 : Double
      epsilon : Double
      first_moment : Array[Double]
      second_moment : Array[Double]
      clipper : GradientClipper
      step_count : Int
    }

    AdamOptimizer::apply

    source
    fn AdamOptimizer::apply(self : AdamOptimizer, parameters : Array[Double], gradients : Array[Double]) -> Unit

    AdamOptimizer::first_moment

    source
    fn AdamOptimizer::first_moment(self : AdamOptimizer) -> Array[Double]

    AdamOptimizer::new

    source
    fn AdamOptimizer::new(dimension : Int, learning_rate? : Double, beta1? : Double, beta2? : Double, epsilon? : Double, clipper? : GradientClipper) -> AdamOptimizer

    AdamOptimizer::reset

    source
    fn AdamOptimizer::reset(self : AdamOptimizer) -> Unit

    AdamOptimizer::second_moment

    source
    fn AdamOptimizer::second_moment(self : AdamOptimizer) -> Array[Double]

    AdamOptimizer::step_count

    source
    fn AdamOptimizer::step_count(self : AdamOptimizer) -> Int

    AdamOptimizer::update

    source
    fn AdamOptimizer::update(self : AdamOptimizer, gradients : Array[Double]) -> Array[Double]

    AdaptiveHistogram

    source
    pub struct AdaptiveHistogram {
      lower : Double
      upper : Double
      bins : Array[HistogramBin]
      seen : Double
      outliers : Int
    }

    AdaptiveHistogram::bin

    source
    fn AdaptiveHistogram::bin(self : AdaptiveHistogram, index : Int) -> HistogramBin?

    AdaptiveHistogram::bin_count

    source
    fn AdaptiveHistogram::bin_count(self : AdaptiveHistogram) -> Int

    AdaptiveHistogram::cdf

    source
    fn AdaptiveHistogram::cdf(self : AdaptiveHistogram, value : Double) -> Double

    AdaptiveHistogram::mean

    source
    fn AdaptiveHistogram::mean(self : AdaptiveHistogram) -> Double

    AdaptiveHistogram::new

    source
    fn AdaptiveHistogram::new(lower : Double, upper : Double, bin_count? : Int) -> AdaptiveHistogram

    AdaptiveHistogram::observe

    source
    fn AdaptiveHistogram::observe(self : AdaptiveHistogram, value : Double, weight? : Double, positive? : Bool) -> Bool

    AdaptiveHistogram::outliers

    source
    fn AdaptiveHistogram::outliers(self : AdaptiveHistogram) -> Int

    AdaptiveHistogram::positive_rate

    source
    fn AdaptiveHistogram::positive_rate(self : AdaptiveHistogram) -> Double

    AdaptiveHistogram::quantile

    source
    fn AdaptiveHistogram::quantile(self : AdaptiveHistogram, probability : Double) -> Double

    AdaptiveHistogram::reset

    source
    fn AdaptiveHistogram::reset(self : AdaptiveHistogram) -> Unit

    AdaptiveHistogram::seen

    source
    fn AdaptiveHistogram::seen(self : AdaptiveHistogram) -> Double

    AdaptiveHistogram::variance

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

    AdaptiveThreshold

    source
    pub struct AdaptiveThreshold {
      target_rate : Double
      histogram : AdaptiveHistogram
      threshold : Double
      updates : Int
    }

    AdaptiveThreshold::is_anomaly

    source
    fn AdaptiveThreshold::is_anomaly(self : AdaptiveThreshold, value : Double) -> Bool

    AdaptiveThreshold::new

    source
    fn AdaptiveThreshold::new(lower : Double, upper : Double, target_rate? : Double, bins? : Int) -> AdaptiveThreshold

    AdaptiveThreshold::observe

    source
    fn AdaptiveThreshold::observe(self : AdaptiveThreshold, value : Double) -> Bool

    AdaptiveThreshold::reset

    source
    fn AdaptiveThreshold::reset(self : AdaptiveThreshold) -> Unit

    AdaptiveThreshold::score

    source
    fn AdaptiveThreshold::score(self : AdaptiveThreshold, value : Double) -> Double

    AdaptiveThreshold::target_rate

    source
    fn AdaptiveThreshold::target_rate(self : AdaptiveThreshold) -> Double

    AdaptiveThreshold::threshold

    source
    fn AdaptiveThreshold::threshold(self : AdaptiveThreshold) -> Double

    AdaptiveThreshold::updates

    source
    fn AdaptiveThreshold::updates(self : AdaptiveThreshold) -> Int

    AggregateSummary

    source
    pub struct AggregateSummary {
      start : Int64
      end : Int64
      count : Int
      weight : Double
      sum : Double
      square_sum : Double
      minimum : Double
      maximum : Double
    }

    AggregateSummary::count

    source
    fn AggregateSummary::count(self : AggregateSummary) -> Int

    AggregateSummary::end

    source
    fn AggregateSummary::end(self : AggregateSummary) -> Int64

    AggregateSummary::maximum

    source
    fn AggregateSummary::maximum(self : AggregateSummary) -> Double

    AggregateSummary::mean

    source
    fn AggregateSummary::mean(self : AggregateSummary) -> Double

    AggregateSummary::merge

    source
    fn AggregateSummary::merge(self : AggregateSummary, other : AggregateSummary) -> Unit

    AggregateSummary::minimum

    source
    fn AggregateSummary::minimum(self : AggregateSummary) -> Double

    AggregateSummary::new

    source
    fn AggregateSummary::new(start : Int64, end : Int64) -> AggregateSummary

    AggregateSummary::observe

    source
    fn AggregateSummary::observe(self : AggregateSummary, value : Double, weight? : Double) -> Bool

    AggregateSummary::reset

    source
    fn AggregateSummary::reset(self : AggregateSummary) -> Unit

    AggregateSummary::start

    source
    fn AggregateSummary::start(self : AggregateSummary) -> Int64

    AggregateSummary::sum

    source
    fn AggregateSummary::sum(self : AggregateSummary) -> Double

    AggregateSummary::variance

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

    AggregateSummary::weight

    source
    fn AggregateSummary::weight(self : AggregateSummary) -> Double

    AlertCondition

    source
    pub(all) enum AlertCondition {
      GreaterThan
      LessThan
      OutsideRange
      Stale
    } derive(Eq, 
    Debug    )

    AlertRule

    source
    pub struct AlertRule {
      name : String
      metric : String
      condition : AlertCondition
      lower : Double
      upper : Double
      severity : AlertSeverity
      cooldown : Int64
      last_alert : Int64?
    }

    AlertRule::evaluate

    source
    fn AlertRule::evaluate(self : AlertRule, snapshot : MetricSnapshot, now : Int64) -> Bool

    AlertRule::greater

    source
    fn AlertRule::greater(name : String, metric : String, threshold : Double, severity? : AlertSeverity, cooldown? : Int64) -> AlertRule

    AlertRule::less

    source
    fn AlertRule::less(name : String, metric : String, threshold : Double, severity? : AlertSeverity, cooldown? : Int64) -> AlertRule

    AlertRule::metric

    source
    fn AlertRule::metric(self : AlertRule) -> String

    AlertRule::name

    source
    fn AlertRule::name(self : AlertRule) -> String

    AlertRule::outside

    source
    fn AlertRule::outside(name : String, metric : String, lower : Double, upper : Double, severity? : AlertSeverity, cooldown? : Int64) -> AlertRule

    AlertRule::reset

    source
    fn AlertRule::reset(self : AlertRule) -> Unit

    AlertRule::severity

    source
    fn AlertRule::severity(self : AlertRule) -> AlertSeverity

    AlertRule::stale

    source
    fn AlertRule::stale(name : String, metric : String, max_age : Int64, severity? : AlertSeverity) -> AlertRule

    AlertSeverity

    source
    pub(all) enum AlertSeverity {
      Info
      Warn
      Critical
    } derive(Eq, 
    Debug    )

    ArmStatistics

    source
    pub struct ArmStatistics {
      arm : Int
      pulls : Int
      reward_sum : Double
      reward_square_sum : Double
      last_reward : Double
    }

    ArmStatistics::arm

    source
    fn ArmStatistics::arm(self : ArmStatistics) -> Int

    ArmStatistics::last_reward

    source
    fn ArmStatistics::last_reward(self : ArmStatistics) -> Double

    ArmStatistics::mean

    source
    fn ArmStatistics::mean(self : ArmStatistics) -> Double

    ArmStatistics::new

    source
    fn ArmStatistics::new(arm : Int) -> ArmStatistics

    ArmStatistics::pulls

    source
    fn ArmStatistics::pulls(self : ArmStatistics) -> Int

    ArmStatistics::reset

    source
    fn ArmStatistics::reset(self : ArmStatistics) -> Unit

    ArmStatistics::reward_sum

    source
    fn ArmStatistics::reward_sum(self : ArmStatistics) -> Double

    ArmStatistics::standard_error

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

    ArmStatistics::update

    source
    fn ArmStatistics::update(self : ArmStatistics, reward : Double) -> Unit

    ArmStatistics::variance

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

    AucTracker

    source
    pub struct AucTracker {
      scores : Array[Double]
      labels : Array[Bool]
    }

    Exact incremental AUC. The tracker stores event scores, so memory is O(n) and the final computation is deterministic with tie handling.

    AucTracker::auc

    source
    fn AucTracker::auc(self : AucTracker) -> Double

    AucTracker::negative_count

    source
    fn AucTracker::negative_count(self : AucTracker) -> Int

    AucTracker::new

    source
    fn AucTracker::new() -> AucTracker

    AucTracker::positive_count

    source
    fn AucTracker::positive_count(self : AucTracker) -> Int

    AucTracker::reset

    source
    fn AucTracker::reset(self : AucTracker) -> Unit

    AucTracker::size

    source
    fn AucTracker::size(self : AucTracker) -> Int

    AucTracker::update

    source
    fn AucTracker::update(self : AucTracker, score : Double, label : Double) -> Unit

    AuditAction

    source
    pub(all) enum AuditAction {
      Train
      Predict
      Promote
      Rollback
      Reject
      Snapshot
    } derive(Eq, 
    Debug    )

    Auditable metadata for model updates, data lineage, and privacy budgets.

    AuditRecord

    source
    pub struct AuditRecord {
      event_id : String
      actor : String
      action : AuditAction
      model : String
      version : String
      timestamp : Int64
      detail : String
      success : Bool
    }

    AuditRecord::action

    source
    fn AuditRecord::action(self : AuditRecord) -> AuditAction

    AuditRecord::actor

    source
    fn AuditRecord::actor(self : AuditRecord) -> String

    AuditRecord::detail

    source
    fn AuditRecord::detail(self : AuditRecord) -> String

    AuditRecord::event_id

    source
    fn AuditRecord::event_id(self : AuditRecord) -> String

    AuditRecord::model

    source
    fn AuditRecord::model(self : AuditRecord) -> String

    AuditRecord::new

    source
    fn AuditRecord::new(event_id : String, actor : String, action : AuditAction, model : String, version : String, timestamp : Int64, detail? : String, success? : Bool) -> AuditRecord

    AuditRecord::success

    source
    fn AuditRecord::success(self : AuditRecord) -> Bool

    AuditRecord::timestamp

    source
    fn AuditRecord::timestamp(self : AuditRecord) -> Int64

    AuditRecord::version

    source
    fn AuditRecord::version(self : AuditRecord) -> String

    AuditTrail

    source
    pub struct AuditTrail {
      capacity : Int
      records : Array[AuditRecord]
      ids : Map[String, Bool]
      accepted : Int
      duplicates : Int
      evicted : Int
    }

    AuditTrail::accepted

    source
    fn AuditTrail::accepted(self : AuditTrail) -> Int

    AuditTrail::append

    source
    fn AuditTrail::append(self : AuditTrail, record : AuditRecord) -> Bool

    AuditTrail::clear

    source
    fn AuditTrail::clear(self : AuditTrail) -> Unit

    AuditTrail::count_action

    source
    fn AuditTrail::count_action(self : AuditTrail, action : AuditAction) -> Int

    AuditTrail::duplicates

    source
    fn AuditTrail::duplicates(self : AuditTrail) -> Int

    AuditTrail::evicted

    source
    fn AuditTrail::evicted(self : AuditTrail) -> Int

    AuditTrail::failed

    source
    fn AuditTrail::failed(self : AuditTrail) -> Int

    AuditTrail::find

    source
    fn AuditTrail::find(self : AuditTrail, event_id : String) -> AuditRecord?

    AuditTrail::new

    source
    fn AuditTrail::new(capacity? : Int) -> AuditTrail

    AuditTrail::records

    source
    fn AuditTrail::records(self : AuditTrail) -> Array[AuditRecord]

    AuditTrail::size

    source
    fn AuditTrail::size(self : AuditTrail) -> Int

    BanditAction

    source
    pub(all) enum BanditAction {
      Explore
      Exploit
    } derive(Eq, 
    Debug    )

    Online decision policies for recommendation, routing, and experimentation.

    The policies in this file are stateful by design. Each policy exposes its counters and reset operation so it can be checkpointed between service instances and tested with deterministic event streams.

    BanditEvaluator

    source
    pub struct BanditEvaluator {
      observations : Int
      reward_sum : Double
      optimal_sum : Double
      regret_sum : Double
      successes : Int
    }

    BanditEvaluator::cumulative_regret

    source
    fn BanditEvaluator::cumulative_regret(self : BanditEvaluator) -> Double

    BanditEvaluator::mean_optimal_reward

    source
    fn BanditEvaluator::mean_optimal_reward(self : BanditEvaluator) -> Double

    BanditEvaluator::mean_reward

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

    BanditEvaluator::new

    source

    BanditEvaluator::observations

    source
    fn BanditEvaluator::observations(self : BanditEvaluator) -> Int

    BanditEvaluator::observe

    source
    fn BanditEvaluator::observe(self : BanditEvaluator, reward : Double, optimal_reward : Double, success? : Bool) -> Unit

    BanditEvaluator::regret_rate

    source
    fn BanditEvaluator::regret_rate(self : BanditEvaluator) -> Double

    BanditEvaluator::reset

    source
    fn BanditEvaluator::reset(self : BanditEvaluator) -> Unit

    BanditEvaluator::success_rate

    source
    fn BanditEvaluator::success_rate(self : BanditEvaluator) -> Double

    BanditHistory

    source
    pub struct BanditHistory {
      capacity : Int
      arms : Array[Int]
      rewards : Array[Double]
      actions : Array[BanditAction]
    }

    BanditHistory::actions

    source

    BanditHistory::append

    source
    fn BanditHistory::append(self : BanditHistory, arm : Int, reward : Double, action : BanditAction) -> Unit

    BanditHistory::arms

    source
    fn BanditHistory::arms(self : BanditHistory) -> Array[Int]

    BanditHistory::exploration_rate

    source
    fn BanditHistory::exploration_rate(self : BanditHistory) -> Double

    BanditHistory::mean_reward

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

    BanditHistory::new

    source
    fn BanditHistory::new(capacity? : Int) -> BanditHistory

    BanditHistory::reset

    source
    fn BanditHistory::reset(self : BanditHistory) -> Unit

    BanditHistory::rewards

    source
    fn BanditHistory::rewards(self : BanditHistory) -> Array[Double]

    BanditHistory::size

    source
    fn BanditHistory::size(self : BanditHistory) -> Int

    BatchNormalizer

    source
    pub struct BatchNormalizer {
      moments : VectorMoments
      dimension : Int
      batches : Int
    }

    BatchNormalizer::batches

    source
    fn BatchNormalizer::batches(self : BatchNormalizer) -> Int

    BatchNormalizer::fit

    source
    fn BatchNormalizer::fit(self : BatchNormalizer, batch : DataBatch) -> Unit

    BatchNormalizer::mean

    source
    fn BatchNormalizer::mean(self : BatchNormalizer) -> Array[Double]

    BatchNormalizer::new

    source
    fn BatchNormalizer::new(dimension : Int) -> BatchNormalizer

    BatchNormalizer::reset

    source
    fn BatchNormalizer::reset(self : BatchNormalizer) -> Unit

    BatchNormalizer::transform

    source
    fn BatchNormalizer::transform(self : BatchNormalizer, batch : DataBatch) -> DataBatch

    BatchNormalizer::variance

    source
    fn BatchNormalizer::variance(self : BatchNormalizer) -> Array[Double]

    BernoulliSampler

    source
    pub struct BernoulliSampler {
      probability : Double
      rng : DeterministicRng
      accepted : Int
      seen : Int
    }

    BernoulliSampler::accept

    source
    fn BernoulliSampler::accept(self : BernoulliSampler) -> Bool

    BernoulliSampler::accepted

    source
    fn BernoulliSampler::accepted(self : BernoulliSampler) -> Int

    BernoulliSampler::new

    source
    fn BernoulliSampler::new(probability : Double, seed? : UInt64) -> BernoulliSampler

    BernoulliSampler::probability

    source
    fn BernoulliSampler::probability(self : BernoulliSampler) -> Double

    BernoulliSampler::rate

    source
    fn BernoulliSampler::rate(self : BernoulliSampler) -> Double

    BernoulliSampler::reset

    source
    fn BernoulliSampler::reset(self : BernoulliSampler) -> Unit

    BernoulliSampler::seen

    source
    fn BernoulliSampler::seen(self : BernoulliSampler) -> Int

    BootstrapCounter

    source
    pub struct BootstrapCounter {
      counts : Array[Int]
      rng : DeterministicRng
      rounds : Int
    }

    BootstrapCounter::counts

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

    BootstrapCounter::coverage

    source
    fn BootstrapCounter::coverage(self : BootstrapCounter) -> Double

    BootstrapCounter::draw

    source
    fn BootstrapCounter::draw(self : BootstrapCounter) -> Array[Int]

    BootstrapCounter::new

    source
    fn BootstrapCounter::new(size : Int, seed? : UInt64) -> BootstrapCounter

    BootstrapCounter::reset

    source
    fn BootstrapCounter::reset(self : BootstrapCounter) -> Unit

    BootstrapCounter::rounds

    source
    fn BootstrapCounter::rounds(self : BootstrapCounter) -> Int

    CalibratedInterval

    source
    pub struct CalibratedInterval {
      center : Double
      radius : Double
      confidence : Double
    }

    CalibratedInterval::center

    source
    fn CalibratedInterval::center(self : CalibratedInterval) -> Double

    CalibratedInterval::confidence

    source
    fn CalibratedInterval::confidence(self : CalibratedInterval) -> Double

    CalibratedInterval::contains

    source
    fn CalibratedInterval::contains(self : CalibratedInterval, value : Double) -> Bool

    CalibratedInterval::lower

    source
    fn CalibratedInterval::lower(self : CalibratedInterval) -> Double

    CalibratedInterval::new

    source
    fn CalibratedInterval::new(center : Double, radius : Double, confidence : Double) -> CalibratedInterval

    CalibratedInterval::radius

    source
    fn CalibratedInterval::radius(self : CalibratedInterval) -> Double

    CalibratedInterval::upper

    source
    fn CalibratedInterval::upper(self : CalibratedInterval) -> Double

    CalibrationBin

    source
    pub struct CalibrationBin {
      count : Double
      predicted : Double
      observed : Double
    }

    CalibrationBin::count

    source
    fn CalibrationBin::count(self : CalibrationBin) -> Double

    CalibrationBin::mean_observed

    source
    fn CalibrationBin::mean_observed(self : CalibrationBin) -> Double

    CalibrationBin::mean_prediction

    source
    fn CalibrationBin::mean_prediction(self : CalibrationBin) -> Double

    CalibrationBin::new

    source

    CalibrationBin::update

    source
    fn CalibrationBin::update(self : CalibrationBin, prediction : Double, label : Double) -> Unit

    CalibrationTracker

    source
    pub struct CalibrationTracker {
      bins : Array[CalibrationBin]
      total : Double
      weighted_gap : Double
    }

    CalibrationTracker::bins

    source

    CalibrationTracker::ece

    source
    fn CalibrationTracker::ece(self : CalibrationTracker) -> Double

    CalibrationTracker::mce

    source
    fn CalibrationTracker::mce(self : CalibrationTracker) -> Double

    CalibrationTracker::new

    source
    fn CalibrationTracker::new(bin_count? : Int) -> CalibrationTracker

    CalibrationTracker::reset

    source
    fn CalibrationTracker::reset(self : CalibrationTracker) -> Unit

    CalibrationTracker::update

    source
    fn CalibrationTracker::update(self : CalibrationTracker, prediction : Double, label : Double) -> Unit

    CanaryExperiment

    source
    pub struct CanaryExperiment {
      name : String
      baseline : String
      candidate : String
      target_samples : Int
      baseline_metric : Double
      candidate_metric : Double
      samples : Int
    }

    CanaryExperiment::baseline

    source
    fn CanaryExperiment::baseline(self : CanaryExperiment) -> Double

    CanaryExperiment::candidate

    source
    fn CanaryExperiment::candidate(self : CanaryExperiment) -> Double

    CanaryExperiment::complete

    source
    fn CanaryExperiment::complete(self : CanaryExperiment) -> Bool

    CanaryExperiment::improvement

    source
    fn CanaryExperiment::improvement(self : CanaryExperiment) -> Double

    CanaryExperiment::new

    source
    fn CanaryExperiment::new(name : String, baseline : String, candidate : String, target_samples? : Int) -> CanaryExperiment

    CanaryExperiment::observe

    source
    fn CanaryExperiment::observe(self : CanaryExperiment, baseline : Double, candidate : Double) -> Unit

    CanaryExperiment::samples

    source
    fn CanaryExperiment::samples(self : CanaryExperiment) -> Int

    CanaryExperiment::winner

    source
    fn CanaryExperiment::winner(self : CanaryExperiment) -> String

    CategoricalEncoder

    source
    pub struct CategoricalEncoder {
      values : Map[String, Int]
      next_index : Int
      unknown_index : Int?
    }

    CategoricalEncoder::contains

    source
    fn CategoricalEncoder::contains(self : CategoricalEncoder, value : String) -> Bool

    CategoricalEncoder::dimension

    source
    fn CategoricalEncoder::dimension(self : CategoricalEncoder) -> Int

    CategoricalEncoder::encode

    source
    fn CategoricalEncoder::encode(self : CategoricalEncoder, value : String) -> Int

    CategoricalEncoder::entries

    source
    fn CategoricalEncoder::entries(self : CategoricalEncoder) -> Array[(String, Int)]

    CategoricalEncoder::new

    source
    fn CategoricalEncoder::new(unknown_index? : Int) -> CategoricalEncoder

    CategoricalEncoder::reset

    source
    fn CategoricalEncoder::reset(self : CategoricalEncoder) -> Unit

    ChangePointDetector

    source
    pub struct ChangePointDetector {
      short : SequenceWindow
      long : SequenceWindow
      threshold : Double
      changes : Int
      last_score : Double
    }

    ChangePointDetector::changes

    source
    fn ChangePointDetector::changes(self : ChangePointDetector) -> Int

    ChangePointDetector::new

    source
    fn ChangePointDetector::new(short_window? : Int, long_window? : Int, threshold? : Double) -> ChangePointDetector

    ChangePointDetector::observe

    source
    fn ChangePointDetector::observe(self : ChangePointDetector, value : Double) -> Bool

    ChangePointDetector::reset

    source
    fn ChangePointDetector::reset(self : ChangePointDetector) -> Unit

    ChangePointDetector::score

    source
    fn ChangePointDetector::score(self : ChangePointDetector) -> Double

    ClassCost

    source
    pub struct ClassCost {
      false_positive : Double
      false_negative : Double
      true_positive : Double
      true_negative : Double
    }

    Cost-sensitive decision rules for imbalanced streaming classification.

    ClassCost::balanced_threshold

    source
    fn ClassCost::balanced_threshold(self : ClassCost) -> Double

    ClassCost::cost

    source
    fn ClassCost::cost(self : ClassCost, prediction : Double, label : Double, threshold : Double) -> Double

    ClassCost::expected_cost

    source
    fn ClassCost::expected_cost(self : ClassCost, probability : Double, threshold : Double) -> Double

    ClassCost::negative_weight

    source
    fn ClassCost::negative_weight(self : ClassCost) -> Double

    ClassCost::new

    source
    fn ClassCost::new(false_positive? : Double, false_negative? : Double, true_positive? : Double, true_negative? : Double) -> ClassCost

    ClassCost::positive_weight

    source
    fn ClassCost::positive_weight(self : ClassCost) -> Double

    ClassCountTracker

    source
    pub struct ClassCountTracker {
      counts : Array[Int]
    }

    ClassCountTracker::count

    source
    fn ClassCountTracker::count(self : ClassCountTracker, label : Int) -> Int

    ClassCountTracker::counts

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

    ClassCountTracker::new

    source
    fn ClassCountTracker::new(classes : Int) -> ClassCountTracker

    ClassCountTracker::observe

    source
    fn ClassCountTracker::observe(self : ClassCountTracker, label : Int) -> Bool

    ClassCountTracker::prior

    source
    fn ClassCountTracker::prior(self : ClassCountTracker, label : Int, smoothing? : Double) -> Double

    ClassCountTracker::priors

    source
    fn ClassCountTracker::priors(self : ClassCountTracker, smoothing? : Double) -> Array[Double]

    ClassCountTracker::total

    source
    fn ClassCountTracker::total(self : ClassCountTracker) -> Int

    ClickThroughRateTracker

    source
    pub struct ClickThroughRateTracker {
      impressions : Double
      clicks : Double
      predicted_sum : Double
      squared_calibration_error : Double
    }

    ClickThroughRateTracker::brier

    source

    ClickThroughRateTracker::ctr

    source

    ClickThroughRateTracker::impressions

    source
    fn ClickThroughRateTracker::impressions(self : ClickThroughRateTracker) -> Double

    ClickThroughRateTracker::new

    source

    ClickThroughRateTracker::predicted_ctr

    source
    fn ClickThroughRateTracker::predicted_ctr(self : ClickThroughRateTracker) -> Double

    ClickThroughRateTracker::reset

    source

    ClickThroughRateTracker::update

    source
    fn ClickThroughRateTracker::update(self : ClickThroughRateTracker, probability : Double, clicked : Bool, weight? : Double) -> Unit

    ConformalInterval

    source
    pub struct ConformalInterval {
      residuals : Array[Double]
      capacity : Int
      confidence : Double
      seen : Int
    }

    Bounded conformal residual tracker for distribution-free prediction bands.

    ConformalInterval::confidence

    source
    fn ConformalInterval::confidence(self : ConformalInterval) -> Double

    ConformalInterval::coverage

    source
    fn ConformalInterval::coverage(self : ConformalInterval, prediction : Double, label : Double) -> Bool

    ConformalInterval::interval

    source
    fn ConformalInterval::interval(self : ConformalInterval, prediction : Double) -> (Double, Double)

    ConformalInterval::new

    source
    fn ConformalInterval::new(capacity? : Int, confidence? : Double) -> ConformalInterval

    ConformalInterval::observe

    source
    fn ConformalInterval::observe(self : ConformalInterval, prediction : Double, label : Double) -> Unit

    ConformalInterval::radius

    source
    fn ConformalInterval::radius(self : ConformalInterval) -> Double

    ConformalInterval::reset

    source
    fn ConformalInterval::reset(self : ConformalInterval) -> Unit

    ConformalInterval::seen

    source
    fn ConformalInterval::seen(self : ConformalInterval) -> Int

    ConformalInterval::size

    source
    fn ConformalInterval::size(self : ConformalInterval) -> Int

    ConfusionMatrix

    source
    pub struct ConfusionMatrix {
      true_positive : Double
      false_positive : Double
      true_negative : Double
      false_negative : Double
    }

    Mutable binary classification confusion matrix for a stream.

    ConfusionMatrix::accuracy

    source
    fn ConfusionMatrix::accuracy(self : ConfusionMatrix) -> Double

    ConfusionMatrix::balanced_accuracy

    source
    fn ConfusionMatrix::balanced_accuracy(self : ConfusionMatrix) -> Double

    ConfusionMatrix::f1

    source
    fn ConfusionMatrix::f1(self : ConfusionMatrix) -> Double

    ConfusionMatrix::false_negative_count

    source
    fn ConfusionMatrix::false_negative_count(self : ConfusionMatrix) -> Double

    ConfusionMatrix::fp

    source
    fn ConfusionMatrix::fp(self : ConfusionMatrix) -> Double

    ConfusionMatrix::mcc

    source
    fn ConfusionMatrix::mcc(self : ConfusionMatrix) -> Double

    ConfusionMatrix::merge

    source
    fn ConfusionMatrix::merge(self : ConfusionMatrix, other : ConfusionMatrix) -> Unit

    ConfusionMatrix::new

    source

    ConfusionMatrix::precision

    source
    fn ConfusionMatrix::precision(self : ConfusionMatrix) -> Double

    ConfusionMatrix::recall

    source
    fn ConfusionMatrix::recall(self : ConfusionMatrix) -> Double

    ConfusionMatrix::reset

    source
    fn ConfusionMatrix::reset(self : ConfusionMatrix) -> Unit

    ConfusionMatrix::specificity

    source
    fn ConfusionMatrix::specificity(self : ConfusionMatrix) -> Double

    ConfusionMatrix::tn

    source
    fn ConfusionMatrix::tn(self : ConfusionMatrix) -> Double

    ConfusionMatrix::total

    source
    fn ConfusionMatrix::total(self : ConfusionMatrix) -> Double

    ConfusionMatrix::tp

    source
    fn ConfusionMatrix::tp(self : ConfusionMatrix) -> Double

    ConfusionMatrix::update

    source
    fn ConfusionMatrix::update(self : ConfusionMatrix, prediction : Double, label : Double, threshold? : Double) -> Unit

    ContextualBandit

    source
    pub struct ContextualBandit {
      models : Array[OnlineRidgeRegression]
      exploration : Double
      steps : Int
    }

    ContextualBandit::arm_count

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

    ContextualBandit::choose

    source
    fn ContextualBandit::choose(self : ContextualBandit, features : Array[Double]) -> Int?

    ContextualBandit::new

    source
    fn ContextualBandit::new(arm_count : Int, dimension : Int, exploration? : Double, learning_rate? : Double) -> ContextualBandit

    ContextualBandit::predict

    source
    fn ContextualBandit::predict(self : ContextualBandit, arm : Int, features : Array[Double]) -> Double

    ContextualBandit::reset

    source
    fn ContextualBandit::reset(self : ContextualBandit) -> Unit

    ContextualBandit::steps

    source
    fn ContextualBandit::steps(self : ContextualBandit) -> Int

    ContextualBandit::update

    source
    fn ContextualBandit::update(self : ContextualBandit, arm : Int, features : Array[Double], reward : Double) -> Bool

    ContextualBandit::weights

    source
    fn ContextualBandit::weights(self : ContextualBandit, arm : Int) -> Array[Double]

    ContractField

    source
    pub struct ContractField {
      name : String
      expected : ContractType
      required : Bool
      minimum : Double?
      maximum : Double?
      vector_length : Int
      allow_empty : Bool
    }

    ContractField::boolean

    source
    fn ContractField::boolean(name : String, required? : Bool) -> ContractField

    ContractField::expected

    source
    fn ContractField::expected(self : ContractField) -> ContractType

    ContractField::name

    source
    fn ContractField::name(self : ContractField) -> String

    ContractField::number

    source
    fn ContractField::number(name : String, required? : Bool, minimum? : Double, maximum? : Double) -> ContractField

    ContractField::required

    source
    fn ContractField::required(self : ContractField) -> Bool

    ContractField::text

    source
    fn ContractField::text(name : String, required? : Bool, allow_empty? : Bool) -> ContractField

    ContractField::vector

    source
    fn ContractField::vector(name : String, length : Int, required? : Bool) -> ContractField

    ContractField::vector_length

    source
    fn ContractField::vector_length(self : ContractField) -> Int

    ContractReport

    source
    pub struct ContractReport {
      accepted : Bool
      checked_fields : Int
      violations : Array[ContractViolation]
    }

    ContractReport::accepted

    source
    fn ContractReport::accepted(self : ContractReport) -> Bool

    ContractReport::checked_fields

    source
    fn ContractReport::checked_fields(self : ContractReport) -> Int

    ContractReport::violation_count

    source
    fn ContractReport::violation_count(self : ContractReport) -> Int

    ContractReport::violations

    source

    ContractType

    source
    pub(all) enum ContractType {
      Number
      Text
      Boolean
      Vector
    } derive(Eq, 
    Debug    )

    ContractValue

    source
    pub(all) enum ContractValue {
      Number(Double)
      Text(String)
      Boolean(Bool)
      Vector(Array[Double])
      Missing
    } derive(Eq, 
    Debug    )

    Runtime data contracts for validating records before they reach a model.

    Contracts make the online path explicit: fields are ordered, typed, and checked with the same rules used by batch ingestion. The implementation deliberately returns structured violations so callers can route bad rows to a dead-letter stream instead of silently dropping them.

    ContractViolation

    source
    pub struct ContractViolation {
      field : String
      kind : ContractViolationKind
      detail : String
    }

    ContractViolation::detail

    source
    fn ContractViolation::detail(self : ContractViolation) -> String

    ContractViolation::field

    source
    fn ContractViolation::field(self : ContractViolation) -> String

    ContractViolation::kind

    source

    ContractViolation::new

    source
    fn ContractViolation::new(field : String, kind : ContractViolationKind, detail : String) -> ContractViolation

    ContractViolationKind

    source
    pub(all) enum ContractViolationKind {
      MissingRequired
      TypeMismatch
      BelowMinimum
      AboveMaximum
      InvalidVectorLength
      EmptyText
    } derive(Eq, 
    Debug    )

    CostSensitiveEvaluator

    source
    pub struct CostSensitiveEvaluator {
      costs : ClassCost
      total : Double
      count : Int
    }

    CostSensitiveEvaluator::count

    source

    CostSensitiveEvaluator::mean

    source

    CostSensitiveEvaluator::new

    source

    CostSensitiveEvaluator::observe

    source
    fn CostSensitiveEvaluator::observe(self : CostSensitiveEvaluator, prediction : Double, label : Double, threshold : Double) -> Double

    CostSensitiveEvaluator::reset

    source

    CostSensitiveEvaluator::total

    source

    CountMinSketch

    source
    pub struct CountMinSketch {
      width : Int
      depth : Int
      table : Array[Array[Int]]
      seeds : Array[Int]
      updates : Int
    }

    CountMinSketch::depth

    source
    fn CountMinSketch::depth(self : CountMinSketch) -> Int

    CountMinSketch::estimate

    source
    fn CountMinSketch::estimate(self : CountMinSketch, key : String) -> Int

    CountMinSketch::new

    source
    fn CountMinSketch::new(width : Int, depth : Int) -> CountMinSketch

    CountMinSketch::reset

    source
    fn CountMinSketch::reset(self : CountMinSketch) -> Unit

    CountMinSketch::update

    source
    fn CountMinSketch::update(self : CountMinSketch, key : String, amount? : Int) -> Unit

    CountMinSketch::updates

    source
    fn CountMinSketch::updates(self : CountMinSketch) -> Int

    CountMinSketch::width

    source
    fn CountMinSketch::width(self : CountMinSketch) -> Int

    CrossValidationFold

    source
    pub struct CrossValidationFold {
      train : DataBatch
      validation : DataBatch
      index : Int
    }

    CrossValidationFold::index

    source
    fn CrossValidationFold::index(self : CrossValidationFold) -> Int

    CrossValidationFold::train

    source

    CrossValidationFold::validation

    source

    CsvOptions

    source
    pub struct CsvOptions {
      separator : Char
      quote : Char
      escape : Char
      trim_fields : Bool
      skip_empty : Bool
    }

    CsvOptions::new

    source
    fn CsvOptions::new(separator? : Char, quote? : Char, escape? : Char, trim_fields? : Bool, skip_empty? : Bool) -> CsvOptions

    CsvOptions::parse_line

    source
    fn CsvOptions::parse_line(self : CsvOptions, line : String) -> Array[String]

    CsvOptions::parse_lines

    source
    fn CsvOptions::parse_lines(self : CsvOptions, text : String) -> Array[Array[String]]

    CsvOptions::separator

    source
    fn CsvOptions::separator(self : CsvOptions) -> Char

    CumulativeSumDetector

    source
    pub struct CumulativeSumDetector {
      target : Double
      allowance : Double
      threshold : Double
      positive : Double
      negative : Double
    }

    Two-sided CUSUM detector for abrupt shifts around a target level.

    CumulativeSumDetector::negative

    source
    fn CumulativeSumDetector::negative(self : CumulativeSumDetector) -> Double

    CumulativeSumDetector::new

    source
    fn CumulativeSumDetector::new(target? : Double, allowance? : Double, threshold? : Double) -> CumulativeSumDetector

    CumulativeSumDetector::positive

    source
    fn CumulativeSumDetector::positive(self : CumulativeSumDetector) -> Double

    CumulativeSumDetector::reset

    source

    CumulativeSumDetector::update

    source
    fn CumulativeSumDetector::update(self : CumulativeSumDetector, value : Double) -> Bool

    DataBatch

    source
    pub struct DataBatch {
      features : Array[Array[Double]]
      labels : Array[Double]
      weights : Array[Double]
    }

    DataBatch::add

    source
    fn DataBatch::add(self : DataBatch, features : Array[Double], label : Double, weight? : Double) -> Bool

    DataBatch::dimension

    source
    fn DataBatch::dimension(self : DataBatch) -> Int

    DataBatch::features

    source
    fn DataBatch::features(self : DataBatch) -> Array[Array[Double]]

    DataBatch::from_arrays

    source
    fn DataBatch::from_arrays(features : Array[Array[Double]], labels : Array[Double]) -> DataBatch

    DataBatch::labels

    source
    fn DataBatch::labels(self : DataBatch) -> Array[Double]

    DataBatch::new

    source
    fn DataBatch::new(dimension? : Int) -> DataBatch

    DataBatch::shuffle

    source
    fn DataBatch::shuffle(self : DataBatch, random_index : (Int) -> Int) -> Unit

    DataBatch::size

    source
    fn DataBatch::size(self : DataBatch) -> Int

    DataBatch::slice

    source
    fn DataBatch::slice(self : DataBatch, start : Int, end : Int) -> DataBatch

    DataBatch::validate

    source
    fn DataBatch::validate(self : DataBatch) -> ValidationReport

    DataBatch::weights

    source
    fn DataBatch::weights(self : DataBatch) -> Array[Double]

    DataContract

    source
    pub struct DataContract {
      name : String
      version : String
      fields : Array[ContractField]
      rows : Int
      accepted_rows : Int
      rejected_rows : Int
    }

    DataContract::acceptance_rate

    source
    fn DataContract::acceptance_rate(self : DataContract) -> Double

    DataContract::accepted_rows

    source
    fn DataContract::accepted_rows(self : DataContract) -> Int

    DataContract::add_field

    source
    fn DataContract::add_field(self : DataContract, field : ContractField) -> Bool

    DataContract::field_count

    source
    fn DataContract::field_count(self : DataContract) -> Int

    DataContract::fields

    source

    DataContract::name

    source
    fn DataContract::name(self : DataContract) -> String

    DataContract::new

    source
    fn DataContract::new(name : String, version? : String) -> DataContract

    DataContract::rejected_rows

    source
    fn DataContract::rejected_rows(self : DataContract) -> Int

    DataContract::reset

    source
    fn DataContract::reset(self : DataContract) -> Unit

    DataContract::rows

    source
    fn DataContract::rows(self : DataContract) -> Int

    DataContract::validate

    source
    fn DataContract::validate(self : DataContract, values : Array[ContractValue]) -> ContractReport

    DataContract::version

    source
    fn DataContract::version(self : DataContract) -> String

    DataLineage

    source
    pub struct DataLineage {
      nodes : Map[String, LineageNode]
      edges : Map[String, Array[String]]
      registrations : Int
    }

    DataLineage::clear

    source
    fn DataLineage::clear(self : DataLineage) -> Unit

    DataLineage::connect

    source
    fn DataLineage::connect(self : DataLineage, input : String, output : String) -> Bool

    DataLineage::inputs

    source
    fn DataLineage::inputs(self : DataLineage, dataset : String) -> Array[String]

    DataLineage::new

    source

    DataLineage::node

    source
    fn DataLineage::node(self : DataLineage, dataset : String) -> LineageNode?

    DataLineage::register

    source
    fn DataLineage::register(self : DataLineage, node : LineageNode) -> Bool

    DataLineage::registrations

    source
    fn DataLineage::registrations(self : DataLineage) -> Int

    DataLineage::upstream

    source
    fn DataLineage::upstream(self : DataLineage, dataset : String) -> Array[String]

    DataQualityReport

    source
    pub struct DataQualityReport {
      rows : Int
      accepted : Int
      rejected : Int
      missing_values : Int
      dimension_errors : Int
      out_of_range : Int
    }

    DataQualityReport::acceptance_rate

    source
    fn DataQualityReport::acceptance_rate(self : DataQualityReport) -> Double

    DataQualityReport::accepted

    source
    fn DataQualityReport::accepted(self : DataQualityReport) -> Int

    DataQualityReport::dimension_errors

    source
    fn DataQualityReport::dimension_errors(self : DataQualityReport) -> Int

    DataQualityReport::missing_values

    source
    fn DataQualityReport::missing_values(self : DataQualityReport) -> Int

    DataQualityReport::new

    source

    DataQualityReport::observe

    source
    fn DataQualityReport::observe(self : DataQualityReport, accepted : Bool, missing : Int, dimension_error : Bool, range_error : Bool) -> Unit

    DataQualityReport::out_of_range

    source
    fn DataQualityReport::out_of_range(self : DataQualityReport) -> Int

    DataQualityReport::rejected

    source
    fn DataQualityReport::rejected(self : DataQualityReport) -> Int

    DataQualityReport::reset

    source
    fn DataQualityReport::reset(self : DataQualityReport) -> Unit

    DataQualityReport::rows

    source
    fn DataQualityReport::rows(self : DataQualityReport) -> Int

    DenseVector

    source
    pub struct DenseVector {
      values : Array[Double]
    } derive(ToJson, 
    Debug    , 
    FromJson    )

    An owned dense vector with explicit dimension-safe operations.

    DenseVector is useful at API boundaries where callers want a named value rather than a raw array. Model hot paths still accept Array[Double] to keep interop with MoonBit data processing code allocation-free.

    DenseVector::add

    source
    fn DenseVector::add(self : DenseVector, other : DenseVector) -> DenseVector

    DenseVector::append

    source
    fn DenseVector::append(self : DenseVector, value : Double) -> Unit

    DenseVector::argmax

    source
    fn DenseVector::argmax(self : DenseVector) -> Int?

    DenseVector::axpy

    source
    fn DenseVector::axpy(self : DenseVector, factor : Double, other : DenseVector) -> Unit

    DenseVector::clamp

    source
    fn DenseVector::clamp(self : DenseVector, lower : Double, upper : Double) -> DenseVector

    DenseVector::concat

    source
    fn DenseVector::concat(self : DenseVector, other : DenseVector) -> DenseVector

    DenseVector::cosine

    source
    fn DenseVector::cosine(self : DenseVector, other : DenseVector) -> Double

    DenseVector::dimension

    source
    fn DenseVector::dimension(self : DenseVector) -> Int

    DenseVector::distance

    source
    fn DenseVector::distance(self : DenseVector, other : DenseVector) -> Double

    DenseVector::distance_squared

    source
    fn DenseVector::distance_squared(self : DenseVector, other : DenseVector) -> Double

    DenseVector::dot

    source
    fn DenseVector::dot(self : DenseVector, other : DenseVector) -> Double

    DenseVector::dot_checked

    source
    fn DenseVector::dot_checked(self : DenseVector, other : DenseVector) -> Double?

    DenseVector::fill

    source
    fn DenseVector::fill(self : DenseVector, value : Double) -> Unit

    DenseVector::from_array

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

    DenseVector::from_view

    source
    fn DenseVector::from_view(values : ArrayView[Double]) -> DenseVector

    DenseVector::get

    source
    fn DenseVector::get(self : DenseVector, index : Int) -> Double?

    DenseVector::hadamard

    source
    fn DenseVector::hadamard(self : DenseVector, other : DenseVector) -> DenseVector

    DenseVector::is_empty

    source
    fn DenseVector::is_empty(self : DenseVector) -> Bool

    DenseVector::is_zero

    source
    fn DenseVector::is_zero(self : DenseVector, tolerance? : Double) -> Bool

    DenseVector::l1_norm

    source
    fn DenseVector::l1_norm(self : DenseVector) -> Double

    DenseVector::l2_norm

    source
    fn DenseVector::l2_norm(self : DenseVector) -> Double

    DenseVector::map

    source
    fn DenseVector::map(self : DenseVector, transform : (Double) -> Double) -> DenseVector

    DenseVector::max_abs

    source
    fn DenseVector::max_abs(self : DenseVector) -> Double

    DenseVector::mean

    source
    fn DenseVector::mean(self : DenseVector) -> Double

    DenseVector::new

    source
    fn DenseVector::new(size : Int, fill? : Double) -> DenseVector

    DenseVector::normalize

    source
    fn DenseVector::normalize(self : DenseVector) -> DenseVector

    DenseVector::ones

    source
    fn DenseVector::ones(size : Int) -> DenseVector

    DenseVector::scale

    source
    fn DenseVector::scale(self : DenseVector, factor : Double) -> DenseVector

    DenseVector::set

    source
    fn DenseVector::set(self : DenseVector, index : Int, value : Double) -> Bool

    DenseVector::slice

    source
    fn DenseVector::slice(self : DenseVector, start : Int, end : Int) -> DenseVector

    DenseVector::softmax

    source
    fn DenseVector::softmax(self : DenseVector) -> DenseVector

    DenseVector::subtract

    source
    fn DenseVector::subtract(self : DenseVector, other : DenseVector) -> DenseVector

    DenseVector::sum

    source
    fn DenseVector::sum(self : DenseVector) -> Double

    DenseVector::top_index

    source
    fn DenseVector::top_index(self : DenseVector, rank : Int) -> Int?

    DenseVector::validate

    source
    fn DenseVector::validate(self : DenseVector, expected : Int) -> ValidationReport

    DenseVector::values

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

    DenseVector::variance

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

    DenseVector::zeros

    source
    fn DenseVector::zeros(size : Int) -> DenseVector

    DenseVector::zip_map

    source
    fn DenseVector::zip_map(self : DenseVector, other : DenseVector, transform : (Double, Double) -> Double) -> DenseVector

    Deployment

    source
    pub struct Deployment {
      model : String
      version : String
      state : DeploymentState
      created_at : Int64
      updated_at : Int64
      traffic : Double
    }

    Deployment::model

    source
    fn Deployment::model(self : Deployment) -> String

    Deployment::new

    source
    fn Deployment::new(model : String, version : String, timestamp : Int64) -> Deployment

    Deployment::set_traffic

    source
    fn Deployment::set_traffic(self : Deployment, share : Double) -> Bool

    Deployment::state

    source

    Deployment::traffic

    source
    fn Deployment::traffic(self : Deployment) -> Double

    Deployment::transition

    source
    fn Deployment::transition(self : Deployment, next : DeploymentState, timestamp : Int64) -> Bool

    Deployment::version

    source
    fn Deployment::version(self : Deployment) -> String

    DeploymentManager

    source
    pub struct DeploymentManager {
      deployments : Map[String, Deployment]
      policy : RollbackPolicy
      transitions : Int
      rollbacks : Int
    }

    DeploymentManager::clear

    source
    fn DeploymentManager::clear(self : DeploymentManager) -> Unit

    DeploymentManager::create

    source
    fn DeploymentManager::create(self : DeploymentManager, deployment : Deployment) -> Bool

    DeploymentManager::get

    source
    fn DeploymentManager::get(self : DeploymentManager, model : String, version : String) -> Deployment?

    DeploymentManager::healthy

    source
    fn DeploymentManager::healthy(self : DeploymentManager, accuracy : Double, loss : Double, error_rate : Double) -> Bool

    DeploymentManager::new

    source

    DeploymentManager::rollbacks

    source
    fn DeploymentManager::rollbacks(self : DeploymentManager) -> Int

    DeploymentManager::transition

    source
    fn DeploymentManager::transition(self : DeploymentManager, model : String, version : String, next : DeploymentState, timestamp : Int64) -> Bool

    DeploymentManager::transitions

    source
    fn DeploymentManager::transitions(self : DeploymentManager) -> Int

    DeploymentState

    source
    pub(all) enum DeploymentState {
      Draft
      Staging
      Canary
      Active
      Paused
      RolledBack
      Retired
    } derive(Eq, 
    Debug    )

    Explicit deployment state machine used by registry and serving layers.

    DeterministicRng

    source
    pub struct DeterministicRng {
      state : UInt64
    }

    Small deterministic pseudo-random generator for reproducible benchmarks.

    DeterministicRng::new

    source
    fn DeterministicRng::new(seed : UInt64) -> DeterministicRng

    DeterministicRng::next_double

    source
    fn DeterministicRng::next_double(self : DeterministicRng) -> Double

    DeterministicRng::next_int

    source
    fn DeterministicRng::next_int(self : DeterministicRng, limit : Int) -> Int

    DeterministicRng::next_u64

    source
    fn DeterministicRng::next_u64(self : DeterministicRng) -> UInt64

    DeterministicRng::normal

    source
    fn DeterministicRng::normal(self : DeterministicRng) -> Double

    DeterministicRng::shuffle

    source
    fn DeterministicRng::shuffle(self : DeterministicRng, values : Array[Int]) -> Unit

    DeterministicRng::uniform

    source
    fn DeterministicRng::uniform(self : DeterministicRng, lower : Double, upper : Double) -> Double

    DistinctCounter

    source
    pub struct DistinctCounter {
      buckets : Int
      bits : Array[Bool]
      observations : Int
    }

    DistinctCounter::estimate

    source
    fn DistinctCounter::estimate(self : DistinctCounter) -> Double

    DistinctCounter::fill_rate

    source
    fn DistinctCounter::fill_rate(self : DistinctCounter) -> Double

    DistinctCounter::new

    source
    fn DistinctCounter::new(buckets : Int) -> DistinctCounter

    DistinctCounter::observations

    source
    fn DistinctCounter::observations(self : DistinctCounter) -> Int

    DistinctCounter::observe

    source
    fn DistinctCounter::observe(self : DistinctCounter, value : String) -> Unit

    DistinctCounter::reset

    source
    fn DistinctCounter::reset(self : DistinctCounter) -> Unit

    DriftMonitor

    source
    pub struct DriftMonitor {
      feature_detectors : Array[PageHinkleyDetector]
      target_detector : PageHinkleyDetector
      feature_drift_events : Int
      target_drift_events : Int
    }

    DriftMonitor::feature_events

    source
    fn DriftMonitor::feature_events(self : DriftMonitor) -> Int

    DriftMonitor::new

    source
    fn DriftMonitor::new(dimension : Int, threshold? : Double, delta? : Double) -> DriftMonitor

    DriftMonitor::reset

    source
    fn DriftMonitor::reset(self : DriftMonitor) -> Unit

    DriftMonitor::target_events

    source
    fn DriftMonitor::target_events(self : DriftMonitor) -> Int

    DriftMonitor::update

    source
    fn DriftMonitor::update(self : DriftMonitor, features : Array[Double], target? : Double) -> Bool

    DuplicateSignatureTracker

    source
    pub struct DuplicateSignatureTracker {
      signatures : Map[String, Int]
      rows : Int
      duplicates : Int
    }

    DuplicateSignatureTracker::duplicate_rate

    source
    fn DuplicateSignatureTracker::duplicate_rate(self : DuplicateSignatureTracker) -> Double

    DuplicateSignatureTracker::duplicates

    source

    DuplicateSignatureTracker::new

    source

    DuplicateSignatureTracker::observe

    source
    fn DuplicateSignatureTracker::observe(self : DuplicateSignatureTracker, features : Array[Double]) -> Bool

    DuplicateSignatureTracker::reset

    source

    DuplicateSignatureTracker::rows

    source

    EarlyStopping

    source
    pub struct EarlyStopping {
      patience : Int
      minimum_delta : Double
      best : Double
      bad_rounds : Int
      initialized : Bool
    }

    EarlyStopping::bad_rounds

    source
    fn EarlyStopping::bad_rounds(self : EarlyStopping) -> Int

    EarlyStopping::best

    source
    fn EarlyStopping::best(self : EarlyStopping) -> Double

    EarlyStopping::new

    source
    fn EarlyStopping::new(patience? : Int, minimum_delta? : Double) -> EarlyStopping

    EarlyStopping::observe

    source
    fn EarlyStopping::observe(self : EarlyStopping, loss : Double) -> Bool

    EarlyStopping::reset

    source
    fn EarlyStopping::reset(self : EarlyStopping) -> Unit

    EarlyStopping::should_stop

    source
    fn EarlyStopping::should_stop(self : EarlyStopping) -> Bool

    EpsilonGreedyBandit

    source
    pub struct EpsilonGreedyBandit {
      arms : Array[ArmStatistics]
      epsilon : Double
      rng : DeterministicRng
      history : BanditHistory
      steps : Int
      explored : Int
    }

    EpsilonGreedyBandit::arm_count

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

    EpsilonGreedyBandit::choose

    source

    EpsilonGreedyBandit::epsilon

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

    EpsilonGreedyBandit::explored

    source
    fn EpsilonGreedyBandit::explored(self : EpsilonGreedyBandit) -> Int

    EpsilonGreedyBandit::history

    source

    EpsilonGreedyBandit::new

    source
    fn EpsilonGreedyBandit::new(arm_count : Int, epsilon? : Double, seed? : UInt64, history_capacity? : Int) -> EpsilonGreedyBandit

    EpsilonGreedyBandit::reset

    source
    fn EpsilonGreedyBandit::reset(self : EpsilonGreedyBandit) -> Unit

    EpsilonGreedyBandit::statistics

    source
    fn EpsilonGreedyBandit::statistics(self : EpsilonGreedyBandit, arm : Int) -> ArmStatistics?

    EpsilonGreedyBandit::steps

    source
    fn EpsilonGreedyBandit::steps(self : EpsilonGreedyBandit) -> Int

    EpsilonGreedyBandit::update

    source
    fn EpsilonGreedyBandit::update(self : EpsilonGreedyBandit, arm : Int, reward : Double, action? : BanditAction) -> Bool

    ErrorBudget

    source
    pub struct ErrorBudget {
      target : Double
      window : Int
      successes : Int
      failures : Int
    }

    ErrorBudget::availability

    source
    fn ErrorBudget::availability(self : ErrorBudget) -> Double

    ErrorBudget::failures

    source
    fn ErrorBudget::failures(self : ErrorBudget) -> Int

    ErrorBudget::healthy

    source
    fn ErrorBudget::healthy(self : ErrorBudget) -> Bool

    ErrorBudget::new

    source
    fn ErrorBudget::new(target? : Double, window? : Int) -> ErrorBudget

    ErrorBudget::observe

    source
    fn ErrorBudget::observe(self : ErrorBudget, success : Bool) -> Unit

    ErrorBudget::remaining

    source
    fn ErrorBudget::remaining(self : ErrorBudget) -> Double

    ErrorBudget::reset

    source
    fn ErrorBudget::reset(self : ErrorBudget) -> Unit

    ErrorBudget::successes

    source
    fn ErrorBudget::successes(self : ErrorBudget) -> Int

    ErrorBudget::target

    source
    fn ErrorBudget::target(self : ErrorBudget) -> Double

    EvaluationSummary

    source
    pub struct EvaluationSummary {
      samples : Double
      log_loss : Double
      mse : Double
      accuracy : Double
      precision : Double
      recall : Double
      f1 : Double
      auc : Double
      ece : Double
    } derive(ToJson, 
    Debug    , 
    FromJson    )

    EvaluationSummary::accuracy

    source
    fn EvaluationSummary::accuracy(self : EvaluationSummary) -> Double

    EvaluationSummary::auc

    source
    fn EvaluationSummary::auc(self : EvaluationSummary) -> Double

    EvaluationSummary::ece

    source
    fn EvaluationSummary::ece(self : EvaluationSummary) -> Double

    EvaluationSummary::f1

    source
    fn EvaluationSummary::f1(self : EvaluationSummary) -> Double

    EvaluationSummary::log_loss

    source
    fn EvaluationSummary::log_loss(self : EvaluationSummary) -> Double

    EvaluationSummary::mse

    source
    fn EvaluationSummary::mse(self : EvaluationSummary) -> Double

    EvaluationSummary::precision

    source
    fn EvaluationSummary::precision(self : EvaluationSummary) -> Double

    EvaluationSummary::recall

    source
    fn EvaluationSummary::recall(self : EvaluationSummary) -> Double

    EvaluationSummary::samples

    source
    fn EvaluationSummary::samples(self : EvaluationSummary) -> Double

    EventLog

    source
    pub struct EventLog {
      capacity : Int
      events : Array[TrainingEvent]
      ids : Map[String, Bool]
      appended : Int
      evicted : Int
    }

    EventLog::append

    source
    fn EventLog::append(self : EventLog, event : TrainingEvent) -> Bool

    EventLog::appended

    source
    fn EventLog::appended(self : EventLog) -> Int

    EventLog::capacity

    source
    fn EventLog::capacity(self : EventLog) -> Int

    EventLog::clear

    source
    fn EventLog::clear(self : EventLog) -> Unit

    EventLog::events

    source
    fn EventLog::events(self : EventLog) -> Array[TrainingEvent]

    EventLog::evicted

    source
    fn EventLog::evicted(self : EventLog) -> Int

    EventLog::first_timestamp

    source
    fn EventLog::first_timestamp(self : EventLog) -> Int64?

    EventLog::last_timestamp

    source
    fn EventLog::last_timestamp(self : EventLog) -> Int64?

    EventLog::new

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

    EventLog::positive_rate

    source
    fn EventLog::positive_rate(self : EventLog) -> Double

    EventLog::replay

    source
    fn EventLog::replay(self : EventLog, consume : (TrainingEvent) -> Unit) -> Unit

    EventLog::size

    source
    fn EventLog::size(self : EventLog) -> Int

    EventRateWindow

    source
    pub struct EventRateWindow {
      width : Int64
      capacity : Int
      timestamps : Array[Int64]
      invalid : Int
    }

    EventRateWindow::capacity

    source
    fn EventRateWindow::capacity(self : EventRateWindow) -> Int

    EventRateWindow::invalid

    source
    fn EventRateWindow::invalid(self : EventRateWindow) -> Int

    EventRateWindow::new

    source
    fn EventRateWindow::new(width : Int64, capacity? : Int) -> EventRateWindow

    EventRateWindow::observe

    source
    fn EventRateWindow::observe(self : EventRateWindow, timestamp : Int64) -> Bool

    EventRateWindow::rate

    source
    fn EventRateWindow::rate(self : EventRateWindow, now : Int64) -> Double

    EventRateWindow::reset

    source
    fn EventRateWindow::reset(self : EventRateWindow) -> Unit

    EventRateWindow::size

    source
    fn EventRateWindow::size(self : EventRateWindow) -> Int

    EwmaAnomalyDetector

    source
    pub struct EwmaAnomalyDetector {
      baseline : ExponentialMovingVariance
      threshold : Double
      anomalies : Int
    }

    EWMA z-score detector. It reports an anomaly before updating its baseline, which prevents a single spike from hiding itself.

    EwmaAnomalyDetector::anomalies

    source
    fn EwmaAnomalyDetector::anomalies(self : EwmaAnomalyDetector) -> Int

    EwmaAnomalyDetector::new

    source
    fn EwmaAnomalyDetector::new(alpha? : Double, threshold? : Double) -> EwmaAnomalyDetector

    EwmaAnomalyDetector::reset

    source
    fn EwmaAnomalyDetector::reset(self : EwmaAnomalyDetector) -> Unit

    EwmaAnomalyDetector::score

    source
    fn EwmaAnomalyDetector::score(self : EwmaAnomalyDetector, value : Double) -> Double

    EwmaAnomalyDetector::update

    source
    fn EwmaAnomalyDetector::update(self : EwmaAnomalyDetector, value : Double) -> Bool

    ExponentialImportance

    source
    pub struct ExponentialImportance {
      scores : Array[Double]
      alpha : Double
      observations : Int
    }

    ExponentialImportance::new

    source
    fn ExponentialImportance::new(dimension : Int, alpha? : Double) -> ExponentialImportance

    ExponentialImportance::observations

    source
    fn ExponentialImportance::observations(self : ExponentialImportance) -> Int

    ExponentialImportance::reset

    source

    ExponentialImportance::scores

    source
    fn ExponentialImportance::scores(self : ExponentialImportance) -> Array[Double]

    ExponentialImportance::top_k

    source
    fn ExponentialImportance::top_k(self : ExponentialImportance, k : Int) -> Array[Int]

    ExponentialImportance::update

    source
    fn ExponentialImportance::update(self : ExponentialImportance, gradients : Array[Double]) -> Unit

    ExponentialMovingAverage

    source
    pub struct ExponentialMovingAverage {
      alpha : Double
      value : Double
      initialized : Bool
    }

    ExponentialMovingAverage::initialized

    source
    fn ExponentialMovingAverage::initialized(self : ExponentialMovingAverage) -> Bool

    ExponentialMovingAverage::new

    source

    ExponentialMovingAverage::reset

    source

    ExponentialMovingAverage::update

    source
    fn ExponentialMovingAverage::update(self : ExponentialMovingAverage, value : Double) -> Double

    ExponentialMovingAverage::value

    source

    ExponentialMovingVariance

    source
    pub struct ExponentialMovingVariance {
      alpha : Double
      mean : Double
      variance : Double
      initialized : Bool
    }

    ExponentialMovingVariance::initialized

    source

    ExponentialMovingVariance::mean

    source

    ExponentialMovingVariance::new

    source

    ExponentialMovingVariance::reset

    source

    ExponentialMovingVariance::standard_deviation

    source
    fn ExponentialMovingVariance::standard_deviation(self : ExponentialMovingVariance) -> Double

    ExponentialMovingVariance::update

    source
    fn ExponentialMovingVariance::update(self : ExponentialMovingVariance, value : Double) -> Unit

    ExponentialMovingVariance::variance

    source

    ExponentialMovingVariance::z_score

    source
    fn ExponentialMovingVariance::z_score(self : ExponentialMovingVariance, value : Double) -> Double

    FTRL

    source
    pub struct FTRL {
      alpha : Double
      beta : Double
      l1 : Double
      l2 : Double
      z : Array[Double]
      n : Array[Double]
    } derive(ToJson, 
    FromJson    )

    FTRL-Proximal Online Logistic Regression Model. Supports L1 and L2 regularization, ideal for large-scale features.

    FTRL::new

    source
    fn FTRL::new(dim : Int, alpha? : Double, beta? : Double, l1? : Double, l2? : Double) -> FTRL

    Create a new FTRL model with dim features.

    FTRL::predict

    source
    fn FTRL::predict(self : FTRL, features : Array[Double]) -> Double

    Predict the probability for a given feature vector.

    FTRL::update

    source
    fn FTRL::update(self : FTRL, features : Array[Double], label : Double) -> Unit

    Update the model with a single sample (features and label). Label should be 0.0 or 1.0.

    FactorizationMachine

    source
    pub struct FactorizationMachine {
      linear : Array[Double]
      factors : Array[Array[Double]]
      learning_rate : Double
      l2 : Double
      updates : Int
    }

    FactorizationMachine::new

    source
    fn FactorizationMachine::new(dimension : Int, rank : Int, learning_rate? : Double, l2? : Double) -> FactorizationMachine

    FactorizationMachine::predict

    source
    fn FactorizationMachine::predict(self : FactorizationMachine, features : SparseVector) -> Double

    FactorizationMachine::updates

    source
    fn FactorizationMachine::updates(self : FactorizationMachine) -> Int

    FairnessMonitor

    source
    pub struct FairnessMonitor {
      groups : Map[String, GroupMetric]
      observations : Int
    }

    FairnessMonitor::group

    source
    fn FairnessMonitor::group(self : FairnessMonitor, group : String) -> GroupMetric?

    FairnessMonitor::groups

    source
    fn FairnessMonitor::groups(self : FairnessMonitor) -> Array[String]

    FairnessMonitor::max_positive_rate_gap

    source
    fn FairnessMonitor::max_positive_rate_gap(self : FairnessMonitor) -> Double

    FairnessMonitor::max_recall_gap

    source
    fn FairnessMonitor::max_recall_gap(self : FairnessMonitor) -> Double

    FairnessMonitor::new

    source

    FairnessMonitor::observations

    source
    fn FairnessMonitor::observations(self : FairnessMonitor) -> Int

    FairnessMonitor::observe

    source
    fn FairnessMonitor::observe(self : FairnessMonitor, group : String, prediction : Double, label : Double, threshold? : Double) -> Unit

    FairnessMonitor::reset

    source
    fn FairnessMonitor::reset(self : FairnessMonitor) -> Unit

    FallbackMode

    source
    pub(all) enum FallbackMode {
      Reject
      BestAvailable
      DefaultRoute
    } derive(Eq, 
    Debug    )

    FeatureAttribution

    source
    pub struct FeatureAttribution {
      index : Int
      contribution : Double
    }

    Lightweight local explanations for linear and sparse predictions.

    FeatureAttribution::contribution

    source
    fn FeatureAttribution::contribution(self : FeatureAttribution) -> Double

    FeatureAttribution::index

    source
    fn FeatureAttribution::index(self : FeatureAttribution) -> Int

    FeatureAttribution::new

    source
    fn FeatureAttribution::new(index : Int, contribution : Double) -> FeatureAttribution

    FeatureCrossEncoder

    source
    pub struct FeatureCrossEncoder {
      hasher : FeatureHasher
      separator : String
      crosses : Int
    }

    FeatureCrossEncoder::buckets

    source
    fn FeatureCrossEncoder::buckets(self : FeatureCrossEncoder) -> Int

    FeatureCrossEncoder::crosses

    source
    fn FeatureCrossEncoder::crosses(self : FeatureCrossEncoder) -> Int

    FeatureCrossEncoder::encode

    source
    fn FeatureCrossEncoder::encode(self : FeatureCrossEncoder, values : Array[String]) -> SparseVector

    FeatureCrossEncoder::encode_ordered

    source
    fn FeatureCrossEncoder::encode_ordered(self : FeatureCrossEncoder, values : Array[String], order : Int) -> SparseVector

    FeatureCrossEncoder::new

    source
    fn FeatureCrossEncoder::new(buckets : Int, separator? : String) -> FeatureCrossEncoder

    FeatureCrossEncoder::reset

    source
    fn FeatureCrossEncoder::reset(self : FeatureCrossEncoder) -> Unit

    FeatureDriftSummary

    source
    pub struct FeatureDriftSummary {
      changed : Array[Bool]
      scores : Array[Double]
    }

    FeatureDriftSummary::changed

    source
    fn FeatureDriftSummary::changed(self : FeatureDriftSummary, index : Int) -> Bool

    FeatureDriftSummary::changed_count

    source
    fn FeatureDriftSummary::changed_count(self : FeatureDriftSummary) -> Int

    FeatureDriftSummary::new

    source
    fn FeatureDriftSummary::new(scores : Array[Double], threshold : Double) -> FeatureDriftSummary

    FeatureDriftSummary::scores

    source
    fn FeatureDriftSummary::scores(self : FeatureDriftSummary) -> Array[Double]

    FeatureHasher

    source
    pub struct FeatureHasher {
      buckets : Int
      signed : Bool
    }

    FeatureHasher::buckets

    source
    fn FeatureHasher::buckets(self : FeatureHasher) -> Int

    FeatureHasher::encode

    source
    fn FeatureHasher::encode(self : FeatureHasher, tokens : Array[String]) -> SparseVector

    FeatureHasher::encode_map

    source
    fn FeatureHasher::encode_map(self : FeatureHasher, values : Map[String, Double]) -> SparseVector

    FeatureHasher::encode_weighted

    source
    fn FeatureHasher::encode_weighted(self : FeatureHasher, tokens : Array[(String, Double)]) -> SparseVector

    FeatureHasher::index

    source
    fn FeatureHasher::index(self : FeatureHasher, token : String) -> Int

    FeatureHasher::new

    source
    fn FeatureHasher::new(buckets : Int, signed? : Bool) -> FeatureHasher

    FeatureMaterializer

    source
    pub struct FeatureMaterializer {
      schema : FeatureSchema
      defaults : Array[Double]
      materialized : Int
      fallback : Int
    }

    FeatureMaterializer::fallback

    source
    fn FeatureMaterializer::fallback(self : FeatureMaterializer) -> Int

    FeatureMaterializer::materialize

    source
    fn FeatureMaterializer::materialize(self : FeatureMaterializer, values : Array[Double]) -> Array[Double]

    FeatureMaterializer::materialized

    source
    fn FeatureMaterializer::materialized(self : FeatureMaterializer) -> Int

    FeatureMaterializer::new

    source
    fn FeatureMaterializer::new(schema : FeatureSchema, defaults? : Array[Double]) -> FeatureMaterializer

    FeatureMaterializer::reset

    source
    fn FeatureMaterializer::reset(self : FeatureMaterializer) -> Unit

    FeaturePipeline

    source
    pub struct FeaturePipeline {
      standardizer : Standardizer
      lower : Array[Double]
      upper : Array[Double]
      clip_enabled : Bool
      hasher : FeatureHasher?
      transformed : Int
    }

    A reusable online feature pipeline: optional clipping, Welford standardization, and deterministic sparse hashing.

    FeaturePipeline::dimension

    source
    fn FeaturePipeline::dimension(self : FeaturePipeline) -> Int

    FeaturePipeline::disable_clip

    source
    fn FeaturePipeline::disable_clip(self : FeaturePipeline) -> Unit

    FeaturePipeline::fit_only

    source
    fn FeaturePipeline::fit_only(self : FeaturePipeline, features : Array[Double]) -> Unit

    FeaturePipeline::mean

    source
    fn FeaturePipeline::mean(self : FeaturePipeline) -> Array[Double]

    FeaturePipeline::new

    source
    fn FeaturePipeline::new(dimension : Int, clip_lower? : Double, clip_upper? : Double, hashing_buckets? : Int) -> FeaturePipeline

    FeaturePipeline::reset

    source
    fn FeaturePipeline::reset(self : FeaturePipeline) -> Unit

    FeaturePipeline::set_clip

    source
    fn FeaturePipeline::set_clip(self : FeaturePipeline, lower : Double, upper : Double) -> Bool

    FeaturePipeline::transform

    source
    fn FeaturePipeline::transform(self : FeaturePipeline, features : Array[Double]) -> Array[Double]

    FeaturePipeline::transform_tokens

    source
    fn FeaturePipeline::transform_tokens(self : FeaturePipeline, tokens : Array[String]) -> SparseVector?

    FeaturePipeline::transformed

    source
    fn FeaturePipeline::transformed(self : FeaturePipeline) -> Int

    FeaturePipeline::variance

    source
    fn FeaturePipeline::variance(self : FeaturePipeline) -> Array[Double]

    FeatureRangeMonitor

    source
    pub struct FeatureRangeMonitor {
      lower : Array[Double]
      upper : Array[Double]
      minimum : Array[Double]
      maximum : Array[Double]
      violations : Array[Int]
    }

    FeatureRangeMonitor::maximum

    source
    fn FeatureRangeMonitor::maximum(self : FeatureRangeMonitor) -> Array[Double]

    FeatureRangeMonitor::minimum

    source
    fn FeatureRangeMonitor::minimum(self : FeatureRangeMonitor) -> Array[Double]

    FeatureRangeMonitor::new

    source
    fn FeatureRangeMonitor::new(lower : Array[Double], upper : Array[Double]) -> FeatureRangeMonitor

    FeatureRangeMonitor::observe

    source
    fn FeatureRangeMonitor::observe(self : FeatureRangeMonitor, features : Array[Double]) -> Bool

    FeatureRangeMonitor::reset

    source
    fn FeatureRangeMonitor::reset(self : FeatureRangeMonitor) -> Unit

    FeatureRangeMonitor::violations

    source
    fn FeatureRangeMonitor::violations(self : FeatureRangeMonitor) -> Array[Int]

    FeatureRecord

    source
    pub struct FeatureRecord {
      key : String
      version : Int
      values : Array[Double]
      timestamp : Int64
      source : String
    }

    FeatureRecord::checksum

    source
    fn FeatureRecord::checksum(self : FeatureRecord) -> String

    FeatureRecord::key

    source
    fn FeatureRecord::key(self : FeatureRecord) -> String

    FeatureRecord::new

    source
    fn FeatureRecord::new(key : String, values : Array[Double], timestamp : Int64, source? : String, version? : Int) -> FeatureRecord

    FeatureRecord::source

    source
    fn FeatureRecord::source(self : FeatureRecord) -> String

    FeatureRecord::timestamp

    source
    fn FeatureRecord::timestamp(self : FeatureRecord) -> Int64

    FeatureRecord::values

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

    FeatureRecord::version

    source
    fn FeatureRecord::version(self : FeatureRecord) -> Int

    FeatureSchema

    source
    pub struct FeatureSchema {
      name : String
      dimension : Int
      minimum : Array[Double]
      maximum : Array[Double]
      required : Bool
    }

    In-memory feature registry with schema checks, versioning, and bounded history.

    FeatureSchema::dimension

    source
    fn FeatureSchema::dimension(self : FeatureSchema) -> Int

    FeatureSchema::name

    source
    fn FeatureSchema::name(self : FeatureSchema) -> String

    FeatureSchema::new

    source
    fn FeatureSchema::new(name : String, dimension : Int, minimum? : Array[Double], maximum? : Array[Double], required? : Bool) -> FeatureSchema

    FeatureSchema::required

    source
    fn FeatureSchema::required(self : FeatureSchema) -> Bool

    FeatureSchema::validate

    source
    fn FeatureSchema::validate(self : FeatureSchema, values : Array[Double]) -> ValidationReport

    FeatureStore

    source
    pub struct FeatureStore {
      schemas : Map[String, FeatureSchema]
      records : Map[String, Array[FeatureRecord]]
      capacity : Int
      writes : Int
      reads : Int
      misses : Int
      rejected : Int
    }

    FeatureStore::at_version

    source
    fn FeatureStore::at_version(self : FeatureStore, name : String, version : Int) -> FeatureRecord?

    FeatureStore::clear

    source
    fn FeatureStore::clear(self : FeatureStore) -> Unit

    FeatureStore::history

    source
    fn FeatureStore::history(self : FeatureStore, name : String) -> Array[FeatureRecord]

    FeatureStore::hit_rate

    source
    fn FeatureStore::hit_rate(self : FeatureStore) -> Double

    FeatureStore::latest

    source
    fn FeatureStore::latest(self : FeatureStore, name : String) -> FeatureRecord?

    FeatureStore::misses

    source
    fn FeatureStore::misses(self : FeatureStore) -> Int

    FeatureStore::new

    source
    fn FeatureStore::new(capacity? : Int) -> FeatureStore

    FeatureStore::put

    source
    fn FeatureStore::put(self : FeatureStore, name : String, record : FeatureRecord) -> Bool

    FeatureStore::reads

    source
    fn FeatureStore::reads(self : FeatureStore) -> Int

    FeatureStore::register

    source
    fn FeatureStore::register(self : FeatureStore, schema : FeatureSchema) -> Bool

    FeatureStore::rejected

    source
    fn FeatureStore::rejected(self : FeatureStore) -> Int

    FeatureStore::schema

    source
    fn FeatureStore::schema(self : FeatureStore, name : String) -> FeatureSchema?

    FeatureStore::writes

    source
    fn FeatureStore::writes(self : FeatureStore) -> Int

    FeatureValue

    source
    pub enum FeatureValue {
      Number(Double)
      Category(String)
      Boolean(Bool)
      Missing
    } derive(Eq, ToJson, 
    Debug    , 
    FromJson    )

    A scalar feature value before it is encoded into a numeric vector.

    FeatureValue::as_number

    source
    fn FeatureValue::as_number(self : FeatureValue, missing_value? : Double) -> Double

    FeatureValue::is_missing

    source
    fn FeatureValue::is_missing(self : FeatureValue) -> Bool

    ForecastBlendModel

    source
    pub struct ForecastBlendModel {
      weights : Map[String, Double]
      forecasts : Map[String, Array[ForecastPoint]]
      updates : Int
    }

    ForecastBlendModel::models

    source
    fn ForecastBlendModel::models(self : ForecastBlendModel) -> Array[String]

    ForecastBlendModel::new

    source

    ForecastBlendModel::observe

    source
    fn ForecastBlendModel::observe(self : ForecastBlendModel, model : String, points : Array[ForecastPoint]) -> Bool

    ForecastBlendModel::predict

    source

    ForecastBlendModel::reset

    source
    fn ForecastBlendModel::reset(self : ForecastBlendModel) -> Unit

    ForecastBlendModel::set_weight

    source
    fn ForecastBlendModel::set_weight(self : ForecastBlendModel, model : String, weight : Double) -> Bool

    ForecastBlendModel::updates

    source
    fn ForecastBlendModel::updates(self : ForecastBlendModel) -> Int

    ForecastBlendModel::weight

    source
    fn ForecastBlendModel::weight(self : ForecastBlendModel, model : String) -> Double

    ForecastErrorTracker

    source
    pub struct ForecastErrorTracker {
      observations : Int
      absolute_error : Double
      squared_error : Double
      percentage_error : Double
      bias : Double
      underestimates : Int
      overestimates : Int
      worst_error : Double
    }

    ForecastErrorTracker::bias

    source
    fn ForecastErrorTracker::bias(self : ForecastErrorTracker) -> Double

    ForecastErrorTracker::mae

    source
    fn ForecastErrorTracker::mae(self : ForecastErrorTracker) -> Double

    ForecastErrorTracker::mape

    source
    fn ForecastErrorTracker::mape(self : ForecastErrorTracker) -> Double

    ForecastErrorTracker::new

    source

    ForecastErrorTracker::observations

    source
    fn ForecastErrorTracker::observations(self : ForecastErrorTracker) -> Int

    ForecastErrorTracker::observe

    source
    fn ForecastErrorTracker::observe(self : ForecastErrorTracker, actual : Double, forecast : Double) -> Unit

    ForecastErrorTracker::overestimates

    source
    fn ForecastErrorTracker::overestimates(self : ForecastErrorTracker) -> Int

    ForecastErrorTracker::reset

    source
    fn ForecastErrorTracker::reset(self : ForecastErrorTracker) -> Unit

    ForecastErrorTracker::rmse

    source
    fn ForecastErrorTracker::rmse(self : ForecastErrorTracker) -> Double

    ForecastErrorTracker::underestimates

    source
    fn ForecastErrorTracker::underestimates(self : ForecastErrorTracker) -> Int

    ForecastErrorTracker::worst_error

    source
    fn ForecastErrorTracker::worst_error(self : ForecastErrorTracker) -> Double

    ForecastPoint

    source
    pub struct ForecastPoint {
      timestamp : Int64
      value : Double
      lower : Double
      upper : Double
    }

    Streaming forecasting models for operational demand and metric series.

    The models expose both point forecasts and uncertainty bands. They update in O(1) or O(period) per observation, which keeps them useful for service health metrics, inventory signals, and low-latency baseline prediction.

    ForecastPoint::lower

    source
    fn ForecastPoint::lower(self : ForecastPoint) -> Double

    ForecastPoint::new

    source
    fn ForecastPoint::new(timestamp : Int64, value : Double, lower : Double, upper : Double) -> ForecastPoint

    ForecastPoint::timestamp

    source
    fn ForecastPoint::timestamp(self : ForecastPoint) -> Int64

    ForecastPoint::upper

    source
    fn ForecastPoint::upper(self : ForecastPoint) -> Double

    ForecastPoint::value

    source
    fn ForecastPoint::value(self : ForecastPoint) -> Double

    ForecastTracker

    source
    pub struct ForecastTracker {
      metrics : RegressionMetrics
      predictions : Int
    }

    ForecastTracker::mae

    source
    fn ForecastTracker::mae(self : ForecastTracker) -> Double

    ForecastTracker::new

    source

    ForecastTracker::observe

    source
    fn ForecastTracker::observe(self : ForecastTracker, prediction : Double, actual : Double) -> Unit

    ForecastTracker::predictions

    source
    fn ForecastTracker::predictions(self : ForecastTracker) -> Int

    ForecastTracker::r2

    source
    fn ForecastTracker::r2(self : ForecastTracker) -> Double

    ForecastTracker::reset

    source
    fn ForecastTracker::reset(self : ForecastTracker) -> Unit

    ForecastTracker::rmse

    source
    fn ForecastTracker::rmse(self : ForecastTracker) -> Double

    GatedRegressor

    source
    pub struct GatedRegressor {
      low : OnlineRidgeRegression
      high : OnlineRidgeRegression
      boundary : Double
      low_count : Int
      high_count : Int
    }

    GatedRegressor::high_count

    source
    fn GatedRegressor::high_count(self : GatedRegressor) -> Int

    GatedRegressor::low_count

    source
    fn GatedRegressor::low_count(self : GatedRegressor) -> Int

    GatedRegressor::new

    source
    fn GatedRegressor::new(dimension : Int, boundary? : Double) -> GatedRegressor

    GatedRegressor::predict

    source
    fn GatedRegressor::predict(self : GatedRegressor, features : Array[Double], gate : Double) -> Double

    GatedRegressor::update

    source
    fn GatedRegressor::update(self : GatedRegressor, features : Array[Double], gate : Double, label : Double) -> Unit

    GaussianClassStats

    source
    pub struct GaussianClassStats {
      count : Double
      mean : Array[Double]
      m2 : Array[Double]
    }

    Per-class Gaussian sufficient statistics.

    GaussianClassStats::count

    source
    fn GaussianClassStats::count(self : GaussianClassStats) -> Double

    GaussianClassStats::log_likelihood

    source
    fn GaussianClassStats::log_likelihood(self : GaussianClassStats, features : Array[Double], smoothing? : Double) -> Double

    GaussianClassStats::mean

    source
    fn GaussianClassStats::mean(self : GaussianClassStats) -> Array[Double]

    GaussianClassStats::new

    source
    fn GaussianClassStats::new(dimension : Int) -> GaussianClassStats

    GaussianClassStats::reset

    source
    fn GaussianClassStats::reset(self : GaussianClassStats) -> Unit

    GaussianClassStats::update

    source
    fn GaussianClassStats::update(self : GaussianClassStats, features : Array[Double], weight? : Double) -> Unit

    GaussianClassStats::variance

    source
    fn GaussianClassStats::variance(self : GaussianClassStats, smoothing? : Double) -> Array[Double]

    GradientAccumulator

    source
    pub struct GradientAccumulator {
      gradients : Array[Double]
      count : Int
    }

    GradientAccumulator::add

    source
    fn GradientAccumulator::add(self : GradientAccumulator, gradients : Array[Double]) -> Unit

    GradientAccumulator::count

    source
    fn GradientAccumulator::count(self : GradientAccumulator) -> Int

    GradientAccumulator::mean

    source
    fn GradientAccumulator::mean(self : GradientAccumulator) -> Array[Double]

    GradientAccumulator::new

    source
    fn GradientAccumulator::new(dimension : Int) -> GradientAccumulator

    GradientAccumulator::sum

    source
    fn GradientAccumulator::sum(self : GradientAccumulator) -> Array[Double]

    GradientAccumulator::take_mean

    source
    fn GradientAccumulator::take_mean(self : GradientAccumulator) -> Array[Double]

    GradientClipper

    source
    pub struct GradientClipper {
      max_norm : Double
      max_value : Double
    }

    GradientClipper::clip

    source
    fn GradientClipper::clip(self : GradientClipper, gradients : Array[Double]) -> Array[Double]

    GradientClipper::max_norm

    source
    fn GradientClipper::max_norm(self : GradientClipper) -> Double

    GradientClipper::max_value

    source
    fn GradientClipper::max_value(self : GradientClipper) -> Double

    GradientClipper::new

    source
    fn GradientClipper::new(max_norm? : Double, max_value? : Double) -> GradientClipper

    GradientGuard

    source
    pub struct GradientGuard {
      lower : Double
      upper : Double
      clipped : Int
      invalid : Int
    }

    GradientGuard::apply

    source
    fn GradientGuard::apply(self : GradientGuard, gradient : Array[Double]) -> Array[Double]

    GradientGuard::clipped

    source
    fn GradientGuard::clipped(self : GradientGuard) -> Int

    GradientGuard::invalid

    source
    fn GradientGuard::invalid(self : GradientGuard) -> Int

    GradientGuard::new

    source
    fn GradientGuard::new(lower? : Double, upper? : Double) -> GradientGuard

    GradientGuard::reset

    source
    fn GradientGuard::reset(self : GradientGuard) -> Unit

    GraphNeighbor

    source
    pub struct GraphNeighbor {
      node : String
      weight : Double
    }

    Incremental graph primitives for recommendation, similarity, and dependency analysis.

    The graph stores directed weighted edges and maintains enough aggregate state for bounded online updates. It is suitable for co-visitation graphs, feature-dependency graphs, and lightweight personalized retrieval.

    GraphNeighbor::new

    source
    fn GraphNeighbor::new(node : String, weight : Double) -> GraphNeighbor

    GraphNeighbor::node

    source
    fn GraphNeighbor::node(self : GraphNeighbor) -> String

    GraphNeighbor::weight

    source
    fn GraphNeighbor::weight(self : GraphNeighbor) -> Double

    GraphNodeScore

    source
    pub struct GraphNodeScore {
      node : String
      score : Double
      rank : Int
    }

    GraphNodeScore::new

    source
    fn GraphNodeScore::new(node : String, score : Double, rank : Int) -> GraphNodeScore

    GraphNodeScore::node

    source
    fn GraphNodeScore::node(self : GraphNodeScore) -> String

    GraphNodeScore::rank

    source
    fn GraphNodeScore::rank(self : GraphNodeScore) -> Int

    GraphNodeScore::score

    source
    fn GraphNodeScore::score(self : GraphNodeScore) -> Double

    GraphSummary

    source
    pub struct GraphSummary {
      nodes : Int
      edges : Int
      total_weight : Double
      density : Double
      average_degree : Double
      self_loops : Int
    }

    GraphSummary::average_degree

    source
    fn GraphSummary::average_degree(self : GraphSummary) -> Double

    GraphSummary::density

    source
    fn GraphSummary::density(self : GraphSummary) -> Double

    GraphSummary::edges

    source
    fn GraphSummary::edges(self : GraphSummary) -> Int

    GraphSummary::nodes

    source
    fn GraphSummary::nodes(self : GraphSummary) -> Int

    GraphSummary::self_loops

    source
    fn GraphSummary::self_loops(self : GraphSummary) -> Int

    GraphSummary::total_weight

    source
    fn GraphSummary::total_weight(self : GraphSummary) -> Double

    GroupMetric

    source
    pub struct GroupMetric {
      group : String
      count : Int
      positives : Int
      true_positives : Int
      false_positives : Int
      false_negatives : Int
    }

    Group-level diagnostics for online classification services.

    GroupMetric::count

    source
    fn GroupMetric::count(self : GroupMetric) -> Int

    GroupMetric::false_positive_rate

    source
    fn GroupMetric::false_positive_rate(self : GroupMetric) -> Double

    GroupMetric::group

    source
    fn GroupMetric::group(self : GroupMetric) -> String

    GroupMetric::new

    source
    fn GroupMetric::new(group : String) -> GroupMetric

    GroupMetric::observe

    source
    fn GroupMetric::observe(self : GroupMetric, prediction : Double, label : Double, threshold? : Double) -> Unit

    GroupMetric::positive_rate

    source
    fn GroupMetric::positive_rate(self : GroupMetric) -> Double

    GroupMetric::precision

    source
    fn GroupMetric::precision(self : GroupMetric) -> Double

    GroupMetric::recall

    source
    fn GroupMetric::recall(self : GroupMetric) -> Double

    GroupMetric::reset

    source
    fn GroupMetric::reset(self : GroupMetric) -> Unit

    HashedFeatureSelector

    source
    pub struct HashedFeatureSelector {
      dimension : Int
      importance : ExponentialImportance
      threshold : Double
    }

    A bounded vocabulary selector that keeps the most useful hashed features.

    HashedFeatureSelector::dimension

    source
    fn HashedFeatureSelector::dimension(self : HashedFeatureSelector) -> Int

    HashedFeatureSelector::new

    source
    fn HashedFeatureSelector::new(dimension : Int, threshold? : Double) -> HashedFeatureSelector

    HashedFeatureSelector::observe

    source
    fn HashedFeatureSelector::observe(self : HashedFeatureSelector, vector : SparseVector, gradient : Double) -> Unit

    HashedFeatureSelector::reset

    source

    HashedFeatureSelector::scores

    source
    fn HashedFeatureSelector::scores(self : HashedFeatureSelector) -> Array[Double]

    HashedFeatureSelector::selected

    source

    HashedFeatureSelector::selected_top_k

    source
    fn HashedFeatureSelector::selected_top_k(self : HashedFeatureSelector, k : Int) -> Array[Int]

    HashingVectorizer

    source
    pub struct HashingVectorizer {
      hasher : FeatureHasher
      lowercase : Bool
      ngram_order : Int
    }

    Token hashing utilities for text and event-key features.

    HashingVectorizer::buckets

    source
    fn HashingVectorizer::buckets(self : HashingVectorizer) -> Int

    HashingVectorizer::encode

    source
    fn HashingVectorizer::encode(self : HashingVectorizer, text : String) -> SparseVector

    HashingVectorizer::new

    source
    fn HashingVectorizer::new(buckets : Int, lowercase? : Bool, ngram_order? : Int) -> HashingVectorizer

    HashingVectorizer::tokens

    source
    fn HashingVectorizer::tokens(self : HashingVectorizer, text : String) -> Array[String]

    HeavyHitter

    source
    pub struct HeavyHitter {
      key : String
      count : Int
      error : Int
    }

    HeavyHitter::count

    source
    fn HeavyHitter::count(self : HeavyHitter) -> Int

    HeavyHitter::error

    source
    fn HeavyHitter::error(self : HeavyHitter) -> Int

    HeavyHitter::key

    source
    fn HeavyHitter::key(self : HeavyHitter) -> String

    HeavyHitter::new

    source
    fn HeavyHitter::new(key : String, count : Int, error : Int) -> HeavyHitter

    HeavyHitters

    source
    pub struct HeavyHitters {
      capacity : Int
      entries : Map[String, Int]
      updates : Int
      evictions : Int
    }

    HeavyHitters::estimate

    source
    fn HeavyHitters::estimate(self : HeavyHitters, key : String) -> Int

    HeavyHitters::evictions

    source
    fn HeavyHitters::evictions(self : HeavyHitters) -> Int

    HeavyHitters::new

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

    HeavyHitters::reset

    source
    fn HeavyHitters::reset(self : HeavyHitters) -> Unit

    HeavyHitters::size

    source
    fn HeavyHitters::size(self : HeavyHitters) -> Int

    HeavyHitters::top

    source
    fn HeavyHitters::top(self : HeavyHitters, limit : Int) -> Array[HeavyHitter]

    HeavyHitters::update

    source
    fn HeavyHitters::update(self : HeavyHitters, key : String, amount? : Int) -> Unit

    HeavyHitters::updates

    source
    fn HeavyHitters::updates(self : HeavyHitters) -> Int

    HistogramAuc

    source
    pub struct HistogramAuc {
      positive : Array[Double]
      negative : Array[Double]
      total_positive : Double
      total_negative : Double
    }

    Fixed-bin AUC approximation for bounded-memory deployments.

    HistogramAuc::auc

    source
    fn HistogramAuc::auc(self : HistogramAuc) -> Double

    HistogramAuc::bins

    source
    fn HistogramAuc::bins(self : HistogramAuc) -> Int

    HistogramAuc::new

    source
    fn HistogramAuc::new(bins? : Int) -> HistogramAuc

    HistogramAuc::reset

    source
    fn HistogramAuc::reset(self : HistogramAuc) -> Unit

    HistogramAuc::update

    source
    fn HistogramAuc::update(self : HistogramAuc, score : Double, label : Double, weight? : Double) -> Unit

    HistogramBin

    source
    pub struct HistogramBin {
      lower : Double
      upper : Double
      count : Double
      sum : Double
      square_sum : Double
      positive : Double
    }

    Streaming histogram and shallow-tree models for bounded online learning.

    These components are deliberately small enough for edge deployment while retaining useful production behavior: bounded memory, incremental updates, quantile queries, adaptive thresholds, and prediction dispersion.

    HistogramBin::count

    source
    fn HistogramBin::count(self : HistogramBin) -> Double

    HistogramBin::lower

    source
    fn HistogramBin::lower(self : HistogramBin) -> Double

    HistogramBin::mean

    source
    fn HistogramBin::mean(self : HistogramBin) -> Double

    HistogramBin::new

    source
    fn HistogramBin::new(lower : Double, upper : Double) -> HistogramBin

    HistogramBin::observe

    source
    fn HistogramBin::observe(self : HistogramBin, value : Double, weight : Double, positive : Bool) -> Unit

    HistogramBin::positive_rate

    source
    fn HistogramBin::positive_rate(self : HistogramBin) -> Double

    HistogramBin::reset

    source
    fn HistogramBin::reset(self : HistogramBin) -> Unit

    HistogramBin::sum

    source
    fn HistogramBin::sum(self : HistogramBin) -> Double

    HistogramBin::upper

    source
    fn HistogramBin::upper(self : HistogramBin) -> Double

    HistogramBin::variance

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

    HoldoutSplit

    source
    pub struct HoldoutSplit {
      train : DataBatch
      holdout : DataBatch
    }

    HoldoutSplit::holdout

    source
    fn HoldoutSplit::holdout(self : HoldoutSplit) -> DataBatch

    HoldoutSplit::holdout_size

    source
    fn HoldoutSplit::holdout_size(self : HoldoutSplit) -> Int

    HoldoutSplit::new

    source
    fn HoldoutSplit::new(batch : DataBatch, train_ratio? : Double) -> HoldoutSplit

    HoldoutSplit::train

    source
    fn HoldoutSplit::train(self : HoldoutSplit) -> DataBatch

    HoldoutSplit::train_size

    source
    fn HoldoutSplit::train_size(self : HoldoutSplit) -> Int

    HoltWinters

    source
    pub struct HoltWinters {
      alpha : Double
      beta : Double
      gamma : Double
      season_length : Int
      seasonals : Array[Double]
      level : Double
      trend : Double
      count : Int
    }

    Holt-Winters style level/trend/seasonal smoother.

    HoltWinters::count

    source
    fn HoltWinters::count(self : HoltWinters) -> Int

    HoltWinters::forecast

    source
    fn HoltWinters::forecast(self : HoltWinters, horizon : Int) -> Array[Double]

    HoltWinters::level

    source
    fn HoltWinters::level(self : HoltWinters) -> Double

    HoltWinters::new

    source
    fn HoltWinters::new(season_length : Int, alpha? : Double, beta? : Double, gamma? : Double) -> HoltWinters

    HoltWinters::reset

    source
    fn HoltWinters::reset(self : HoltWinters) -> Unit

    HoltWinters::seasonals

    source
    fn HoltWinters::seasonals(self : HoltWinters) -> Array[Double]

    HoltWinters::trend

    source
    fn HoltWinters::trend(self : HoltWinters) -> Double

    HoltWinters::update

    source
    fn HoltWinters::update(self : HoltWinters, value : Double) -> Double

    IdempotencyLedger

    source
    pub struct IdempotencyLedger {
      capacity : Int
      keys : Map[String, Int64]
      order : Array[String]
      duplicates : Int
      evictions : Int
    }

    Bounded idempotency ledger for event consumers. A key is accepted only once while it remains in the ledger; evictions are deterministic FIFO.

    IdempotencyLedger::accept

    source
    fn IdempotencyLedger::accept(self : IdempotencyLedger, key : String, timestamp : Int64) -> Bool

    IdempotencyLedger::contains

    source
    fn IdempotencyLedger::contains(self : IdempotencyLedger, key : String) -> Bool

    IdempotencyLedger::duplicates

    source
    fn IdempotencyLedger::duplicates(self : IdempotencyLedger) -> Int

    IdempotencyLedger::evictions

    source
    fn IdempotencyLedger::evictions(self : IdempotencyLedger) -> Int

    IdempotencyLedger::new

    source
    fn IdempotencyLedger::new(capacity? : Int) -> IdempotencyLedger

    IdempotencyLedger::reset

    source
    fn IdempotencyLedger::reset(self : IdempotencyLedger) -> Unit

    IdempotencyLedger::size

    source
    fn IdempotencyLedger::size(self : IdempotencyLedger) -> Int

    IdempotencyLedger::timestamp

    source
    fn IdempotencyLedger::timestamp(self : IdempotencyLedger, key : String) -> Int64?

    IngestionGate

    source
    pub struct IngestionGate {
      contract : DataContract
      ledger : IdempotencyLedger
      summary : RowQualitySummary
    }

    Combines contract validation and idempotency checks into one ingestion gate. It is intentionally stateful so its counters can feed monitoring.

    IngestionGate::accept

    source
    fn IngestionGate::accept(self : IngestionGate, key : String, timestamp : Int64, values : Array[ContractValue]) -> Bool

    IngestionGate::contract

    source
    fn IngestionGate::contract(self : IngestionGate) -> DataContract

    IngestionGate::ledger

    source

    IngestionGate::new

    source
    fn IngestionGate::new(contract : DataContract, ledger_capacity? : Int) -> IngestionGate

    IngestionGate::reset

    source
    fn IngestionGate::reset(self : IngestionGate) -> Unit

    IngestionGate::summary

    source

    IntermittentDemandForecaster

    source
    pub struct IntermittentDemandForecaster {
      alpha : Double
      demand : Double
      interval : Double
      since_demand : Int
      observations : Int
      nonzero : Int
    }

    Croston-style intermittent demand forecaster. It separately smooths non-zero demand size and the interval between non-zero arrivals.

    IntermittentDemandForecaster::demand_size

    source

    IntermittentDemandForecaster::forecast

    source

    IntermittentDemandForecaster::interval

    source

    IntermittentDemandForecaster::new

    source

    IntermittentDemandForecaster::nonzero

    source

    IntermittentDemandForecaster::observations

    source

    IntermittentDemandForecaster::predict

    source
    fn IntermittentDemandForecaster::predict(self : IntermittentDemandForecaster, horizon : Int, start_timestamp? : Int64, step? : Int64) -> Array[ForecastPoint]

    IntermittentDemandForecaster::reset

    source

    IntermittentDemandForecaster::update

    source
    fn IntermittentDemandForecaster::update(self : IntermittentDemandForecaster, value : Double) -> Double

    ItemCooccurrenceModel

    source
    pub struct ItemCooccurrenceModel {
      pair_weights : Map[String, Double]
      item_counts : Map[String, Double]
      sessions : Int
      events : Int
    }

    Maintains item co-occurrence weights from sessions or baskets. Pair keys are kept canonical so (a,b) and (b,a) share one statistic.

    ItemCooccurrenceModel::events

    source

    ItemCooccurrenceModel::item_count

    source
    fn ItemCooccurrenceModel::item_count(self : ItemCooccurrenceModel, item : String) -> Double

    ItemCooccurrenceModel::items

    source

    ItemCooccurrenceModel::new

    source

    ItemCooccurrenceModel::observe

    source
    fn ItemCooccurrenceModel::observe(self : ItemCooccurrenceModel, items : Array[String]) -> Unit

    ItemCooccurrenceModel::recommend

    source
    fn ItemCooccurrenceModel::recommend(self : ItemCooccurrenceModel, history : Array[String], limit? : Int) -> Array[GraphNeighbor]

    ItemCooccurrenceModel::reset

    source

    ItemCooccurrenceModel::score

    source
    fn ItemCooccurrenceModel::score(self : ItemCooccurrenceModel, left : String, right : String) -> Double

    ItemCooccurrenceModel::sessions

    source
    fn ItemCooccurrenceModel::sessions(self : ItemCooccurrenceModel) -> Int

    ItemCooccurrenceModel::similarity

    source
    fn ItemCooccurrenceModel::similarity(self : ItemCooccurrenceModel, left : String, right : String) -> Double

    KernelKind

    source
    pub enum KernelKind {
      Linear
      Polynomial(degree~ : Int, scale~ : Double, offset~ : Double)
      Gaussian(width~ : Double)
    } derive(Eq, ToJson, 
    Debug    , 
    FromJson    )

    Kernel choices for compact online non-linear models.

    KernelKind::evaluate

    source
    fn KernelKind::evaluate(self : KernelKind, left : Array[Double], right : Array[Double]) -> Double

    KernelSupport

    source
    pub struct KernelSupport {
      features : Array[Double]
      label : Double
      coefficient : Double
    }

    KernelSupport::coefficient

    source
    fn KernelSupport::coefficient(self : KernelSupport) -> Double

    KernelSupport::features

    source
    fn KernelSupport::features(self : KernelSupport) -> Array[Double]

    KernelSupport::label

    source
    fn KernelSupport::label(self : KernelSupport) -> Double

    KeyedFeatureJoin

    source
    pub struct KeyedFeatureJoin {
      capacity : Int
      pending_features : Map[String, Array[Double]]
      pending_labels : Map[String, Double]
      matched : Int
      dropped : Int
    }

    Bounded keyed join for combining asynchronous feature and label streams.

    KeyedFeatureJoin::dropped

    source
    fn KeyedFeatureJoin::dropped(self : KeyedFeatureJoin) -> Int

    KeyedFeatureJoin::matched

    source
    fn KeyedFeatureJoin::matched(self : KeyedFeatureJoin) -> Int

    KeyedFeatureJoin::new

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

    KeyedFeatureJoin::pending

    source
    fn KeyedFeatureJoin::pending(self : KeyedFeatureJoin) -> Int

    KeyedFeatureJoin::put_features

    source
    fn KeyedFeatureJoin::put_features(self : KeyedFeatureJoin, key : String, features : Array[Double]) -> Array[Double]?

    KeyedFeatureJoin::put_label

    source
    fn KeyedFeatureJoin::put_label(self : KeyedFeatureJoin, key : String, label : Double) -> Array[Double]?

    KeyedFeatureJoin::reset

    source
    fn KeyedFeatureJoin::reset(self : KeyedFeatureJoin) -> Unit

    LatencyTracker

    source
    pub struct LatencyTracker {
      samples : SequenceWindow
      total : Int
      rejected : Int
    }

    LatencyTracker::count

    source
    fn LatencyTracker::count(self : LatencyTracker) -> Int

    LatencyTracker::mean

    source
    fn LatencyTracker::mean(self : LatencyTracker) -> Double

    LatencyTracker::new

    source
    fn LatencyTracker::new(capacity? : Int) -> LatencyTracker

    LatencyTracker::observe

    source
    fn LatencyTracker::observe(self : LatencyTracker, milliseconds : Double) -> Bool

    LatencyTracker::p95

    source
    fn LatencyTracker::p95(self : LatencyTracker) -> Double

    LatencyTracker::percentile

    source
    fn LatencyTracker::percentile(self : LatencyTracker, probability : Double) -> Double

    LatencyTracker::rejected

    source
    fn LatencyTracker::rejected(self : LatencyTracker) -> Int

    LatencyTracker::reset

    source
    fn LatencyTracker::reset(self : LatencyTracker) -> Unit

    LatencyTracker::total

    source
    fn LatencyTracker::total(self : LatencyTracker) -> Int

    LearningCurve

    source
    pub struct LearningCurve {
      train : MetricSeries
      validation : MetricSeries
    }

    LearningCurve::generalization_gap

    source
    fn LearningCurve::generalization_gap(self : LearningCurve) -> Double

    LearningCurve::new

    source
    fn LearningCurve::new(capacity? : Int) -> LearningCurve

    LearningCurve::record

    source
    fn LearningCurve::record(self : LearningCurve, train_loss : Double, validation_loss : Double) -> Unit

    LearningCurve::reset

    source
    fn LearningCurve::reset(self : LearningCurve) -> Unit

    LearningCurve::train

    source
    fn LearningCurve::train(self : LearningCurve) -> Array[Double]

    LearningCurve::validation

    source
    fn LearningCurve::validation(self : LearningCurve) -> Array[Double]

    LearningRateSchedule

    source
    pub enum LearningRateSchedule {
      Constant
      InverseScaling(power~ : Double)
      ExponentialDecay(decay~ : Double)
      CosineDecay(minimum~ : Double, period~ : Int)
    } derive(Eq, ToJson, 
    Debug    , 
    FromJson    )

    Learning-rate schedules shared by adaptive online optimizers.

    LearningRateSchedule::rate

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

    LineageNode

    source
    pub struct LineageNode {
      dataset : String
      source : String
      schema : String
      row_count : Int
      checksum : String
      timestamp : Int64
    }

    LineageNode::checksum

    source
    fn LineageNode::checksum(self : LineageNode) -> String

    LineageNode::dataset

    source
    fn LineageNode::dataset(self : LineageNode) -> String

    LineageNode::new

    source
    fn LineageNode::new(dataset : String, source : String, schema : String, row_count : Int, checksum : String, timestamp : Int64) -> LineageNode

    LineageNode::row_count

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

    LineageNode::schema

    source
    fn LineageNode::schema(self : LineageNode) -> String

    LineageNode::source

    source
    fn LineageNode::source(self : LineageNode) -> String

    LineageNode::timestamp

    source
    fn LineageNode::timestamp(self : LineageNode) -> Int64

    LinearEndpoint

    source
    pub struct LinearEndpoint {
      weights : Array[Double]
      bias : Double
      version : String
      prediction_guard : PredictionGuard
      requests : Int
      rejected : Int
    }

    LinearEndpoint::new

    source
    fn LinearEndpoint::new(weights : Array[Double], bias? : Double, version? : String, lower? : Double, upper? : Double) -> LinearEndpoint

    LinearEndpoint::predict

    source

    LinearEndpoint::predict_batch

    source

    LinearEndpoint::rejected

    source
    fn LinearEndpoint::rejected(self : LinearEndpoint) -> Int

    LinearEndpoint::requests

    source
    fn LinearEndpoint::requests(self : LinearEndpoint) -> Int

    LinearEndpoint::reset

    source
    fn LinearEndpoint::reset(self : LinearEndpoint) -> Unit

    LinearEndpoint::version

    source
    fn LinearEndpoint::version(self : LinearEndpoint) -> String

    LinearEndpoint::weights

    source
    fn LinearEndpoint::weights(self : LinearEndpoint) -> Array[Double]

    LossAccumulator

    source
    pub struct LossAccumulator {
      kind : LossKind
      parameter : Double
      count : Int
      weight : Double
      total : Double
      absolute_gradient : Double
      maximum : Double
    }

    LossAccumulator::count

    source
    fn LossAccumulator::count(self : LossAccumulator) -> Int

    LossAccumulator::kind

    source

    LossAccumulator::maximum

    source
    fn LossAccumulator::maximum(self : LossAccumulator) -> Double

    LossAccumulator::mean

    source
    fn LossAccumulator::mean(self : LossAccumulator) -> Double

    LossAccumulator::mean_absolute_gradient

    source
    fn LossAccumulator::mean_absolute_gradient(self : LossAccumulator) -> Double

    LossAccumulator::new

    source
    fn LossAccumulator::new(kind : LossKind, parameter? : Double) -> LossAccumulator

    LossAccumulator::reset

    source
    fn LossAccumulator::reset(self : LossAccumulator) -> Unit

    LossAccumulator::update

    source
    fn LossAccumulator::update(self : LossAccumulator, prediction : Double, label : Double, weight? : Double) -> Double

    LossAccumulator::weight

    source
    fn LossAccumulator::weight(self : LossAccumulator) -> Double

    LossKind

    source
    pub(all) enum LossKind {
      Squared
      Absolute
      Huber
      LogLoss
      Hinge
      Quantile
      Poisson
    } derive(Eq, 
    Debug    )

    Loss functions and defensive gradient utilities shared by online learners. The implementations are allocation-light and keep all numerical guards at the package boundary so a malformed event cannot poison a long-running job.

    LossSchedule

    source
    pub struct LossSchedule {
      initial : Double
      decay : Double
      floor : Double
      step : Int
    }

    LossSchedule::advance

    source
    fn LossSchedule::advance(self : LossSchedule, steps? : Int) -> Double

    LossSchedule::new

    source
    fn LossSchedule::new(initial : Double, decay? : Double, floor? : Double) -> LossSchedule

    LossSchedule::reset

    source
    fn LossSchedule::reset(self : LossSchedule) -> Unit

    LossSchedule::step

    source
    fn LossSchedule::step(self : LossSchedule) -> Int

    LossSchedule::value

    source
    fn LossSchedule::value(self : LossSchedule) -> Double

    MarkovTransitionModel

    source
    pub struct MarkovTransitionModel {
      states : Int
      transitions : Array[Array[Double]]
      totals : Array[Double]
      previous : Int?
    }

    MarkovTransitionModel::distribution

    source
    fn MarkovTransitionModel::distribution(self : MarkovTransitionModel, from : Int) -> Array[Double]

    MarkovTransitionModel::new

    source
    fn MarkovTransitionModel::new(states : Int, smoothing? : Double) -> MarkovTransitionModel

    MarkovTransitionModel::next_state

    source
    fn MarkovTransitionModel::next_state(self : MarkovTransitionModel, from : Int) -> Int?

    MarkovTransitionModel::observe

    source
    fn MarkovTransitionModel::observe(self : MarkovTransitionModel, state : Int) -> Bool

    MarkovTransitionModel::probability

    source
    fn MarkovTransitionModel::probability(self : MarkovTransitionModel, from : Int, to : Int) -> Double

    MarkovTransitionModel::reset

    source

    MarkovTransitionModel::states

    source

    Matrix

    source
    pub struct Matrix {
      rows : Int
      cols : Int
      values : Array[Double]
    } derive(ToJson, 
    Debug    , 
    FromJson    )

    Matrix::add

    source
    fn Matrix::add(self : Matrix, other : Matrix) -> Matrix

    Matrix::cols

    source
    fn Matrix::cols(self : Matrix) -> Int

    Matrix::column

    source
    fn Matrix::column(self : Matrix, index : Int) -> DenseVector?

    Matrix::determinant

    source
    fn Matrix::determinant(self : Matrix) -> Double

    Compute a determinant with partial pivoting. The method is intended for small online covariance matrices, not for large dense linear algebra.

    Matrix::frobenius_norm

    source
    fn Matrix::frobenius_norm(self : Matrix) -> Double

    Matrix::from_rows

    source
    fn Matrix::from_rows(rows : Array[Array[Double]]) -> Matrix

    Matrix::get

    source
    fn Matrix::get(self : Matrix, row : Int, col : Int) -> Double?

    Matrix::identity

    source
    fn Matrix::identity(size : Int) -> Matrix

    Matrix::inverse

    source
    fn Matrix::inverse(self : Matrix) -> Matrix?

    Matrix::is_symmetric

    source
    fn Matrix::is_symmetric(self : Matrix, tolerance? : Double) -> Bool

    Matrix::multiply

    source
    fn Matrix::multiply(self : Matrix, other : Matrix) -> Matrix

    Matrix::multiply_vector

    source
    fn Matrix::multiply_vector(self : Matrix, vector : Array[Double]) -> Array[Double]

    Matrix::new

    source
    fn Matrix::new(rows : Int, cols : Int, fill? : Double) -> Matrix

    Matrix::row

    source
    fn Matrix::row(self : Matrix, index : Int) -> DenseVector?

    Matrix::rows

    source
    fn Matrix::rows(self : Matrix) -> Int

    Matrix::scale

    source
    fn Matrix::scale(self : Matrix, factor : Double) -> Matrix

    Matrix::set

    source
    fn Matrix::set(self : Matrix, row : Int, col : Int, value : Double) -> Bool

    Matrix::solve

    source
    fn Matrix::solve(self : Matrix, right_hand_side : Array[Double]) -> Array[Double]?

    Solve a square linear system using Gaussian elimination with pivoting.

    Matrix::to_rows

    source
    fn Matrix::to_rows(self : Matrix) -> Array[Array[Double]]

    Matrix::trace

    source
    fn Matrix::trace(self : Matrix) -> Double

    Matrix::transpose

    source
    fn Matrix::transpose(self : Matrix) -> Matrix

    MetricSeries

    source
    pub struct MetricSeries {
      name : String
      capacity : Int
      values : Array[Double]
      seen : Int
    }

    Bounded metric history for dashboards and regression tests.

    MetricSeries::last

    source
    fn MetricSeries::last(self : MetricSeries) -> Double?

    MetricSeries::maximum

    source
    fn MetricSeries::maximum(self : MetricSeries) -> Double

    MetricSeries::mean

    source
    fn MetricSeries::mean(self : MetricSeries) -> Double

    MetricSeries::minimum

    source
    fn MetricSeries::minimum(self : MetricSeries) -> Double

    MetricSeries::name

    source
    fn MetricSeries::name(self : MetricSeries) -> String

    MetricSeries::new

    source
    fn MetricSeries::new(name : String, capacity? : Int) -> MetricSeries

    MetricSeries::record

    source
    fn MetricSeries::record(self : MetricSeries, value : Double) -> Unit

    MetricSeries::reset

    source
    fn MetricSeries::reset(self : MetricSeries) -> Unit

    MetricSeries::seen

    source
    fn MetricSeries::seen(self : MetricSeries) -> Int

    MetricSeries::trend

    source
    fn MetricSeries::trend(self : MetricSeries) -> Double

    MetricSeries::values

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

    MetricSnapshot

    source
    pub struct MetricSnapshot {
      name : String
      value : Double
      timestamp : Int64
      samples : Int
    }

    Production-facing health and SLO primitives for continuously trained models.

    MetricSnapshot::name

    source
    fn MetricSnapshot::name(self : MetricSnapshot) -> String

    MetricSnapshot::new

    source
    fn MetricSnapshot::new(name : String, value : Double, timestamp : Int64, samples? : Int) -> MetricSnapshot

    MetricSnapshot::samples

    source
    fn MetricSnapshot::samples(self : MetricSnapshot) -> Int

    MetricSnapshot::timestamp

    source
    fn MetricSnapshot::timestamp(self : MetricSnapshot) -> Int64

    MetricSnapshot::value

    source
    fn MetricSnapshot::value(self : MetricSnapshot) -> Double

    MetricsTracker

    source
    pub struct MetricsTracker {
      count : Double
      sum_squared_error : Double
      sum_log_loss : Double
    }

    Incremental metrics tracker.

    MetricsTracker::log_loss

    source
    fn MetricsTracker::log_loss(self : MetricsTracker) -> Double

    Get the current LogLoss.

    MetricsTracker::mse

    source
    fn MetricsTracker::mse(self : MetricsTracker) -> Double

    Get the current Mean Squared Error (MSE).

    MetricsTracker::new

    source

    Create a new metrics tracker.

    MetricsTracker::update

    source
    fn MetricsTracker::update(self : MetricsTracker, pred : Double, label : Double) -> Unit

    Update metrics with a new prediction and ground truth label.

    MiniBatchAccumulator

    source
    pub struct MiniBatchAccumulator {
      dimension : Int
      features : Array[Array[Double]]
      labels : Array[Double]
      weights : Array[Double]
      capacity : Int
    }

    Reusable mini-batch accumulator for callers that need deterministic batch boundaries while keeping the learner online between flushes.

    MiniBatchAccumulator::add

    source
    fn MiniBatchAccumulator::add(self : MiniBatchAccumulator, features : Array[Double], label : Double, weight? : Double) -> Bool

    MiniBatchAccumulator::clear

    source
    fn MiniBatchAccumulator::clear(self : MiniBatchAccumulator) -> Unit

    MiniBatchAccumulator::flush

    source

    MiniBatchAccumulator::new

    source
    fn MiniBatchAccumulator::new(dimension : Int, capacity? : Int) -> MiniBatchAccumulator

    MiniBatchAccumulator::ready

    source
    fn MiniBatchAccumulator::ready(self : MiniBatchAccumulator) -> Bool

    MiniBatchAccumulator::size

    source

    MissingValueImputer

    source
    pub struct MissingValueImputer {
      policy : MissingValuePolicy
      means : Array[Double]
      counts : Array[Int]
      last : Array[Double]
      imputed : Int
      rejected : Int
    }

    MissingValueImputer::imputed

    source
    fn MissingValueImputer::imputed(self : MissingValueImputer) -> Int

    MissingValueImputer::means

    source
    fn MissingValueImputer::means(self : MissingValueImputer) -> Array[Double]

    MissingValueImputer::new

    source
    fn MissingValueImputer::new(dimension : Int, policy? : MissingValuePolicy) -> MissingValueImputer

    MissingValueImputer::observe

    source
    fn MissingValueImputer::observe(self : MissingValueImputer, values : Array[Double]) -> Unit

    MissingValueImputer::rejected

    source
    fn MissingValueImputer::rejected(self : MissingValueImputer) -> Int

    MissingValueImputer::reset

    source
    fn MissingValueImputer::reset(self : MissingValueImputer) -> Unit

    MissingValueImputer::transform

    source
    fn MissingValueImputer::transform(self : MissingValueImputer, values : Array[Double]) -> Array[Double]?

    MissingValuePolicy

    source
    pub enum MissingValuePolicy {
      Reject
      Zero
      Mean
      CarryForward
    } derive(Eq, ToJson, 
    Debug    , 
    FromJson    )

    ModelArtifact

    source
    pub struct ModelArtifact {
      name : String
      version : String
      checksum : String
      created_at : String
      stage : String
      metrics : Map[String, Double]
    } derive(ToJson, 
    Debug    , 
    FromJson    )

    Lightweight in-process model registry for reproducible experiments.

    ModelArtifact::add_metric

    source
    fn ModelArtifact::add_metric(self : ModelArtifact, name : String, value : Double) -> Unit

    ModelArtifact::checksum

    source
    fn ModelArtifact::checksum(self : ModelArtifact) -> String

    ModelArtifact::metric

    source
    fn ModelArtifact::metric(self : ModelArtifact, name : String) -> Double?

    ModelArtifact::metrics

    source
    fn ModelArtifact::metrics(self : ModelArtifact) -> Map[String, Double]

    ModelArtifact::name

    source
    fn ModelArtifact::name(self : ModelArtifact) -> String

    ModelArtifact::new

    source
    fn ModelArtifact::new(name : String, version : String, checksum : String, created_at : String) -> ModelArtifact

    ModelArtifact::set_stage

    source
    fn ModelArtifact::set_stage(self : ModelArtifact, stage : String) -> Unit

    ModelArtifact::stage

    source
    fn ModelArtifact::stage(self : ModelArtifact) -> String

    ModelArtifact::version

    source
    fn ModelArtifact::version(self : ModelArtifact) -> String

    ModelCard

    source
    pub struct ModelCard {
      name : String
      version : String
      task : String
      owner : String
      features : Array[String]
      guarantees : Array[String]
      notes : Array[String]
    }

    ModelCard::add_feature

    source
    fn ModelCard::add_feature(self : ModelCard, feature : String) -> Unit

    ModelCard::add_guarantee

    source
    fn ModelCard::add_guarantee(self : ModelCard, guarantee : String) -> Unit

    ModelCard::add_note

    source
    fn ModelCard::add_note(self : ModelCard, note : String) -> Unit

    ModelCard::features

    source
    fn ModelCard::features(self : ModelCard) -> Array[String]

    ModelCard::guarantees

    source
    fn ModelCard::guarantees(self : ModelCard) -> Array[String]

    ModelCard::name

    source
    fn ModelCard::name(self : ModelCard) -> String

    ModelCard::new

    source
    fn ModelCard::new(name : String, version : String, task : String, owner : String) -> ModelCard

    ModelCard::notes

    source
    fn ModelCard::notes(self : ModelCard) -> Array[String]

    ModelCard::owner

    source
    fn ModelCard::owner(self : ModelCard) -> String

    ModelCard::task

    source
    fn ModelCard::task(self : ModelCard) -> String

    ModelCard::version

    source
    fn ModelCard::version(self : ModelCard) -> String

    ModelHealth

    source
    pub struct ModelHealth {
      accepted : Int
      rejected : Int
      prediction_errors : Int
      inference_failures : Int
      latency : MetricSeries
      loss : MetricSeries
    }

    ModelHealth::acceptance_rate

    source
    fn ModelHealth::acceptance_rate(self : ModelHealth) -> Double

    ModelHealth::accepted

    source
    fn ModelHealth::accepted(self : ModelHealth) -> Int

    ModelHealth::inference_failures

    source
    fn ModelHealth::inference_failures(self : ModelHealth) -> Int

    ModelHealth::mean_loss

    source
    fn ModelHealth::mean_loss(self : ModelHealth) -> Double

    ModelHealth::new

    source

    ModelHealth::p95_latency

    source
    fn ModelHealth::p95_latency(self : ModelHealth) -> Double

    ModelHealth::record_error

    source
    fn ModelHealth::record_error(self : ModelHealth) -> Unit

    ModelHealth::record_prediction_error

    source
    fn ModelHealth::record_prediction_error(self : ModelHealth) -> Unit

    ModelHealth::record_sample

    source
    fn ModelHealth::record_sample(self : ModelHealth, accepted : Bool, loss : Double, latency_ms : Double) -> Unit

    ModelHealth::rejected

    source
    fn ModelHealth::rejected(self : ModelHealth) -> Int

    ModelHealth::reset

    source
    fn ModelHealth::reset(self : ModelHealth) -> Unit

    ModelMonitor

    source
    pub struct ModelMonitor {
      name : String
      metrics : Map[String, RunningMoments]
      rules : Array[AlertRule]
      snapshots : Int
      alerts : Int
    }

    ModelMonitor::add_rule

    source
    fn ModelMonitor::add_rule(self : ModelMonitor, rule : AlertRule) -> Unit

    ModelMonitor::alert_count

    source
    fn ModelMonitor::alert_count(self : ModelMonitor) -> Int

    ModelMonitor::mean

    source
    fn ModelMonitor::mean(self : ModelMonitor, metric : String) -> Double

    ModelMonitor::new

    source
    fn ModelMonitor::new(name : String) -> ModelMonitor

    ModelMonitor::observe

    source
    fn ModelMonitor::observe(self : ModelMonitor, snapshot : MetricSnapshot, now : Int64) -> Array[String]

    ModelMonitor::reset

    source
    fn ModelMonitor::reset(self : ModelMonitor) -> Unit

    ModelMonitor::snapshot_count

    source
    fn ModelMonitor::snapshot_count(self : ModelMonitor) -> Int

    ModelMonitor::variance

    source
    fn ModelMonitor::variance(self : ModelMonitor, metric : String) -> Double

    ModelRegistry

    source
    pub struct ModelRegistry {
      artifacts : Map[String, ModelArtifact]
      registrations : Int
    }

    ModelRegistry::clear

    source
    fn ModelRegistry::clear(self : ModelRegistry) -> Unit

    ModelRegistry::get

    source
    fn ModelRegistry::get(self : ModelRegistry, name : String, version : String) -> ModelArtifact?

    ModelRegistry::new

    source

    ModelRegistry::promote

    source
    fn ModelRegistry::promote(self : ModelRegistry, name : String, version : String, stage : String) -> Bool

    ModelRegistry::register

    source
    fn ModelRegistry::register(self : ModelRegistry, artifact : ModelArtifact) -> Bool

    ModelRegistry::registrations

    source
    fn ModelRegistry::registrations(self : ModelRegistry) -> Int

    ModelRegistry::size

    source
    fn ModelRegistry::size(self : ModelRegistry) -> Int

    ModelRegistry::versions

    source
    fn ModelRegistry::versions(self : ModelRegistry, name : String) -> Array[String]

    ModelRouter

    source
    pub struct ModelRouter {
      candidates : Map[String, RouteCandidate]
      policy : RoutingPolicy
      fallback : FallbackMode
      default_route : String?
      cursor : Int
      decisions : Int
      fallbacks : Int
      rejected : Int
    }

    ModelRouter::available_routes

    source
    fn ModelRouter::available_routes(self : ModelRouter) -> Array[String]

    ModelRouter::candidate

    source
    fn ModelRouter::candidate(self : ModelRouter, route_id : String) -> RouteCandidate?

    ModelRouter::choose

    source
    fn ModelRouter::choose(self : ModelRouter) -> RouteDecision?

    ModelRouter::decisions

    source
    fn ModelRouter::decisions(self : ModelRouter) -> Int

    ModelRouter::fallback_rate

    source
    fn ModelRouter::fallback_rate(self : ModelRouter) -> Double

    ModelRouter::fallbacks

    source
    fn ModelRouter::fallbacks(self : ModelRouter) -> Int

    ModelRouter::new

    source
    fn ModelRouter::new(policy? : RoutingPolicy, fallback? : FallbackMode) -> ModelRouter

    ModelRouter::record

    source
    fn ModelRouter::record(self : ModelRouter, route_id : String, success : Bool, latency : Double, timestamp : Int64) -> Bool

    ModelRouter::register

    source
    fn ModelRouter::register(self : ModelRouter, candidate : RouteCandidate, default? : Bool) -> Bool

    ModelRouter::rejected

    source
    fn ModelRouter::rejected(self : ModelRouter) -> Int

    ModelRouter::remove

    source
    fn ModelRouter::remove(self : ModelRouter, route_id : String) -> Bool

    ModelRouter::reset

    source
    fn ModelRouter::reset(self : ModelRouter) -> Unit

    ModelRouter::routes

    source
    fn ModelRouter::routes(self : ModelRouter) -> Array[String]

    ModelRouter::set_default

    source
    fn ModelRouter::set_default(self : ModelRouter, route_id : String) -> Bool

    ModelRouter::set_fallback

    source
    fn ModelRouter::set_fallback(self : ModelRouter, fallback : FallbackMode) -> Unit

    ModelRouter::set_policy

    source
    fn ModelRouter::set_policy(self : ModelRouter, policy : RoutingPolicy) -> Unit

    MomentumOptimizer

    source
    pub struct MomentumOptimizer {
      learning_rate : Double
      momentum : Double
      dampening : Double
      velocity : Array[Double]
      clipper : GradientClipper
      step_count : Int
    }

    MomentumOptimizer::apply

    source
    fn MomentumOptimizer::apply(self : MomentumOptimizer, parameters : Array[Double], gradients : Array[Double]) -> Unit

    MomentumOptimizer::new

    source
    fn MomentumOptimizer::new(dimension : Int, learning_rate? : Double, momentum? : Double, dampening? : Double, clipper? : GradientClipper) -> MomentumOptimizer

    MomentumOptimizer::reset

    source
    fn MomentumOptimizer::reset(self : MomentumOptimizer) -> Unit

    MomentumOptimizer::update

    source
    fn MomentumOptimizer::update(self : MomentumOptimizer, gradients : Array[Double]) -> Array[Double]

    MomentumOptimizer::velocity

    source
    fn MomentumOptimizer::velocity(self : MomentumOptimizer) -> Array[Double]

    MultivariateAnomalyDetector

    source
    pub struct MultivariateAnomalyDetector {
      moments : VectorMoments
      threshold : Double
      anomalies : Int
    }

    Diagonal multivariate z-score detector for low-memory edge deployments.

    MultivariateAnomalyDetector::anomalies

    source

    MultivariateAnomalyDetector::mean

    source

    MultivariateAnomalyDetector::new

    source
    fn MultivariateAnomalyDetector::new(dimension : Int, threshold? : Double) -> MultivariateAnomalyDetector

    MultivariateAnomalyDetector::reset

    source

    MultivariateAnomalyDetector::score

    source
    fn MultivariateAnomalyDetector::score(self : MultivariateAnomalyDetector, values : Array[Double]) -> Double

    MultivariateAnomalyDetector::update

    source
    fn MultivariateAnomalyDetector::update(self : MultivariateAnomalyDetector, values : Array[Double]) -> Bool

    ObjectiveKind

    source
    pub enum ObjectiveKind {
      Squared
      Logistic
      Huber(delta~ : Double)
      Quantile(probability~ : Double)
      Hinge
    } derive(Eq, ToJson, 
    Debug    , 
    FromJson    )

    ObjectiveKind::gradient

    source
    fn ObjectiveKind::gradient(self : ObjectiveKind, prediction : Double, label : Double) -> Double

    ObjectiveKind::loss

    source
    fn ObjectiveKind::loss(self : ObjectiveKind, prediction : Double, label : Double) -> Double

    ObjectiveTracker

    source
    pub struct ObjectiveTracker {
      objective : ObjectiveKind
      count : Double
      total : Double
      last : Double
    }

    ObjectiveTracker::count

    source
    fn ObjectiveTracker::count(self : ObjectiveTracker) -> Double

    ObjectiveTracker::last

    source
    fn ObjectiveTracker::last(self : ObjectiveTracker) -> Double

    ObjectiveTracker::mean

    source
    fn ObjectiveTracker::mean(self : ObjectiveTracker) -> Double

    ObjectiveTracker::new

    source

    ObjectiveTracker::observe

    source
    fn ObjectiveTracker::observe(self : ObjectiveTracker, prediction : Double, label : Double, weight? : Double) -> Unit

    ObjectiveTracker::reset

    source
    fn ObjectiveTracker::reset(self : ObjectiveTracker) -> Unit

    OneHotEncoder

    source
    pub struct OneHotEncoder {
      values : Map[String, Int]
      unknown_index : Int?
      next_index : Int
      unknowns : Int
    }

    OneHotEncoder::contains

    source
    fn OneHotEncoder::contains(self : OneHotEncoder, value : String) -> Bool

    OneHotEncoder::dimension

    source
    fn OneHotEncoder::dimension(self : OneHotEncoder) -> Int

    OneHotEncoder::encode

    source
    fn OneHotEncoder::encode(self : OneHotEncoder, value : String) -> Int

    OneHotEncoder::entries

    source
    fn OneHotEncoder::entries(self : OneHotEncoder) -> Array[(String, Int)]

    OneHotEncoder::fit

    source
    fn OneHotEncoder::fit(self : OneHotEncoder, value : String) -> Int

    OneHotEncoder::new

    source
    fn OneHotEncoder::new(unknown_index? : Int) -> OneHotEncoder

    OneHotEncoder::reset

    source
    fn OneHotEncoder::reset(self : OneHotEncoder) -> Unit

    OneHotEncoder::unknowns

    source
    fn OneHotEncoder::unknowns(self : OneHotEncoder) -> Int

    OneHotEncoder::vector

    source
    fn OneHotEncoder::vector(self : OneHotEncoder, value : String) -> Array[Double]

    OnlineAR

    source
    pub struct OnlineAR {
      lags : Int
      coefficients : Array[Double]
      history : SequenceWindow
      learning_rate : Double
      observations : Int
      squared_error : Double
    }

    OnlineAR::coefficients

    source
    fn OnlineAR::coefficients(self : OnlineAR) -> Array[Double]

    OnlineAR::new

    source
    fn OnlineAR::new(lags : Int, learning_rate? : Double) -> OnlineAR

    OnlineAR::observations

    source
    fn OnlineAR::observations(self : OnlineAR) -> Int

    OnlineAR::predict

    source
    fn OnlineAR::predict(self : OnlineAR) -> Double

    OnlineAR::reset

    source
    fn OnlineAR::reset(self : OnlineAR) -> Unit

    OnlineAR::rmse

    source
    fn OnlineAR::rmse(self : OnlineAR) -> Double

    OnlineAR::update

    source
    fn OnlineAR::update(self : OnlineAR, value : Double) -> Double

    OnlineAutoregressive

    source
    pub struct OnlineAutoregressive {
      lags : Int
      weights : Array[Double]
      history : Array[Double]
      learning_rate : Double
      l2 : Double
      steps : Int
    }

    Online autoregressive model with a fixed lag window.

    OnlineAutoregressive::feature_vector

    source
    fn OnlineAutoregressive::feature_vector(self : OnlineAutoregressive) -> Array[Double]

    OnlineAutoregressive::forecast

    source
    fn OnlineAutoregressive::forecast(self : OnlineAutoregressive, horizon : Int) -> Array[Double]

    OnlineAutoregressive::history

    source
    fn OnlineAutoregressive::history(self : OnlineAutoregressive) -> Array[Double]

    OnlineAutoregressive::lags

    source

    OnlineAutoregressive::new

    source
    fn OnlineAutoregressive::new(lags : Int, learning_rate? : Double, l2? : Double) -> OnlineAutoregressive

    OnlineAutoregressive::predict

    source
    fn OnlineAutoregressive::predict(self : OnlineAutoregressive) -> Double

    OnlineAutoregressive::reset

    source
    fn OnlineAutoregressive::reset(self : OnlineAutoregressive) -> Unit

    OnlineAutoregressive::steps

    source

    OnlineAutoregressive::update

    source
    fn OnlineAutoregressive::update(self : OnlineAutoregressive, value : Double) -> Double

    OnlineAutoregressive::weights

    source
    fn OnlineAutoregressive::weights(self : OnlineAutoregressive) -> Array[Double]

    OnlineBaggingClassifier

    source
    pub struct OnlineBaggingClassifier {
      models : Array[AdagradLogisticRegression]
      rng : DeterministicRng
      observations : Int
    }

    Online bagging around Adagrad logistic learners.

    OnlineBaggingClassifier::member_predictions

    source
    fn OnlineBaggingClassifier::member_predictions(self : OnlineBaggingClassifier, features : Array[Double]) -> Array[Double]

    OnlineBaggingClassifier::models

    source

    OnlineBaggingClassifier::new

    source
    fn OnlineBaggingClassifier::new(model_count : Int, dimension : Int, seed? : UInt64) -> OnlineBaggingClassifier

    OnlineBaggingClassifier::observations

    source
    fn OnlineBaggingClassifier::observations(self : OnlineBaggingClassifier) -> Int

    OnlineBaggingClassifier::predict

    source
    fn OnlineBaggingClassifier::predict(self : OnlineBaggingClassifier, features : Array[Double]) -> Double

    OnlineBaggingClassifier::reset

    source

    OnlineBaggingClassifier::update

    source
    fn OnlineBaggingClassifier::update(self : OnlineBaggingClassifier, features : Array[Double], label : Double) -> Unit

    OnlineBatchScorer

    source
    pub struct OnlineBatchScorer {
      endpoint : LinearEndpoint
      batcher : RequestBatcher
      stats : ServingStats
    }

    OnlineBatchScorer::endpoint

    source

    OnlineBatchScorer::flush

    source

    OnlineBatchScorer::new

    source
    fn OnlineBatchScorer::new(weights : Array[Double], batch_size? : Int, version? : String) -> OnlineBatchScorer

    OnlineBatchScorer::pending

    source
    fn OnlineBatchScorer::pending(self : OnlineBatchScorer) -> Int

    OnlineBatchScorer::reset

    source
    fn OnlineBatchScorer::reset(self : OnlineBatchScorer) -> Unit

    OnlineBatchScorer::stats

    source

    OnlineBatchScorer::submit

    source

    OnlineBernoulliNB

    source
    pub struct OnlineBernoulliNB {
      ones : Array[Array[Double]]
      counts : Array[Double]
      smoothing : Double
      steps : Int
    }

    Bernoulli Naive Bayes for binary sparse-style features.

    OnlineBernoulliNB::feature_probability

    source
    fn OnlineBernoulliNB::feature_probability(self : OnlineBernoulliNB, label : Int, index : Int) -> Double

    OnlineBernoulliNB::log_scores

    source
    fn OnlineBernoulliNB::log_scores(self : OnlineBernoulliNB, features : Array[Double]) -> Array[Double]

    OnlineBernoulliNB::new

    source
    fn OnlineBernoulliNB::new(classes : Int, dimension : Int, smoothing? : Double) -> OnlineBernoulliNB

    OnlineBernoulliNB::predict

    source
    fn OnlineBernoulliNB::predict(self : OnlineBernoulliNB, features : Array[Double]) -> Int?

    OnlineBernoulliNB::predict_proba

    source
    fn OnlineBernoulliNB::predict_proba(self : OnlineBernoulliNB, features : Array[Double]) -> Array[Double]

    OnlineBernoulliNB::reset

    source
    fn OnlineBernoulliNB::reset(self : OnlineBernoulliNB) -> Unit

    OnlineBernoulliNB::steps

    source
    fn OnlineBernoulliNB::steps(self : OnlineBernoulliNB) -> Int

    OnlineBernoulliNB::update

    source
    fn OnlineBernoulliNB::update(self : OnlineBernoulliNB, features : Array[Double], label : Int, weight? : Double) -> Bool

    OnlineConformalRegressor

    source
    pub struct OnlineConformalRegressor {
      confidence : Double
      scores : OnlineQuantileSketch
      observations : Int
      covered : Int
      misses : Int
    }

    OnlineConformalRegressor::confidence

    source
    fn OnlineConformalRegressor::confidence(self : OnlineConformalRegressor) -> Double

    OnlineConformalRegressor::coverage

    source
    fn OnlineConformalRegressor::coverage(self : OnlineConformalRegressor) -> Double

    OnlineConformalRegressor::covered

    source

    OnlineConformalRegressor::interval

    source
    fn OnlineConformalRegressor::interval(self : OnlineConformalRegressor, prediction : Double) -> CalibratedInterval

    OnlineConformalRegressor::misses

    source

    OnlineConformalRegressor::new

    source
    fn OnlineConformalRegressor::new(confidence? : Double, capacity? : Int) -> OnlineConformalRegressor

    OnlineConformalRegressor::observations

    source
    fn OnlineConformalRegressor::observations(self : OnlineConformalRegressor) -> Int

    OnlineConformalRegressor::observe

    source
    fn OnlineConformalRegressor::observe(self : OnlineConformalRegressor, prediction : Double, actual : Double) -> Double

    OnlineConformalRegressor::radius

    source

    OnlineConformalRegressor::reset

    source

    OnlineCounter

    source
    pub struct OnlineCounter {
      values : Map[String, Double]
      updates : Int
    }

    Generic weighted counters for stream dashboards.

    OnlineCounter::add

    source
    fn OnlineCounter::add(self : OnlineCounter, key : String, value? : Double) -> Unit

    OnlineCounter::get

    source
    fn OnlineCounter::get(self : OnlineCounter, key : String) -> Double

    OnlineCounter::keys

    source
    fn OnlineCounter::keys(self : OnlineCounter) -> Array[String]

    OnlineCounter::new

    source

    OnlineCounter::reset

    source
    fn OnlineCounter::reset(self : OnlineCounter) -> Unit

    OnlineCounter::total

    source
    fn OnlineCounter::total(self : OnlineCounter) -> Double

    OnlineCounter::updates

    source
    fn OnlineCounter::updates(self : OnlineCounter) -> Int

    OnlineDecisionStump

    source
    pub struct OnlineDecisionStump {
      feature : Int
      threshold : Double
      left_positive : Double
      left_negative : Double
      right_positive : Double
      right_negative : Double
      updates : Int
    }

    A streaming decision stump over one numeric feature.

    OnlineDecisionStump::accuracy

    source
    fn OnlineDecisionStump::accuracy(self : OnlineDecisionStump) -> Double

    OnlineDecisionStump::feature

    source
    fn OnlineDecisionStump::feature(self : OnlineDecisionStump) -> Int

    OnlineDecisionStump::new

    source
    fn OnlineDecisionStump::new(feature : Int, threshold? : Double) -> OnlineDecisionStump

    OnlineDecisionStump::predict

    source
    fn OnlineDecisionStump::predict(self : OnlineDecisionStump, features : Array[Double], smoothing? : Double) -> Double

    OnlineDecisionStump::reset

    source
    fn OnlineDecisionStump::reset(self : OnlineDecisionStump) -> Unit

    OnlineDecisionStump::threshold

    source
    fn OnlineDecisionStump::threshold(self : OnlineDecisionStump) -> Double

    OnlineDecisionStump::update

    source
    fn OnlineDecisionStump::update(self : OnlineDecisionStump, features : Array[Double], label : Double, weight? : Double) -> Unit

    OnlineDecisionStump::update_threshold

    source
    fn OnlineDecisionStump::update_threshold(self : OnlineDecisionStump, threshold : Double) -> Unit

    OnlineDecisionStump::updates

    source
    fn OnlineDecisionStump::updates(self : OnlineDecisionStump) -> Int

    OnlineEvaluationSession

    source
    pub struct OnlineEvaluationSession {
      metrics : MetricsTracker
      confusion : ConfusionMatrix
      auc_tracker : AucTracker
      calibration : CalibrationTracker
      regression : RegressionMetrics
    }

    OnlineEvaluationSession::classification

    source

    OnlineEvaluationSession::new

    source

    OnlineEvaluationSession::observe_binary

    source
    fn OnlineEvaluationSession::observe_binary(self : OnlineEvaluationSession, probability : Double, label : Double) -> Unit

    OnlineEvaluationSession::observe_regression

    source
    fn OnlineEvaluationSession::observe_regression(self : OnlineEvaluationSession, prediction : Double, label : Double) -> Unit

    OnlineEvaluationSession::regression

    source

    OnlineEvaluationSession::reset

    source

    OnlineEvaluationSession::summary

    source

    OnlineFeatureSelector

    source
    pub struct OnlineFeatureSelector {
      moments : VectorMoments
      target : RunningMoments
      cross : Array[Double]
      observations : Double
    }

    Online absolute-correlation tracker for feature monitoring and pruning.

    OnlineFeatureSelector::absolute_importance

    source
    fn OnlineFeatureSelector::absolute_importance(self : OnlineFeatureSelector) -> Array[Double]

    OnlineFeatureSelector::correlations

    source
    fn OnlineFeatureSelector::correlations(self : OnlineFeatureSelector) -> Array[Double]

    OnlineFeatureSelector::dimension

    source
    fn OnlineFeatureSelector::dimension(self : OnlineFeatureSelector) -> Int

    OnlineFeatureSelector::new

    source
    fn OnlineFeatureSelector::new(dimension : Int) -> OnlineFeatureSelector

    OnlineFeatureSelector::observations

    source
    fn OnlineFeatureSelector::observations(self : OnlineFeatureSelector) -> Double

    OnlineFeatureSelector::rank

    source
    fn OnlineFeatureSelector::rank(self : OnlineFeatureSelector, top_k : Int) -> Array[Int]

    OnlineFeatureSelector::reset

    source

    OnlineFeatureSelector::select

    source
    fn OnlineFeatureSelector::select(self : OnlineFeatureSelector, threshold : Double) -> Array[Int]

    OnlineFeatureSelector::update

    source
    fn OnlineFeatureSelector::update(self : OnlineFeatureSelector, features : Array[Double], target : Double) -> Unit

    OnlineGammaRegression

    source
    pub struct OnlineGammaRegression {
      weights : Array[Double]
      learning_rate : Double
      l2 : Double
      steps : Int
    }

    OnlineGammaRegression::loss

    source
    fn OnlineGammaRegression::loss(self : OnlineGammaRegression, features : Array[Double], value : Double) -> Double

    OnlineGammaRegression::new

    source
    fn OnlineGammaRegression::new(dimension : Int, learning_rate? : Double, l2? : Double) -> OnlineGammaRegression

    OnlineGammaRegression::predict

    source
    fn OnlineGammaRegression::predict(self : OnlineGammaRegression, features : Array[Double]) -> Double

    OnlineGammaRegression::reset

    source

    OnlineGammaRegression::steps

    source

    OnlineGammaRegression::update

    source
    fn OnlineGammaRegression::update(self : OnlineGammaRegression, features : Array[Double], value : Double) -> Unit

    OnlineGammaRegression::weights

    source
    fn OnlineGammaRegression::weights(self : OnlineGammaRegression) -> Array[Double]

    OnlineGaussianNB

    source
    pub struct OnlineGaussianNB {
      classes : Array[GaussianClassStats]
      class_counts : Array[Double]
      smoothing : Double
      steps : Int
    }

    Incremental Gaussian Naive Bayes for categorical labels.

    OnlineGaussianNB::class_counts

    source
    fn OnlineGaussianNB::class_counts(self : OnlineGaussianNB) -> Array[Double]

    OnlineGaussianNB::classes

    source
    fn OnlineGaussianNB::classes(self : OnlineGaussianNB) -> Int

    OnlineGaussianNB::dimension

    source
    fn OnlineGaussianNB::dimension(self : OnlineGaussianNB) -> Int

    OnlineGaussianNB::log_priors

    source
    fn OnlineGaussianNB::log_priors(self : OnlineGaussianNB) -> Array[Double]

    OnlineGaussianNB::log_scores

    source
    fn OnlineGaussianNB::log_scores(self : OnlineGaussianNB, features : Array[Double]) -> Array[Double]

    OnlineGaussianNB::new

    source
    fn OnlineGaussianNB::new(classes : Int, dimension : Int, smoothing? : Double) -> OnlineGaussianNB

    OnlineGaussianNB::predict

    source
    fn OnlineGaussianNB::predict(self : OnlineGaussianNB, features : Array[Double]) -> Int?

    OnlineGaussianNB::predict_proba

    source
    fn OnlineGaussianNB::predict_proba(self : OnlineGaussianNB, features : Array[Double]) -> Array[Double]

    OnlineGaussianNB::reset

    source
    fn OnlineGaussianNB::reset(self : OnlineGaussianNB) -> Unit

    OnlineGaussianNB::steps

    source
    fn OnlineGaussianNB::steps(self : OnlineGaussianNB) -> Int

    OnlineGaussianNB::update

    source
    fn OnlineGaussianNB::update(self : OnlineGaussianNB, features : Array[Double], label : Int, weight? : Double) -> Bool

    OnlineGraph

    source
    pub struct OnlineGraph {
      adjacency : Map[String, Map[String, Double]]
      edges : Int
      total_weight : Double
      self_loops : Int
      updates : Int
    }

    OnlineGraph::add_edge

    source
    fn OnlineGraph::add_edge(self : OnlineGraph, source : String, target : String, weight? : Double) -> Bool

    OnlineGraph::edge_count

    source
    fn OnlineGraph::edge_count(self : OnlineGraph) -> Int

    OnlineGraph::neighbors

    source
    fn OnlineGraph::neighbors(self : OnlineGraph, source : String, limit? : Int) -> Array[GraphNeighbor]

    OnlineGraph::new

    source

    OnlineGraph::node_count

    source
    fn OnlineGraph::node_count(self : OnlineGraph) -> Int

    OnlineGraph::nodes

    source
    fn OnlineGraph::nodes(self : OnlineGraph) -> Array[String]

    OnlineGraph::out_degree

    source
    fn OnlineGraph::out_degree(self : OnlineGraph, node : String) -> Int

    OnlineGraph::page_rank

    source
    fn OnlineGraph::page_rank(self : OnlineGraph, iterations? : Int, damping? : Double) -> Array[GraphNodeScore]

    OnlineGraph::remove_edge

    source
    fn OnlineGraph::remove_edge(self : OnlineGraph, source : String, target : String) -> Bool

    OnlineGraph::reset

    source
    fn OnlineGraph::reset(self : OnlineGraph) -> Unit

    OnlineGraph::set_edge

    source
    fn OnlineGraph::set_edge(self : OnlineGraph, source : String, target : String, weight : Double) -> Bool

    OnlineGraph::summary

    source
    fn OnlineGraph::summary(self : OnlineGraph) -> GraphSummary

    OnlineGraph::updates

    source
    fn OnlineGraph::updates(self : OnlineGraph) -> Int

    OnlineGraph::weight

    source
    fn OnlineGraph::weight(self : OnlineGraph, source : String, target : String) -> Double?

    OnlineGraph::weighted_degree

    source
    fn OnlineGraph::weighted_degree(self : OnlineGraph, node : String) -> Double

    OnlineHoltWinters

    source
    pub struct OnlineHoltWinters {
      period : Int
      alpha : Double
      beta : Double
      gamma : Double
      level : Double
      trend : Double
      seasonals : Array[Double]
      errors : OnlineQuantileSketch
      steps : Int
      initialized : Bool
    }

    OnlineHoltWinters::level

    source
    fn OnlineHoltWinters::level(self : OnlineHoltWinters) -> Double

    OnlineHoltWinters::new

    source
    fn OnlineHoltWinters::new(period : Int, alpha? : Double, beta? : Double, gamma? : Double, error_capacity? : Int) -> OnlineHoltWinters

    OnlineHoltWinters::period

    source
    fn OnlineHoltWinters::period(self : OnlineHoltWinters) -> Int

    OnlineHoltWinters::predict

    source
    fn OnlineHoltWinters::predict(self : OnlineHoltWinters, horizon : Int, start_timestamp? : Int64, step? : Int64) -> Array[ForecastPoint]

    OnlineHoltWinters::reset

    source
    fn OnlineHoltWinters::reset(self : OnlineHoltWinters) -> Unit

    OnlineHoltWinters::residual_scale

    source
    fn OnlineHoltWinters::residual_scale(self : OnlineHoltWinters) -> Double

    OnlineHoltWinters::steps

    source
    fn OnlineHoltWinters::steps(self : OnlineHoltWinters) -> Int

    OnlineHoltWinters::trend

    source
    fn OnlineHoltWinters::trend(self : OnlineHoltWinters) -> Double

    OnlineHoltWinters::update

    source
    fn OnlineHoltWinters::update(self : OnlineHoltWinters, value : Double) -> Double

    OnlineHuberRegression

    source
    pub struct OnlineHuberRegression {
      weights : Array[Double]
      learning_rate : Double
      delta : Double
      l2 : Double
      steps : Int
    }

    Robust online regression using the Huber loss.

    OnlineHuberRegression::loss

    source
    fn OnlineHuberRegression::loss(self : OnlineHuberRegression, features : Array[Double], label : Double) -> Double

    OnlineHuberRegression::new

    source
    fn OnlineHuberRegression::new(dimension : Int, learning_rate? : Double, delta? : Double, l2? : Double) -> OnlineHuberRegression

    OnlineHuberRegression::predict

    source
    fn OnlineHuberRegression::predict(self : OnlineHuberRegression, features : Array[Double]) -> Double

    OnlineHuberRegression::steps

    source

    OnlineHuberRegression::update

    source
    fn OnlineHuberRegression::update(self : OnlineHuberRegression, features : Array[Double], label : Double) -> Unit

    OnlineHuberRegression::weights

    source
    fn OnlineHuberRegression::weights(self : OnlineHuberRegression) -> Array[Double]

    OnlineIsotonicCalibrator

    source
    pub struct OnlineIsotonicCalibrator {
      scores : Array[Double]
      labels : Array[Double]
      capacity : Int
    }

    OnlineIsotonicCalibrator::new

    source

    OnlineIsotonicCalibrator::predict

    source
    fn OnlineIsotonicCalibrator::predict(self : OnlineIsotonicCalibrator, score : Double) -> Double

    OnlineIsotonicCalibrator::reset

    source

    OnlineIsotonicCalibrator::size

    source

    OnlineIsotonicCalibrator::update

    source
    fn OnlineIsotonicCalibrator::update(self : OnlineIsotonicCalibrator, score : Double, label : Double) -> Unit

    OnlineKMeans

    source
    pub struct OnlineKMeans {
      centroids : Array[Array[Double]]
      counts : Array[Double]
      learning_rate : Double
      assignments : Int
    }

    Streaming k-means with bounded state and optional exponential adaptation.

    OnlineKMeans::assignments

    source
    fn OnlineKMeans::assignments(self : OnlineKMeans) -> Int

    OnlineKMeans::centroids

    source
    fn OnlineKMeans::centroids(self : OnlineKMeans) -> Array[Array[Double]]

    OnlineKMeans::cluster_counts

    source
    fn OnlineKMeans::cluster_counts(self : OnlineKMeans) -> Array[Double]

    OnlineKMeans::clusters

    source
    fn OnlineKMeans::clusters(self : OnlineKMeans) -> Int

    OnlineKMeans::dimension

    source
    fn OnlineKMeans::dimension(self : OnlineKMeans) -> Int

    OnlineKMeans::distance_to_nearest

    source
    fn OnlineKMeans::distance_to_nearest(self : OnlineKMeans, features : Array[Double]) -> Double

    OnlineKMeans::nearest

    source
    fn OnlineKMeans::nearest(self : OnlineKMeans, features : Array[Double]) -> Int?

    OnlineKMeans::new

    source
    fn OnlineKMeans::new(clusters : Int, dimension : Int, learning_rate? : Double) -> OnlineKMeans

    OnlineKMeans::reset

    source
    fn OnlineKMeans::reset(self : OnlineKMeans) -> Unit

    OnlineKMeans::update

    source
    fn OnlineKMeans::update(self : OnlineKMeans, features : Array[Double]) -> Int?

    OnlineKernelClassifier

    source
    pub struct OnlineKernelClassifier {
      kernel : KernelKind
      budget : Int
      supports : Array[KernelSupport]
      learning_rate : Double
      bias : Double
      updates : Int
    }

    Budgeted kernel perceptron for non-linear binary classification.

    OnlineKernelClassifier::loss

    source
    fn OnlineKernelClassifier::loss(self : OnlineKernelClassifier, features : Array[Double], label : Double) -> Double

    OnlineKernelClassifier::new

    source
    fn OnlineKernelClassifier::new(kernel? : KernelKind, budget? : Int, learning_rate? : Double) -> OnlineKernelClassifier

    OnlineKernelClassifier::predict

    source
    fn OnlineKernelClassifier::predict(self : OnlineKernelClassifier, features : Array[Double]) -> Double

    OnlineKernelClassifier::predict_label

    source
    fn OnlineKernelClassifier::predict_label(self : OnlineKernelClassifier, features : Array[Double]) -> Double

    OnlineKernelClassifier::reset

    source

    OnlineKernelClassifier::score

    source
    fn OnlineKernelClassifier::score(self : OnlineKernelClassifier, features : Array[Double]) -> Double

    OnlineKernelClassifier::support_count

    source
    fn OnlineKernelClassifier::support_count(self : OnlineKernelClassifier) -> Int

    OnlineKernelClassifier::update

    source
    fn OnlineKernelClassifier::update(self : OnlineKernelClassifier, features : Array[Double], label : Double) -> Bool

    OnlineKernelClassifier::updates

    source

    OnlineMatrixFactorization

    source
    pub struct OnlineMatrixFactorization {
      users : Array[Array[Double]]
      items : Array[Array[Double]]
      learning_rate : Double
      regularization : Double
      updates : Int
    }

    Online matrix factorization for implicit or explicit feedback streams.

    OnlineMatrixFactorization::item_count

    source

    OnlineMatrixFactorization::item_vector

    source
    fn OnlineMatrixFactorization::item_vector(self : OnlineMatrixFactorization, item : Int) -> Array[Double]?

    OnlineMatrixFactorization::new

    source
    fn OnlineMatrixFactorization::new(users : Int, items : Int, rank : Int, learning_rate? : Double, regularization? : Double) -> OnlineMatrixFactorization

    OnlineMatrixFactorization::predict

    source
    fn OnlineMatrixFactorization::predict(self : OnlineMatrixFactorization, user : Int, item : Int) -> Double

    OnlineMatrixFactorization::rank

    source

    OnlineMatrixFactorization::reset

    source

    OnlineMatrixFactorization::update

    source
    fn OnlineMatrixFactorization::update(self : OnlineMatrixFactorization, user : Int, item : Int, rating : Double) -> Bool

    OnlineMatrixFactorization::updates

    source

    OnlineMatrixFactorization::user_count

    source

    OnlineMatrixFactorization::user_vector

    source
    fn OnlineMatrixFactorization::user_vector(self : OnlineMatrixFactorization, user : Int) -> Array[Double]?

    OnlineMedoid

    source
    pub struct OnlineMedoid {
      center : Array[Double]
      count : Double
      learning_rate : Double
      cost : Double
    }

    OnlineMedoid::center

    source
    fn OnlineMedoid::center(self : OnlineMedoid) -> Array[Double]

    OnlineMedoid::count

    source
    fn OnlineMedoid::count(self : OnlineMedoid) -> Double

    OnlineMedoid::mean_cost

    source
    fn OnlineMedoid::mean_cost(self : OnlineMedoid) -> Double

    OnlineMedoid::new

    source
    fn OnlineMedoid::new(dimension : Int, learning_rate? : Double) -> OnlineMedoid

    OnlineMedoid::reset

    source
    fn OnlineMedoid::reset(self : OnlineMedoid) -> Unit

    OnlineMedoid::update

    source
    fn OnlineMedoid::update(self : OnlineMedoid, features : Array[Double]) -> Double

    OnlineMinMaxScaler

    source
    pub struct OnlineMinMaxScaler {
      minimum : Array[Double]
      maximum : Array[Double]
      initialized : Array[Bool]
      observations : Int
    }

    OnlineMinMaxScaler::inverse

    source
    fn OnlineMinMaxScaler::inverse(self : OnlineMinMaxScaler, values : Array[Double], lower? : Double, upper? : Double) -> Array[Double]

    OnlineMinMaxScaler::maximum

    source
    fn OnlineMinMaxScaler::maximum(self : OnlineMinMaxScaler) -> Array[Double]

    OnlineMinMaxScaler::minimum

    source
    fn OnlineMinMaxScaler::minimum(self : OnlineMinMaxScaler) -> Array[Double]

    OnlineMinMaxScaler::new

    source
    fn OnlineMinMaxScaler::new(dimension : Int) -> OnlineMinMaxScaler

    OnlineMinMaxScaler::observations

    source
    fn OnlineMinMaxScaler::observations(self : OnlineMinMaxScaler) -> Int

    OnlineMinMaxScaler::reset

    source
    fn OnlineMinMaxScaler::reset(self : OnlineMinMaxScaler) -> Unit

    OnlineMinMaxScaler::transform

    source
    fn OnlineMinMaxScaler::transform(self : OnlineMinMaxScaler, values : Array[Double], lower? : Double, upper? : Double) -> Array[Double]

    OnlineMinMaxScaler::update

    source
    fn OnlineMinMaxScaler::update(self : OnlineMinMaxScaler, values : Array[Double]) -> Unit

    OnlinePCA

    source
    pub struct OnlinePCA {
      components : Array[Array[Double]]
      mean : Array[Double]
      learning_rate : Double
      count : Double
      explained : Array[Double]
    }

    Online principal-component analysis using Oja's rule.

    OnlinePCA::component_vectors

    source
    fn OnlinePCA::component_vectors(self : OnlinePCA) -> Array[Array[Double]]

    OnlinePCA::components

    source
    fn OnlinePCA::components(self : OnlinePCA) -> Int

    OnlinePCA::count

    source
    fn OnlinePCA::count(self : OnlinePCA) -> Double

    OnlinePCA::dimension

    source
    fn OnlinePCA::dimension(self : OnlinePCA) -> Int

    OnlinePCA::explained_variance

    source
    fn OnlinePCA::explained_variance(self : OnlinePCA) -> Array[Double]

    OnlinePCA::mean

    source
    fn OnlinePCA::mean(self : OnlinePCA) -> Array[Double]

    OnlinePCA::new

    source
    fn OnlinePCA::new(components : Int, dimension : Int, learning_rate? : Double) -> OnlinePCA

    OnlinePCA::reconstruct

    source
    fn OnlinePCA::reconstruct(self : OnlinePCA, transformed : Array[Double]) -> Array[Double]

    OnlinePCA::reset

    source
    fn OnlinePCA::reset(self : OnlinePCA) -> Unit

    OnlinePCA::transform

    source
    fn OnlinePCA::transform(self : OnlinePCA, values : Array[Double]) -> Array[Double]

    OnlinePCA::update

    source
    fn OnlinePCA::update(self : OnlinePCA, values : Array[Double]) -> Unit

    OnlinePlattScaler

    source
    pub struct OnlinePlattScaler {
      slope : Double
      intercept : Double
      learning_rate : Double
      steps : Int
    }

    Online Platt scaling for turning arbitrary scores into calibrated probabilities.

    OnlinePlattScaler::intercept

    source
    fn OnlinePlattScaler::intercept(self : OnlinePlattScaler) -> Double

    OnlinePlattScaler::new

    source
    fn OnlinePlattScaler::new(learning_rate? : Double) -> OnlinePlattScaler

    OnlinePlattScaler::predict

    source
    fn OnlinePlattScaler::predict(self : OnlinePlattScaler, score : Double) -> Double

    OnlinePlattScaler::reset

    source
    fn OnlinePlattScaler::reset(self : OnlinePlattScaler) -> Unit

    OnlinePlattScaler::slope

    source
    fn OnlinePlattScaler::slope(self : OnlinePlattScaler) -> Double

    OnlinePlattScaler::steps

    source
    fn OnlinePlattScaler::steps(self : OnlinePlattScaler) -> Int

    OnlinePlattScaler::update

    source
    fn OnlinePlattScaler::update(self : OnlinePlattScaler, score : Double, label : Double) -> Unit

    OnlinePoissonRegression

    source
    pub struct OnlinePoissonRegression {
      weights : Array[Double]
      learning_rate : Double
      l2 : Double
      steps : Int
    }

    Online Poisson regression for count-valued event streams.

    OnlinePoissonRegression::loss

    source
    fn OnlinePoissonRegression::loss(self : OnlinePoissonRegression, features : Array[Double], count : Double) -> Double

    OnlinePoissonRegression::new

    source
    fn OnlinePoissonRegression::new(dimension : Int, learning_rate? : Double, l2? : Double) -> OnlinePoissonRegression

    OnlinePoissonRegression::predict

    source
    fn OnlinePoissonRegression::predict(self : OnlinePoissonRegression, features : Array[Double]) -> Double

    OnlinePoissonRegression::rate

    source
    fn OnlinePoissonRegression::rate(self : OnlinePoissonRegression, features : Array[Double]) -> Double

    OnlinePoissonRegression::reset

    source

    OnlinePoissonRegression::steps

    source

    OnlinePoissonRegression::update

    source
    fn OnlinePoissonRegression::update(self : OnlinePoissonRegression, features : Array[Double], count : Double) -> Unit

    OnlinePoissonRegression::weights

    source

    OnlineQuantileInterval

    source
    pub struct OnlineQuantileInterval {
      lower : OnlineQuantileRegression
      upper : OnlineQuantileRegression
      observations : Int
    }

    OnlineQuantileInterval::contains

    source
    fn OnlineQuantileInterval::contains(self : OnlineQuantileInterval, features : Array[Double], label : Double) -> Bool

    OnlineQuantileInterval::new

    source
    fn OnlineQuantileInterval::new(dimension : Int, coverage? : Double, learning_rate? : Double) -> OnlineQuantileInterval

    OnlineQuantileInterval::observations

    source
    fn OnlineQuantileInterval::observations(self : OnlineQuantileInterval) -> Int

    OnlineQuantileInterval::predict

    source
    fn OnlineQuantileInterval::predict(self : OnlineQuantileInterval, features : Array[Double]) -> (Double, Double)

    OnlineQuantileInterval::reset

    source

    OnlineQuantileInterval::update

    source
    fn OnlineQuantileInterval::update(self : OnlineQuantileInterval, features : Array[Double], label : Double) -> Unit

    OnlineQuantileRegression

    source
    pub struct OnlineQuantileRegression {
      weights : Array[Double]
      learning_rate : Double
      quantile : Double
      l2 : Double
      steps : Int
    }

    Online quantile regression for prediction intervals and tail forecasting.

    OnlineQuantileRegression::new

    source
    fn OnlineQuantileRegression::new(dimension : Int, quantile? : Double, learning_rate? : Double, l2? : Double) -> OnlineQuantileRegression

    OnlineQuantileRegression::pinball_loss

    source
    fn OnlineQuantileRegression::pinball_loss(self : OnlineQuantileRegression, features : Array[Double], label : Double) -> Double

    OnlineQuantileRegression::predict

    source
    fn OnlineQuantileRegression::predict(self : OnlineQuantileRegression, features : Array[Double]) -> Double

    OnlineQuantileRegression::quantile

    source
    fn OnlineQuantileRegression::quantile(self : OnlineQuantileRegression) -> Double

    OnlineQuantileRegression::update

    source
    fn OnlineQuantileRegression::update(self : OnlineQuantileRegression, features : Array[Double], label : Double) -> Unit

    OnlineQuantileRegression::weights

    source

    OnlineQuantileSketch

    source
    pub struct OnlineQuantileSketch {
      capacity : Int
      values : Array[Double]
      seen : Int
    }

    OnlineQuantileSketch::median

    source
    fn OnlineQuantileSketch::median(self : OnlineQuantileSketch) -> Double?

    OnlineQuantileSketch::new

    source
    fn OnlineQuantileSketch::new(capacity? : Int) -> OnlineQuantileSketch

    OnlineQuantileSketch::quantile

    source
    fn OnlineQuantileSketch::quantile(self : OnlineQuantileSketch, probability : Double) -> Double?

    OnlineQuantileSketch::reset

    source
    fn OnlineQuantileSketch::reset(self : OnlineQuantileSketch) -> Unit

    OnlineQuantileSketch::seen

    source

    OnlineQuantileSketch::update

    source
    fn OnlineQuantileSketch::update(self : OnlineQuantileSketch, value : Double) -> Unit

    OnlineReliabilityMonitor

    source
    pub struct OnlineReliabilityMonitor {
      bins : Array[ReliabilityBin]
      observations : Int
      positives : Int
      log_loss : Double
    }

    OnlineReliabilityMonitor::bins

    source

    OnlineReliabilityMonitor::brier_score

    source
    fn OnlineReliabilityMonitor::brier_score(self : OnlineReliabilityMonitor) -> Double

    OnlineReliabilityMonitor::expected_calibration_error

    source
    fn OnlineReliabilityMonitor::expected_calibration_error(self : OnlineReliabilityMonitor) -> Double

    OnlineReliabilityMonitor::log_loss

    source
    fn OnlineReliabilityMonitor::log_loss(self : OnlineReliabilityMonitor) -> Double

    OnlineReliabilityMonitor::maximum_calibration_error

    source
    fn OnlineReliabilityMonitor::maximum_calibration_error(self : OnlineReliabilityMonitor) -> Double

    OnlineReliabilityMonitor::new

    source

    OnlineReliabilityMonitor::observations

    source
    fn OnlineReliabilityMonitor::observations(self : OnlineReliabilityMonitor) -> Int

    OnlineReliabilityMonitor::observe

    source
    fn OnlineReliabilityMonitor::observe(self : OnlineReliabilityMonitor, probability : Double, label : Double) -> Bool

    OnlineReliabilityMonitor::positive_rate

    source
    fn OnlineReliabilityMonitor::positive_rate(self : OnlineReliabilityMonitor) -> Double

    OnlineReliabilityMonitor::reset

    source

    OnlineRidgeRegression

    source
    pub struct OnlineRidgeRegression {
      weights : Array[Double]
      diagonal : Array[Double]
      learning_rate : Double
      l2 : Double
      intercept : Double
      intercept_diagonal : Double
      steps : Int
    }

    Streaming ridge regression with a diagonal preconditioner.

    OnlineRidgeRegression::dimension

    source
    fn OnlineRidgeRegression::dimension(self : OnlineRidgeRegression) -> Int

    OnlineRidgeRegression::intercept

    source
    fn OnlineRidgeRegression::intercept(self : OnlineRidgeRegression) -> Double

    OnlineRidgeRegression::loss

    source
    fn OnlineRidgeRegression::loss(self : OnlineRidgeRegression, features : Array[Double], label : Double) -> Double

    OnlineRidgeRegression::new

    source
    fn OnlineRidgeRegression::new(dimension : Int, learning_rate? : Double, l2? : Double) -> OnlineRidgeRegression

    OnlineRidgeRegression::predict

    source
    fn OnlineRidgeRegression::predict(self : OnlineRidgeRegression, features : Array[Double]) -> Double

    OnlineRidgeRegression::reset

    source

    OnlineRidgeRegression::residual

    source
    fn OnlineRidgeRegression::residual(self : OnlineRidgeRegression, features : Array[Double], label : Double) -> Double

    OnlineRidgeRegression::rmse

    source
    fn OnlineRidgeRegression::rmse(self : OnlineRidgeRegression, samples : Array[Array[Double]], labels : Array[Double]) -> Double

    OnlineRidgeRegression::steps

    source

    OnlineRidgeRegression::update

    source
    fn OnlineRidgeRegression::update(self : OnlineRidgeRegression, features : Array[Double], label : Double) -> Unit

    OnlineRidgeRegression::update_weighted

    source
    fn OnlineRidgeRegression::update_weighted(self : OnlineRidgeRegression, features : Array[Double], label : Double, sample_weight : Double) -> Unit

    OnlineRidgeRegression::weights

    source
    fn OnlineRidgeRegression::weights(self : OnlineRidgeRegression) -> Array[Double]

    OnlineRobustScaler

    source
    pub struct OnlineRobustScaler {
      sketches : Array[OnlineQuantileSketch]
      observations : Int
    }

    OnlineRobustScaler::new

    source
    fn OnlineRobustScaler::new(dimension : Int, capacity? : Int) -> OnlineRobustScaler

    OnlineRobustScaler::observations

    source
    fn OnlineRobustScaler::observations(self : OnlineRobustScaler) -> Int

    OnlineRobustScaler::quantile

    source
    fn OnlineRobustScaler::quantile(self : OnlineRobustScaler, feature : Int, probability : Double) -> Double?

    OnlineRobustScaler::reset

    source
    fn OnlineRobustScaler::reset(self : OnlineRobustScaler) -> Unit

    OnlineRobustScaler::transform

    source
    fn OnlineRobustScaler::transform(self : OnlineRobustScaler, values : Array[Double]) -> Array[Double]

    OnlineRobustScaler::update

    source
    fn OnlineRobustScaler::update(self : OnlineRobustScaler, values : Array[Double]) -> Unit

    OnlineSoftmaxRegression

    source
    pub struct OnlineSoftmaxRegression {
      weights : Array[Array[Double]]
      learning_rate : Double
      l2 : Double
      steps : Int
    }

    Online multiclass softmax regression.

    The implementation uses a stable log-sum-exp softmax and updates all classes for each event. This makes it suitable for streaming routing, intent classification, and low-latency edge inference.

    OnlineSoftmaxRegression::accuracy_on

    source
    fn OnlineSoftmaxRegression::accuracy_on(self : OnlineSoftmaxRegression, samples : Array[Array[Double]], labels : Array[Int]) -> Double

    OnlineSoftmaxRegression::classes

    source

    OnlineSoftmaxRegression::dimension

    source

    OnlineSoftmaxRegression::logits

    source
    fn OnlineSoftmaxRegression::logits(self : OnlineSoftmaxRegression, features : Array[Double]) -> Array[Double]

    OnlineSoftmaxRegression::loss

    source
    fn OnlineSoftmaxRegression::loss(self : OnlineSoftmaxRegression, features : Array[Double], label : Int) -> Double

    OnlineSoftmaxRegression::new

    source
    fn OnlineSoftmaxRegression::new(classes : Int, dimension : Int, learning_rate? : Double, l2? : Double) -> OnlineSoftmaxRegression

    OnlineSoftmaxRegression::predict_class

    source
    fn OnlineSoftmaxRegression::predict_class(self : OnlineSoftmaxRegression, features : Array[Double]) -> Int?

    OnlineSoftmaxRegression::predict_proba

    source
    fn OnlineSoftmaxRegression::predict_proba(self : OnlineSoftmaxRegression, features : Array[Double]) -> Array[Double]

    OnlineSoftmaxRegression::predict_top_k

    source
    fn OnlineSoftmaxRegression::predict_top_k(self : OnlineSoftmaxRegression, features : Array[Double], k : Int) -> Array[Int]

    OnlineSoftmaxRegression::reset

    source

    OnlineSoftmaxRegression::steps

    source

    OnlineSoftmaxRegression::top_k_accuracy

    source
    fn OnlineSoftmaxRegression::top_k_accuracy(self : OnlineSoftmaxRegression, samples : Array[Array[Double]], labels : Array[Int], k : Int) -> Double

    OnlineSoftmaxRegression::update

    source
    fn OnlineSoftmaxRegression::update(self : OnlineSoftmaxRegression, features : Array[Double], label : Int) -> Bool

    OnlineSoftmaxRegression::update_weighted

    source
    fn OnlineSoftmaxRegression::update_weighted(self : OnlineSoftmaxRegression, features : Array[Double], label : Int, weight : Double) -> Bool

    OnlineSoftmaxRegression::weight_norm_squared

    source
    fn OnlineSoftmaxRegression::weight_norm_squared(self : OnlineSoftmaxRegression) -> Double

    OnlineSoftmaxRegression::weights

    source

    OnlineStumpEnsemble

    source
    pub struct OnlineStumpEnsemble {
      stumps : Array[OnlineDecisionStump]
      rng : DeterministicRng
      updates : Int
    }

    A small random stump ensemble for bounded-memory online classification.

    OnlineStumpEnsemble::accuracy

    source
    fn OnlineStumpEnsemble::accuracy(self : OnlineStumpEnsemble) -> Double

    OnlineStumpEnsemble::feature_indices

    source
    fn OnlineStumpEnsemble::feature_indices(self : OnlineStumpEnsemble) -> Array[Int]

    OnlineStumpEnsemble::new

    source
    fn OnlineStumpEnsemble::new(stump_count : Int, dimension : Int, seed? : UInt64) -> OnlineStumpEnsemble

    OnlineStumpEnsemble::predict

    source
    fn OnlineStumpEnsemble::predict(self : OnlineStumpEnsemble, features : Array[Double]) -> Double

    OnlineStumpEnsemble::predict_label

    source
    fn OnlineStumpEnsemble::predict_label(self : OnlineStumpEnsemble, features : Array[Double], threshold? : Double) -> Double

    OnlineStumpEnsemble::reset

    source
    fn OnlineStumpEnsemble::reset(self : OnlineStumpEnsemble) -> Unit

    OnlineStumpEnsemble::size

    source

    OnlineStumpEnsemble::thresholds

    source
    fn OnlineStumpEnsemble::thresholds(self : OnlineStumpEnsemble) -> Array[Double]

    OnlineStumpEnsemble::update

    source
    fn OnlineStumpEnsemble::update(self : OnlineStumpEnsemble, features : Array[Double], label : Double, weight? : Double) -> Unit

    OnlineStumpEnsemble::updates

    source
    fn OnlineStumpEnsemble::updates(self : OnlineStumpEnsemble) -> Int

    OptimizerStatistics

    source
    pub struct OptimizerStatistics {
      steps : Int
      gradient_l1 : Double
      gradient_l2 : Double
      update_l2 : Double
    }

    OptimizerStatistics::mean_gradient_l1

    source
    fn OptimizerStatistics::mean_gradient_l1(self : OptimizerStatistics) -> Double

    OptimizerStatistics::mean_gradient_l2

    source
    fn OptimizerStatistics::mean_gradient_l2(self : OptimizerStatistics) -> Double

    OptimizerStatistics::mean_update_l2

    source
    fn OptimizerStatistics::mean_update_l2(self : OptimizerStatistics) -> Double

    OptimizerStatistics::new

    source

    OptimizerStatistics::record

    source
    fn OptimizerStatistics::record(self : OptimizerStatistics, gradient : Array[Double], update : Array[Double]) -> Unit

    OptimizerStatistics::steps

    source
    fn OptimizerStatistics::steps(self : OptimizerStatistics) -> Int

    PageHinkleyDetector

    source
    pub struct PageHinkleyDetector {
      threshold : Double
      delta : Double
      mean : Double
      cumulative : Double
      minimum : Double
      count : Double
    }

    Page-Hinkley change detector for gradual concept drift.

    PageHinkleyDetector::count

    source
    fn PageHinkleyDetector::count(self : PageHinkleyDetector) -> Double

    PageHinkleyDetector::mean

    source
    fn PageHinkleyDetector::mean(self : PageHinkleyDetector) -> Double

    PageHinkleyDetector::new

    source
    fn PageHinkleyDetector::new(threshold? : Double, delta? : Double) -> PageHinkleyDetector

    PageHinkleyDetector::reset

    source
    fn PageHinkleyDetector::reset(self : PageHinkleyDetector) -> Unit

    PageHinkleyDetector::update

    source
    fn PageHinkleyDetector::update(self : PageHinkleyDetector, value : Double) -> Bool

    PairwiseRanker

    source
    pub struct PairwiseRanker {
      weights : Array[Double]
      learning_rate : Double
      margin : Double
      l2 : Double
      updates : Int
    }

    Online pairwise ranking model trained with a hinge objective.

    PairwiseRanker::compare

    source
    fn PairwiseRanker::compare(self : PairwiseRanker, left : Array[Double], right : Array[Double]) -> Double

    PairwiseRanker::dimension

    source
    fn PairwiseRanker::dimension(self : PairwiseRanker) -> Int

    PairwiseRanker::loss

    source
    fn PairwiseRanker::loss(self : PairwiseRanker, positive : Array[Double], negative : Array[Double]) -> Double

    PairwiseRanker::new

    source
    fn PairwiseRanker::new(dimension : Int, learning_rate? : Double, margin? : Double, l2? : Double) -> PairwiseRanker

    PairwiseRanker::reset

    source
    fn PairwiseRanker::reset(self : PairwiseRanker) -> Unit

    PairwiseRanker::score

    source
    fn PairwiseRanker::score(self : PairwiseRanker, features : Array[Double]) -> Double

    PairwiseRanker::update

    source
    fn PairwiseRanker::update(self : PairwiseRanker, positive : Array[Double], negative : Array[Double]) -> Bool

    PairwiseRanker::updates

    source
    fn PairwiseRanker::updates(self : PairwiseRanker) -> Int

    PairwiseRanker::weights

    source
    fn PairwiseRanker::weights(self : PairwiseRanker) -> Array[Double]

    PassiveAggressiveRegressor

    source
    pub struct PassiveAggressiveRegressor {
      weights : Array[Double]
      aggressiveness : Double
      epsilon : Double
      l2 : Double
      updates : Int
    }

    Passive-aggressive online regression with robust step sizing.

    PassiveAggressiveRegressor::new

    source
    fn PassiveAggressiveRegressor::new(dimension : Int, aggressiveness? : Double, epsilon? : Double, l2? : Double) -> PassiveAggressiveRegressor

    PassiveAggressiveRegressor::predict

    source
    fn PassiveAggressiveRegressor::predict(self : PassiveAggressiveRegressor, features : Array[Double]) -> Double

    PassiveAggressiveRegressor::reset

    source

    PassiveAggressiveRegressor::update

    source
    fn PassiveAggressiveRegressor::update(self : PassiveAggressiveRegressor, features : Array[Double], label : Double) -> Bool

    PassiveAggressiveRegressor::updates

    source

    PassiveAggressiveRegressor::weights

    source

    PosteriorBandit

    source
    pub struct PosteriorBandit {
      alpha : Array[Double]
      beta : Array[Double]
      rng : DeterministicRng
      steps : Int
    }

    PosteriorBandit::arm_count

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

    PosteriorBandit::choose

    source
    fn PosteriorBandit::choose(self : PosteriorBandit) -> Int?

    PosteriorBandit::mean

    source
    fn PosteriorBandit::mean(self : PosteriorBandit, arm : Int) -> Double

    PosteriorBandit::new

    source
    fn PosteriorBandit::new(arm_count : Int, prior? : Double, seed? : UInt64) -> PosteriorBandit

    PosteriorBandit::reset

    source
    fn PosteriorBandit::reset(self : PosteriorBandit) -> Unit

    PosteriorBandit::sample

    source
    fn PosteriorBandit::sample(self : PosteriorBandit, arm : Int) -> Double

    PosteriorBandit::steps

    source
    fn PosteriorBandit::steps(self : PosteriorBandit) -> Int

    PosteriorBandit::uncertainty

    source
    fn PosteriorBandit::uncertainty(self : PosteriorBandit, arm : Int) -> Double

    PosteriorBandit::update

    source
    fn PosteriorBandit::update(self : PosteriorBandit, arm : Int, reward : Double) -> Bool

    PredictionEnvelope

    source
    pub struct PredictionEnvelope {
      request_id : String
      route_id : String
      version : String
      values : Array[Double]
      confidence : Double
      timestamp : Int64
      cached : Bool
    }

    PredictionEnvelope::cached

    source
    fn PredictionEnvelope::cached(self : PredictionEnvelope) -> Bool

    PredictionEnvelope::confidence

    source
    fn PredictionEnvelope::confidence(self : PredictionEnvelope) -> Double

    PredictionEnvelope::new

    source
    fn PredictionEnvelope::new(request_id : String, decision : RouteDecision, values : Array[Double], confidence : Double, timestamp : Int64, cached? : Bool) -> PredictionEnvelope

    PredictionEnvelope::request_id

    source
    fn PredictionEnvelope::request_id(self : PredictionEnvelope) -> String

    PredictionEnvelope::route_id

    source
    fn PredictionEnvelope::route_id(self : PredictionEnvelope) -> String

    PredictionEnvelope::timestamp

    source
    fn PredictionEnvelope::timestamp(self : PredictionEnvelope) -> Int64

    PredictionEnvelope::values

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

    PredictionEnvelope::version

    source
    fn PredictionEnvelope::version(self : PredictionEnvelope) -> String

    PredictionGuard

    source
    pub struct PredictionGuard {
      lower : Double
      upper : Double
      repaired : Int
    }

    PredictionGuard::apply

    source
    fn PredictionGuard::apply(self : PredictionGuard, prediction : Double) -> Double

    PredictionGuard::new

    source
    fn PredictionGuard::new(lower : Double, upper : Double) -> PredictionGuard

    PredictionGuard::repaired

    source
    fn PredictionGuard::repaired(self : PredictionGuard) -> Int

    PredictionGuard::reset

    source
    fn PredictionGuard::reset(self : PredictionGuard) -> Unit

    PredictionRequest

    source
    pub struct PredictionRequest {
      request_id : String
      features : Array[Double]
      timestamp : Int64
      group : String
    }

    Deterministic model-serving helpers for embedding online models in services.

    PredictionRequest::features

    source
    fn PredictionRequest::features(self : PredictionRequest) -> Array[Double]

    PredictionRequest::group

    source
    fn PredictionRequest::group(self : PredictionRequest) -> String

    PredictionRequest::new

    source
    fn PredictionRequest::new(request_id : String, features : Array[Double], timestamp : Int64, group? : String) -> PredictionRequest

    PredictionRequest::request_id

    source
    fn PredictionRequest::request_id(self : PredictionRequest) -> String

    PredictionRequest::timestamp

    source
    fn PredictionRequest::timestamp(self : PredictionRequest) -> Int64

    PredictionResponse

    source
    pub struct PredictionResponse {
      request_id : String
      prediction : Double
      probability : Double
      model_version : String
      latency_ms : Double
      accepted : Bool
    }

    PredictionResponse::accepted

    source
    fn PredictionResponse::accepted(self : PredictionResponse) -> Bool

    PredictionResponse::latency_ms

    source
    fn PredictionResponse::latency_ms(self : PredictionResponse) -> Double

    PredictionResponse::model_version

    source
    fn PredictionResponse::model_version(self : PredictionResponse) -> String

    PredictionResponse::new

    source
    fn PredictionResponse::new(request_id : String, prediction : Double, model_version : String, latency_ms? : Double, accepted? : Bool) -> PredictionResponse

    PredictionResponse::prediction

    source
    fn PredictionResponse::prediction(self : PredictionResponse) -> Double

    PredictionResponse::probability

    source
    fn PredictionResponse::probability(self : PredictionResponse) -> Double

    PredictionResponse::request_id

    source
    fn PredictionResponse::request_id(self : PredictionResponse) -> String

    PredictionSet

    source
    pub struct PredictionSet {
      labels : Array[Int]
      probabilities : Array[Double]
      threshold : Double
    }

    PredictionSet::contains

    source
    fn PredictionSet::contains(self : PredictionSet, label : Int) -> Bool

    PredictionSet::labels

    source
    fn PredictionSet::labels(self : PredictionSet) -> Array[Int]

    PredictionSet::new

    source
    fn PredictionSet::new(probabilities : Array[Double], threshold? : Double) -> PredictionSet

    PredictionSet::probability

    source
    fn PredictionSet::probability(self : PredictionSet, label : Int) -> Double

    PredictionSet::size

    source
    fn PredictionSet::size(self : PredictionSet) -> Int

    PrivacyBudget

    source
    pub struct PrivacyBudget {
      total : Double
      remaining_budget : Double
      queries : Int
      rejected : Int
    }

    PrivacyBudget::consume

    source
    fn PrivacyBudget::consume(self : PrivacyBudget, cost : Double) -> Bool

    PrivacyBudget::exhausted

    source
    fn PrivacyBudget::exhausted(self : PrivacyBudget) -> Bool

    PrivacyBudget::new

    source
    fn PrivacyBudget::new(epsilon : Double) -> PrivacyBudget

    PrivacyBudget::queries

    source
    fn PrivacyBudget::queries(self : PrivacyBudget) -> Int

    PrivacyBudget::rejected

    source
    fn PrivacyBudget::rejected(self : PrivacyBudget) -> Int

    PrivacyBudget::remaining

    source
    fn PrivacyBudget::remaining(self : PrivacyBudget) -> Double

    PrivacyBudget::reset

    source
    fn PrivacyBudget::reset(self : PrivacyBudget) -> Unit

    PrivacyBudget::spent

    source
    fn PrivacyBudget::spent(self : PrivacyBudget) -> Double

    PrivacyBudget::total

    source
    fn PrivacyBudget::total(self : PrivacyBudget) -> Double

    ProbabilityThresholdPolicy

    source
    pub struct ProbabilityThresholdPolicy {
      target_rate : Double
      threshold : Double
      observations : Int
      positives : Int
    }

    ProbabilityThresholdPolicy::new

    source
    fn ProbabilityThresholdPolicy::new(target_rate? : Double) -> ProbabilityThresholdPolicy

    ProbabilityThresholdPolicy::observations

    source

    ProbabilityThresholdPolicy::observe

    source
    fn ProbabilityThresholdPolicy::observe(self : ProbabilityThresholdPolicy, probability : Double) -> Bool

    ProbabilityThresholdPolicy::positive_rate

    source
    fn ProbabilityThresholdPolicy::positive_rate(self : ProbabilityThresholdPolicy) -> Double

    ProbabilityThresholdPolicy::reset

    source

    ProbabilityThresholdPolicy::target_rate

    source
    fn ProbabilityThresholdPolicy::target_rate(self : ProbabilityThresholdPolicy) -> Double

    ProbabilityThresholdPolicy::threshold

    source

    PromotionGate

    source
    pub struct PromotionGate {
      minimum_auc : Double
      maximum_log_loss : Double
      minimum_samples : Int
    }

    PromotionGate::accept

    source
    fn PromotionGate::accept(self : PromotionGate, summary : EvaluationSummary) -> Bool

    PromotionGate::new

    source
    fn PromotionGate::new(minimum_auc? : Double, maximum_log_loss? : Double, minimum_samples? : Int) -> PromotionGate

    QualityGate

    source
    pub struct QualityGate {
      dimension : Int
      min_weight : Double
      max_weight : Double
      allow_nan_like : Bool
    }

    QualityGate::dimension

    source
    fn QualityGate::dimension(self : QualityGate) -> Int

    QualityGate::new

    source
    fn QualityGate::new(dimension : Int, min_weight? : Double, max_weight? : Double) -> QualityGate

    QualityGate::validate_features

    source
    fn QualityGate::validate_features(self : QualityGate, features : Array[Double]) -> ValidationReport

    QualityGate::validate_sample

    source
    fn QualityGate::validate_sample(self : QualityGate, features : Array[Double], weight : Double) -> ValidationReport

    QualityGate::validate_weight

    source
    fn QualityGate::validate_weight(self : QualityGate, weight : Double) -> ValidationReport

    QuantileBinner

    source
    pub struct QuantileBinner {
      boundaries : Array[Double]
    }

    QuantileBinner::bin

    source
    fn QuantileBinner::bin(self : QuantileBinner, value : Double) -> Int

    QuantileBinner::bins

    source
    fn QuantileBinner::bins(self : QuantileBinner) -> Int

    QuantileBinner::boundaries

    source
    fn QuantileBinner::boundaries(self : QuantileBinner) -> Array[Double]

    QuantileBinner::new

    source
    fn QuantileBinner::new(boundaries : Array[Double]) -> QuantileBinner

    QuantileBinner::one_hot

    source
    fn QuantileBinner::one_hot(self : QuantileBinner, value : Double) -> Array[Double]

    RLS

    source
    pub struct RLS {
      weights : Array[Double]
      p : Array[Array[Double]]
      lambda : Double
    } derive(ToJson, 
    FromJson    )

    Recursive Least Squares (RLS) model for online linear regression.

    RLS::new

    source
    fn RLS::new(dim : Int, lambda? : Double, alpha? : Double) -> RLS

    Create a new RLS model with dim features. lambda is the forgetting factor (default 1.0). alpha is the initial ridge regression penalty (default 1.0).

    RLS::predict

    source
    fn RLS::predict(self : RLS, features : Array[Double]) -> Double

    Predict the output for a given feature vector.

    RLS::update

    source
    fn RLS::update(self : RLS, features : Array[Double], label : Double) -> Unit

    Update the model with a single sample (features and label).

    RMSPropOptimizer

    source
    pub struct RMSPropOptimizer {
      learning_rate : Double
      decay : Double
      epsilon : Double
      mean_square : Array[Double]
      clipper : GradientClipper
      step_count : Int
    }

    RMSPropOptimizer::apply

    source
    fn RMSPropOptimizer::apply(self : RMSPropOptimizer, parameters : Array[Double], gradients : Array[Double]) -> Unit

    RMSPropOptimizer::mean_square

    source
    fn RMSPropOptimizer::mean_square(self : RMSPropOptimizer) -> Array[Double]

    RMSPropOptimizer::new

    source
    fn RMSPropOptimizer::new(dimension : Int, learning_rate? : Double, decay? : Double, epsilon? : Double, clipper? : GradientClipper) -> RMSPropOptimizer

    RMSPropOptimizer::reset

    source
    fn RMSPropOptimizer::reset(self : RMSPropOptimizer) -> Unit

    RMSPropOptimizer::update

    source
    fn RMSPropOptimizer::update(self : RMSPropOptimizer, gradients : Array[Double]) -> Array[Double]

    RandomFourierFeatures

    source
    pub struct RandomFourierFeatures {
      input_dimension : Int
      output_dimension : Int
      weights : Array[Array[Double]]
      phases : Array[Double]
      scale : Double
      rng : DeterministicRng
    }

    Random Fourier feature map for approximating a Gaussian kernel.

    RandomFourierFeatures::input_dimension

    source
    fn RandomFourierFeatures::input_dimension(self : RandomFourierFeatures) -> Int

    RandomFourierFeatures::new

    source
    fn RandomFourierFeatures::new(input_dimension : Int, output_dimension : Int, width? : Double, seed? : UInt64) -> RandomFourierFeatures

    RandomFourierFeatures::output_dimension

    source
    fn RandomFourierFeatures::output_dimension(self : RandomFourierFeatures) -> Int

    RandomFourierFeatures::transform

    source
    fn RandomFourierFeatures::transform(self : RandomFourierFeatures, features : Array[Double]) -> Array[Double]

    RandomFourierFeatures::weight_matrix

    source
    fn RandomFourierFeatures::weight_matrix(self : RandomFourierFeatures) -> Array[Array[Double]]

    RankingMetrics

    source
    pub struct RankingMetrics {
      queries : Double
      reciprocal_rank : Double
      ndcg_sum : Double
      hits : Array[Double]
    }

    RankingMetrics::mrr

    source
    fn RankingMetrics::mrr(self : RankingMetrics) -> Double

    RankingMetrics::ndcg

    source
    fn RankingMetrics::ndcg(self : RankingMetrics) -> Double

    RankingMetrics::new

    source
    fn RankingMetrics::new(max_k? : Int) -> RankingMetrics

    RankingMetrics::observe

    source
    fn RankingMetrics::observe(self : RankingMetrics, relevances : Array[Double]) -> Unit

    RankingMetrics::queries

    source
    fn RankingMetrics::queries(self : RankingMetrics) -> Double

    RankingMetrics::recall_at

    source
    fn RankingMetrics::recall_at(self : RankingMetrics, k : Int) -> Double

    RankingMetrics::reset

    source
    fn RankingMetrics::reset(self : RankingMetrics) -> Unit

    RateLimiter

    source
    pub struct RateLimiter {
      limit : Int
      period : Int
      ticks : Int
      accepted : Int
    }

    RateLimiter::accepted

    source
    fn RateLimiter::accepted(self : RateLimiter) -> Int

    RateLimiter::allow

    source
    fn RateLimiter::allow(self : RateLimiter) -> Bool

    RateLimiter::new

    source
    fn RateLimiter::new(limit : Int, period : Int) -> RateLimiter

    RateLimiter::reset

    source
    fn RateLimiter::reset(self : RateLimiter) -> Unit

    RegressionMetrics

    source
    pub struct RegressionMetrics {
      count : Double
      absolute_error : Double
      squared_error : Double
      label_sum : Double
      label_squared_sum : Double
      minimum_error : Double
      maximum_error : Double
    }

    Regression metrics that remain stable under incremental updates.

    RegressionMetrics::count

    source
    fn RegressionMetrics::count(self : RegressionMetrics) -> Double

    RegressionMetrics::mae

    source
    fn RegressionMetrics::mae(self : RegressionMetrics) -> Double

    RegressionMetrics::maximum_error

    source
    fn RegressionMetrics::maximum_error(self : RegressionMetrics) -> Double

    RegressionMetrics::minimum_error

    source
    fn RegressionMetrics::minimum_error(self : RegressionMetrics) -> Double

    RegressionMetrics::mse

    source
    fn RegressionMetrics::mse(self : RegressionMetrics) -> Double

    RegressionMetrics::new

    source

    RegressionMetrics::r2

    source
    fn RegressionMetrics::r2(self : RegressionMetrics) -> Double

    RegressionMetrics::reset

    source
    fn RegressionMetrics::reset(self : RegressionMetrics) -> Unit

    RegressionMetrics::rmse

    source
    fn RegressionMetrics::rmse(self : RegressionMetrics) -> Double

    RegressionMetrics::update

    source
    fn RegressionMetrics::update(self : RegressionMetrics, prediction : Double, label : Double, weight? : Double) -> Unit

    Regularizer

    source
    pub struct Regularizer {
      l1 : Double
      l2 : Double
    }

    Regularizer::gradient

    source
    fn Regularizer::gradient(self : Regularizer, weights : Array[Double], index : Int) -> Double

    Regularizer::new

    source
    fn Regularizer::new(l1? : Double, l2? : Double) -> Regularizer

    Regularizer::penalty

    source
    fn Regularizer::penalty(self : Regularizer, weights : Array[Double]) -> Double

    Regularizer::proximal

    source
    fn Regularizer::proximal(self : Regularizer, value : Double, step : Double) -> Double

    ReliabilityBin

    source
    pub struct ReliabilityBin {
      lower : Double
      upper : Double
      count : Int
      predicted_sum : Double
      observed_sum : Double
      squared_error : Double
    }

    Online reliability and uncertainty calibration utilities.

    Calibrated probabilities and conformal-style intervals are useful at the final serving boundary: they turn a raw score into an operational signal with explicit coverage, confidence, and alerting statistics.

    ReliabilityBin::brier

    source
    fn ReliabilityBin::brier(self : ReliabilityBin) -> Double

    ReliabilityBin::count

    source
    fn ReliabilityBin::count(self : ReliabilityBin) -> Int

    ReliabilityBin::empirical_rate

    source
    fn ReliabilityBin::empirical_rate(self : ReliabilityBin) -> Double

    ReliabilityBin::error

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

    ReliabilityBin::lower

    source
    fn ReliabilityBin::lower(self : ReliabilityBin) -> Double

    ReliabilityBin::mean_prediction

    source
    fn ReliabilityBin::mean_prediction(self : ReliabilityBin) -> Double

    ReliabilityBin::new

    source
    fn ReliabilityBin::new(lower : Double, upper : Double) -> ReliabilityBin

    ReliabilityBin::observe

    source
    fn ReliabilityBin::observe(self : ReliabilityBin, probability : Double, label : Double) -> Unit

    ReliabilityBin::reset

    source
    fn ReliabilityBin::reset(self : ReliabilityBin) -> Unit

    ReliabilityBin::upper

    source
    fn ReliabilityBin::upper(self : ReliabilityBin) -> Double

    ReproducibilityManifest

    source
    pub struct ReproducibilityManifest {
      model : String
      version : String
      source_checksum : String
      data_checksum : String
      seed : Int
      parameters : Map[String, String]
    }

    ReproducibilityManifest::data_checksum

    source
    fn ReproducibilityManifest::data_checksum(self : ReproducibilityManifest) -> String

    ReproducibilityManifest::fingerprint

    source
    fn ReproducibilityManifest::fingerprint(self : ReproducibilityManifest) -> String

    ReproducibilityManifest::model

    source

    ReproducibilityManifest::new

    source
    fn ReproducibilityManifest::new(model : String, version : String, source_checksum : String, data_checksum : String, seed : Int) -> ReproducibilityManifest

    ReproducibilityManifest::parameter

    source
    fn ReproducibilityManifest::parameter(self : ReproducibilityManifest, key : String) -> String

    ReproducibilityManifest::parameter_count

    source
    fn ReproducibilityManifest::parameter_count(self : ReproducibilityManifest) -> Int

    ReproducibilityManifest::seed

    source

    ReproducibilityManifest::set

    source
    fn ReproducibilityManifest::set(self : ReproducibilityManifest, key : String, value : String) -> Unit

    ReproducibilityManifest::source_checksum

    source
    fn ReproducibilityManifest::source_checksum(self : ReproducibilityManifest) -> String

    ReproducibilityManifest::version

    source
    fn ReproducibilityManifest::version(self : ReproducibilityManifest) -> String

    RequestBatcher

    source
    pub struct RequestBatcher {
      capacity : Int
      requests : Array[PredictionRequest]
      flushed : Int
      dropped : Int
    }

    RequestBatcher::add

    source
    fn RequestBatcher::add(self : RequestBatcher, request : PredictionRequest) -> Bool

    RequestBatcher::dropped

    source
    fn RequestBatcher::dropped(self : RequestBatcher) -> Int

    RequestBatcher::flush

    source

    RequestBatcher::flushed

    source
    fn RequestBatcher::flushed(self : RequestBatcher) -> Int

    RequestBatcher::new

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

    RequestBatcher::pending

    source
    fn RequestBatcher::pending(self : RequestBatcher) -> Int

    RequestBatcher::ready

    source
    fn RequestBatcher::ready(self : RequestBatcher) -> Bool

    RequestBatcher::reset

    source
    fn RequestBatcher::reset(self : RequestBatcher) -> Unit

    ReservoirSampler

    source
    pub struct ReservoirSampler {
      capacity : Int
      values : Array[Double]
      seen : Int
      rng : DeterministicRng
    }

    ReservoirSampler::capacity

    source
    fn ReservoirSampler::capacity(self : ReservoirSampler) -> Int

    ReservoirSampler::new

    source
    fn ReservoirSampler::new(capacity : Int, seed? : UInt64) -> ReservoirSampler

    ReservoirSampler::observe

    source
    fn ReservoirSampler::observe(self : ReservoirSampler, value : Double) -> Bool

    ReservoirSampler::reset

    source
    fn ReservoirSampler::reset(self : ReservoirSampler) -> Unit

    ReservoirSampler::sample

    source
    fn ReservoirSampler::sample(self : ReservoirSampler) -> Array[Double]

    ReservoirSampler::seen

    source
    fn ReservoirSampler::seen(self : ReservoirSampler) -> Int

    RollbackPolicy

    source
    pub struct RollbackPolicy {
      minimum_accuracy : Double
      maximum_loss : Double
      maximum_error_rate : Double
    }

    RollbackPolicy::new

    source
    fn RollbackPolicy::new(minimum_accuracy? : Double, maximum_loss? : Double, maximum_error_rate? : Double) -> RollbackPolicy

    RollbackPolicy::should_rollback

    source
    fn RollbackPolicy::should_rollback(self : RollbackPolicy, accuracy : Double, loss : Double, error_rate : Double) -> Bool

    RollingWindow

    source
    pub struct RollingWindow {
      capacity : Int
      features : Array[Array[Double]]
      labels : Array[Double]
      weights : Array[Double]
      dropped : Int
    }

    RollingWindow::batch

    source

    RollingWindow::capacity

    source
    fn RollingWindow::capacity(self : RollingWindow) -> Int

    RollingWindow::clear

    source
    fn RollingWindow::clear(self : RollingWindow) -> Unit

    RollingWindow::dropped

    source
    fn RollingWindow::dropped(self : RollingWindow) -> Int

    RollingWindow::new

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

    RollingWindow::push

    source
    fn RollingWindow::push(self : RollingWindow, features : Array[Double], label : Double, weight? : Double) -> Bool

    RollingWindow::size

    source
    fn RollingWindow::size(self : RollingWindow) -> Int

    RouteCandidate

    source
    pub struct RouteCandidate {
      id : String
      version : String
      weight : Double
      latency_budget : Double
      max_batch : Int
      health : RouteHealth
      requests : Int
      failures : Int
      total_latency : Double
      last_seen : Int64
    }

    RouteCandidate::available

    source
    fn RouteCandidate::available(self : RouteCandidate) -> Bool

    RouteCandidate::average_latency

    source
    fn RouteCandidate::average_latency(self : RouteCandidate) -> Double

    RouteCandidate::error_rate

    source
    fn RouteCandidate::error_rate(self : RouteCandidate) -> Double

    RouteCandidate::failures

    source
    fn RouteCandidate::failures(self : RouteCandidate) -> Int

    RouteCandidate::health

    source

    RouteCandidate::id

    source
    fn RouteCandidate::id(self : RouteCandidate) -> String

    RouteCandidate::latency_budget

    source
    fn RouteCandidate::latency_budget(self : RouteCandidate) -> Double

    RouteCandidate::max_batch

    source
    fn RouteCandidate::max_batch(self : RouteCandidate) -> Int

    RouteCandidate::new

    source
    fn RouteCandidate::new(id : String, version : String, weight? : Double, latency_budget? : Double, max_batch? : Int) -> RouteCandidate

    RouteCandidate::record

    source
    fn RouteCandidate::record(self : RouteCandidate, success : Bool, latency : Double, timestamp : Int64) -> Unit

    RouteCandidate::requests

    source
    fn RouteCandidate::requests(self : RouteCandidate) -> Int

    RouteCandidate::reset

    source
    fn RouteCandidate::reset(self : RouteCandidate) -> Unit

    RouteCandidate::set_health

    source
    fn RouteCandidate::set_health(self : RouteCandidate, health : RouteHealth) -> Unit

    RouteCandidate::set_weight

    source
    fn RouteCandidate::set_weight(self : RouteCandidate, weight : Double) -> Unit

    RouteCandidate::version

    source
    fn RouteCandidate::version(self : RouteCandidate) -> String

    RouteCandidate::weight

    source
    fn RouteCandidate::weight(self : RouteCandidate) -> Double

    RouteDecision

    source
    pub struct RouteDecision {
      route_id : String
      version : String
      fallback : Bool
      reason : String
    }

    RouteDecision::is_fallback

    source
    fn RouteDecision::is_fallback(self : RouteDecision) -> Bool

    RouteDecision::new

    source
    fn RouteDecision::new(route_id : String, version : String, fallback : Bool, reason : String) -> RouteDecision

    RouteDecision::reason

    source
    fn RouteDecision::reason(self : RouteDecision) -> String

    RouteDecision::route_id

    source
    fn RouteDecision::route_id(self : RouteDecision) -> String

    RouteDecision::version

    source
    fn RouteDecision::version(self : RouteDecision) -> String

    RouteHealth

    source
    pub(all) enum RouteHealth {
      Healthy
      Warming
      Degraded
      Offline
    } derive(Eq, 
    Debug    )

    Production-oriented model routing and score caching.

    Routing decisions are kept independent from model implementations. This lets a service deploy several versions, enforce health and latency budgets, and still return a deterministic fallback when the preferred route is warming or temporarily unavailable.

    RoutingPolicy

    source
    pub(all) enum RoutingPolicy {
      RoundRobin
      Weighted
      LeastLatency
      LowestErrorRate
    } derive(Eq, 
    Debug    )

    RowQualitySummary

    source
    pub struct RowQualitySummary {
      rows : Int
      accepted : Int
      rejected : Int
      duplicates : Int
      missing_values : Int
      type_errors : Int
    }

    RowQualitySummary::acceptance_rate

    source
    fn RowQualitySummary::acceptance_rate(self : RowQualitySummary) -> Double

    RowQualitySummary::accepted

    source
    fn RowQualitySummary::accepted(self : RowQualitySummary) -> Int

    RowQualitySummary::duplicates

    source
    fn RowQualitySummary::duplicates(self : RowQualitySummary) -> Int

    RowQualitySummary::missing_values

    source
    fn RowQualitySummary::missing_values(self : RowQualitySummary) -> Int

    RowQualitySummary::new

    source

    RowQualitySummary::observe

    source
    fn RowQualitySummary::observe(self : RowQualitySummary, report : ContractReport, duplicate : Bool) -> Unit

    RowQualitySummary::rejected

    source
    fn RowQualitySummary::rejected(self : RowQualitySummary) -> Int

    RowQualitySummary::reset

    source
    fn RowQualitySummary::reset(self : RowQualitySummary) -> Unit

    RowQualitySummary::rows

    source
    fn RowQualitySummary::rows(self : RowQualitySummary) -> Int

    RowQualitySummary::type_errors

    source
    fn RowQualitySummary::type_errors(self : RowQualitySummary) -> Int

    RunningMean

    source
    pub struct RunningMean {
      count : Double
      mean : Double
    }

    RunningMean::count

    source
    fn RunningMean::count(self : RunningMean) -> Double

    RunningMean::merge

    source
    fn RunningMean::merge(self : RunningMean, other : RunningMean) -> Unit

    RunningMean::new

    source

    RunningMean::update

    source
    fn RunningMean::update(self : RunningMean, value : Double) -> Unit

    RunningMean::value

    source
    fn RunningMean::value(self : RunningMean) -> Double

    RunningMoments

    source
    pub struct RunningMoments {
      count : Double
      mean : Double
      m2 : Double
      minimum : Double
      maximum : Double
    }

    Numerically stable scalar moments using Welford's recurrence.

    RunningMoments::count

    source
    fn RunningMoments::count(self : RunningMoments) -> Double

    RunningMoments::maximum

    source
    fn RunningMoments::maximum(self : RunningMoments) -> Double

    RunningMoments::mean

    source
    fn RunningMoments::mean(self : RunningMoments) -> Double

    RunningMoments::merge

    source
    fn RunningMoments::merge(self : RunningMoments, other : RunningMoments) -> Unit

    RunningMoments::minimum

    source
    fn RunningMoments::minimum(self : RunningMoments) -> Double

    RunningMoments::new

    source

    RunningMoments::population_variance

    source
    fn RunningMoments::population_variance(self : RunningMoments) -> Double

    RunningMoments::range

    source
    fn RunningMoments::range(self : RunningMoments) -> Double

    RunningMoments::reset

    source
    fn RunningMoments::reset(self : RunningMoments) -> Unit

    RunningMoments::standard_deviation

    source
    fn RunningMoments::standard_deviation(self : RunningMoments) -> Double

    RunningMoments::update

    source
    fn RunningMoments::update(self : RunningMoments, value : Double, weight? : Double) -> Unit

    RunningMoments::variance

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

    RunningMoments::z_score

    source
    fn RunningMoments::z_score(self : RunningMoments, value : Double) -> Double

    SGDLogisticRegression

    source
    pub struct SGDLogisticRegression {
      weights : Array[Double]
      alpha : Double
    } derive(ToJson, 
    FromJson    )

    Online Logistic Regression using Stochastic Gradient Descent.

    SGDLogisticRegression::new

    source
    fn SGDLogisticRegression::new(dim : Int, alpha? : Double) -> SGDLogisticRegression

    Create a new SGD Logistic Regression model.

    SGDLogisticRegression::predict

    source
    fn SGDLogisticRegression::predict(self : SGDLogisticRegression, features : Array[Double]) -> Double

    Predict the probability (0 to 1) for a given feature vector.

    SGDLogisticRegression::update

    source
    fn SGDLogisticRegression::update(self : SGDLogisticRegression, features : Array[Double], label : Double) -> Unit

    Update the model with a single sample (features and label). Label should be 0.0 or 1.0.

    ScalarTransform

    source
    pub struct ScalarTransform {
      kind : ScalarTransformKind
      applied : Int
      invalid : Int
    }

    ScalarTransform::applied

    source
    fn ScalarTransform::applied(self : ScalarTransform) -> Int

    ScalarTransform::apply

    source
    fn ScalarTransform::apply(self : ScalarTransform, value : Double) -> Double

    ScalarTransform::apply_array

    source
    fn ScalarTransform::apply_array(self : ScalarTransform, values : Array[Double]) -> Array[Double]

    ScalarTransform::invalid

    source
    fn ScalarTransform::invalid(self : ScalarTransform) -> Int

    ScalarTransform::inverse

    source
    fn ScalarTransform::inverse(self : ScalarTransform, value : Double) -> Double

    ScalarTransform::kind

    source

    ScalarTransform::new

    source

    ScalarTransform::reset

    source
    fn ScalarTransform::reset(self : ScalarTransform) -> Unit

    ScalarTransformKind

    source
    pub(all) enum ScalarTransformKind {
      Identity
      Clip(lower~ : Double, upper~ : Double)
      Log1p
      SignedLog
      Sqrt
      Abs
    } derive(Eq, 
    Debug    )

    Stateful feature transforms for production event pipelines.

    Transforms are kept separate from models so the same preprocessing state can be persisted, monitored, and reused by training and serving paths.

    ScoreCacheEntry

    source
    pub struct ScoreCacheEntry {
      key : String
      values : Array[Double]
      created_at : Int64
      expires_at : Int64
      hits : Int
    }

    ScoreCacheEntry::created_at

    source
    fn ScoreCacheEntry::created_at(self : ScoreCacheEntry) -> Int64

    ScoreCacheEntry::expired

    source
    fn ScoreCacheEntry::expired(self : ScoreCacheEntry, now : Int64) -> Bool

    ScoreCacheEntry::expires_at

    source
    fn ScoreCacheEntry::expires_at(self : ScoreCacheEntry) -> Int64

    ScoreCacheEntry::hits

    source
    fn ScoreCacheEntry::hits(self : ScoreCacheEntry) -> Int

    ScoreCacheEntry::key

    source
    fn ScoreCacheEntry::key(self : ScoreCacheEntry) -> String

    ScoreCacheEntry::new

    source
    fn ScoreCacheEntry::new(key : String, values : Array[Double], created_at : Int64, ttl : Int64) -> ScoreCacheEntry

    ScoreCacheEntry::record_hit

    source
    fn ScoreCacheEntry::record_hit(self : ScoreCacheEntry) -> Unit

    ScoreCacheEntry::values

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

    ScoreMemoCache

    source
    pub struct ScoreMemoCache {
      capacity : Int
      ttl : Int64
      entries : Map[String, ScoreCacheEntry]
      order : Array[String]
      lookups : Int
      hits : Int
      misses : Int
      evictions : Int
    }

    ScoreMemoCache::clear

    source
    fn ScoreMemoCache::clear(self : ScoreMemoCache) -> Unit

    ScoreMemoCache::evictions

    source
    fn ScoreMemoCache::evictions(self : ScoreMemoCache) -> Int

    ScoreMemoCache::get

    source
    fn ScoreMemoCache::get(self : ScoreMemoCache, key : String, now : Int64) -> Array[Double]?

    ScoreMemoCache::hit_rate

    source
    fn ScoreMemoCache::hit_rate(self : ScoreMemoCache) -> Double

    ScoreMemoCache::hits

    source
    fn ScoreMemoCache::hits(self : ScoreMemoCache) -> Int

    ScoreMemoCache::lookups

    source
    fn ScoreMemoCache::lookups(self : ScoreMemoCache) -> Int

    ScoreMemoCache::misses

    source
    fn ScoreMemoCache::misses(self : ScoreMemoCache) -> Int

    ScoreMemoCache::new

    source
    fn ScoreMemoCache::new(capacity? : Int, ttl? : Int64) -> ScoreMemoCache

    ScoreMemoCache::put

    source
    fn ScoreMemoCache::put(self : ScoreMemoCache, key : String, values : Array[Double], now : Int64) -> Bool

    ScoreMemoCache::remove

    source
    fn ScoreMemoCache::remove(self : ScoreMemoCache, key : String) -> Bool

    ScoreMemoCache::size

    source
    fn ScoreMemoCache::size(self : ScoreMemoCache) -> Int

    SeasonalMean

    source
    pub struct SeasonalMean {
      sums : Array[Double]
      counts : Array[Double]
      observations : Int
    }

    Seasonal baseline using per-phase running means.

    SeasonalMean::forecast

    source
    fn SeasonalMean::forecast(self : SeasonalMean, horizon : Int) -> Array[Double]

    SeasonalMean::mean_at

    source
    fn SeasonalMean::mean_at(self : SeasonalMean, index : Int) -> Double

    SeasonalMean::new

    source
    fn SeasonalMean::new(period : Int) -> SeasonalMean

    SeasonalMean::observations

    source
    fn SeasonalMean::observations(self : SeasonalMean) -> Int

    SeasonalMean::period

    source
    fn SeasonalMean::period(self : SeasonalMean) -> Int

    SeasonalMean::reset

    source
    fn SeasonalMean::reset(self : SeasonalMean) -> Unit

    SeasonalMean::update

    source
    fn SeasonalMean::update(self : SeasonalMean, value : Double) -> Double

    SeasonalNaiveBaseline

    source
    pub struct SeasonalNaiveBaseline {
      period : Int
      history : Array[Double]
      observations : Int
    }

    SeasonalNaiveBaseline::forecast

    source
    fn SeasonalNaiveBaseline::forecast(self : SeasonalNaiveBaseline) -> Double

    SeasonalNaiveBaseline::history

    source
    fn SeasonalNaiveBaseline::history(self : SeasonalNaiveBaseline) -> Array[Double]

    SeasonalNaiveBaseline::new

    source

    SeasonalNaiveBaseline::observations

    source
    fn SeasonalNaiveBaseline::observations(self : SeasonalNaiveBaseline) -> Int

    SeasonalNaiveBaseline::period

    source

    SeasonalNaiveBaseline::predict

    source
    fn SeasonalNaiveBaseline::predict(self : SeasonalNaiveBaseline, horizon : Int, start_timestamp? : Int64, step? : Int64) -> Array[ForecastPoint]

    SeasonalNaiveBaseline::reset

    source

    SeasonalNaiveBaseline::update

    source
    fn SeasonalNaiveBaseline::update(self : SeasonalNaiveBaseline, value : Double) -> Double

    SequenceFeatureBuilder

    source
    pub struct SequenceFeatureBuilder {
      lags : Int
      include_delta : Bool
      include_mean : Bool
      include_variance : Bool
      window : SequenceWindow
    }

    SequenceFeatureBuilder::feature_count

    source
    fn SequenceFeatureBuilder::feature_count(self : SequenceFeatureBuilder) -> Int

    SequenceFeatureBuilder::new

    source
    fn SequenceFeatureBuilder::new(lags : Int, include_delta? : Bool, include_mean? : Bool, include_variance? : Bool) -> SequenceFeatureBuilder

    SequenceFeatureBuilder::reset

    source

    SequenceFeatureBuilder::transform

    source
    fn SequenceFeatureBuilder::transform(self : SequenceFeatureBuilder, value : Double) -> Array[Double]

    SequenceWindow

    source
    pub struct SequenceWindow {
      capacity : Int
      values : Array[Double]
      total : Double
      sum_squares : Double
    }

    Compact sequence-learning primitives for event streams and demand signals.

    SequenceWindow::capacity

    source
    fn SequenceWindow::capacity(self : SequenceWindow) -> Int

    SequenceWindow::clear

    source
    fn SequenceWindow::clear(self : SequenceWindow) -> Unit

    SequenceWindow::last

    source
    fn SequenceWindow::last(self : SequenceWindow) -> Double

    SequenceWindow::mean

    source
    fn SequenceWindow::mean(self : SequenceWindow) -> Double

    SequenceWindow::new

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

    SequenceWindow::push

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

    SequenceWindow::size

    source
    fn SequenceWindow::size(self : SequenceWindow) -> Int

    SequenceWindow::values

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

    SequenceWindow::variance

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

    ServingStats

    source
    pub struct ServingStats {
      requests : Int
      successes : Int
      failures : Int
      total_latency : Double
      max_latency : Double
      bytes : Int
    }

    ServingStats::bytes

    source
    fn ServingStats::bytes(self : ServingStats) -> Int

    ServingStats::max_latency

    source
    fn ServingStats::max_latency(self : ServingStats) -> Double

    ServingStats::mean_latency

    source
    fn ServingStats::mean_latency(self : ServingStats) -> Double

    ServingStats::new

    source

    ServingStats::observe

    source
    fn ServingStats::observe(self : ServingStats, response : PredictionResponse, payload_bytes? : Int) -> Unit

    ServingStats::requests

    source
    fn ServingStats::requests(self : ServingStats) -> Int

    ServingStats::reset

    source
    fn ServingStats::reset(self : ServingStats) -> Unit

    ServingStats::success_rate

    source
    fn ServingStats::success_rate(self : ServingStats) -> Double

    SessionSummary

    source
    pub struct SessionSummary {
      start : Int64
      end : Int64
      events : Int
      value : Double
    }

    SessionSummary::end

    source
    fn SessionSummary::end(self : SessionSummary) -> Int64

    SessionSummary::events

    source
    fn SessionSummary::events(self : SessionSummary) -> Int

    SessionSummary::new

    source
    fn SessionSummary::new(start : Int64, end : Int64, events : Int, value : Double) -> SessionSummary

    SessionSummary::start

    source
    fn SessionSummary::start(self : SessionSummary) -> Int64

    SessionSummary::value

    source
    fn SessionSummary::value(self : SessionSummary) -> Double

    SessionWindowAggregator

    source
    pub struct SessionWindowAggregator {
      gap : Int64
      current_start : Int64?
      current_end : Int64?
      current_events : Int
      current_value : Double
      sessions : Array[SessionSummary]
      accepted : Int
      invalid : Int
    }

    SessionWindowAggregator::accepted

    source

    SessionWindowAggregator::close

    source
    fn SessionWindowAggregator::close(self : SessionWindowAggregator, timestamp : Int64) -> Array[SessionSummary]

    SessionWindowAggregator::current_events

    source
    fn SessionWindowAggregator::current_events(self : SessionWindowAggregator) -> Int

    SessionWindowAggregator::invalid

    source

    SessionWindowAggregator::new

    source

    SessionWindowAggregator::observe

    source
    fn SessionWindowAggregator::observe(self : SessionWindowAggregator, timestamp : Int64, value : Double) -> Bool

    SessionWindowAggregator::reset

    source

    SessionWindowAggregator::session_count

    source
    fn SessionWindowAggregator::session_count(self : SessionWindowAggregator) -> Int

    ShadowEvaluator

    source
    pub struct ShadowEvaluator {
      primary_version : String
      shadow_version : String
      comparisons : Int
      disagreements : Int
      absolute_difference : Double
    }

    ShadowEvaluator::comparisons

    source
    fn ShadowEvaluator::comparisons(self : ShadowEvaluator) -> Int

    ShadowEvaluator::disagreement_rate

    source
    fn ShadowEvaluator::disagreement_rate(self : ShadowEvaluator) -> Double

    ShadowEvaluator::disagreements

    source
    fn ShadowEvaluator::disagreements(self : ShadowEvaluator) -> Int

    ShadowEvaluator::mean_absolute_difference

    source
    fn ShadowEvaluator::mean_absolute_difference(self : ShadowEvaluator) -> Double

    ShadowEvaluator::new

    source
    fn ShadowEvaluator::new(primary_version : String, shadow_version : String) -> ShadowEvaluator

    ShadowEvaluator::observe

    source
    fn ShadowEvaluator::observe(self : ShadowEvaluator, primary : Double, shadow : Double, tolerance? : Double) -> Bool

    ShadowEvaluator::reset

    source
    fn ShadowEvaluator::reset(self : ShadowEvaluator) -> Unit

    ShadowEvaluator::versions

    source
    fn ShadowEvaluator::versions(self : ShadowEvaluator) -> (String, String)

    SlidingWindowAggregator

    source
    pub struct SlidingWindowAggregator {
      width : Int64
      capacity : Int
      timestamps : Array[Int64]
      values : Array[Double]
      weights : Array[Double]
      accepted : Int
      evicted : Int
      invalid : Int
    }

    SlidingWindowAggregator::accepted

    source

    SlidingWindowAggregator::capacity

    source

    SlidingWindowAggregator::evicted

    source

    SlidingWindowAggregator::invalid

    source

    SlidingWindowAggregator::new

    source
    fn SlidingWindowAggregator::new(width : Int64, capacity? : Int) -> SlidingWindowAggregator

    SlidingWindowAggregator::observe

    source
    fn SlidingWindowAggregator::observe(self : SlidingWindowAggregator, timestamp : Int64, value : Double, weight? : Double) -> Bool

    SlidingWindowAggregator::reset

    source

    SlidingWindowAggregator::size

    source

    SlidingWindowAggregator::summary

    source

    SlidingWindowAggregator::timestamps

    source
    fn SlidingWindowAggregator::timestamps(self : SlidingWindowAggregator) -> Array[Int64]

    SnapshotCatalog

    source
    pub struct SnapshotCatalog {
      snapshots : Map[String, SnapshotEnvelope]
      writes : Int
    }

    SnapshotCatalog::clear

    source
    fn SnapshotCatalog::clear(self : SnapshotCatalog) -> Unit

    SnapshotCatalog::get

    source
    fn SnapshotCatalog::get(self : SnapshotCatalog, key : String) -> SnapshotEnvelope?

    SnapshotCatalog::keys

    source
    fn SnapshotCatalog::keys(self : SnapshotCatalog) -> Array[String]

    SnapshotCatalog::new

    source

    SnapshotCatalog::put

    source
    fn SnapshotCatalog::put(self : SnapshotCatalog, key : String, snapshot : SnapshotEnvelope) -> Bool

    SnapshotCatalog::size

    source
    fn SnapshotCatalog::size(self : SnapshotCatalog) -> Int

    SnapshotCatalog::writes

    source
    fn SnapshotCatalog::writes(self : SnapshotCatalog) -> Int

    SnapshotEnvelope

    source
    pub struct SnapshotEnvelope {
      schema : String
      model : String
      version : String
      payload : String
      checksum : String
    } derive(ToJson, 
    Debug    , 
    FromJson    )

    A small, versioned envelope for application-owned model snapshots.

    SnapshotEnvelope::checksum

    source
    fn SnapshotEnvelope::checksum(self : SnapshotEnvelope) -> String

    SnapshotEnvelope::is_compatible

    source
    fn SnapshotEnvelope::is_compatible(self : SnapshotEnvelope, schema : String, model : String) -> Bool

    SnapshotEnvelope::model

    source
    fn SnapshotEnvelope::model(self : SnapshotEnvelope) -> String

    SnapshotEnvelope::new

    source
    fn SnapshotEnvelope::new(schema : String, model : String, version : String, payload : String, checksum : String) -> SnapshotEnvelope

    SnapshotEnvelope::payload

    source
    fn SnapshotEnvelope::payload(self : SnapshotEnvelope) -> String

    SnapshotEnvelope::schema

    source
    fn SnapshotEnvelope::schema(self : SnapshotEnvelope) -> String

    SnapshotEnvelope::to_json_string

    source
    fn SnapshotEnvelope::to_json_string(self : SnapshotEnvelope) -> String

    SnapshotEnvelope::version

    source
    fn SnapshotEnvelope::version(self : SnapshotEnvelope) -> String

    SoftmaxBandit

    source
    pub struct SoftmaxBandit {
      arms : Array[ArmStatistics]
      temperature : Double
      rng : DeterministicRng
      history : BanditHistory
      steps : Int
    }

    SoftmaxBandit::arm_count

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

    SoftmaxBandit::choose

    source
    fn SoftmaxBandit::choose(self : SoftmaxBandit) -> Int?

    SoftmaxBandit::history

    source

    SoftmaxBandit::new

    source
    fn SoftmaxBandit::new(arm_count : Int, temperature? : Double, seed? : UInt64, history_capacity? : Int) -> SoftmaxBandit

    SoftmaxBandit::probabilities

    source
    fn SoftmaxBandit::probabilities(self : SoftmaxBandit) -> Array[Double]

    SoftmaxBandit::reset

    source
    fn SoftmaxBandit::reset(self : SoftmaxBandit) -> Unit

    SoftmaxBandit::steps

    source
    fn SoftmaxBandit::steps(self : SoftmaxBandit) -> Int

    SoftmaxBandit::update

    source
    fn SoftmaxBandit::update(self : SoftmaxBandit, arm : Int, reward : Double) -> Bool

    SparseAccumulator

    source
    pub struct SparseAccumulator {
      dimension : Int
      values : Map[Int, Double]
    }

    SparseAccumulator::add

    source
    fn SparseAccumulator::add(self : SparseAccumulator, index : Int, value : Double) -> Bool

    SparseAccumulator::clear

    source
    fn SparseAccumulator::clear(self : SparseAccumulator) -> Unit

    SparseAccumulator::dimension

    source
    fn SparseAccumulator::dimension(self : SparseAccumulator) -> Int

    SparseAccumulator::get

    source
    fn SparseAccumulator::get(self : SparseAccumulator, index : Int) -> Double

    SparseAccumulator::new

    source
    fn SparseAccumulator::new(dimension : Int) -> SparseAccumulator

    SparseAccumulator::to_vector

    source

    SparseAdagradClassifier

    source
    pub struct SparseAdagradClassifier {
      weights : Array[Double]
      accumulator : Array[Double]
      learning_rate : Double
      epsilon : Double
      l2 : Double
      steps : Int
    }

    Sparse Adagrad logistic regression with a dense accumulator for predictable inference and sparse updates.

    SparseAdagradClassifier::new

    source
    fn SparseAdagradClassifier::new(dimension : Int, learning_rate? : Double, epsilon? : Double, l2? : Double) -> SparseAdagradClassifier

    SparseAdagradClassifier::predict

    source
    fn SparseAdagradClassifier::predict(self : SparseAdagradClassifier, features : SparseVector) -> Double

    SparseAdagradClassifier::reset

    source

    SparseAdagradClassifier::steps

    source

    SparseAdagradClassifier::update

    source
    fn SparseAdagradClassifier::update(self : SparseAdagradClassifier, features : SparseVector, label : Double) -> Unit

    SparseAdagradClassifier::weight

    source
    fn SparseAdagradClassifier::weight(self : SparseAdagradClassifier, index : Int) -> Double

    SparseAdagradClassifier::weights

    source

    SparseEntry

    source
    pub struct SparseEntry {
      index : Int
      value : Double
    } derive(ToJson, 
    Debug    , 
    FromJson    )

    A sparse feature entry. Indices are zero-based and values equal to zero are omitted from canonical sparse vectors.

    SparseEntry::index

    source
    fn SparseEntry::index(self : SparseEntry) -> Int

    SparseEntry::new

    source
    fn SparseEntry::new(index : Int, value : Double) -> SparseEntry

    SparseEntry::value

    source
    fn SparseEntry::value(self : SparseEntry) -> Double

    SparseFTRL

    source
    pub struct SparseFTRL {
      dimension : Int
      alpha : Double
      beta : Double
      l1 : Double
      l2 : Double
      z : Array[Double]
      n : Array[Double]
      steps : Int
    }

    FTRL-Proximal for sparse vectors. Only non-zero coordinates are touched during an update, which keeps the per-event cost O(nnz).

    SparseFTRL::dimension

    source
    fn SparseFTRL::dimension(self : SparseFTRL) -> Int

    SparseFTRL::new

    source
    fn SparseFTRL::new(dimension : Int, alpha? : Double, beta? : Double, l1? : Double, l2? : Double) -> SparseFTRL

    SparseFTRL::non_zero_weights

    source
    fn SparseFTRL::non_zero_weights(self : SparseFTRL, tolerance? : Double) -> SparseVector

    SparseFTRL::predict

    source
    fn SparseFTRL::predict(self : SparseFTRL, features : SparseVector) -> Double

    SparseFTRL::reset

    source
    fn SparseFTRL::reset(self : SparseFTRL) -> Unit

    SparseFTRL::steps

    source
    fn SparseFTRL::steps(self : SparseFTRL) -> Int

    SparseFTRL::update

    source
    fn SparseFTRL::update(self : SparseFTRL, features : SparseVector, label : Double) -> Unit

    SparseFTRL::weight

    source
    fn SparseFTRL::weight(self : SparseFTRL, index : Int) -> Double

    SparseVector

    source
    pub struct SparseVector {
      dimension : Int
      entries : Array[SparseEntry]
    } derive(ToJson, 
    Debug    , 
    FromJson    )

    SparseVector::add

    source

    SparseVector::contains

    source
    fn SparseVector::contains(self : SparseVector, index : Int) -> Bool

    SparseVector::cosine

    source
    fn SparseVector::cosine(self : SparseVector, other : SparseVector) -> Double

    SparseVector::dimension

    source
    fn SparseVector::dimension(self : SparseVector) -> Int

    SparseVector::distance_squared

    source
    fn SparseVector::distance_squared(self : SparseVector, other : SparseVector) -> Double

    SparseVector::dot_dense

    source
    fn SparseVector::dot_dense(self : SparseVector, values : Array[Double]) -> Double

    SparseVector::dot_sparse

    source
    fn SparseVector::dot_sparse(self : SparseVector, other : SparseVector) -> Double

    SparseVector::entries

    source
    fn SparseVector::entries(self : SparseVector) -> Array[SparseEntry]

    SparseVector::from_dense

    source
    fn SparseVector::from_dense(values : Array[Double], threshold? : Double) -> SparseVector

    SparseVector::from_entries

    source
    fn SparseVector::from_entries(dimension : Int, entries : Array[SparseEntry]) -> SparseVector

    SparseVector::get

    source
    fn SparseVector::get(self : SparseVector, index : Int) -> Double

    SparseVector::is_empty

    source
    fn SparseVector::is_empty(self : SparseVector) -> Bool

    SparseVector::is_sorted

    source
    fn SparseVector::is_sorted(self : SparseVector) -> Bool

    SparseVector::l1_norm

    source
    fn SparseVector::l1_norm(self : SparseVector) -> Double

    SparseVector::l2_norm

    source
    fn SparseVector::l2_norm(self : SparseVector) -> Double

    SparseVector::map

    source
    fn SparseVector::map(self : SparseVector, transform : (Double) -> Double) -> SparseVector

    SparseVector::max_abs

    source
    fn SparseVector::max_abs(self : SparseVector) -> Double

    SparseVector::new

    source
    fn SparseVector::new(dimension : Int) -> SparseVector

    SparseVector::nnz

    source
    fn SparseVector::nnz(self : SparseVector) -> Int

    SparseVector::normalize

    source
    fn SparseVector::normalize(self : SparseVector) -> SparseVector

    SparseVector::scale

    source
    fn SparseVector::scale(self : SparseVector, factor : Double) -> SparseVector

    SparseVector::set

    source
    fn SparseVector::set(self : SparseVector, index : Int, value : Double) -> SparseVector

    SparseVector::subtract

    source
    fn SparseVector::subtract(self : SparseVector, other : SparseVector) -> SparseVector

    SparseVector::threshold

    source
    fn SparseVector::threshold(self : SparseVector, limit : Double) -> SparseVector

    SparseVector::to_dense

    source
    fn SparseVector::to_dense(self : SparseVector) -> Array[Double]

    StabilityTracker

    source
    pub struct StabilityTracker {
      previous : Array[Double]
      observations : Int
      drift : Double
    }

    StabilityTracker::mean_drift

    source
    fn StabilityTracker::mean_drift(self : StabilityTracker) -> Double

    StabilityTracker::new

    source
    fn StabilityTracker::new(dimension : Int) -> StabilityTracker

    StabilityTracker::observations

    source
    fn StabilityTracker::observations(self : StabilityTracker) -> Int

    StabilityTracker::observe

    source
    fn StabilityTracker::observe(self : StabilityTracker, values : Array[Double]) -> Double

    StabilityTracker::reset

    source
    fn StabilityTracker::reset(self : StabilityTracker) -> Unit

    Standardizer

    source
    pub struct Standardizer {
      count : Double
      mean : Array[Double]
      m2 : Array[Double]
    } derive(ToJson, 
    FromJson    )

    A standardizer that tracks running mean and variance to standardize features incrementally using Welford's online algorithm.

    Standardizer::count

    source
    fn Standardizer::count(self : Standardizer) -> Double

    Standardizer::mean

    source
    fn Standardizer::mean(self : Standardizer) -> Array[Double]

    Return a copy of the current running means.

    Standardizer::new

    source
    fn Standardizer::new(dim : Int) -> Standardizer

    Create a new feature standardizer for dim features.

    Standardizer::reset

    source
    fn Standardizer::reset(self : Standardizer) -> Unit

    Standardizer::update_and_transform

    source
    fn Standardizer::update_and_transform(self : Standardizer, features : Array[Double]) -> Array[Double]

    Update the standardizer with a new feature vector, returning the standardized features.

    Standardizer::variance

    source
    fn Standardizer::variance(self : Standardizer) -> Array[Double]

    Return the unbiased running variance for every feature.

    StratifiedSampler

    source
    pub struct StratifiedSampler {
      capacity_per_class : Int
      samples : Map[Int, Array[Array[Double]]]
      seen : Int
      rng : DeterministicRng
    }

    StratifiedSampler::class_count

    source
    fn StratifiedSampler::class_count(self : StratifiedSampler, label : Int) -> Int

    StratifiedSampler::classes

    source
    fn StratifiedSampler::classes(self : StratifiedSampler) -> Array[Int]

    StratifiedSampler::new

    source
    fn StratifiedSampler::new(capacity_per_class : Int, seed? : UInt64) -> StratifiedSampler

    StratifiedSampler::observe

    source
    fn StratifiedSampler::observe(self : StratifiedSampler, label : Int, features : Array[Double]) -> Bool

    StratifiedSampler::reset

    source
    fn StratifiedSampler::reset(self : StratifiedSampler) -> Unit

    StratifiedSampler::samples

    source
    fn StratifiedSampler::samples(self : StratifiedSampler, label : Int) -> Array[Array[Double]]

    StratifiedSampler::seen

    source
    fn StratifiedSampler::seen(self : StratifiedSampler) -> Int

    StreamCounters

    source
    pub struct StreamCounters {
      rows : Int
      accepted : Int
      rejected : Int
      positive : Int
      negative : Int
    }

    StreamCounters::acceptance_rate

    source
    fn StreamCounters::acceptance_rate(self : StreamCounters) -> Double

    StreamCounters::accepted

    source
    fn StreamCounters::accepted(self : StreamCounters) -> Int

    StreamCounters::new

    source

    StreamCounters::observe

    source
    fn StreamCounters::observe(self : StreamCounters, accepted : Bool, label? : Double) -> Unit

    StreamCounters::rejected

    source
    fn StreamCounters::rejected(self : StreamCounters) -> Int

    StreamCounters::rows

    source
    fn StreamCounters::rows(self : StreamCounters) -> Int

    StreamWatermark

    source
    pub struct StreamWatermark {
      current : Int64
      allowed_lateness : Int64
      late_events : Int
    }

    StreamWatermark::current

    source
    fn StreamWatermark::current(self : StreamWatermark) -> Int64

    StreamWatermark::late_events

    source
    fn StreamWatermark::late_events(self : StreamWatermark) -> Int

    StreamWatermark::new

    source
    fn StreamWatermark::new(allowed_lateness : Int64) -> StreamWatermark

    StreamWatermark::observe

    source
    fn StreamWatermark::observe(self : StreamWatermark, timestamp : Int64) -> Bool

    StreamWatermark::reset

    source
    fn StreamWatermark::reset(self : StreamWatermark) -> Unit

    StreamingDecisionStump

    source
    pub struct StreamingDecisionStump {
      feature : Int
      threshold : Double
      left : StumpStatistics
      right : StumpStatistics
      updates : Int
      mistakes : Int
    }

    StreamingDecisionStump::accuracy

    source
    fn StreamingDecisionStump::accuracy(self : StreamingDecisionStump) -> Double

    StreamingDecisionStump::branch

    source
    fn StreamingDecisionStump::branch(self : StreamingDecisionStump, features : Array[Double]) -> Bool

    StreamingDecisionStump::feature

    source

    StreamingDecisionStump::left

    source

    StreamingDecisionStump::mistakes

    source

    StreamingDecisionStump::new

    source
    fn StreamingDecisionStump::new(feature : Int, threshold : Double) -> StreamingDecisionStump

    StreamingDecisionStump::predict

    source
    fn StreamingDecisionStump::predict(self : StreamingDecisionStump, features : Array[Double]) -> Double

    StreamingDecisionStump::predict_probability

    source
    fn StreamingDecisionStump::predict_probability(self : StreamingDecisionStump, features : Array[Double]) -> Double

    StreamingDecisionStump::reset

    source

    StreamingDecisionStump::right

    source

    StreamingDecisionStump::threshold

    source
    fn StreamingDecisionStump::threshold(self : StreamingDecisionStump) -> Double

    StreamingDecisionStump::update

    source
    fn StreamingDecisionStump::update(self : StreamingDecisionStump, features : Array[Double], label : Double, weight? : Double) -> Bool

    StreamingDecisionStump::updates

    source

    StreamingStumpEnsemble

    source
    pub struct StreamingStumpEnsemble {
      stumps : Array[StreamingDecisionStump]
      observations : Int
      total_loss : Double
    }

    StreamingStumpEnsemble::dispersion

    source
    fn StreamingStumpEnsemble::dispersion(self : StreamingStumpEnsemble, features : Array[Double]) -> Double

    StreamingStumpEnsemble::mse

    source

    StreamingStumpEnsemble::new

    source
    fn StreamingStumpEnsemble::new(features : Array[(Int, Double)]) -> StreamingStumpEnsemble

    StreamingStumpEnsemble::observations

    source
    fn StreamingStumpEnsemble::observations(self : StreamingStumpEnsemble) -> Int

    StreamingStumpEnsemble::predict

    source
    fn StreamingStumpEnsemble::predict(self : StreamingStumpEnsemble, features : Array[Double]) -> Double

    StreamingStumpEnsemble::predict_probability

    source
    fn StreamingStumpEnsemble::predict_probability(self : StreamingStumpEnsemble, features : Array[Double]) -> Double

    StreamingStumpEnsemble::reset

    source

    StreamingStumpEnsemble::stump_count

    source
    fn StreamingStumpEnsemble::stump_count(self : StreamingStumpEnsemble) -> Int

    StreamingStumpEnsemble::stumps

    source

    StreamingStumpEnsemble::update

    source
    fn StreamingStumpEnsemble::update(self : StreamingStumpEnsemble, features : Array[Double], label : Double) -> Double

    StumpStatistics

    source
    pub struct StumpStatistics {
      count : Double
      sum : Double
      square_sum : Double
      positive : Double
    }

    StumpStatistics::count

    source
    fn StumpStatistics::count(self : StumpStatistics) -> Double

    StumpStatistics::mean

    source
    fn StumpStatistics::mean(self : StumpStatistics) -> Double

    StumpStatistics::new

    source

    StumpStatistics::observe

    source
    fn StumpStatistics::observe(self : StumpStatistics, label : Double, positive : Bool, weight : Double) -> Unit

    StumpStatistics::positive_rate

    source
    fn StumpStatistics::positive_rate(self : StumpStatistics) -> Double

    StumpStatistics::reset

    source
    fn StumpStatistics::reset(self : StumpStatistics) -> Unit

    StumpStatistics::variance

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

    TargetEncoder

    source
    pub struct TargetEncoder {
      sums : Map[String, Double]
      counts : Map[String, Double]
      prior : RunningMean
      smoothing : Double
    }

    TargetEncoder::encode

    source
    fn TargetEncoder::encode(self : TargetEncoder, category : String) -> Double

    TargetEncoder::known_categories

    source
    fn TargetEncoder::known_categories(self : TargetEncoder) -> Int

    TargetEncoder::new

    source
    fn TargetEncoder::new(smoothing? : Double) -> TargetEncoder

    TargetEncoder::reset

    source
    fn TargetEncoder::reset(self : TargetEncoder) -> Unit

    TargetEncoder::update

    source
    fn TargetEncoder::update(self : TargetEncoder, category : String, target : Double, weight? : Double) -> Unit

    TextStatistics

    source
    pub struct TextStatistics {
      documents : Int
      tokens : Int
      vocabulary : Map[String, Int]
    }

    TextStatistics::documents

    source
    fn TextStatistics::documents(self : TextStatistics) -> Int

    TextStatistics::frequency

    source
    fn TextStatistics::frequency(self : TextStatistics, word : String) -> Int

    TextStatistics::new

    source

    TextStatistics::observe

    source
    fn TextStatistics::observe(self : TextStatistics, words : Array[String]) -> Unit

    TextStatistics::reset

    source
    fn TextStatistics::reset(self : TextStatistics) -> Unit

    TextStatistics::tokens

    source
    fn TextStatistics::tokens(self : TextStatistics) -> Int

    TextStatistics::top_words

    source
    fn TextStatistics::top_words(self : TextStatistics, k : Int) -> Array[String]

    TextStatistics::vocabulary_size

    source
    fn TextStatistics::vocabulary_size(self : TextStatistics) -> Int

    TextVocabulary

    source
    pub struct TextVocabulary {
      counts : Map[String, Int]
      maximum : Int
      documents : Int
      unknowns : Int
    }

    TextVocabulary::documents

    source
    fn TextVocabulary::documents(self : TextVocabulary) -> Int

    TextVocabulary::index

    source
    fn TextVocabulary::index(self : TextVocabulary, token : String) -> Int?

    TextVocabulary::new

    source
    fn TextVocabulary::new(maximum? : Int) -> TextVocabulary

    TextVocabulary::observe

    source
    fn TextVocabulary::observe(self : TextVocabulary, tokens : Array[String]) -> Unit

    TextVocabulary::reset

    source
    fn TextVocabulary::reset(self : TextVocabulary) -> Unit

    TextVocabulary::size

    source
    fn TextVocabulary::size(self : TextVocabulary) -> Int

    TextVocabulary::tokens

    source
    fn TextVocabulary::tokens(self : TextVocabulary) -> Array[String]

    TextVocabulary::unknowns

    source
    fn TextVocabulary::unknowns(self : TextVocabulary) -> Int

    ThresholdOptimizer

    source
    pub struct ThresholdOptimizer {
      costs : ClassCost
      minimum : Double
      maximum : Double
      steps : Int
      best_threshold : Double
      best_cost : Double
    }

    ThresholdOptimizer::cost

    source
    fn ThresholdOptimizer::cost(self : ThresholdOptimizer) -> Double

    ThresholdOptimizer::fit

    source
    fn ThresholdOptimizer::fit(self : ThresholdOptimizer, predictions : Array[Double], labels : Array[Double]) -> Double

    ThresholdOptimizer::new

    source
    fn ThresholdOptimizer::new(costs? : ClassCost, minimum? : Double, maximum? : Double, steps? : Int) -> ThresholdOptimizer

    ThresholdOptimizer::reset

    source
    fn ThresholdOptimizer::reset(self : ThresholdOptimizer) -> Unit

    ThresholdOptimizer::threshold

    source
    fn ThresholdOptimizer::threshold(self : ThresholdOptimizer) -> Double

    ThroughputTracker

    source
    pub struct ThroughputTracker {
      capacity : Int
      events : SequenceWindow
      accepted : Int
      dropped : Int
    }

    ThroughputTracker::accepted

    source
    fn ThroughputTracker::accepted(self : ThroughputTracker) -> Int

    ThroughputTracker::dropped

    source
    fn ThroughputTracker::dropped(self : ThroughputTracker) -> Int

    ThroughputTracker::new

    source
    fn ThroughputTracker::new(capacity? : Int) -> ThroughputTracker

    ThroughputTracker::observe

    source
    fn ThroughputTracker::observe(self : ThroughputTracker, timestamp : Int64) -> Bool

    ThroughputTracker::rate

    source
    fn ThroughputTracker::rate(self : ThroughputTracker, duration : Double) -> Double

    TimeFeatureEncoder

    source
    pub struct TimeFeatureEncoder {
      period : Int64
      include_sine : Bool
      include_cosine : Bool
      include_elapsed : Bool
      origin : Int64?
    }

    TimeFeatureEncoder::feature_count

    source
    fn TimeFeatureEncoder::feature_count(self : TimeFeatureEncoder) -> Int

    TimeFeatureEncoder::new

    source
    fn TimeFeatureEncoder::new(period : Int64, include_sine? : Bool, include_cosine? : Bool, include_elapsed? : Bool) -> TimeFeatureEncoder

    TimeFeatureEncoder::period

    source
    fn TimeFeatureEncoder::period(self : TimeFeatureEncoder) -> Int64

    TimeFeatureEncoder::reset

    source
    fn TimeFeatureEncoder::reset(self : TimeFeatureEncoder) -> Unit

    TimeFeatureEncoder::transform

    source
    fn TimeFeatureEncoder::transform(self : TimeFeatureEncoder, timestamp : Int64) -> Array[Double]

    TimeWindowAggregate

    source
    pub struct TimeWindowAggregate {
      start : Int64
      end : Int64
      events : Int
      positives : Double
      weight : Double
      loss : RegressionMetrics
    }

    TimeWindowAggregate::contains

    source
    fn TimeWindowAggregate::contains(self : TimeWindowAggregate, timestamp : Int64) -> Bool

    TimeWindowAggregate::events

    source
    fn TimeWindowAggregate::events(self : TimeWindowAggregate) -> Int

    TimeWindowAggregate::mae

    source
    fn TimeWindowAggregate::mae(self : TimeWindowAggregate) -> Double

    TimeWindowAggregate::new

    source
    fn TimeWindowAggregate::new(start : Int64, end : Int64) -> TimeWindowAggregate

    TimeWindowAggregate::observe

    source
    fn TimeWindowAggregate::observe(self : TimeWindowAggregate, event : TrainingEvent, prediction : Double) -> Bool

    TimeWindowAggregate::rmse

    source
    fn TimeWindowAggregate::rmse(self : TimeWindowAggregate) -> Double

    TimeWindowAggregate::weighted_positive_rate

    source
    fn TimeWindowAggregate::weighted_positive_rate(self : TimeWindowAggregate) -> Double

    TopKMetrics

    source
    pub struct TopKMetrics {
      total : Double
      hits : Array[Double]
    }

    TopKMetrics::accuracy

    source
    fn TopKMetrics::accuracy(self : TopKMetrics, k : Int) -> Double

    TopKMetrics::new

    source
    fn TopKMetrics::new(max_k? : Int) -> TopKMetrics

    TopKMetrics::reset

    source
    fn TopKMetrics::reset(self : TopKMetrics) -> Unit

    TopKMetrics::total

    source
    fn TopKMetrics::total(self : TopKMetrics) -> Double

    TopKMetrics::update

    source
    fn TopKMetrics::update(self : TopKMetrics, ranked : Array[Int], label : Int) -> Unit

    TrafficSplitter

    source
    pub struct TrafficSplitter {
      buckets : Map[String, Double]
      default_version : String
      assigned : Int
    }

    TrafficSplitter::assigned

    source
    fn TrafficSplitter::assigned(self : TrafficSplitter) -> Int

    TrafficSplitter::new

    source
    fn TrafficSplitter::new(default_version : String) -> TrafficSplitter

    TrafficSplitter::reset

    source
    fn TrafficSplitter::reset(self : TrafficSplitter) -> Unit

    TrafficSplitter::route

    source
    fn TrafficSplitter::route(self : TrafficSplitter, hash : Int) -> String

    TrafficSplitter::set

    source
    fn TrafficSplitter::set(self : TrafficSplitter, version : String, share : Double) -> Unit

    TrafficSplitter::share

    source
    fn TrafficSplitter::share(self : TrafficSplitter, version : String) -> Double

    TrainingEvent

    source
    pub struct TrainingEvent {
      id : String
      timestamp : Int64
      features : Array[Double]
      label : Double
      weight : Double
    } derive(ToJson, 
    Debug    , 
    FromJson    )

    Immutable training event that can be replayed for deterministic validation.

    TrainingEvent::features

    source
    fn TrainingEvent::features(self : TrainingEvent) -> Array[Double]

    TrainingEvent::id

    source
    fn TrainingEvent::id(self : TrainingEvent) -> String

    TrainingEvent::label

    source
    fn TrainingEvent::label(self : TrainingEvent) -> Double

    TrainingEvent::new

    source
    fn TrainingEvent::new(id : String, timestamp : Int64, features : Array[Double], label : Double, weight? : Double) -> TrainingEvent

    TrainingEvent::timestamp

    source
    fn TrainingEvent::timestamp(self : TrainingEvent) -> Int64

    TrainingEvent::weight

    source
    fn TrainingEvent::weight(self : TrainingEvent) -> Double

    TrainingReport

    source
    pub struct TrainingReport {
      samples : Int
      accepted : Int
      rejected : Int
      total_loss : Double
      final_loss : Double
      elapsed_steps : Int
    } derive(ToJson, 
    Debug    , 
    FromJson    )

    TrainingReport::accepted

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

    TrainingReport::final_loss

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

    TrainingReport::mean_loss

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

    TrainingReport::new

    source

    TrainingReport::record

    source
    fn TrainingReport::record(self : TrainingReport, accepted : Bool, loss : Double) -> Unit

    TrainingReport::rejected

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

    TrainingReport::reset

    source
    fn TrainingReport::reset(self : TrainingReport) -> Unit

    TrainingReport::samples

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

    TumblingWindowAggregator

    source
    pub struct TumblingWindowAggregator {
      width : Int64
      allowed_lateness : Int64
      windows : Map[Int64, AggregateSummary]
      watermark : Int64
      accepted : Int
      late : Int
      invalid : Int
    }

    TumblingWindowAggregator::accepted

    source

    TumblingWindowAggregator::advance_watermark

    source
    fn TumblingWindowAggregator::advance_watermark(self : TumblingWindowAggregator, watermark : Int64) -> Bool

    TumblingWindowAggregator::close_before

    source
    fn TumblingWindowAggregator::close_before(self : TumblingWindowAggregator, timestamp : Int64) -> Array[AggregateSummary]

    TumblingWindowAggregator::invalid

    source

    TumblingWindowAggregator::late

    source

    TumblingWindowAggregator::new

    source
    fn TumblingWindowAggregator::new(width : Int64, allowed_lateness? : Int64) -> TumblingWindowAggregator

    TumblingWindowAggregator::observe

    source
    fn TumblingWindowAggregator::observe(self : TumblingWindowAggregator, timestamp : Int64, value : Double, weight? : Double) -> Bool

    TumblingWindowAggregator::ready_windows

    source

    TumblingWindowAggregator::reset

    source

    TumblingWindowAggregator::watermark

    source
    fn TumblingWindowAggregator::watermark(self : TumblingWindowAggregator) -> Int64

    TumblingWindowAggregator::window

    source

    TumblingWindowAggregator::window_count

    source
    fn TumblingWindowAggregator::window_count(self : TumblingWindowAggregator) -> Int

    UcbBandit

    source
    pub struct UcbBandit {
      arms : Array[ArmStatistics]
      exploration : Double
      history : BanditHistory
      steps : Int
    }

    UcbBandit::arm_count

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

    UcbBandit::choose

    source
    fn UcbBandit::choose(self : UcbBandit) -> Int?

    UcbBandit::history

    source
    fn UcbBandit::history(self : UcbBandit) -> BanditHistory

    UcbBandit::new

    source
    fn UcbBandit::new(arm_count : Int, exploration? : Double, history_capacity? : Int) -> UcbBandit

    UcbBandit::reset

    source
    fn UcbBandit::reset(self : UcbBandit) -> Unit

    UcbBandit::statistics

    source
    fn UcbBandit::statistics(self : UcbBandit, arm : Int) -> ArmStatistics?

    UcbBandit::steps

    source
    fn UcbBandit::steps(self : UcbBandit) -> Int

    UcbBandit::update

    source
    fn UcbBandit::update(self : UcbBandit, arm : Int, reward : Double) -> Bool

    UcbBandit::upper_bound

    source
    fn UcbBandit::upper_bound(self : UcbBandit, arm : Int) -> Double

    UserItemRecommender

    source
    pub struct UserItemRecommender {
      preferences : Map[String, Map[String, Double]]
      popularity : Map[String, Double]
      interactions : Int
    }

    A compact user-item preference store with popularity and cold-start fallbacks. Scores are weighted by the caller, so clicks, purchases, and negative feedback can share one serving interface.

    UserItemRecommender::interactions

    source
    fn UserItemRecommender::interactions(self : UserItemRecommender) -> Int

    UserItemRecommender::items

    source
    fn UserItemRecommender::items(self : UserItemRecommender) -> Array[String]

    UserItemRecommender::new

    source

    UserItemRecommender::observe

    source
    fn UserItemRecommender::observe(self : UserItemRecommender, user : String, item : String, value? : Double) -> Bool

    UserItemRecommender::recommend

    source
    fn UserItemRecommender::recommend(self : UserItemRecommender, user : String, limit? : Int) -> Array[GraphNeighbor]

    UserItemRecommender::reset

    source
    fn UserItemRecommender::reset(self : UserItemRecommender) -> Unit

    UserItemRecommender::score

    source
    fn UserItemRecommender::score(self : UserItemRecommender, user : String, item : String) -> Double

    UserItemRecommender::users

    source
    fn UserItemRecommender::users(self : UserItemRecommender) -> Array[String]

    ValidationReport

    source
    pub struct ValidationReport {
      valid : Bool
      message : String
    } derive(Eq, ToJson, 
    Debug    , 
    FromJson    )

    ValidationReport::error

    source
    fn ValidationReport::error(message : String) -> ValidationReport

    ValidationReport::is_valid

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

    ValidationReport::message

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

    ValidationReport::ok

    source

    VectorMoments

    source
    pub struct VectorMoments {
      moments : Array[RunningMoments]
    }

    Per-feature running statistics for dense streams.

    VectorMoments::dimension

    source
    fn VectorMoments::dimension(self : VectorMoments) -> Int

    VectorMoments::mean

    source
    fn VectorMoments::mean(self : VectorMoments) -> Array[Double]

    VectorMoments::moment

    source
    fn VectorMoments::moment(self : VectorMoments, index : Int) -> RunningMoments?

    VectorMoments::new

    source
    fn VectorMoments::new(dimension : Int) -> VectorMoments

    VectorMoments::reset

    source
    fn VectorMoments::reset(self : VectorMoments) -> Unit

    VectorMoments::standardize

    source
    fn VectorMoments::standardize(self : VectorMoments, values : Array[Double]) -> Array[Double]

    VectorMoments::update

    source
    fn VectorMoments::update(self : VectorMoments, values : Array[Double], weight? : Double) -> Unit

    VectorMoments::variance

    source
    fn VectorMoments::variance(self : VectorMoments) -> Array[Double]

    VectorTransformPipeline

    source
    pub struct VectorTransformPipeline {
      transforms : Array[ScalarTransform]
      expected_dimension : Int
      rows : Int
      rejected : Int
    }

    VectorTransformPipeline::add

    source

    VectorTransformPipeline::dimension

    source

    VectorTransformPipeline::inverse

    source
    fn VectorTransformPipeline::inverse(self : VectorTransformPipeline, values : Array[Double]) -> Array[Double]

    VectorTransformPipeline::new

    source
    fn VectorTransformPipeline::new(expected_dimension : Int) -> VectorTransformPipeline

    VectorTransformPipeline::rejected

    source

    VectorTransformPipeline::reset

    source

    VectorTransformPipeline::rows

    source

    VectorTransformPipeline::transform

    source
    fn VectorTransformPipeline::transform(self : VectorTransformPipeline, values : Array[Double]) -> Array[Double]

    VectorTransformPipeline::transform_count

    source
    fn VectorTransformPipeline::transform_count(self : VectorTransformPipeline) -> Int

    WeightedHistogram

    source
    pub struct WeightedHistogram {
      lower : Double
      upper : Double
      bins : Array[Double]
      total : Double
    }

    WeightedHistogram::counts

    source
    fn WeightedHistogram::counts(self : WeightedHistogram) -> Array[Double]

    WeightedHistogram::new

    source
    fn WeightedHistogram::new(lower? : Double, upper? : Double, bins? : Int) -> WeightedHistogram

    WeightedHistogram::observe

    source
    fn WeightedHistogram::observe(self : WeightedHistogram, value : Double, weight? : Double) -> Unit

    WeightedHistogram::probabilities

    source
    fn WeightedHistogram::probabilities(self : WeightedHistogram) -> Array[Double]

    WeightedHistogram::quantile

    source
    fn WeightedHistogram::quantile(self : WeightedHistogram, probability : Double) -> Double

    WeightedHistogram::reset

    source
    fn WeightedHistogram::reset(self : WeightedHistogram) -> Unit

    WeightedHistogram::total

    source
    fn WeightedHistogram::total(self : WeightedHistogram) -> Double

    WeightedProbabilityEnsemble

    source
    pub struct WeightedProbabilityEnsemble {
      weights : Array[Double]
      observations : Int
    }

    Weighted probability ensemble with online expert reweighting.

    WeightedProbabilityEnsemble::experts

    source

    WeightedProbabilityEnsemble::new

    source

    WeightedProbabilityEnsemble::normalized_weights

    source
    fn WeightedProbabilityEnsemble::normalized_weights(self : WeightedProbabilityEnsemble) -> Array[Double]

    WeightedProbabilityEnsemble::observations

    source

    WeightedProbabilityEnsemble::predict

    source
    fn WeightedProbabilityEnsemble::predict(self : WeightedProbabilityEnsemble, predictions : Array[Double]) -> Double

    WeightedProbabilityEnsemble::reset

    source

    WeightedProbabilityEnsemble::update

    source
    fn WeightedProbabilityEnsemble::update(self : WeightedProbabilityEnsemble, predictions : Array[Double], label : Double, learning_rate? : Double) -> Unit

    WeightedProbabilityEnsemble::weights

    source

    WindowKind

    source
    pub(all) enum WindowKind {
      Tumbling
      Sliding
      Session
    } derive(Eq, 
    Debug    )

    Time-aware aggregations for event streams.

    These structures make time semantics explicit: callers choose a window width, late-event policy, and watermark rather than relying on wall-clock state hidden inside a model. All aggregators expose bounded counters that are suitable for service health dashboards.

    absolute_error

    source
    fn absolute_error(prediction : Double, label : Double) -> Double

    add_scaled_in_place

    source
    fn add_scaled_in_place(target : Array[Double], source : Array[Double], scale : Double) -> Unit

    add_values

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

    alert_condition_catalog

    source
    fn alert_condition_catalog() -> Array[AlertCondition]

    alert_severity_catalog

    source
    fn alert_severity_catalog() -> Array[AlertSeverity]

    all_close

    source
    fn all_close(left : Array[Double], right : Array[Double], tolerance? : Double) -> Bool

    append_interactions

    source
    fn append_interactions(values : Array[Double], include_diagonal? : Bool) -> Array[Double]

    apply_scalar_transform

    source
    fn apply_scalar_transform(kind : ScalarTransformKind, value : Double) -> Double

    argmax

    source
    fn argmax(values : Array[Double]) -> Int?

    attribution_sum

    source
    fn attribution_sum(attributions : Array[FeatureAttribution]) -> Double

    audit_action_catalog

    source
    fn audit_action_catalog() -> Array[AuditAction]

    bandit_action_catalog

    source
    fn bandit_action_catalog() -> Array[BanditAction]

    binary_cross_entropy

    source
    fn binary_cross_entropy(probability : Double, label : Double) -> Double

    clamp

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

    clamp_probability

    source
    fn clamp_probability(value : Double) -> Double

    copy_vector

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

    cosine_similarity

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

    cost_matrix

    source
    fn cost_matrix(costs : ClassCost) -> Array[Array[Double]]

    cost_sensitive_decision

    source
    fn cost_sensitive_decision(probability : Double, costs : ClassCost) -> Bool

    cross_feature

    source
    fn cross_feature(left : String, right : String, separator? : String) -> String

    csv_escape

    source
    fn csv_escape(field : String, options? : CsvOptions) -> String

    csv_write_row

    source
    fn csv_write_row(fields : Array[String], options? : CsvOptions) -> String

    cumulative_sum

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

    deployment_state_catalog

    source
    fn deployment_state_catalog() -> Array[DeploymentState]

    dot_product

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

    dot_product_checked

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

    evaluate_binary

    source
    fn evaluate_binary(model : AdagradLogisticRegression, batch : DataBatch) -> OnlineEvaluationSession

    evaluate_regression

    source
    fn evaluate_regression(model : OnlineRidgeRegression, batch : DataBatch) -> OnlineEvaluationSession

    expected_binary_cost

    source
    fn expected_binary_cost(probability : Double, positive_cost : Double, negative_cost : Double) -> Double

    explain_linear

    source
    fn explain_linear(weights : Array[Double], features : Array[Double], top_k? : Int) -> Array[FeatureAttribution]

    explain_sparse

    source
    fn explain_sparse(weights : SparseVector, features : SparseVector, top_k? : Int) -> Array[FeatureAttribution]

    generate_feature_crosses

    source
    fn generate_feature_crosses(features : Array[String], order? : Int) -> Array[String]

    hadamard_product

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

    hash_feature

    source
    fn hash_feature(name : String, buckets : Int) -> Int

    hash_feature_with_sign

    source
    fn hash_feature_with_sign(name : String, buckets : Int) -> SparseEntry

    hinge_loss

    source
    fn hinge_loss(score : Double, label : Double) -> Double

    invert_scalar_transform

    source
    fn invert_scalar_transform(kind : ScalarTransformKind, value : Double) -> Double

    is_non_decreasing

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

    l1_norm

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

    logit

    source
    fn logit(probability : Double) -> Double

    logits_to_probability

    source
    fn logits_to_probability(logit : Double) -> Double

    loss_gradient

    source
    fn loss_gradient(kind : LossKind, prediction : Double, label : Double, parameter? : Double) -> Double

    loss_gradient_vector

    source
    fn loss_gradient_vector(kind : LossKind, predictions : Array[Double], labels : Array[Double]) -> Array[Double]

    loss_kind_catalog

    source
    fn loss_kind_catalog() -> Array[LossKind]

    loss_value

    source
    fn loss_value(kind : LossKind, prediction : Double, label : Double, parameter? : Double) -> Double

    make_fold

    source
    fn make_fold(batch : DataBatch, folds : Int, index : Int) -> CrossValidationFold

    make_snapshot

    source
    fn make_snapshot(model : String, version : String, payload : String) -> SnapshotEnvelope

    matrix_row_sums

    source
    fn matrix_row_sums(matrix : Matrix) -> Array[Double]

    max_abs

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

    mean_values

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

    moving_average

    source
    fn moving_average(previous : Double, value : Double, smoothing : Double) -> Double

    normalize_l2

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

    one_hot

    source
    fn one_hot(index : Int, size : Int) -> Array[Double]

    outer_product

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

    pairwise_interactions

    source
    fn pairwise_interactions(values : Array[Double], include_diagonal? : Bool) -> Array[Double]

    polynomial_features

    source
    fn polynomial_features(values : Array[Double], degree : Int) -> Array[Double]

    Stateless numeric feature engineering helpers.

    probabilities_from_logits

    source
    fn probabilities_from_logits(logits : Array[Double]) -> Array[Double]

    probability_to_logit

    source
    fn probability_to_logit(probability : Double) -> Double

    r2_score

    source
    fn r2_score(predictions : Array[Double], labels : Array[Double]) -> Double

    rank_one_update

    source
    fn rank_one_update(matrix : Matrix, vector : Array[Double], scale : Double) -> Unit

    safe_threshold

    source
    fn safe_threshold(threshold : Double) -> Double

    sample_indices

    source
    fn sample_indices(size : Int, seed? : UInt64) -> Array[Int]

    scalar_transform_catalog

    source
    fn scalar_transform_catalog() -> Array[ScalarTransformKind]

    scale_values

    source
    fn scale_values(values : Array[Double], scale : Double) -> Array[Double]

    sigmoid

    source
    fn sigmoid(value : Double) -> Double

    smooth_l1_loss

    source
    fn smooth_l1_loss(error : Double, beta? : Double) -> Double

    snapshot_checksum

    source
    fn snapshot_checksum(payload : String) -> String

    softplus

    source
    fn softplus(value : Double) -> Double

    split_indices

    source
    fn split_indices(size : Int, train_ratio? : Double, seed? : UInt64) -> (Array[Int], Array[Int])

    squared_error

    source
    fn squared_error(prediction : Double, label : Double) -> Double

    squared_norm

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

    standard_deviation

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

    subtract_scaled_in_place

    source
    fn subtract_scaled_in_place(target : Array[Double], source : Array[Double], scale : Double) -> Unit

    subtract_values

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

    sum_values

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

    threshold_is_valid

    source
    fn threshold_is_valid(threshold : Double) -> Bool

    top_index

    source
    fn top_index(values : Array[Double], rank : Int) -> Int?

    train_adagrad

    source
    fn train_adagrad(model : AdagradLogisticRegression, batch : DataBatch, report : TrainingReport) -> TrainingReport

    Train a dense Adagrad classifier over a batch and return an auditable report. The function keeps the event loop explicit for easy replay.

    train_ridge

    source
    fn train_ridge(model : OnlineRidgeRegression, batch : DataBatch, report : TrainingReport) -> TrainingReport

    valid_dimension

    source
    fn valid_dimension(dim : Int) -> Bool

    validate_dimension

    source
    fn validate_dimension(dim : Int) -> ValidationReport

    validate_label

    source
    fn validate_label(value : Double) -> ValidationReport

    validate_probability

    source
    fn validate_probability(value : Double) -> ValidationReport

    validate_vector

    source
    fn validate_vector(features : Array[Double], dim : Int) -> ValidationReport

    variance_values

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

    verify_snapshot

    source
    fn verify_snapshot(envelope : SnapshotEnvelope) -> Bool

    weighted_loss

    source
    fn weighted_loss(kind : LossKind, predictions : Array[Double], labels : Array[Double], weights? : Array[Double]) -> Double

    weighted_mean

    source
    fn weighted_mean(values : Array[Double], weights : Array[Double]) -> Double

    weighted_variance

    source
    fn weighted_variance(values : Array[Double], weights : Array[Double]) -> Double

    window_kind_catalog

    source
    fn window_kind_catalog() -> Array[WindowKind]

    Source Files

    Powered by MoonBit

    Site sourceReport issueModulesSkillsCLIBuild queueStatistics

    © 2026 mooncakes.io