Struct MetaTrainingReport 

pub struct MetaTrainingReport {
    pub iterations: usize,
    pub initial_meta_loss: f64,
    pub final_meta_loss: f64,
    pub loss_history: Vec<f64>,
    pub initial_validation_loss: Option<f64>,
    pub final_validation_loss: Option<f64>,
    pub validation_history: Vec<f64>,
    pub selection_metric: SelectionMetric,
    pub gradient_norms: Vec<f64>,
    pub weight_count: usize,
}

What a meta-training run measured.

Every field is an observation, not a target: final_meta_loss is the value the kept weights actually achieve on the training tasks, and Self::improved is the honest answer to “did this help”, judged by whichever criterion Self::selection_metric names.

Fields

iterations: usize

ES iterations completed.

initial_meta_loss: f64

Training meta-loss of the weights the trainer started from.

final_meta_loss: f64

Training meta-loss of the weights the trainer kept.

loss_history: Vec<f64>

Training meta-loss after each iteration, in order.

initial_validation_loss: Option<f64>

Validation meta-loss of the starting weights, if validation tasks were supplied.

final_validation_loss: Option<f64>

Validation meta-loss of the weights the trainer kept.

validation_history: Vec<f64>

Validation meta-loss after each iteration, if validation tasks were supplied.

selection_metric: SelectionMetric

Which loss chose the kept weights.

gradient_norms: Vec<f64>

Euclidean norm of the estimated meta-gradient at each iteration.

weight_count: usize

Number of learned weights being optimized.

Implementations

impl MetaTrainingReport

pub fn improved(&self) -> bool

Whether the run left the optimizer better than it found it, judged by the selection metric.

This is weaker than it sounds under SelectionMetric::TrainingLoss

With no validation tasks there is nothing to compare the training loss against, so improved() == true means only “it fits the training tasks better” — which is exactly what an overfitting run also reports. The NTM controller was measured driving its training meta-loss down ~30% while making a held-out task 40x worse; that run returns true here, and under TrainingLoss Self::relative_improvement and Self::relative_training_improvement are the same number, so the report carries no signal that separates the two cases.

To get a claim about generalisation, train through EsMetaTrainer::train_with_validation: the metric becomes SelectionMetric::ValidationLoss, and the gap between relative_improvement() and relative_training_improvement() becomes the overfitting measurement. Check Self::selection_metric before trusting this method as a generalisation result.

pub fn relative_improvement(&self) -> f64

Fractional reduction in the selection metric (negative if training made it worse).

pub fn relative_training_improvement(&self) -> f64

Fractional reduction in the training meta-loss specifically.

Comparing this against Self::relative_improvement under SelectionMetric::ValidationLoss is how a caller sees overfitting: a large training improvement next to a small validation one means the run specialised to the training family.

Trait Implementations

impl Clone for MetaTrainingReport

fn clone(&self) -> Self

Returns a duplicate of the value.

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

Performs copy-assignment from source.

impl Debug for MetaTrainingReport

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

Formats the value using the given formatter.