Struct Calibration 

pub struct Calibration {
    pub n: usize,
    pub brier: f64,
    pub log_loss: f64,
    pub skill: f64,
    pub bins: Vec<ReliabilityBin>,
    pub check_n: usize,
    pub check_skill: f64,
    pub check_log_loss: f64,
    pub hit_rate: f64,
    pub by_provenance: Vec<ProvenanceScore>,
}

Calibration summary over a set of forecasts.

Fields

n: usize

Forecasts scored.

brier: f64

Prequential Brier score, mean (p_chosen − 1)². Lower is better; 0.25 is the always-0.5 baseline.

log_loss: f64

Prequential log-loss, mean −ln p_chosen, in nats. Lower is better; ln 2 ≈ 0.693 is the always-0.5 baseline.

Comparable across time for one acquisition rule, and not comparable across acquisition rules: an information-seeking rule deliberately serves duels near p = 0.5, which carry the highest log-loss by construction. Comparing rules on their own self-chosen question sets would score the willingness to ask hard questions as a failure. Use check_log_loss for that.

skill: f64

Brier skill against a coin flip, 1 − B/0.25. 0 = no better than chance, 1 = perfect and certain, negative = worse than a coin.

bins: Vec<ReliabilityBin>

Reliability diagram buckets over P(A wins).

check_n: usize

Forecasts among the uniformly-random check duels.

check_skill: f64

Brier skill restricted to the check duels — the selection-bias-free number.

check_log_loss: f64

Log-loss restricted to the uniformly-random check duels, in nats. The only log-loss here that means the same thing under any acquisition rule.

hit_rate: f64

Running hit rate, kept only so a frontend can show how misleading it is next to the skill score.

by_provenance: Vec<ProvenanceScore>

The same scores, split by how the answer was collected. Empty streams are omitted, so a session that has never committed a hand edit carries exactly one row and reads as it always did.

Trait Implementations

impl Clone for Calibration

fn clone(&self) -> Calibration

Returns a duplicate of the value.

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

Performs copy-assignment from source.

impl Debug for Calibration

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

Formats the value using the given formatter.

impl<'de> Deserialize<'de> for Calibration

fn deserialize<__D>(__deserializer: __D) -> Result<Self, __D::Error>

where __D: Deserializer<'de>,

Deserialize this value from the given Serde deserializer.

impl Serialize for Calibration

fn serialize<__S>(&self, __serializer: __S) -> Result<__S::Ok, __S::Error>

where __S: Serializer,

Serialize this value into the given Serde serializer.