Meta-Learning
Last reviewed
Jun 1, 2026
Sources
18 citations
Review status
Source-backed
Revision
v7 · 5,623 words
Improve this article
Add missing citations, update stale details, or suggest a clearer explanation.
Suggest edit
CtrlK
Last reviewed
Jun 1, 2026
Sources
18 citations
Review status
Source-backed
Revision
v7 · 5,623 words
Add missing citations, update stale details, or suggest a clearer explanation.
See also: Machine learning terms, Few-shot learning, Transfer learning
Meta-learning, also referred to as "learning to learn", is an advanced paradigm in the field of machine learning that focuses on the design of algorithms and models capable of improving their performance on new tasks by utilizing previous learning experiences. The primary objective of meta-learning is to develop models that can adapt quickly to new tasks with minimal data and training time. Rather than training a model from scratch for every new problem, meta-learning systems extract generalizable knowledge across a distribution of tasks so that encountering a novel task requires only a small number of examples or gradient steps to achieve strong performance.
The term "learning to learn" captures the core intuition: just as humans draw on prior experience when picking up a new skill, meta-learning algorithms accumulate structural knowledge (such as good initial parameters, effective distance metrics, or useful learning rules) that accelerates future learning. This idea has roots in early work by Schmidhuber (1987),[1] Thrun and Pratt (1998),[2] and Hochreiter et al. (2001), but the field experienced a resurgence starting around 2016 with the introduction of modern deep learning-based approaches.
At its core, meta-learning operates at two levels. The first level is the base learner, which solves individual tasks (for example, classifying images of a particular set of categories). The second level is the meta-learner, which learns across tasks to improve the base learner's ability to adapt. This two-level structure is what distinguishes meta-learning from conventional machine learning and even from transfer learning, which reuses features from a source task but does not explicitly optimize the learning process itself.
Machine learning has made significant progress in recent years, enabling the development of models that can achieve state-of-the-art performance on various tasks, such as image recognition, natural language processing, and reinforcement learning. However, traditional machine learning models often require extensive amounts of data and computational resources to achieve high performance. Moreover, these models are typically designed for a specific task, and their ability to generalize to new tasks is limited. Meta-learning addresses these limitations by seeking to develop models that can learn more effectively from limited data and can adapt to novel tasks more rapidly.
Conventional supervised learning assumes that training and test data come from the same distribution. When a model trained on one task is deployed on a different task, performance typically degrades unless substantial retraining is performed. Transfer learning partially addresses this by pre-training on a large source dataset and fine-tuning on a target task, but it still requires a meaningful amount of labeled target data. Meta-learning goes further by explicitly optimizing the learning procedure itself, enabling adaptation from as few as one or five examples per class.
The meta-learning literature can be understood through three complementary perspectives, each describing what the meta-learner learns:
| Perspective | What is Learned | Representative Methods | Core Idea |
|---|---|---|---|
| Learning good initial parameters | A parameter initialization from which few gradient steps yield strong task performance | MAML, Reptile, Meta-SGD | Find a point in parameter space close to the optima of many tasks |
| Learning the optimizer | An update rule or optimization algorithm tailored for rapid adaptation | Meta-Learner LSTM, Learning to Optimize | Replace hand-designed optimizers with learned update rules |
| Learning the metric space | An embedding function and distance metric for comparing examples | Prototypical Networks, Matching Networks, Relation Networks | Map inputs to a space where nearest-neighbor classification works well |
These perspectives are not mutually exclusive. Some methods combine elements from multiple perspectives. For instance, Meta-SGD learns both an initialization and a per-parameter learning rate, bridging the first two perspectives.
A central concept in meta-learning is episodic training (also called task-based training). Instead of training on individual data points, meta-learning algorithms train on a collection of tasks (or episodes). Each episode simulates the few-shot scenario the model will encounter at test time. During training, the model repeatedly samples a task, adapts to a small support set of labeled examples, and is then evaluated on a query set from the same task. The outer learning loop adjusts the model so that this inner adaptation step becomes increasingly effective across tasks.
This two-level structure distinguishes meta-learning from standard training. The inner loop learns task-specific knowledge from a handful of examples, while the outer loop accumulates cross-task knowledge that makes the inner loop more efficient.
There are several types of meta-learning, each with its distinct approach to the "learning to learn" problem. The literature commonly groups meta-learning methods into three broad families: metric-based, model-based, and optimization-based approaches.[16]
Metric-based meta-learning techniques focus on learning a similarity measure (or distance function) between data points in an embedding space. Once a good embedding is learned, classification of new examples reduces to finding the nearest neighbor among the labeled support examples. The core assumption is that a well-trained embedding function will place examples of the same class close together, even for classes never seen during training.
Siamese Networks were among the earliest deep learning approaches to one-shot learning. Introduced by Koch, Zemel, and Salakhutdinov (2015), a Siamese Network consists of two identical sub-networks (sharing weights) that each process one input image.[3] The two resulting feature vectors are compared using a distance function, typically the weighted L1 distance followed by a sigmoid activation, to produce a similarity score. During training, the network learns to assign high similarity to pairs from the same class and low similarity to pairs from different classes. At test time, a new example is compared against each support example, and the class of the most similar support example is predicted.
Siamese Networks are conceptually straightforward and flexible, but they perform pairwise comparisons rather than reasoning about full class distributions, which can be a limitation when multiple support examples are available.
Matching Networks, proposed by Vinyals, Blundell, Lillicrap, and Kavukcuoglu (2016), formalized the N-way K-shot episodic evaluation protocol that became the standard benchmark framework for few-shot learning.[6] The model uses an attention mechanism over the support set embeddings to classify query examples. Specifically, the predicted label for a query point is a weighted combination of the support labels, where the weights are determined by a softmax over cosine similarities in the learned embedding space.
A key innovation of Matching Networks is the use of a Full Context Embedding (FCE) module, which uses a bidirectional LSTM to condition each support example's embedding on the entire support set. This contextual embedding allows the model to account for the relationships between all support examples when computing similarities. On the Omniglot benchmark, Matching Networks improved one-shot accuracy from 88.0% to 93.8%.[6]
Prototypical Networks, introduced by Snell, Swersky, and Zemel (2017), simplify the metric-based approach by computing a single prototype for each class.[9] The prototype is defined as the mean of the embedded support examples belonging to that class. Classification is performed by computing the Euclidean distance between a query embedding and each class prototype, then applying a softmax to obtain class probabilities.
The elegance of Prototypical Networks lies in their simplicity and theoretical grounding. The authors showed that using Euclidean distance in the embedding space is equivalent to performing linear classification when the embedding is learned appropriately.[9] Prototypical Networks consistently achieve strong results on few-shot benchmarks and are computationally efficient because they avoid pairwise comparisons between the query and every individual support example.
Relation Networks, proposed by Sung, Yang, Zhang, Xiang, Torr, and Hospedales (2018), replace the fixed distance metric (such as Euclidean or cosine distance) with a learned relation module.[12] The model concatenates the embedding of a query example with each support example (or class prototype) and passes the concatenated representation through a small neural network that outputs a relation score between 0 and 1. This learned comparison function can capture non-linear relationships that fixed metrics might miss.
The following table summarizes the major metric-based approaches:
| Method | Year | Authors | Distance/Similarity | Key Innovation |
|---|---|---|---|---|
| Siamese Networks | 2015 | Koch, Zemel, Salakhutdinov | Weighted L1 + sigmoid | Pairwise similarity learning for one-shot tasks |
| Matching Networks | 2016 | Vinyals et al. | Cosine similarity + attention | Episodic N-way K-shot protocol; Full Context Embeddings |
| Prototypical Networks | 2017 | Snell, Swersky, Zemel | Euclidean distance to class prototypes | Class-level prototypes as mean embeddings |
| Relation Networks | 2018 | Sung et al. | Learned relation module (neural network) | Learnable non-linear distance function |
Model-based meta-learning techniques (sometimes called "black-box" meta-learning) use the architecture of the model itself to enable rapid adaptation. These methods typically employ a model with an internal or external memory component that can quickly store and retrieve task-specific information. The idea is that the model's forward pass, possibly conditioned on the support set, directly produces predictions for new examples without an explicit inner optimization loop.
Santoro, Bartunov, Botvinick, Wierstra, and Lillicrap (2016) introduced Memory-Augmented Neural Networks for meta-learning.[5] The approach extends the Neural Turing Machine (NTM) architecture with a content-based memory access mechanism specifically designed for one-shot learning. The network is trained to rapidly bind new class information to memory slots and retrieve this information when classifying query examples.
The key insight behind MANNs is that external memory provides a substrate for fast adaptation: the slow weights of the network (trained via backpropagation across episodes) learn a general strategy for reading from and writing to memory, while the memory contents themselves change rapidly within each episode to accommodate new class information. On Omniglot, MANNs achieved results competitive with hand-engineered one-shot learning systems while being fully trainable end-to-end.[5]
Munkhdalai and Yu (2017) proposed Meta Networks, which learn a meta-level knowledge across tasks and use "fast parameterization" to rapidly shift the model's inductive biases for new tasks. MetaNet consists of two components: a base learner that operates in the input task space and a meta learner that operates in a task-agnostic meta space. The meta learner generates fast weights that modulate the base learner's parameters, allowing the entire network to reconfigure itself for each new task.
On the Omniglot and mini-ImageNet benchmarks, MetaNet achieved near human-level performance and outperformed baseline approaches by up to 6% accuracy. The fast weight generation mechanism gives MetaNet the flexibility to handle tasks with varying input and output distributions.
Optimization-based meta-learning techniques focus on learning how to optimize model parameters more effectively. Rather than learning a fixed model, these methods learn an initialization, a learning rate, or an optimizer that allows rapid fine-tuning on new tasks. The central idea is that the meta-learned initialization sits in a region of parameter space from which a few gradient steps on a new task's loss function lead to strong generalization.
Model-Agnostic Meta-Learning, introduced by Finn, Abbeel, and Levine (2017), is one of the most influential meta-learning algorithms.[8] MAML is model-agnostic, meaning it is compatible with any model that is trained using gradient descent and can be applied to classification, regression, and reinforcement learning tasks.
Algorithm. MAML learns an initialization of model parameters, denoted theta, such that one or a few steps of gradient descent on a new task's support set produce parameters that generalize well to that task's query set. The training procedure involves two nested loops:
Inner loop (task-level adaptation): For each sampled task T_i, MAML takes one or more gradient steps on the task's support set loss to produce adapted parameters theta_i'. With a single gradient step and inner learning rate alpha, this is: theta_i' = theta - alpha * grad(L_T_i(theta)), where L_T_i is the loss on task T_i's support set.
Outer loop (meta-update): The meta-objective evaluates the adapted parameters theta_i' on each task's query set. The initialization theta is then updated by descending the gradient of the sum of query set losses across all sampled tasks: theta = theta - beta * grad(sum_i L_T_i(theta_i')), where beta is the meta learning rate.
Because the outer loop differentiates through the inner loop gradient step, MAML requires computing second-order derivatives (the gradient of a gradient). This is sometimes called "backpropagating through the optimization." In practice, the computational cost of second-order derivatives can be mitigated by using the first-order approximation, called First-Order MAML (FOMAML), which ignores the second-order terms and still performs surprisingly well.
Results. MAML achieved state-of-the-art performance on the Omniglot and mini-ImageNet few-shot classification benchmarks at the time of publication. It also demonstrated strong performance on few-shot regression tasks and policy gradient reinforcement learning, validating its model-agnostic nature.[8] The simplicity and generality of MAML have made it one of the most widely cited and extended works in meta-learning.
Variants. Several extensions of MAML have been proposed:
| Variant | Authors | Year | Key Modification |
|---|---|---|---|
| FOMAML | Finn et al. | 2017 | First-order approximation; drops second-order derivatives |
| Meta-SGD | Li et al. | 2017 | Additionally meta-learns the inner loop learning rate per parameter |
| MAML++ | Antoniou et al. | 2019 | Stabilization techniques: multi-step loss, learned inner LR, batch norm fixes |
| ANIL | Raghu et al. | 2020 | Almost No Inner Loop: only adapts the final classification head |
| iMAML | Rajeswaran et al. | 2019 | Implicit differentiation for the meta-gradient, avoiding unrolled computation graphs |
Reptile, introduced by Nichol, Achiam, and Schulman (2018) at OpenAI, is a simpler alternative to MAML that uses only first-order derivatives.[11] The algorithm works by repeatedly sampling a task, performing several steps of stochastic gradient descent (SGD) on that task, and then moving the initialization parameters toward the task-trained weights.
Concretely, for each task, Reptile runs k steps of SGD starting from the current initialization theta to obtain task-adapted parameters theta_i'. The meta-update is simply: theta = theta + epsilon * (theta_i' - theta), where epsilon is a step size. This amounts to moving the initialization toward the result of training on each task.
A key advantage of Reptile over MAML is computational simplicity. MAML unrolls and differentiates through the computation graph of gradient descent, requiring second-order derivatives. Reptile performs standard SGD on each task without unrolling a computation graph or calculating any second derivatives, making it take less computation and memory than MAML.
Despite its simplicity, Nichol et al. showed that Reptile performs comparably to MAML on standard few-shot benchmarks. The authors provided a theoretical analysis using a Taylor series expansion showing that Reptile and MAML optimize for the same quantity when accounting for higher-order gradient terms: both methods implicitly maximize the inner product between gradients from different mini-batches of the same task, which promotes generalization.[11]
Ravi and Larochelle (2017) proposed an optimization-based approach where the meta-learner is an LSTM that learns to produce update rules for the base learner.[10] They observed that the update formula of LSTM cell states resembles the gradient descent update rule, motivating the use of an LSTM to output both the learning rate and the direction of parameter updates. This approach is notable for introducing the widely used train/validation/test class split for the mini-ImageNet dataset.[10]
The following table compares the three major families of meta-learning methods across several dimensions:
| Dimension | Metric-Based | Model-Based | Optimization-Based |
|---|---|---|---|
| Core idea | Learn an embedding space and distance function | Use model architecture (e.g., memory) for fast adaptation | Learn an initialization or optimizer for rapid fine-tuning |
| Adaptation mechanism | Nearest-neighbor or attention over support embeddings | Forward pass through memory-augmented network | Gradient descent on support set from meta-learned starting point |
| Inner loop | None (non-parametric at test time) | Implicit (memory read/write) | Explicit gradient steps |
| Representative methods | Matching Networks, Prototypical Networks, Relation Networks | MANN, MetaNet, SNAIL | MAML, Reptile, Meta-Learner LSTM |
| Scalability | High (simple forward pass) | Moderate (depends on memory size) | Moderate (requires inner loop unrolling) |
| Task generality | Primarily classification | Classification, sequence tasks | Classification, regression, RL |
| Second-order gradients needed | No | No | Yes (MAML); No (FOMAML, Reptile) |
Meta-learning is closely connected to few-shot learning, the challenge of learning new concepts from very few labeled examples. The standard evaluation protocol for few-shot classification is the N-way K-shot setting, formalized by Vinyals et al. (2016).[6]
In an N-way K-shot episode:
Common configurations include 5-way 1-shot (5 classes, 1 example each) and 5-way 5-shot (5 classes, 5 examples each). The former tests the extreme low-data regime, while the latter provides a slightly more generous setting. Accuracy is averaged over hundreds or thousands of randomly sampled episodes to produce a reliable estimate.
The N-way K-shot framework provides a controlled experimental setting, but it is also somewhat artificial: real-world few-shot problems may involve imbalanced classes, varying numbers of classes, or variable shot counts. The Meta-Dataset benchmark (described below) was introduced partly to address these limitations.
Several benchmark datasets have become standard for evaluating meta-learning algorithms. These datasets are specifically designed for episodic few-shot evaluation.
The Omniglot dataset, introduced by Lake, Salakhutdinov, and Tenenbaum (2015), is often called the "transpose of MNIST" because it contains many classes with few examples each (the opposite of MNIST, which has few classes with many examples).[4] Omniglot consists of 1,623 handwritten characters from 50 different alphabets, with 20 hand-drawn examples per character. The standard protocol splits the dataset into a background set (30 alphabets for training/validation) and an evaluation set (20 alphabets for testing). Images are grayscale at 105 x 105 pixels.
Omniglot served as the primary benchmark for early meta-learning research, but modern methods have largely saturated its performance (often exceeding 99% accuracy on 5-way 1-shot tasks), prompting the community to shift toward more challenging benchmarks.
Mini-ImageNet was first proposed by Vinyals et al. (2016)[6] and uses the class split introduced by Ravi and Larochelle (2017).[10] It is a subset of the ImageNet ILSVRC-2012 dataset, containing 100 classes with 600 color images per class, all resized to 84 x 84 pixels. The standard split allocates 64 classes for training, 16 for validation, and 20 for testing. Mini-ImageNet is more challenging than Omniglot because it uses natural color images with greater visual complexity and intra-class variation.
Tiered-ImageNet, introduced by Ren, Triantafillou, Ravi, Snell, Swersky, Tenenbaum, Larochelle, and Zemel (2018), is a larger and more challenging subset of ImageNet. It contains 608 classes with approximately 1,300 images per class, totaling 779,165 images at 84 x 84 pixels. The key design choice is that classes are organized by their WordNet hierarchy, and the train/validation/test splits (351/97/160 classes) are constructed so that no semantic overlap exists between splits. This hierarchical separation makes tiered-ImageNet harder because models cannot exploit shared high-level categories across splits.
Meta-Dataset, introduced by Triantafillou et al. (2020) at ICLR, is a large-scale benchmark consisting of ten diverse image classification datasets, including subsets of ImageNet, CUB-200-2011 (birds), Aircraft, Describable Textures, Quick Draw, Fungi, VGG Flower, Traffic Signs, and MSCOCO.[14] Unlike mini-ImageNet and tiered-ImageNet, Meta-Dataset presents episodes with variable numbers of classes and shots, creating a more realistic evaluation setting. It also tests cross-dataset generalization: models trained on a subset of the component datasets are evaluated on held-out datasets from entirely different visual domains.
The following table summarizes the main meta-learning benchmarks:
| Dataset | Year | Classes | Images per Class | Image Size | Total Images | Key Feature |
|---|---|---|---|---|---|---|
| Omniglot | 2015 | 1,623 | 20 | 105 x 105 (grayscale) | ~32,460 | Handwritten characters; many classes, few examples |
| Mini-ImageNet | 2016 | 100 | 600 | 84 x 84 (color) | 60,000 | Subset of ImageNet; standard 64/16/20 split |
| Tiered-ImageNet | 2018 | 608 | ~1,300 | 84 x 84 (color) | 779,165 | Hierarchical class separation; no semantic overlap |
| Meta-Dataset | 2020 | Varies | Varies | Varies | ~50M+ | 10 diverse datasets; variable ways and shots |
The rise of large language models (LLMs) has introduced a new perspective on meta-learning through the lens of in-context learning (ICL). When a model like GPT-3 is prompted with a few input-output examples followed by a new input, it can often produce the correct output without any parameter updates. This behavior closely resembles few-shot meta-learning: the model adapts to a new "task" defined by the prompt examples, using knowledge accumulated during pre-training.
Brown et al. (2020) explicitly framed GPT-3 as a meta-learner, noting that during pre-training, the model develops broad skills and pattern recognition abilities that it uses at inference time to rapidly recognize and perform the desired task.[13] The paper showed that few-shot performance improves more rapidly with model scale than zero-shot performance, suggesting that larger models are more proficient meta-learners.[13]
Subsequent theoretical work has deepened this connection. Dai et al. (2023) showed that Transformer attention has a dual form of gradient descent, meaning that in-context learning can be understood as implicit fine-tuning.[17] In this view, GPT produces "meta-gradients" from the demonstration examples and applies them to its representations, effectively performing an optimization step within the forward pass.[17] This finding provides a formal bridge between in-context learning in LLMs and classical optimization-based meta-learning.
Coda-Forno et al. (2023) introduced the concept of meta-in-context learning, showing that the in-context learning abilities of LLMs can be recursively improved.[18] As a model observes more tasks during a session, it gets better at solving subsequent tasks, paralleling the way meta-learning algorithms improve across episodes.[18]
In-context learning can be seen as a form of model-based meta-learning where the Transformer architecture itself serves as the "memory" that stores and retrieves task-relevant information from the context window. The pre-training process functions as the outer loop, and the forward pass on the prompt functions as the inner adaptation step. This perspective has generated growing interest in bridging the gap between classical meta-learning and the capabilities of foundation models, with researchers exploring whether explicitly incorporating meta-learning objectives into LLM pre-training could further enhance in-context learning performance.
Meta-reinforcement learning (meta-RL) applies meta-learning principles to reinforcement learning problems, enabling agents to adapt to new environments or tasks with minimal interaction. In standard RL, an agent typically requires millions of environment steps to learn a policy for a single task. Meta-RL aims to produce agents that can learn new tasks in just a few episodes by leveraging experience from related tasks seen during meta-training.
Two concurrent papers in 2016 laid the groundwork for modern meta-RL. Duan et al. (2016) introduced RL-squared ("Fast Reinforcement Learning via Slow Reinforcement Learning"), and Wang et al. (2016) independently proposed "Learning to Reinforcement Learn." Both approaches train a recurrent policy (typically an LSTM) across a distribution of Markov Decision Processes (MDPs). The recurrent network receives the previous action, reward, and observation as inputs, enabling it to implicitly implement a learning algorithm within its hidden state. During meta-testing, the recurrent policy adapts its behavior within an episode based on the rewards it receives, without any explicit gradient updates.
The original MAML paper (Finn et al., 2017) also demonstrated the algorithm's applicability to reinforcement learning, where the inner loop performs policy gradient updates on a new task and the outer loop optimizes the policy initialization.[8] Subsequent work, such as ProMP (Rothfuss et al., 2019), improved the stability and sample efficiency of MAML-based meta-RL through low-variance gradient estimators.
Meta-RL has been applied to robotics (where robots must quickly adapt to new objects or physical parameters), navigation (where agents must learn new environments), and game playing (where rules or opponent strategies may vary). The ability to adapt within a few episodes is particularly valuable in real-world robotics, where each episode corresponds to physical interaction and data collection is expensive.
The connection between meta-learning and automated machine learning (AutoML) is deep and multifaceted. AutoML systems aim to automate the design choices in the machine learning pipeline, including feature engineering, model selection, hyperparameter tuning, and neural architecture search (NAS). Many of these problems can be cast as meta-learning problems: learn from previous experiments what works well, and use that knowledge to make better choices on new datasets or tasks.
Neural Architecture Search (NAS) automates the design of neural network architectures. Early NAS methods, such as the work by Zoph and Le (2017), used reinforcement learning to train a controller that generates architecture specifications. The controller's policy is updated based on the validation performance of the generated architectures, effectively "learning to design" networks. This process mirrors meta-learning: the controller accumulates knowledge across many architecture evaluations and uses it to propose better architectures.
More recent approaches combine NAS with gradient-based meta-learning. For example, Across-Task NAS (AT-NAS) integrates MAML-style meta-learning with evolutionary algorithms to search for architectures that perform well across a distribution of tasks, rather than a single task.
Meta-learning also applies to hyperparameter optimization. Rather than tuning hyperparameters independently for each new dataset, meta-learning approaches learn from previous tuning experiments to warm-start the search. Systems like Auto-sklearn use meta-features of datasets (such as dimensionality and class balance) to recommend promising hyperparameter configurations based on performance on similar datasets. This transfer of knowledge across optimization runs reduces the computational burden significantly, since promising regions of the search space can be identified without running the full optimization from scratch.
Andrychowicz et al. (2016) proposed "learning to learn by gradient descent by gradient descent," where an LSTM-based optimizer replaces hand-designed optimizers like SGD or Adam.[7] The LSTM optimizer is trained on a distribution of optimization problems and learns update rules that can outperform fixed optimizers on new problems.[7] This approach represents a direct form of meta-learning applied to the optimization process itself.
Meta-learning has found applications across a wide range of domains, demonstrating its versatility beyond standard few-shot image classification.
Training models to classify images from new categories given only one or a few labeled examples remains the most common evaluation setting for meta-learning algorithms. State-of-the-art methods on mini-ImageNet and tiered-ImageNet benchmarks routinely surpass 70% accuracy in the challenging 5-way 1-shot setting.
Drug discovery is fundamentally a low-data problem, since acquiring labeled molecular data through experiments is both expensive and time-consuming. Meta-learning techniques, particularly Prototypical Networks and MAML variants, have been adapted for molecular property prediction tasks. Stanley et al. (2021) introduced metric-based meta-learning to drug discovery, showing that Prototypical Networks outperform traditional machine learning models on the Tox21 toxicity dataset.[15] More recent work has explored Bayesian meta-learning hypernetwork frameworks and attention-based graph neural network architectures for few-shot molecular property prediction, demonstrating enhanced stability and improved prediction accuracy over conventional methods.
In robotics, meta-learning enables robots to acquire new manipulation and locomotion skills from just a handful of human demonstrations. Finn, Yu, and Zhang (2017) demonstrated one-shot visual imitation learning using a MAML-based approach, where a robot learned to place objects in novel configurations from a single demonstration. More recent work (2024) has introduced Meta-Controller architectures that tokenize states and actions across different robot embodiments into joint-level representations, enabling few-shot policy adaptation across diverse robot platforms. Applications include table tennis, drawer opening, pouring, and multi-stage manipulation tasks.
Adapting language models to new NLP tasks (such as sentiment analysis for a new domain or relation extraction from a new corpus) with minimal labeled data is another key application. Meta In-Context Learning (Meta-ICL) has been shown to improve LLMs' zero-shot and few-shot relation extraction capabilities by leveraging meta-learning principles within the prompting framework.
Meta-learning methods have been applied to medical image classification where labeled data is scarce and expensive to obtain. A 2025 comparative study evaluated Prototypical Networks, Relation Networks, MAML, and FOMAML for few-shot chest X-ray disease classification, finding that Prototypical Networks combined with DenseNet-121 achieved the best performance.
Meta-learning also finds use in:
Despite significant progress, meta-learning faces several open challenges:
Task diversity and distribution shift: Meta-learning algorithms assume that meta-training and meta-testing tasks come from a related distribution. When the test tasks are substantially different from the training tasks, performance can degrade significantly.
Scalability: Many meta-learning methods involve nested optimization loops, which can be computationally expensive. Scaling meta-learning to very large models and task distributions remains an active area of research.
Theoretical understanding: While empirical results are strong, the theoretical foundations of meta-learning are still developing. Questions about what makes a good task distribution, how many meta-training tasks are needed, and what guarantees can be provided about meta-test performance are active research topics.
Cross-domain generalization: Most meta-learning benchmarks evaluate within a single domain (e.g., image classification). Developing methods that generalize across modalities and problem types is an important frontier.
Continual meta-learning: Integrating meta-learning with continual learning so that a system can accumulate meta-knowledge over time without forgetting earlier experience is a growing research direction.
Foundation models and in-context learning: Understanding the relationship between large-scale pre-training and meta-learning, and whether in-context learning in LLMs can be improved through explicit meta-learning objectives, remains an open question.
Combining meta-learning with large pre-trained models: Recent work such as ReptiLoRA (2024) explores combining Reptile-style meta-learning with low-rank adaptation (LoRA) on large language models, using first-order updates without complex gradient computations. This direction seeks to make few-shot adaptation practical for billion-parameter models.
Imagine you are learning to play different card games. The first card game takes you a long time to learn because you have never played any card games before. But by the time you learn your tenth card game, you pick it up much faster because you already understand things like taking turns, following rules, and forming strategies. You did not just learn the individual games; you learned how to learn card games in general.
Meta-learning works the same way for computers. Instead of training a computer to solve one specific problem with lots and lots of examples, meta-learning trains it on many different small problems. After seeing enough different problems, the computer gets really good at picking up new problems quickly, even if it only sees a few examples. It learned how to learn.