Understanding the meta-learning problem structure, with its tasks, support sets ( $S_i$ ), and query sets ( $Q_i$ ), is the first step. Now, we need a way to organize the diverse array of algorithms designed to solve this problem. Meta-learning algorithms are typically categorized into three main families based on their core mechanism for enabling fast adaptation. These categories provide a useful framework, although some algorithms might incorporate elements from more than one. The primary perspectives are:

Gradient-Based Meta-Learning: These methods learn model parameters (often an initialization) such that new tasks can be learned efficiently with only a few gradient steps using the task-specific support set.
Metric-Based Meta-Learning: These approaches learn an embedding function or a metric space where examples from the same class cluster together, allowing classification or regression on the query set based on similarity to support set examples.
Optimization-Based Meta-Learning: This category explicitly frames meta-learning as an optimization problem, often involving learning the optimizer itself or related hyperparameters to facilitate rapid learning on new tasks.

Let's examine each category in more detail.

A categorization of common meta-learning approaches based on their primary mechanism for achieving fast adaptation.

Gradient-Based Meta-Learning

Algorithms in this family aim to find a set of initial model parameters $\theta$ that are highly sensitive to changes based on new task data. The meta-objective is typically to minimize the loss on the query sets $Q_i$ after a small number of gradient updates have been performed using the corresponding support sets $S_i$ .

The most prominent example is Model-Agnostic Meta-Learning (MAML). In MAML, for each task $T_i$ sampled during meta-training, an inner loop performs one or more standard gradient descent steps on the support set $S_i$ to obtain task-adapted parameters $\theta_i'$ .

\theta_i' = \theta - \alpha \nabla_{\theta} \mathcal{L}_{S_i}(\theta)

The outer loop then updates the initial parameters $\theta$ by differentiating through this inner update step, using the performance on the query set $Q_i$ . This requires computing second-order derivatives (gradients of gradients), often referred to as the meta-gradient.

\theta \leftarrow \theta - \beta \nabla_{\theta} \sum_{T_i} \mathcal{L}_{Q_i}(\theta_i') = \theta - \beta \sum_{T_i} \nabla_{\theta} \mathcal{L}_{Q_i}(\theta - \alpha \nabla_{\theta} \mathcal{L}_{S_i}(\theta))

Variants like First-Order MAML (FOMAML) and Reptile simplify this by ignoring second-order terms, significantly reducing computational cost but potentially altering the optimization dynamics. Implicit MAML (iMAML) uses implicit differentiation to compute meta-gradients more stably and efficiently, particularly for many inner steps.

For foundation models, the high dimensionality of $\theta$ makes computing and storing full second-order gradients extremely expensive. This motivates the use of first-order approximations or techniques specifically designed for scale, which we will examine in Chapter 2.

Metric-Based Meta-Learning

Instead of optimizing parameters for gradient updates, metric-based methods learn an embedding function $f_{\phi}$ that maps inputs into a space where similarity corresponds to class membership or task relevance. Adaptation typically involves comparing query examples to support examples in this learned space using a distance metric (e.g., Euclidean distance) or a learned similarity function.

Prototypical Networks are a well-known example. They compute a single "prototype" representation $c_k$ for each class $k$ present in the support set $S_i$ by averaging the embeddings of its examples: $c_k = \frac{1}{|S_{i,k}|} \sum_{x_j \in S_{i,k}} f_{\phi}(x_j)$ . Classification of a query point $x_q$ is then done via a softmax over distances to the prototypes:

p(y=k | x_q) = \frac{\exp(-d(f_{\phi}(x_q), c_k))}{\sum_{k'} \exp(-d(f_{\phi}(x_q), c_{k'}))}

Other notable approaches include Matching Networks, which use attention mechanisms to compute weighted combinations of support set examples for query prediction, and Relation Networks, which employ a separate neural network module to learn a non-linear similarity score between query and support example embeddings.

These methods often rely heavily on the quality of the learned embedding function $f_{\phi}$ . When working with foundation models, one might leverage the powerful pre-trained representations directly or fine-tune the embedding function during meta-training. Adapting these techniques to extremely high-dimensional embeddings from foundation models presents unique challenges, explored further in Chapter 3.

Optimization-Based Meta-Learning

This perspective views meta-learning more broadly as learning aspects of the optimization process itself. Instead of just learning an initial parameter set $\theta$ , these methods might learn the update rule, the learning rates, or other optimization hyperparameters.

One line of work is Learning to Optimize (L2O), where a separate neural network (the meta-learner, often an RNN like LSTM) is trained to output the parameter updates for the base model (the learner). The meta-learner observes the gradients and states of the learner and proposes updates $\Delta \theta_t$ intended to minimize the task loss rapidly.

\theta_{t+1} = \theta_t + \Delta \theta_t \quad \text{where} \quad \Delta \theta_t = g_{\psi}(\nabla_{\theta_t} \mathcal{L}(\theta_t), h_t)

Here, $g_{\psi}$ is the meta-learner parameterized by $\psi$ , and $h_t$ is its internal state. The parameters $\psi$ are trained across many tasks to produce efficient optimization trajectories.

Furthermore, many meta-learning algorithms, including MAML, can be formally understood through the lens of Bilevel Optimization. The outer optimization adjusts meta-parameters (like initial weights $\theta$ in MAML, or the meta-learner $\psi$ in L2O) to minimize an outer objective (e.g., query set loss after adaptation). The inner optimization adapts parameters to a specific task (e.g., minimizing support set loss). This viewpoint, discussed in Chapter 4, provides a powerful framework for analyzing and developing meta-learning algorithms. Learning optimal initializations, while often associated with gradient-based methods, is also fundamentally an optimization problem addressed within this framework.

Choosing an Approach

Each category has strengths and weaknesses. Gradient-based methods directly optimize for adaptation performance via gradients but can be computationally intensive and sensitive to optimization details. Metric-based methods are often simpler to implement and computationally cheaper at test time but rely heavily on the quality of the embedding space and the chosen metric. Optimization-based methods offer flexibility in tailoring the learning process but can be complex to train and analyze.

The choice often depends on the specific problem, the nature of the tasks, computational budget, and whether the goal is primarily fast adaptation of existing parameters or learning effective representations from scratch. In the context of foundation models, scalability and efficient use of pre-trained knowledge become primary considerations, influencing the suitability of different approaches and motivating hybrid strategies or specialized adaptation techniques, as we will see in later chapters. Understanding these fundamental categories is essential for navigating the advanced techniques required for adapting large-scale models effectively.