Struct MetaLearner 

pub struct MetaLearner {
    pub config: MetaLearnerConfig,
    pub meta_params: MetaParameters,
    pub task_history: HashMap<TaskId, TaskAdaptation>,
    pub meta_step: u64,
}

MAML-inspired meta-learner.

Overview

• MetaLearner::adapt_to_task runs the inner loop: starting from the shared meta_params it takes config.inner_steps gradient-descent steps on the support set of the given task and evaluates the adapted model on the query set.
• MetaLearner::meta_update runs the outer loop: given a batch of TaskAdaptations it averages the adapted weights, computes a meta-gradient (direction from current meta-weights to the average), and updates meta_params with config.meta_lr.
• MetaLearner::predict performs linear inference.

Fields

config: MetaLearnerConfig

Hyper-parameters that control the learning algorithm.

meta_params: MetaParameters

Shared meta-parameters (the “good initialisation” learned by MAML).

task_history: HashMap<TaskId, TaskAdaptation>

Per-task adaptation results keyed by TaskId.

meta_step: u64

Count of completed outer meta-update steps.

Implementations

impl MetaLearner

pub fn new(config: MetaLearnerConfig) -> Self

Create a new MetaLearner with weights initialised using xorshift64.

Each weight is set to xorshift64(state) as f64 / u64::MAX as f64 * 0.01 so that the initial values are small random numbers in [0, 0.01).

pub fn loss(prediction: f64, label: f64, task_type: &TaskType) -> f64

Compute the scalar loss for a single prediction/label pair.

task_type	loss formula
Classification	max(0, 1 - label * tanh(prediction))
Regression	(prediction - label)²
Ranking	max(0, 1 - prediction * label)

pub fn gradient( features: &[f64], prediction: f64, label: f64, ) -> (Vec<f64>, f64)

Compute the gradient of the MSE loss with respect to the linear model parameters (weights and bias).

Returns (dL/dw, dL/db) where dL/dw[i] = 2*(prediction-label)*features[i] and dL/db = 2*(prediction-label).

pub fn predict( &self, features: &[f64], adaptation: Option<&TaskAdaptation>, ) -> Result<f64, MetaError>

Perform a linear prediction using either the meta-parameters or, if adaptation is Some, the task-adapted parameters.

Errors

Returns MetaError::DimensionMismatch if features.len() != config.dims.

pub fn adapt_to_task( &mut self, task: &MetaTask, ) -> Result<TaskAdaptation, MetaError>

Run the inner loop for task: adapt from meta_params using the support set, then evaluate on the query set.

The resulting TaskAdaptation is stored in task_history and returned to the caller.

Errors

• MetaError::EmptySupportSet — if the task support set is empty.
• MetaError::EmptyQuerySet — if the task query set is empty.
• MetaError::DimensionMismatch — if any example has the wrong number of features.

pub fn meta_update( &mut self, adaptations: &[TaskAdaptation], ) -> Result<(), MetaError>

Run the outer loop (meta-update).

Averages adapted_weights across all provided adaptations, then computes a meta-gradient as the direction from current meta-weights to that average and applies a single gradient-descent step with meta_lr.

Errors

• MetaError::NoAdaptations — if adaptations is empty.
• MetaError::DimensionMismatch — if any adaptation has the wrong number of weight dimensions.

pub fn task_similarity(a: &TaskAdaptation, b: &TaskAdaptation) -> f64

Compute the cosine similarity between the adapted_weights of two task adaptations. Returns 0.0 if either weight vector is all-zero.

pub fn best_task(&self) -> Option<(&TaskId, &TaskAdaptation)>

Return the task with the lowest query loss from the history, or None if the history is empty.

pub fn reset_task(&mut self, task_id: &TaskId)

Remove the stored adaptation for task_id from the history.

pub fn stats(&self) -> MetaLearnerStats

Compute aggregate statistics over the current task history.