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
moon add phjphj676/moon-online-models@0.2.0
Download zipAuthor
Version
0.2.0
License
Apache-2.0
Repository
Last updated
6 hours ago
Downloads
3
README#moon-online-models
phjphj676/moon-online-models is a native MoonBit toolkit for applications
that learn from events continuously: CTR/risk scoring, device telemetry,
incremental forecasting, ranking, feature streams, and model monitoring. It
is the acceptance version of the August 2026 MoonBit Hackathon project.
#What is included
- Dense online learners: RLS, SGD/FTRL logistic regression, Adagrad, ridge, Huber, quantile, softmax, Naive Bayes, k-means, kernels, PCA, factorization, tree stumps, ensembles, and time-series models.
- Sparse and streaming data: sparse vectors, hashing, CSV parsing, categorical encoding, feature crosses, online joins, reservoirs, bootstrapping, and schema-checked feature storage.
- Evaluation and safety: exact and histogram AUC, calibration, regression and ranking metrics, conformal intervals, drift detectors, fairness gaps, cost-sensitive thresholds, validation, gradient/prediction guards.
- Operations: model snapshots and checksums, registry and deployment state transitions, canary experiments, serving batchers, SLO/error budgets, alerts, audit trails, data lineage, privacy budgets, and reproducibility manifests.
The implementation is deliberately dependency-light: the root package only
uses moonbitlang/core/math and moonbitlang/core/json. Public state is
bounded where a stream can grow without limit; callers can inspect counters,
reset state, and reject malformed dimensions at the boundary.
#Install
moon add phjphj676/moon-online-models#Minimal example
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])For sparse CTR-style features:
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)#Verification
Run the same checks locally that the repository CI runs:
moon version --all
moon update
moon check --target all
moon test --target all
moon fmt && git diff --exit-code
moon info && git diff --exit-codeThe local wasm-gc test suite contains 16 boundary and behavior scenarios;
the native benchmark trains 20,000 deterministic events and records its
measured output in benchmarks/RESULTS.md. Re-run
it with benchmarks/run.ps1 on the acceptance machine.
#Package and repository
- Package: phjphj676/moon-online-models@0.2.0
- GitHub: https://github.com/phjphj676/moon-online-models
- GitLink mirror: https://www.gitlink.org.cn/phjphj676/moon-online-models
- Default branch: master
- License: Apache-2.0; see LICENSE.
- The project proposal and acceptance notes are retained in 申报书.md.
The code is original MoonBit implementation authored by the repository owner.
No generated build directory or credentials are part of the package.
#OnlineLearner
A trait for online learning models that can be incrementally updated.
#Snapshot
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
A linear regressor with Adagrad updates, useful when labels are continuous
and the stream has heterogeneous feature scales.
#AdagradLinearRegression::dimension
#AdagradLinearRegression::loss
fn AdagradLinearRegression::loss(self : AdagradLinearRegression, features : Array[Double], label : Double) -> Double#AdagradLinearRegression::new
fn AdagradLinearRegression::new(dimension : Int, learning_rate? : Double, epsilon? : Double, l2? : Double) -> AdagradLinearRegression#AdagradLinearRegression::predict
fn AdagradLinearRegression::predict(self : AdagradLinearRegression, features : Array[Double]) -> Double#AdagradLinearRegression::reset
#AdagradLinearRegression::residual
fn AdagradLinearRegression::residual(self : AdagradLinearRegression, features : Array[Double], label : Double) -> Double#AdagradLinearRegression::steps
#AdagradLinearRegression::update
fn AdagradLinearRegression::update(self : AdagradLinearRegression, features : Array[Double], label : Double) -> Unit#AdagradLinearRegression::weights
#AdagradLogisticRegression
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
#AdagradLogisticRegression::dimension
#AdagradLogisticRegression::feature_importance
#AdagradLogisticRegression::logit
fn AdagradLogisticRegression::logit(self : AdagradLogisticRegression, features : Array[Double]) -> Double#AdagradLogisticRegression::loss
fn AdagradLogisticRegression::loss(self : AdagradLogisticRegression, features : Array[Double], label : Double) -> Double#AdagradLogisticRegression::new
fn AdagradLogisticRegression::new(dimension : Int, learning_rate? : Double, epsilon? : Double, l1? : Double, l2? : Double) -> AdagradLogisticRegression#AdagradLogisticRegression::predict
fn AdagradLogisticRegression::predict(self : AdagradLogisticRegression, features : Array[Double]) -> Double#AdagradLogisticRegression::predict_label
fn AdagradLogisticRegression::predict_label(self : AdagradLogisticRegression, features : Array[Double], threshold? : Double) -> Double#AdagradLogisticRegression::regularization
#AdagradLogisticRegression::reset
#AdagradLogisticRegression::seen
#AdagradLogisticRegression::sparsity
fn AdagradLogisticRegression::sparsity(self : AdagradLogisticRegression, tolerance? : Double) -> Double#AdagradLogisticRegression::steps
#AdagradLogisticRegression::update
fn AdagradLogisticRegression::update(self : AdagradLogisticRegression, features : Array[Double], label : Double) -> Unit#AdagradLogisticRegression::update_weighted
fn AdagradLogisticRegression::update_weighted(self : AdagradLogisticRegression, features : Array[Double], label : Double, sample_weight : Double) -> Unit#AdagradLogisticRegression::weights
#AdagradOptimizer
pub struct AdagradOptimizer {
learning_rate : Double
epsilon : Double
schedule : LearningRateSchedule
accumulator : Array[Double]
clipper : GradientClipper
step_count : Int
statistics : OptimizerStatistics
}#AdagradOptimizer::accumulated
#AdagradOptimizer::apply
fn AdagradOptimizer::apply(self : AdagradOptimizer, parameters : Array[Double], gradients : Array[Double]) -> Unit#AdagradOptimizer::new
fn AdagradOptimizer::new(dimension : Int, learning_rate? : Double, epsilon? : Double, schedule? : LearningRateSchedule, clipper? : GradientClipper) -> AdagradOptimizer#AdagradOptimizer::statistics
#AdagradOptimizer::update
#AdamOptimizer
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
fn AdamOptimizer::apply(self : AdamOptimizer, parameters : Array[Double], gradients : Array[Double]) -> Unit#AdamOptimizer::first_moment
#AdamOptimizer::new
fn AdamOptimizer::new(dimension : Int, learning_rate? : Double, beta1? : Double, beta2? : Double, epsilon? : Double, clipper? : GradientClipper) -> AdamOptimizer#AdamOptimizer::second_moment
#AdamOptimizer::update
#AlertCondition
#AlertRule
pub struct AlertRule {
name : String
metric : String
condition : AlertCondition
lower : Double
upper : Double
severity : AlertSeverity
cooldown : Int64
last_alert : Int64?
}#AlertRule::evaluate
#AlertRule::greater
fn AlertRule::greater(name : String, metric : String, threshold : Double, severity? : AlertSeverity, cooldown? : Int64) -> AlertRule#AlertRule::less
fn AlertRule::less(name : String, metric : String, threshold : Double, severity? : AlertSeverity, cooldown? : Int64) -> AlertRule#AlertRule::outside
fn AlertRule::outside(name : String, metric : String, lower : Double, upper : Double, severity? : AlertSeverity, cooldown? : Int64) -> AlertRule#AlertRule::stale
fn AlertRule::stale(name : String, metric : String, max_age : Int64, severity? : AlertSeverity) -> AlertRule#AucTracker
Exact incremental AUC. The tracker stores event scores, so memory is O(n)
and the final computation is deterministic with tie handling.
#AucTracker::update
#AuditAction
Auditable metadata for model updates, data lineage, and privacy budgets.
#AuditRecord
pub struct AuditRecord {
event_id : String
actor : String
action : AuditAction
model : String
version : String
timestamp : Int64
detail : String
success : Bool
}#AuditRecord::new
fn AuditRecord::new(event_id : String, actor : String, action : AuditAction, model : String, version : String, timestamp : Int64, detail? : String, success? : Bool) -> AuditRecord#AuditTrail
pub struct AuditTrail {
capacity : Int
records : Array[AuditRecord]
ids : Map[String, Bool]
accepted : Int
duplicates : Int
evicted : Int
}#AuditTrail::count_action
#BatchNormalizer
#BatchNormalizer::fit
#BatchNormalizer::transform
#BatchNormalizer::variance
#BernoulliSampler
pub struct BernoulliSampler {
probability : Double
rng : DeterministicRng
accepted : Int
seen : Int
}#BernoulliSampler::new
#BernoulliSampler::probability
#BootstrapCounter
#BootstrapCounter::new
#CalibrationBin
pub struct CalibrationBin {
count : Double
predicted : Double
observed : Double
}#CalibrationBin::mean_observed
#CalibrationBin::mean_prediction
#CalibrationBin::update
#CalibrationTracker
#CalibrationTracker::bins
#CalibrationTracker::update
fn CalibrationTracker::update(self : CalibrationTracker, prediction : Double, label : Double) -> Unit#CanaryExperiment
pub struct CanaryExperiment {
name : String
baseline : String
candidate : String
target_samples : Int
baseline_metric : Double
candidate_metric : Double
samples : Int
}#CanaryExperiment::improvement
#CanaryExperiment::new
fn CanaryExperiment::new(name : String, baseline : String, candidate : String, target_samples? : Int) -> CanaryExperiment#CanaryExperiment::observe
fn CanaryExperiment::observe(self : CanaryExperiment, baseline : Double, candidate : Double) -> Unit#CategoricalEncoder
#CategoricalEncoder::contains
#CategoricalEncoder::dimension
#CategoricalEncoder::encode
#CategoricalEncoder::entries
#CategoricalEncoder::new
#ChangePointDetector
pub struct ChangePointDetector {
short : SequenceWindow
long : SequenceWindow
threshold : Double
changes : Int
last_score : Double
}#ChangePointDetector::changes
#ChangePointDetector::new
fn ChangePointDetector::new(short_window? : Int, long_window? : Int, threshold? : Double) -> ChangePointDetector#ChangePointDetector::observe
#ChangePointDetector::score
#ClassCost
pub struct ClassCost {
false_positive : Double
false_negative : Double
true_positive : Double
true_negative : Double
}Cost-sensitive decision rules for imbalanced streaming classification.
#ClassCost::cost
#ClassCost::expected_cost
#ClassCost::new
#ClassCountTracker
#ClassCountTracker::count
#ClassCountTracker::counts
#ClassCountTracker::observe
#ClassCountTracker::prior
#ClassCountTracker::priors
#ClickThroughRateTracker
pub struct ClickThroughRateTracker {
impressions : Double
clicks : Double
predicted_sum : Double
squared_calibration_error : Double
}#ClickThroughRateTracker::brier
#ClickThroughRateTracker::ctr
#ClickThroughRateTracker::impressions
#ClickThroughRateTracker::predicted_ctr
#ClickThroughRateTracker::reset
#ClickThroughRateTracker::update
fn ClickThroughRateTracker::update(self : ClickThroughRateTracker, probability : Double, clicked : Bool, weight? : Double) -> Unit#ConformalInterval
pub struct ConformalInterval {
residuals : Array[Double]
capacity : Int
confidence : Double
seen : Int
}Bounded conformal residual tracker for distribution-free prediction bands.
#ConformalInterval::confidence
#ConformalInterval::coverage
fn ConformalInterval::coverage(self : ConformalInterval, prediction : Double, label : Double) -> Bool#ConformalInterval::interval
#ConformalInterval::new
#ConformalInterval::observe
fn ConformalInterval::observe(self : ConformalInterval, prediction : Double, label : Double) -> Unit#ConfusionMatrix
pub struct ConfusionMatrix {
true_positive : Double
false_positive : Double
true_negative : Double
false_negative : Double
}Mutable binary classification confusion matrix for a stream.
#ConfusionMatrix::balanced_accuracy
#ConfusionMatrix::false_negative_count
#ConfusionMatrix::merge
#ConfusionMatrix::specificity
#ConfusionMatrix::update
fn ConfusionMatrix::update(self : ConfusionMatrix, prediction : Double, label : Double, threshold? : Double) -> Unit#CostSensitiveEvaluator
#CostSensitiveEvaluator::count
#CostSensitiveEvaluator::mean
#CostSensitiveEvaluator::new
#CostSensitiveEvaluator::observe
fn CostSensitiveEvaluator::observe(self : CostSensitiveEvaluator, prediction : Double, label : Double, threshold : Double) -> Double#CostSensitiveEvaluator::reset
#CostSensitiveEvaluator::total
#CrossValidationFold
#CrossValidationFold::train
#CrossValidationFold::validation
#CsvOptions
pub struct CsvOptions {
separator : Char
quote : Char
escape : Char
trim_fields : Bool
skip_empty : Bool
}#CsvOptions::new
fn CsvOptions::new(separator? : Char, quote? : Char, escape? : Char, trim_fields? : Bool, skip_empty? : Bool) -> CsvOptions#CsvOptions::parse_line
#CsvOptions::parse_lines
#CumulativeSumDetector
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
#CumulativeSumDetector::new
fn CumulativeSumDetector::new(target? : Double, allowance? : Double, threshold? : Double) -> CumulativeSumDetector#CumulativeSumDetector::positive
#CumulativeSumDetector::reset
#CumulativeSumDetector::update
#DataBatch
#DataBatch::add
#DataBatch::from_arrays
#DataBatch::shuffle
#DataLineage
pub struct DataLineage {
nodes : Map[String, LineageNode]
edges : Map[String, Array[String]]
registrations : Int
}#DataLineage::connect
#DataLineage::inputs
#DataLineage::register
#DataLineage::upstream
#DataQualityReport
pub struct DataQualityReport {
rows : Int
accepted : Int
rejected : Int
missing_values : Int
dimension_errors : Int
out_of_range : Int
}#DataQualityReport::acceptance_rate
#DataQualityReport::dimension_errors
#DataQualityReport::missing_values
#DataQualityReport::observe
fn DataQualityReport::observe(self : DataQualityReport, accepted : Bool, missing : Int, dimension_error : Bool, range_error : Bool) -> Unit#DataQualityReport::out_of_range
#DenseVector
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::axpy
#DenseVector::clamp
#DenseVector::concat
#DenseVector::distance
#DenseVector::distance_squared
#DenseVector::dot_checked
#DenseVector::hadamard
#DenseVector::map
#DenseVector::slice
#DenseVector::subtract
#DenseVector::validate
#DenseVector::zip_map
fn DenseVector::zip_map(self : DenseVector, other : DenseVector, transform : (Double, Double) -> Double) -> DenseVector#Deployment
pub struct Deployment {
model : String
version : String
state : DeploymentState
created_at : Int64
updated_at : Int64
traffic : Double
}#Deployment::new
#Deployment::transition
#DeploymentManager
pub struct DeploymentManager {
deployments : Map[String, Deployment]
policy : RollbackPolicy
transitions : Int
rollbacks : Int
}#DeploymentManager::create
#DeploymentManager::get
fn DeploymentManager::get(self : DeploymentManager, model : String, version : String) -> Deployment?#DeploymentManager::healthy
fn DeploymentManager::healthy(self : DeploymentManager, accuracy : Double, loss : Double, error_rate : Double) -> Bool#DeploymentManager::new
#DeploymentManager::transition
fn DeploymentManager::transition(self : DeploymentManager, model : String, version : String, next : DeploymentState, timestamp : Int64) -> Bool#DeploymentManager::transitions
#DeploymentState
Explicit deployment state machine used by registry and serving layers.
#DeterministicRng
pub struct DeterministicRng {
state : UInt64
}Small deterministic pseudo-random generator for reproducible benchmarks.
#DeterministicRng::next_double
#DeterministicRng::next_int
#DeterministicRng::shuffle
#DeterministicRng::uniform
#DriftMonitor
pub struct DriftMonitor {
feature_detectors : Array[PageHinkleyDetector]
target_detector : PageHinkleyDetector
feature_drift_events : Int
target_drift_events : Int
}#DriftMonitor::new
#DriftMonitor::update
#DuplicateSignatureTracker
#DuplicateSignatureTracker::duplicate_rate
#DuplicateSignatureTracker::duplicates
#DuplicateSignatureTracker::new
#DuplicateSignatureTracker::observe
fn DuplicateSignatureTracker::observe(self : DuplicateSignatureTracker, features : Array[Double]) -> Bool#DuplicateSignatureTracker::reset
#DuplicateSignatureTracker::rows
#EarlyStopping
pub struct EarlyStopping {
patience : Int
minimum_delta : Double
best : Double
bad_rounds : Int
initialized : Bool
}#EarlyStopping::new
#ErrorBudget
pub struct ErrorBudget {
target : Double
window : Int
successes : Int
failures : Int
}#EvaluationSummary
#EvaluationSummary::accuracy
#EvaluationSummary::log_loss
#EvaluationSummary::precision
#EventLog
pub struct EventLog {
capacity : Int
events : Array[TrainingEvent]
ids : Map[String, Bool]
appended : Int
evicted : Int
}#EventLog::replay
#EwmaAnomalyDetector
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
#EwmaAnomalyDetector::new
#EwmaAnomalyDetector::score
#EwmaAnomalyDetector::update
#ExponentialImportance
#ExponentialImportance::new
#ExponentialImportance::observations
#ExponentialImportance::reset
#ExponentialImportance::scores
#ExponentialImportance::top_k
#ExponentialImportance::update
#ExponentialMovingAverage
pub struct ExponentialMovingAverage {
alpha : Double
value : Double
initialized : Bool
}#ExponentialMovingAverage::initialized
#ExponentialMovingAverage::new
#ExponentialMovingAverage::reset
#ExponentialMovingAverage::update
#ExponentialMovingAverage::value
#ExponentialMovingVariance
pub struct ExponentialMovingVariance {
alpha : Double
mean : Double
variance : Double
initialized : Bool
}#ExponentialMovingVariance::initialized
#ExponentialMovingVariance::mean
#ExponentialMovingVariance::new
#ExponentialMovingVariance::reset
#ExponentialMovingVariance::standard_deviation
#ExponentialMovingVariance::update
#ExponentialMovingVariance::variance
#ExponentialMovingVariance::z_score
#FTRL
FTRL-Proximal Online Logistic Regression Model.
Supports L1 and L2 regularization, ideal for large-scale features.
#FTRL::new
Create a new FTRL model with dim features.
#FTRL::predict
Predict the probability for a given feature vector.
#FactorizationMachine
#FactorizationMachine::new
fn FactorizationMachine::new(dimension : Int, rank : Int, learning_rate? : Double, l2? : Double) -> FactorizationMachine#FactorizationMachine::predict
#FactorizationMachine::updates
#FairnessMonitor
#FairnessMonitor::group
#FairnessMonitor::max_positive_rate_gap
#FairnessMonitor::max_recall_gap
#FairnessMonitor::observe
fn FairnessMonitor::observe(self : FairnessMonitor, group : String, prediction : Double, label : Double, threshold? : Double) -> Unit#FeatureAttribution
pub struct FeatureAttribution {
index : Int
contribution : Double
}Lightweight local explanations for linear and sparse predictions.
#FeatureAttribution::contribution
#FeatureAttribution::new
#FeatureDriftSummary
#FeatureDriftSummary::changed
#FeatureDriftSummary::changed_count
#FeatureDriftSummary::new
#FeatureDriftSummary::scores
#FeatureHasher
pub struct FeatureHasher {
buckets : Int
signed : Bool
}#FeatureHasher::encode
#FeatureHasher::encode_map
#FeatureHasher::encode_weighted
fn FeatureHasher::encode_weighted(self : FeatureHasher, tokens : Array[(String, Double)]) -> SparseVector#FeatureMaterializer
pub struct FeatureMaterializer {
schema : FeatureSchema
defaults : Array[Double]
materialized : Int
fallback : Int
}#FeatureMaterializer::fallback
#FeatureMaterializer::materialize
fn FeatureMaterializer::materialize(self : FeatureMaterializer, values : Array[Double]) -> Array[Double]#FeatureMaterializer::materialized
#FeatureMaterializer::new
fn FeatureMaterializer::new(schema : FeatureSchema, defaults? : Array[Double]) -> FeatureMaterializer#FeaturePipeline
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::disable_clip
#FeaturePipeline::fit_only
#FeaturePipeline::new
fn FeaturePipeline::new(dimension : Int, clip_lower? : Double, clip_upper? : Double, hashing_buckets? : Int) -> FeaturePipeline#FeaturePipeline::set_clip
#FeaturePipeline::transform
#FeaturePipeline::transform_tokens
fn FeaturePipeline::transform_tokens(self : FeaturePipeline, tokens : Array[String]) -> SparseVector?#FeaturePipeline::variance
#FeatureRangeMonitor
#FeatureRangeMonitor::maximum
#FeatureRangeMonitor::minimum
#FeatureRangeMonitor::new
#FeatureRangeMonitor::observe
#FeatureRangeMonitor::violations
#FeatureRecord
pub struct FeatureRecord {
key : String
version : Int
values : Array[Double]
timestamp : Int64
source : String
}#FeatureRecord::new
fn FeatureRecord::new(key : String, values : Array[Double], timestamp : Int64, source? : String, version? : Int) -> FeatureRecord#FeatureSchema
In-memory feature registry with schema checks, versioning, and bounded history.
#FeatureSchema::new
fn FeatureSchema::new(name : String, dimension : Int, minimum? : Array[Double], maximum? : Array[Double], required? : Bool) -> FeatureSchema#FeatureSchema::validate
#FeatureStore
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
#FeatureStore::history
#FeatureStore::latest
#FeatureStore::put
#FeatureStore::register
#FeatureStore::schema
#FeatureValue
A scalar feature value before it is encoded into a numeric vector.
#FeatureValue::as_number
#ForecastTracker
#ForecastTracker::observe
#GatedRegressor
pub struct GatedRegressor {
low : OnlineRidgeRegression
high : OnlineRidgeRegression
boundary : Double
low_count : Int
high_count : Int
}#GatedRegressor::new
#GatedRegressor::predict
fn GatedRegressor::predict(self : GatedRegressor, features : Array[Double], gate : Double) -> Double#GatedRegressor::update
fn GatedRegressor::update(self : GatedRegressor, features : Array[Double], gate : Double, label : Double) -> Unit#GaussianClassStats
Per-class Gaussian sufficient statistics.
#GaussianClassStats::log_likelihood
fn GaussianClassStats::log_likelihood(self : GaussianClassStats, features : Array[Double], smoothing? : Double) -> Double#GaussianClassStats::mean
#GaussianClassStats::update
fn GaussianClassStats::update(self : GaussianClassStats, features : Array[Double], weight? : Double) -> Unit#GaussianClassStats::variance
#GradientAccumulator
#GradientAccumulator::add
#GradientAccumulator::mean
#GradientAccumulator::sum
#GradientAccumulator::take_mean
#GradientClipper
pub struct GradientClipper {
max_norm : Double
max_value : Double
}#GradientClipper::clip
#GradientClipper::new
#GradientGuard
pub struct GradientGuard {
lower : Double
upper : Double
clipped : Int
invalid : Int
}#GradientGuard::apply
#GroupMetric
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::false_positive_rate
#GroupMetric::observe
fn GroupMetric::observe(self : GroupMetric, prediction : Double, label : Double, threshold? : Double) -> Unit#HashedFeatureSelector
pub struct HashedFeatureSelector {
dimension : Int
importance : ExponentialImportance
threshold : Double
}A bounded vocabulary selector that keeps the most useful hashed features.
#HashedFeatureSelector::dimension
#HashedFeatureSelector::new
#HashedFeatureSelector::observe
fn HashedFeatureSelector::observe(self : HashedFeatureSelector, vector : SparseVector, gradient : Double) -> Unit#HashedFeatureSelector::reset
#HashedFeatureSelector::scores
#HashedFeatureSelector::selected
#HashedFeatureSelector::selected_top_k
#HashingVectorizer
Token hashing utilities for text and event-key features.
#HashingVectorizer::encode
#HashingVectorizer::new
fn HashingVectorizer::new(buckets : Int, lowercase? : Bool, ngram_order? : Int) -> HashingVectorizer#HashingVectorizer::tokens
#HistogramAuc
Fixed-bin AUC approximation for bounded-memory deployments.
#HistogramAuc::update
fn HistogramAuc::update(self : HistogramAuc, score : Double, label : Double, weight? : Double) -> Unit#HoldoutSplit
#HoldoutSplit::new
#HoltWinters
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::forecast
#HoltWinters::new
fn HoltWinters::new(season_length : Int, alpha? : Double, beta? : Double, gamma? : Double) -> HoltWinters#KernelKind
Kernel choices for compact online non-linear models.
#KernelKind::evaluate
#KernelSupport
#KeyedFeatureJoin
Bounded keyed join for combining asynchronous feature and label streams.
#KeyedFeatureJoin::put_features
fn KeyedFeatureJoin::put_features(self : KeyedFeatureJoin, key : String, features : Array[Double]) -> Array[Double]?#KeyedFeatureJoin::put_label
fn KeyedFeatureJoin::put_label(self : KeyedFeatureJoin, key : String, label : Double) -> Array[Double]?#LatencyTracker
#LatencyTracker::observe
#LatencyTracker::percentile
#LearningCurve
#LearningCurve::generalization_gap
#LearningCurve::record
fn LearningCurve::record(self : LearningCurve, train_loss : Double, validation_loss : Double) -> Unit#LearningRateSchedule
Learning-rate schedules shared by adaptive online optimizers.
#LearningRateSchedule::rate
#LineageNode
pub struct LineageNode {
dataset : String
source : String
schema : String
row_count : Int
checksum : String
timestamp : Int64
}#LineageNode::new
fn LineageNode::new(dataset : String, source : String, schema : String, row_count : Int, checksum : String, timestamp : Int64) -> LineageNode#LinearEndpoint
pub struct LinearEndpoint {
weights : Array[Double]
bias : Double
version : String
prediction_guard : PredictionGuard
requests : Int
rejected : Int
}#LinearEndpoint::new
fn LinearEndpoint::new(weights : Array[Double], bias? : Double, version? : String, lower? : Double, upper? : Double) -> LinearEndpoint#LinearEndpoint::predict
fn LinearEndpoint::predict(self : LinearEndpoint, request : PredictionRequest) -> PredictionResponse#LinearEndpoint::predict_batch
fn LinearEndpoint::predict_batch(self : LinearEndpoint, requests : Array[PredictionRequest]) -> Array[PredictionResponse]#LossAccumulator
pub struct LossAccumulator {
kind : LossKind
parameter : Double
count : Int
weight : Double
total : Double
absolute_gradient : Double
maximum : Double
}#LossAccumulator::mean_absolute_gradient
#LossAccumulator::new
#LossAccumulator::update
fn LossAccumulator::update(self : LossAccumulator, prediction : Double, label : Double, weight? : Double) -> Double#LossKind
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
pub struct LossSchedule {
initial : Double
decay : Double
floor : Double
step : Int
}#LossSchedule::new
#MarkovTransitionModel
#MarkovTransitionModel::distribution
#MarkovTransitionModel::new
#MarkovTransitionModel::next_state
#MarkovTransitionModel::observe
#MarkovTransitionModel::probability
#MarkovTransitionModel::reset
#MarkovTransitionModel::states
#Matrix
#Matrix::determinant
Compute a determinant with partial pivoting. The method is intended for
small online covariance matrices, not for large dense linear algebra.
#Matrix::multiply_vector
#Matrix::solve
Solve a square linear system using Gaussian elimination with pivoting.
#MetricSeries
Bounded metric history for dashboards and regression tests.
#MetricSnapshot
pub struct MetricSnapshot {
name : String
value : Double
timestamp : Int64
samples : Int
}Production-facing health and SLO primitives for continuously trained models.
#MetricSnapshot::new
fn MetricSnapshot::new(name : String, value : Double, timestamp : Int64, samples? : Int) -> MetricSnapshot#MetricsTracker
pub struct MetricsTracker {
count : Double
sum_squared_error : Double
sum_log_loss : Double
}Incremental metrics tracker.
#MetricsTracker::log_loss
Get the current LogLoss.
#MetricsTracker::mse
Get the current Mean Squared Error (MSE).
#MetricsTracker::update
Update metrics with a new prediction and ground truth label.
#MiniBatchAccumulator
Reusable mini-batch accumulator for callers that need deterministic batch
boundaries while keeping the learner online between flushes.
#MiniBatchAccumulator::add
fn MiniBatchAccumulator::add(self : MiniBatchAccumulator, features : Array[Double], label : Double, weight? : Double) -> Bool#MiniBatchAccumulator::clear
#MiniBatchAccumulator::flush
#MiniBatchAccumulator::new
#MiniBatchAccumulator::ready
#MissingValuePolicy
#ModelArtifact
Lightweight in-process model registry for reproducible experiments.
#ModelArtifact::add_metric
#ModelArtifact::metric
#ModelArtifact::new
fn ModelArtifact::new(name : String, version : String, checksum : String, created_at : String) -> ModelArtifact#ModelArtifact::set_stage
#ModelCard
#ModelCard::add_guarantee
#ModelCard::new
#ModelHealth
pub struct ModelHealth {
accepted : Int
rejected : Int
prediction_errors : Int
inference_failures : Int
latency : MetricSeries
loss : MetricSeries
}#ModelHealth::record_prediction_error
#ModelHealth::record_sample
fn ModelHealth::record_sample(self : ModelHealth, accepted : Bool, loss : Double, latency_ms : Double) -> Unit#ModelMonitor
pub struct ModelMonitor {
name : String
metrics : Map[String, RunningMoments]
rules : Array[AlertRule]
snapshots : Int
alerts : Int
}#ModelMonitor::add_rule
#ModelMonitor::observe
fn ModelMonitor::observe(self : ModelMonitor, snapshot : MetricSnapshot, now : Int64) -> Array[String]#ModelMonitor::variance
#ModelRegistry
#ModelRegistry::get
#ModelRegistry::promote
fn ModelRegistry::promote(self : ModelRegistry, name : String, version : String, stage : String) -> Bool#ModelRegistry::register
#ModelRegistry::versions
#MomentumOptimizer
pub struct MomentumOptimizer {
learning_rate : Double
momentum : Double
dampening : Double
velocity : Array[Double]
clipper : GradientClipper
step_count : Int
}#MomentumOptimizer::apply
fn MomentumOptimizer::apply(self : MomentumOptimizer, parameters : Array[Double], gradients : Array[Double]) -> Unit#MomentumOptimizer::new
fn MomentumOptimizer::new(dimension : Int, learning_rate? : Double, momentum? : Double, dampening? : Double, clipper? : GradientClipper) -> MomentumOptimizer#MomentumOptimizer::update
#MomentumOptimizer::velocity
#MultivariateAnomalyDetector
pub struct MultivariateAnomalyDetector {
moments : VectorMoments
threshold : Double
anomalies : Int
}Diagonal multivariate z-score detector for low-memory edge deployments.
#MultivariateAnomalyDetector::anomalies
#MultivariateAnomalyDetector::mean
#MultivariateAnomalyDetector::new
fn MultivariateAnomalyDetector::new(dimension : Int, threshold? : Double) -> MultivariateAnomalyDetector#MultivariateAnomalyDetector::reset
#MultivariateAnomalyDetector::score
fn MultivariateAnomalyDetector::score(self : MultivariateAnomalyDetector, values : Array[Double]) -> Double#MultivariateAnomalyDetector::update
fn MultivariateAnomalyDetector::update(self : MultivariateAnomalyDetector, values : Array[Double]) -> Bool#ObjectiveKind
#ObjectiveKind::gradient
#ObjectiveKind::loss
#ObjectiveTracker
pub struct ObjectiveTracker {
objective : ObjectiveKind
count : Double
total : Double
last : Double
}#ObjectiveTracker::observe
fn ObjectiveTracker::observe(self : ObjectiveTracker, prediction : Double, label : Double, weight? : Double) -> Unit#OnlineAR
pub struct OnlineAR {
lags : Int
coefficients : Array[Double]
history : SequenceWindow
learning_rate : Double
observations : Int
squared_error : Double
}#OnlineAutoregressive
Online autoregressive model with a fixed lag window.
#OnlineAutoregressive::feature_vector
#OnlineAutoregressive::forecast
#OnlineAutoregressive::history
#OnlineAutoregressive::new
fn OnlineAutoregressive::new(lags : Int, learning_rate? : Double, l2? : Double) -> OnlineAutoregressive#OnlineAutoregressive::predict
#OnlineAutoregressive::reset
#OnlineAutoregressive::steps
#OnlineAutoregressive::update
#OnlineAutoregressive::weights
#OnlineBaggingClassifier
pub struct OnlineBaggingClassifier {
models : Array[AdagradLogisticRegression]
rng : DeterministicRng
observations : Int
}Online bagging around Adagrad logistic learners.
#OnlineBaggingClassifier::member_predictions
fn OnlineBaggingClassifier::member_predictions(self : OnlineBaggingClassifier, features : Array[Double]) -> Array[Double]#OnlineBaggingClassifier::models
#OnlineBaggingClassifier::new
fn OnlineBaggingClassifier::new(model_count : Int, dimension : Int, seed? : UInt64) -> OnlineBaggingClassifier#OnlineBaggingClassifier::observations
#OnlineBaggingClassifier::predict
fn OnlineBaggingClassifier::predict(self : OnlineBaggingClassifier, features : Array[Double]) -> Double#OnlineBaggingClassifier::reset
#OnlineBaggingClassifier::update
fn OnlineBaggingClassifier::update(self : OnlineBaggingClassifier, features : Array[Double], label : Double) -> Unit#OnlineBatchScorer
pub struct OnlineBatchScorer {
endpoint : LinearEndpoint
batcher : RequestBatcher
stats : ServingStats
}#OnlineBatchScorer::endpoint
#OnlineBatchScorer::flush
#OnlineBatchScorer::new
fn OnlineBatchScorer::new(weights : Array[Double], batch_size? : Int, version? : String) -> OnlineBatchScorer#OnlineBatchScorer::stats
#OnlineBatchScorer::submit
fn OnlineBatchScorer::submit(self : OnlineBatchScorer, request : PredictionRequest) -> Array[PredictionResponse]#OnlineBernoulliNB
Bernoulli Naive Bayes for binary sparse-style features.
#OnlineBernoulliNB::feature_probability
fn OnlineBernoulliNB::feature_probability(self : OnlineBernoulliNB, label : Int, index : Int) -> Double#OnlineBernoulliNB::log_scores
fn OnlineBernoulliNB::log_scores(self : OnlineBernoulliNB, features : Array[Double]) -> Array[Double]#OnlineBernoulliNB::new
#OnlineBernoulliNB::predict
#OnlineBernoulliNB::predict_proba
fn OnlineBernoulliNB::predict_proba(self : OnlineBernoulliNB, features : Array[Double]) -> Array[Double]#OnlineBernoulliNB::update
fn OnlineBernoulliNB::update(self : OnlineBernoulliNB, features : Array[Double], label : Int, weight? : Double) -> Bool#OnlineCounter
Generic weighted counters for stream dashboards.
#OnlineCounter::add
#OnlineDecisionStump
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
#OnlineDecisionStump::feature
#OnlineDecisionStump::new
#OnlineDecisionStump::predict
fn OnlineDecisionStump::predict(self : OnlineDecisionStump, features : Array[Double], smoothing? : Double) -> Double#OnlineDecisionStump::threshold
#OnlineDecisionStump::update
fn OnlineDecisionStump::update(self : OnlineDecisionStump, features : Array[Double], label : Double, weight? : Double) -> Unit#OnlineDecisionStump::update_threshold
#OnlineDecisionStump::updates
#OnlineEvaluationSession
pub struct OnlineEvaluationSession {
metrics : MetricsTracker
confusion : ConfusionMatrix
auc_tracker : AucTracker
calibration : CalibrationTracker
regression : RegressionMetrics
}#OnlineEvaluationSession::classification
#OnlineEvaluationSession::observe_binary
fn OnlineEvaluationSession::observe_binary(self : OnlineEvaluationSession, probability : Double, label : Double) -> Unit#OnlineEvaluationSession::observe_regression
fn OnlineEvaluationSession::observe_regression(self : OnlineEvaluationSession, prediction : Double, label : Double) -> Unit#OnlineEvaluationSession::regression
#OnlineEvaluationSession::reset
#OnlineEvaluationSession::summary
#OnlineFeatureSelector
pub struct OnlineFeatureSelector {
moments : VectorMoments
target : RunningMoments
cross : Array[Double]
observations : Double
}Online absolute-correlation tracker for feature monitoring and pruning.
#OnlineFeatureSelector::absolute_importance
#OnlineFeatureSelector::correlations
#OnlineFeatureSelector::dimension
#OnlineFeatureSelector::new
#OnlineFeatureSelector::observations
#OnlineFeatureSelector::rank
#OnlineFeatureSelector::reset
#OnlineFeatureSelector::select
#OnlineFeatureSelector::update
fn OnlineFeatureSelector::update(self : OnlineFeatureSelector, features : Array[Double], target : Double) -> Unit#OnlineGammaRegression
pub struct OnlineGammaRegression {
weights : Array[Double]
learning_rate : Double
l2 : Double
steps : Int
}#OnlineGammaRegression::loss
fn OnlineGammaRegression::loss(self : OnlineGammaRegression, features : Array[Double], value : Double) -> Double#OnlineGammaRegression::new
fn OnlineGammaRegression::new(dimension : Int, learning_rate? : Double, l2? : Double) -> OnlineGammaRegression#OnlineGammaRegression::predict
#OnlineGammaRegression::reset
#OnlineGammaRegression::steps
#OnlineGammaRegression::update
fn OnlineGammaRegression::update(self : OnlineGammaRegression, features : Array[Double], value : Double) -> Unit#OnlineGammaRegression::weights
#OnlineGaussianNB
pub struct OnlineGaussianNB {
classes : Array[GaussianClassStats]
class_counts : Array[Double]
smoothing : Double
steps : Int
}Incremental Gaussian Naive Bayes for categorical labels.
#OnlineGaussianNB::class_counts
#OnlineGaussianNB::log_priors
#OnlineGaussianNB::log_scores
#OnlineGaussianNB::new
#OnlineGaussianNB::predict
#OnlineGaussianNB::predict_proba
fn OnlineGaussianNB::predict_proba(self : OnlineGaussianNB, features : Array[Double]) -> Array[Double]#OnlineGaussianNB::update
fn OnlineGaussianNB::update(self : OnlineGaussianNB, features : Array[Double], label : Int, weight? : Double) -> Bool#OnlineHuberRegression
pub struct OnlineHuberRegression {
weights : Array[Double]
learning_rate : Double
delta : Double
l2 : Double
steps : Int
}Robust online regression using the Huber loss.
#OnlineHuberRegression::loss
fn OnlineHuberRegression::loss(self : OnlineHuberRegression, features : Array[Double], label : Double) -> Double#OnlineHuberRegression::new
fn OnlineHuberRegression::new(dimension : Int, learning_rate? : Double, delta? : Double, l2? : Double) -> OnlineHuberRegression#OnlineHuberRegression::predict
#OnlineHuberRegression::steps
#OnlineHuberRegression::update
fn OnlineHuberRegression::update(self : OnlineHuberRegression, features : Array[Double], label : Double) -> Unit#OnlineHuberRegression::weights
#OnlineIsotonicCalibrator
#OnlineIsotonicCalibrator::new
#OnlineIsotonicCalibrator::predict
#OnlineIsotonicCalibrator::reset
#OnlineIsotonicCalibrator::size
#OnlineIsotonicCalibrator::update
fn OnlineIsotonicCalibrator::update(self : OnlineIsotonicCalibrator, score : Double, label : Double) -> Unit#OnlineKMeans
Streaming k-means with bounded state and optional exponential adaptation.
#OnlineKMeans::centroids
#OnlineKMeans::cluster_counts
#OnlineKMeans::distance_to_nearest
#OnlineKMeans::nearest
#OnlineKMeans::new
#OnlineKMeans::update
#OnlineKernelClassifier
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
fn OnlineKernelClassifier::loss(self : OnlineKernelClassifier, features : Array[Double], label : Double) -> Double#OnlineKernelClassifier::new
fn OnlineKernelClassifier::new(kernel? : KernelKind, budget? : Int, learning_rate? : Double) -> OnlineKernelClassifier#OnlineKernelClassifier::predict
fn OnlineKernelClassifier::predict(self : OnlineKernelClassifier, features : Array[Double]) -> Double#OnlineKernelClassifier::predict_label
fn OnlineKernelClassifier::predict_label(self : OnlineKernelClassifier, features : Array[Double]) -> Double#OnlineKernelClassifier::reset
#OnlineKernelClassifier::score
#OnlineKernelClassifier::support_count
#OnlineKernelClassifier::update
fn OnlineKernelClassifier::update(self : OnlineKernelClassifier, features : Array[Double], label : Double) -> Bool#OnlineKernelClassifier::updates
#OnlineMatrixFactorization
Online matrix factorization for implicit or explicit feedback streams.
#OnlineMatrixFactorization::item_count
#OnlineMatrixFactorization::item_vector
fn OnlineMatrixFactorization::item_vector(self : OnlineMatrixFactorization, item : Int) -> Array[Double]?#OnlineMatrixFactorization::new
fn OnlineMatrixFactorization::new(users : Int, items : Int, rank : Int, learning_rate? : Double, regularization? : Double) -> OnlineMatrixFactorization#OnlineMatrixFactorization::predict
fn OnlineMatrixFactorization::predict(self : OnlineMatrixFactorization, user : Int, item : Int) -> Double#OnlineMatrixFactorization::rank
#OnlineMatrixFactorization::reset
#OnlineMatrixFactorization::update
fn OnlineMatrixFactorization::update(self : OnlineMatrixFactorization, user : Int, item : Int, rating : Double) -> Bool#OnlineMatrixFactorization::updates
#OnlineMatrixFactorization::user_count
#OnlineMatrixFactorization::user_vector
fn OnlineMatrixFactorization::user_vector(self : OnlineMatrixFactorization, user : Int) -> Array[Double]?#OnlineMedoid
pub struct OnlineMedoid {
center : Array[Double]
count : Double
learning_rate : Double
cost : Double
}#OnlineMedoid::new
#OnlineMedoid::update
#OnlinePCA
Online principal-component analysis using Oja's rule.
#OnlinePCA::component_vectors
#OnlinePCA::explained_variance
#OnlinePCA::new
#OnlinePCA::reconstruct
#OnlinePCA::transform
#OnlinePlattScaler
pub struct OnlinePlattScaler {
slope : Double
intercept : Double
learning_rate : Double
steps : Int
}Online Platt scaling for turning arbitrary scores into calibrated
probabilities.
#OnlinePlattScaler::intercept
#OnlinePlattScaler::new
#OnlinePlattScaler::predict
#OnlinePlattScaler::update
#OnlinePoissonRegression
pub struct OnlinePoissonRegression {
weights : Array[Double]
learning_rate : Double
l2 : Double
steps : Int
}Online Poisson regression for count-valued event streams.
#OnlinePoissonRegression::loss
fn OnlinePoissonRegression::loss(self : OnlinePoissonRegression, features : Array[Double], count : Double) -> Double#OnlinePoissonRegression::new
fn OnlinePoissonRegression::new(dimension : Int, learning_rate? : Double, l2? : Double) -> OnlinePoissonRegression#OnlinePoissonRegression::predict
fn OnlinePoissonRegression::predict(self : OnlinePoissonRegression, features : Array[Double]) -> Double#OnlinePoissonRegression::rate
fn OnlinePoissonRegression::rate(self : OnlinePoissonRegression, features : Array[Double]) -> Double#OnlinePoissonRegression::reset
#OnlinePoissonRegression::steps
#OnlinePoissonRegression::update
fn OnlinePoissonRegression::update(self : OnlinePoissonRegression, features : Array[Double], count : Double) -> Unit#OnlinePoissonRegression::weights
#OnlineQuantileInterval
pub struct OnlineQuantileInterval {
lower : OnlineQuantileRegression
upper : OnlineQuantileRegression
observations : Int
}#OnlineQuantileInterval::contains
fn OnlineQuantileInterval::contains(self : OnlineQuantileInterval, features : Array[Double], label : Double) -> Bool#OnlineQuantileInterval::new
fn OnlineQuantileInterval::new(dimension : Int, coverage? : Double, learning_rate? : Double) -> OnlineQuantileInterval#OnlineQuantileInterval::observations
#OnlineQuantileInterval::predict
fn OnlineQuantileInterval::predict(self : OnlineQuantileInterval, features : Array[Double]) -> (Double, Double)#OnlineQuantileInterval::reset
#OnlineQuantileInterval::update
fn OnlineQuantileInterval::update(self : OnlineQuantileInterval, features : Array[Double], label : Double) -> Unit#OnlineQuantileRegression
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
fn OnlineQuantileRegression::new(dimension : Int, quantile? : Double, learning_rate? : Double, l2? : Double) -> OnlineQuantileRegression#OnlineQuantileRegression::pinball_loss
fn OnlineQuantileRegression::pinball_loss(self : OnlineQuantileRegression, features : Array[Double], label : Double) -> Double#OnlineQuantileRegression::predict
fn OnlineQuantileRegression::predict(self : OnlineQuantileRegression, features : Array[Double]) -> Double#OnlineQuantileRegression::quantile
#OnlineQuantileRegression::update
fn OnlineQuantileRegression::update(self : OnlineQuantileRegression, features : Array[Double], label : Double) -> Unit#OnlineQuantileRegression::weights
#OnlineQuantileSketch
#OnlineQuantileSketch::median
#OnlineQuantileSketch::new
#OnlineQuantileSketch::quantile
#OnlineQuantileSketch::reset
#OnlineQuantileSketch::update
#OnlineRidgeRegression
Streaming ridge regression with a diagonal preconditioner.
#OnlineRidgeRegression::dimension
#OnlineRidgeRegression::intercept
#OnlineRidgeRegression::loss
fn OnlineRidgeRegression::loss(self : OnlineRidgeRegression, features : Array[Double], label : Double) -> Double#OnlineRidgeRegression::new
fn OnlineRidgeRegression::new(dimension : Int, learning_rate? : Double, l2? : Double) -> OnlineRidgeRegression#OnlineRidgeRegression::predict
#OnlineRidgeRegression::reset
#OnlineRidgeRegression::residual
fn OnlineRidgeRegression::residual(self : OnlineRidgeRegression, features : Array[Double], label : Double) -> Double#OnlineRidgeRegression::rmse
fn OnlineRidgeRegression::rmse(self : OnlineRidgeRegression, samples : Array[Array[Double]], labels : Array[Double]) -> Double#OnlineRidgeRegression::steps
#OnlineRidgeRegression::update
fn OnlineRidgeRegression::update(self : OnlineRidgeRegression, features : Array[Double], label : Double) -> Unit#OnlineRidgeRegression::update_weighted
fn OnlineRidgeRegression::update_weighted(self : OnlineRidgeRegression, features : Array[Double], label : Double, sample_weight : Double) -> Unit#OnlineRidgeRegression::weights
#OnlineSoftmaxRegression
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
fn OnlineSoftmaxRegression::accuracy_on(self : OnlineSoftmaxRegression, samples : Array[Array[Double]], labels : Array[Int]) -> Double#OnlineSoftmaxRegression::classes
#OnlineSoftmaxRegression::dimension
#OnlineSoftmaxRegression::logits
fn OnlineSoftmaxRegression::logits(self : OnlineSoftmaxRegression, features : Array[Double]) -> Array[Double]#OnlineSoftmaxRegression::loss
fn OnlineSoftmaxRegression::loss(self : OnlineSoftmaxRegression, features : Array[Double], label : Int) -> Double#OnlineSoftmaxRegression::new
fn OnlineSoftmaxRegression::new(classes : Int, dimension : Int, learning_rate? : Double, l2? : Double) -> OnlineSoftmaxRegression#OnlineSoftmaxRegression::predict_class
fn OnlineSoftmaxRegression::predict_class(self : OnlineSoftmaxRegression, features : Array[Double]) -> Int?#OnlineSoftmaxRegression::predict_proba
fn OnlineSoftmaxRegression::predict_proba(self : OnlineSoftmaxRegression, features : Array[Double]) -> Array[Double]#OnlineSoftmaxRegression::predict_top_k
fn OnlineSoftmaxRegression::predict_top_k(self : OnlineSoftmaxRegression, features : Array[Double], k : Int) -> Array[Int]#OnlineSoftmaxRegression::reset
#OnlineSoftmaxRegression::steps
#OnlineSoftmaxRegression::top_k_accuracy
fn OnlineSoftmaxRegression::top_k_accuracy(self : OnlineSoftmaxRegression, samples : Array[Array[Double]], labels : Array[Int], k : Int) -> Double#OnlineSoftmaxRegression::update
fn OnlineSoftmaxRegression::update(self : OnlineSoftmaxRegression, features : Array[Double], label : Int) -> Bool#OnlineSoftmaxRegression::update_weighted
fn OnlineSoftmaxRegression::update_weighted(self : OnlineSoftmaxRegression, features : Array[Double], label : Int, weight : Double) -> Bool#OnlineSoftmaxRegression::weight_norm_squared
#OnlineSoftmaxRegression::weights
#OnlineStumpEnsemble
pub struct OnlineStumpEnsemble {
stumps : Array[OnlineDecisionStump]
rng : DeterministicRng
updates : Int
}A small random stump ensemble for bounded-memory online classification.
#OnlineStumpEnsemble::accuracy
#OnlineStumpEnsemble::feature_indices
#OnlineStumpEnsemble::new
fn OnlineStumpEnsemble::new(stump_count : Int, dimension : Int, seed? : UInt64) -> OnlineStumpEnsemble#OnlineStumpEnsemble::predict
#OnlineStumpEnsemble::predict_label
fn OnlineStumpEnsemble::predict_label(self : OnlineStumpEnsemble, features : Array[Double], threshold? : Double) -> Double#OnlineStumpEnsemble::thresholds
#OnlineStumpEnsemble::update
fn OnlineStumpEnsemble::update(self : OnlineStumpEnsemble, features : Array[Double], label : Double, weight? : Double) -> Unit#OnlineStumpEnsemble::updates
#OptimizerStatistics
pub struct OptimizerStatistics {
steps : Int
gradient_l1 : Double
gradient_l2 : Double
update_l2 : Double
}#OptimizerStatistics::mean_gradient_l1
#OptimizerStatistics::mean_gradient_l2
#OptimizerStatistics::mean_update_l2
#OptimizerStatistics::record
fn OptimizerStatistics::record(self : OptimizerStatistics, gradient : Array[Double], update : Array[Double]) -> Unit#PageHinkleyDetector
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
#PageHinkleyDetector::new
#PageHinkleyDetector::update
#PairwiseRanker
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
fn PairwiseRanker::compare(self : PairwiseRanker, left : Array[Double], right : Array[Double]) -> Double#PairwiseRanker::loss
fn PairwiseRanker::loss(self : PairwiseRanker, positive : Array[Double], negative : Array[Double]) -> Double#PairwiseRanker::new
fn PairwiseRanker::new(dimension : Int, learning_rate? : Double, margin? : Double, l2? : Double) -> PairwiseRanker#PairwiseRanker::score
#PairwiseRanker::update
fn PairwiseRanker::update(self : PairwiseRanker, positive : Array[Double], negative : Array[Double]) -> Bool#PassiveAggressiveRegressor
pub struct PassiveAggressiveRegressor {
weights : Array[Double]
aggressiveness : Double
epsilon : Double
l2 : Double
updates : Int
}Passive-aggressive online regression with robust step sizing.
#PassiveAggressiveRegressor::new
fn PassiveAggressiveRegressor::new(dimension : Int, aggressiveness? : Double, epsilon? : Double, l2? : Double) -> PassiveAggressiveRegressor#PassiveAggressiveRegressor::predict
fn PassiveAggressiveRegressor::predict(self : PassiveAggressiveRegressor, features : Array[Double]) -> Double#PassiveAggressiveRegressor::reset
#PassiveAggressiveRegressor::update
fn PassiveAggressiveRegressor::update(self : PassiveAggressiveRegressor, features : Array[Double], label : Double) -> Bool#PassiveAggressiveRegressor::updates
#PassiveAggressiveRegressor::weights
#PredictionGuard
pub struct PredictionGuard {
lower : Double
upper : Double
repaired : Int
}#PredictionGuard::apply
#PredictionGuard::new
#PredictionRequest
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
#PredictionRequest::new
fn PredictionRequest::new(request_id : String, features : Array[Double], timestamp : Int64, group? : String) -> PredictionRequest#PredictionRequest::request_id
#PredictionRequest::timestamp
#PredictionResponse
pub struct PredictionResponse {
request_id : String
prediction : Double
probability : Double
model_version : String
latency_ms : Double
accepted : Bool
}#PredictionResponse::accepted
#PredictionResponse::latency_ms
#PredictionResponse::model_version
#PredictionResponse::new
fn PredictionResponse::new(request_id : String, prediction : Double, model_version : String, latency_ms? : Double, accepted? : Bool) -> PredictionResponse#PredictionResponse::prediction
#PredictionResponse::probability
#PredictionResponse::request_id
#PredictionSet
#PredictionSet::new
#PredictionSet::probability
#PrivacyBudget
pub struct PrivacyBudget {
total : Double
remaining_budget : Double
queries : Int
rejected : Int
}#PromotionGate
pub struct PromotionGate {
minimum_auc : Double
maximum_log_loss : Double
minimum_samples : Int
}#PromotionGate::accept
#PromotionGate::new
fn PromotionGate::new(minimum_auc? : Double, maximum_log_loss? : Double, minimum_samples? : Int) -> PromotionGate#QualityGate
pub struct QualityGate {
dimension : Int
min_weight : Double
max_weight : Double
allow_nan_like : Bool
}#QualityGate::new
#QualityGate::validate_features
#QualityGate::validate_sample
fn QualityGate::validate_sample(self : QualityGate, features : Array[Double], weight : Double) -> ValidationReport#QualityGate::validate_weight
#QuantileBinner
#QuantileBinner::boundaries
#QuantileBinner::one_hot
#RLS
Recursive Least Squares (RLS) model for online linear regression.
#RLS::new
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
Predict the output for a given feature vector.
#RMSPropOptimizer
pub struct RMSPropOptimizer {
learning_rate : Double
decay : Double
epsilon : Double
mean_square : Array[Double]
clipper : GradientClipper
step_count : Int
}#RMSPropOptimizer::apply
fn RMSPropOptimizer::apply(self : RMSPropOptimizer, parameters : Array[Double], gradients : Array[Double]) -> Unit#RMSPropOptimizer::mean_square
#RMSPropOptimizer::new
fn RMSPropOptimizer::new(dimension : Int, learning_rate? : Double, decay? : Double, epsilon? : Double, clipper? : GradientClipper) -> RMSPropOptimizer#RMSPropOptimizer::update
#RandomFourierFeatures
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
#RandomFourierFeatures::new
fn RandomFourierFeatures::new(input_dimension : Int, output_dimension : Int, width? : Double, seed? : UInt64) -> RandomFourierFeatures#RandomFourierFeatures::output_dimension
#RandomFourierFeatures::transform
fn RandomFourierFeatures::transform(self : RandomFourierFeatures, features : Array[Double]) -> Array[Double]#RandomFourierFeatures::weight_matrix
#RankingMetrics
pub struct RankingMetrics {
queries : Double
reciprocal_rank : Double
ndcg_sum : Double
hits : Array[Double]
}#RankingMetrics::observe
#RankingMetrics::recall_at
#RateLimiter
pub struct RateLimiter {
limit : Int
period : Int
ticks : Int
accepted : Int
}#RegressionMetrics
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::maximum_error
#RegressionMetrics::minimum_error
#RegressionMetrics::update
fn RegressionMetrics::update(self : RegressionMetrics, prediction : Double, label : Double, weight? : Double) -> Unit#Regularizer
pub struct Regularizer {
l1 : Double
l2 : Double
}#Regularizer::gradient
#Regularizer::penalty
#Regularizer::proximal
#ReproducibilityManifest
pub struct ReproducibilityManifest {
model : String
version : String
source_checksum : String
data_checksum : String
seed : Int
parameters : Map[String, String]
}#ReproducibilityManifest::data_checksum
#ReproducibilityManifest::fingerprint
#ReproducibilityManifest::model
#ReproducibilityManifest::new
fn ReproducibilityManifest::new(model : String, version : String, source_checksum : String, data_checksum : String, seed : Int) -> ReproducibilityManifest#ReproducibilityManifest::parameter
#ReproducibilityManifest::parameter_count
#ReproducibilityManifest::seed
#ReproducibilityManifest::set
fn ReproducibilityManifest::set(self : ReproducibilityManifest, key : String, value : String) -> Unit#ReproducibilityManifest::source_checksum
#ReproducibilityManifest::version
#RequestBatcher
pub struct RequestBatcher {
capacity : Int
requests : Array[PredictionRequest]
flushed : Int
dropped : Int
}#RequestBatcher::add
#RequestBatcher::flush
#ReservoirSampler
pub struct ReservoirSampler {
capacity : Int
values : Array[Double]
seen : Int
rng : DeterministicRng
}#ReservoirSampler::new
#ReservoirSampler::observe
#ReservoirSampler::sample
#RollbackPolicy
pub struct RollbackPolicy {
minimum_accuracy : Double
maximum_loss : Double
maximum_error_rate : Double
}#RollbackPolicy::new
fn RollbackPolicy::new(minimum_accuracy? : Double, maximum_loss? : Double, maximum_error_rate? : Double) -> RollbackPolicy#RollbackPolicy::should_rollback
fn RollbackPolicy::should_rollback(self : RollbackPolicy, accuracy : Double, loss : Double, error_rate : Double) -> Bool#RollingWindow
#RollingWindow::push
fn RollingWindow::push(self : RollingWindow, features : Array[Double], label : Double, weight? : Double) -> Bool#RunningMean
pub struct RunningMean {
count : Double
mean : Double
}#RunningMoments
pub struct RunningMoments {
count : Double
mean : Double
m2 : Double
minimum : Double
maximum : Double
}Numerically stable scalar moments using Welford's recurrence.
#RunningMoments::merge
#RunningMoments::population_variance
#RunningMoments::standard_deviation
#RunningMoments::update
#RunningMoments::z_score
#SGDLogisticRegression
Online Logistic Regression using Stochastic Gradient Descent.
#SGDLogisticRegression::new
Create a new SGD Logistic Regression model.
#SGDLogisticRegression::predict
Predict the probability (0 to 1) for a given feature vector.
#SGDLogisticRegression::update
fn SGDLogisticRegression::update(self : SGDLogisticRegression, features : Array[Double], label : Double) -> UnitUpdate the model with a single sample (features and label).
Label should be 0.0 or 1.0.
#SeasonalMean
Seasonal baseline using per-phase running means.
#SeasonalMean::forecast
#SequenceFeatureBuilder
pub struct SequenceFeatureBuilder {
lags : Int
include_delta : Bool
include_mean : Bool
include_variance : Bool
window : SequenceWindow
}#SequenceFeatureBuilder::feature_count
#SequenceFeatureBuilder::new
fn SequenceFeatureBuilder::new(lags : Int, include_delta? : Bool, include_mean? : Bool, include_variance? : Bool) -> SequenceFeatureBuilder#SequenceFeatureBuilder::reset
#SequenceFeatureBuilder::transform
fn SequenceFeatureBuilder::transform(self : SequenceFeatureBuilder, value : Double) -> Array[Double]#SequenceWindow
pub struct SequenceWindow {
capacity : Int
values : Array[Double]
total : Double
sum_squares : Double
}Compact sequence-learning primitives for event streams and demand signals.
#ServingStats
pub struct ServingStats {
requests : Int
successes : Int
failures : Int
total_latency : Double
max_latency : Double
bytes : Int
}#ServingStats::observe
fn ServingStats::observe(self : ServingStats, response : PredictionResponse, payload_bytes? : Int) -> Unit#ShadowEvaluator
pub struct ShadowEvaluator {
primary_version : String
shadow_version : String
comparisons : Int
disagreements : Int
absolute_difference : Double
}#ShadowEvaluator::disagreement_rate
#ShadowEvaluator::disagreements
#ShadowEvaluator::mean_absolute_difference
#ShadowEvaluator::new
#ShadowEvaluator::observe
fn ShadowEvaluator::observe(self : ShadowEvaluator, primary : Double, shadow : Double, tolerance? : Double) -> Bool#ShadowEvaluator::versions
#SnapshotCatalog
#SnapshotCatalog::get
#SnapshotCatalog::put
#SnapshotEnvelope
A small, versioned envelope for application-owned model snapshots.
#SnapshotEnvelope::is_compatible
fn SnapshotEnvelope::is_compatible(self : SnapshotEnvelope, schema : String, model : String) -> Bool#SnapshotEnvelope::new
fn SnapshotEnvelope::new(schema : String, model : String, version : String, payload : String, checksum : String) -> SnapshotEnvelope#SnapshotEnvelope::to_json_string
#SparseAccumulator
#SparseAccumulator::add
#SparseAccumulator::get
#SparseAccumulator::to_vector
#SparseAdagradClassifier
Sparse Adagrad logistic regression with a dense accumulator for predictable
inference and sparse updates.
#SparseAdagradClassifier::new
fn SparseAdagradClassifier::new(dimension : Int, learning_rate? : Double, epsilon? : Double, l2? : Double) -> SparseAdagradClassifier#SparseAdagradClassifier::predict
fn SparseAdagradClassifier::predict(self : SparseAdagradClassifier, features : SparseVector) -> Double#SparseAdagradClassifier::reset
#SparseAdagradClassifier::steps
#SparseAdagradClassifier::update
fn SparseAdagradClassifier::update(self : SparseAdagradClassifier, features : SparseVector, label : Double) -> Unit#SparseAdagradClassifier::weight
#SparseAdagradClassifier::weights
#SparseEntry
A sparse feature entry. Indices are zero-based and values equal to zero
are omitted from canonical sparse vectors.
#SparseFTRL
FTRL-Proximal for sparse vectors. Only non-zero coordinates are touched
during an update, which keeps the per-event cost O(nnz).
#SparseFTRL::new
fn SparseFTRL::new(dimension : Int, alpha? : Double, beta? : Double, l1? : Double, l2? : Double) -> SparseFTRL#SparseFTRL::non_zero_weights
#SparseFTRL::predict
#SparseFTRL::update
#SparseVector
pub struct SparseVector {
dimension : Int
entries : Array[SparseEntry]
} derive(ToJson, Debug, FromJson)#SparseVector::add
#SparseVector::cosine
#SparseVector::distance_squared
#SparseVector::dot_dense
#SparseVector::dot_sparse
#SparseVector::from_dense
#SparseVector::from_entries
#SparseVector::map
#SparseVector::scale
#SparseVector::set
#SparseVector::subtract
#SparseVector::threshold
#StabilityTracker
#StabilityTracker::mean_drift
#StabilityTracker::observations
#StabilityTracker::observe
#Standardizer
A standardizer that tracks running mean and variance to standardize features incrementally
using Welford's online algorithm.
#Standardizer::mean
Return a copy of the current running means.
#Standardizer::new
Create a new feature standardizer for dim features.
#Standardizer::update_and_transform
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
Return the unbiased running variance for every feature.
#StratifiedSampler
pub struct StratifiedSampler {
capacity_per_class : Int
samples : Map[Int, Array[Array[Double]]]
seen : Int
rng : DeterministicRng
}#StratifiedSampler::class_count
#StratifiedSampler::classes
#StratifiedSampler::new
#StratifiedSampler::observe
fn StratifiedSampler::observe(self : StratifiedSampler, label : Int, features : Array[Double]) -> Bool#StratifiedSampler::samples
#StreamCounters
pub struct StreamCounters {
rows : Int
accepted : Int
rejected : Int
positive : Int
negative : Int
}#StreamCounters::acceptance_rate
#StreamCounters::observe
#StreamWatermark
pub struct StreamWatermark {
current : Int64
allowed_lateness : Int64
late_events : Int
}#StreamWatermark::observe
#TargetEncoder
pub struct TargetEncoder {
sums : Map[String, Double]
counts : Map[String, Double]
prior : RunningMean
smoothing : Double
}#TargetEncoder::encode
#TargetEncoder::known_categories
#TargetEncoder::update
fn TargetEncoder::update(self : TargetEncoder, category : String, target : Double, weight? : Double) -> Unit#TextStatistics
#TextStatistics::frequency
#TextStatistics::observe
#TextStatistics::top_words
#TextStatistics::vocabulary_size
#ThresholdOptimizer
pub struct ThresholdOptimizer {
costs : ClassCost
minimum : Double
maximum : Double
steps : Int
best_threshold : Double
best_cost : Double
}#ThresholdOptimizer::fit
fn ThresholdOptimizer::fit(self : ThresholdOptimizer, predictions : Array[Double], labels : Array[Double]) -> Double#ThresholdOptimizer::new
fn ThresholdOptimizer::new(costs? : ClassCost, minimum? : Double, maximum? : Double, steps? : Int) -> ThresholdOptimizer#ThresholdOptimizer::threshold
#ThroughputTracker
#ThroughputTracker::observe
#ThroughputTracker::rate
#TimeWindowAggregate
pub struct TimeWindowAggregate {
start : Int64
end : Int64
events : Int
positives : Double
weight : Double
loss : RegressionMetrics
}#TimeWindowAggregate::contains
#TimeWindowAggregate::new
#TimeWindowAggregate::observe
fn TimeWindowAggregate::observe(self : TimeWindowAggregate, event : TrainingEvent, prediction : Double) -> Bool#TimeWindowAggregate::weighted_positive_rate
#TopKMetrics
#TopKMetrics::update
#TrafficSplitter
#TrafficSplitter::route
#TrafficSplitter::set
#TrafficSplitter::share
#TrainingEvent
Immutable training event that can be replayed for deterministic validation.
#TrainingEvent::new
fn TrainingEvent::new(id : String, timestamp : Int64, features : Array[Double], label : Double, weight? : Double) -> TrainingEvent#TrainingReport
#TrainingReport::record
#ValidationReport
#VectorMoments
Per-feature running statistics for dense streams.
#VectorMoments::moment
#VectorMoments::standardize
#VectorMoments::update
#WeightedHistogram
#WeightedHistogram::counts
#WeightedHistogram::new
#WeightedHistogram::observe
#WeightedHistogram::probabilities
#WeightedHistogram::quantile
#WeightedProbabilityEnsemble
Weighted probability ensemble with online expert reweighting.
#WeightedProbabilityEnsemble::experts
#WeightedProbabilityEnsemble::new
#WeightedProbabilityEnsemble::normalized_weights
fn WeightedProbabilityEnsemble::normalized_weights(self : WeightedProbabilityEnsemble) -> Array[Double]#WeightedProbabilityEnsemble::observations
#WeightedProbabilityEnsemble::predict
fn WeightedProbabilityEnsemble::predict(self : WeightedProbabilityEnsemble, predictions : Array[Double]) -> Double#WeightedProbabilityEnsemble::reset
#WeightedProbabilityEnsemble::update
fn WeightedProbabilityEnsemble::update(self : WeightedProbabilityEnsemble, predictions : Array[Double], label : Double, learning_rate? : Double) -> Unit#WeightedProbabilityEnsemble::weights
#add_scaled_in_place
#all_close
#append_interactions
#cost_sensitive_decision
#dot_product_checked
#evaluate_binary
#evaluate_regression
#expected_binary_cost
fn expected_binary_cost(probability : Double, positive_cost : Double, negative_cost : Double) -> Double#explain_linear
fn explain_linear(weights : Array[Double], features : Array[Double], top_k? : Int) -> Array[FeatureAttribution]#explain_sparse
fn explain_sparse(weights : SparseVector, features : SparseVector, top_k? : Int) -> Array[FeatureAttribution]#generate_feature_crosses
#hadamard_product
#loss_gradient
fn loss_gradient(kind : LossKind, prediction : Double, label : Double, parameter? : Double) -> Double#loss_gradient_vector
#loss_value
#make_snapshot
#moving_average
fn moving_average(previous : Double, value : Double, smoothing : Double) -> Double#pairwise_interactions
#polynomial_features
Stateless numeric feature engineering helpers.
#probabilities_from_logits
#rank_one_update
#split_indices
#subtract_scaled_in_place
#subtract_values
#train_adagrad
fn train_adagrad(model : AdagradLogisticRegression, batch : DataBatch, report : TrainingReport) -> TrainingReportTrain a dense Adagrad classifier over a batch and return an auditable
report. The function keeps the event loop explicit for easy replay.
#train_ridge
fn train_ridge(model : OnlineRidgeRegression, batch : DataBatch, report : TrainingReport) -> TrainingReport#weighted_loss
Source Files
- adagrad_model.mbt
- aggregation.mbt
- audit_logging.mbt
- batch_learning.mbt
- bayes_models.mbt
- calibration_models.mbt
- cost_sensitive.mbt
- count_models.mbt
- data_quality.mbt
- data_stream.mbt
- drift_detectors.mbt
- ensembles.mbt
- event_stream.mbt
- experiment.mbt
- explainability.mbt
- fairness.mbt
- feature_engineering.mbt
- feature_selection.mbt
- feature_store.mbt
- ftrl.mbt
- kernel_models.mbt
- linear_algebra.mbt
- logistic_regression.mbt
- losses.mbt
- metrics.mbt
- metrics_advanced.mbt
- model_lifecycle.mbt
- model_registry.mbt
- monitoring.mbt
- objective_functions.mbt
- online_clustering.mbt
- online_factorization.mbt
- online_hashing.mbt
- online_ranking.mbt
- optimizers.mbt
- pca.mbt
- pipeline.mbt
- ridge_models.mbt
- rls.mbt
- sampling.mbt
- sequence_models.mbt
- serialization_utils.mbt
- serving.mbt
- softmax.mbt
- sparse.mbt
- sparse_models.mbt
- standardizer.mbt
- stream_join.mbt
- stream_statistics.mbt
- time_series.mbt
- training_utilities.mbt
- traits.mbt
- tree_models.mbt
- uncertainty.mbt
- validation.mbt
- vectors.mbt
A native MoonBit toolkit for online learning, sparse and dense models, streaming features, evaluation, monitoring, serving, and reproducible model lifecycle workflows.
machine-learningregressiononline-learningincremental-learningclassificationstreaming-datamodel-monitoringmoonbit
0.2.0
Apache-2.0
Updated 6 hours ago
3 downloads