Meta-learning, often described as “learning to learn,” represents one of the most ambitious goals in artificial intelligence: creating systems that can rapidly adapt to new tasks with minimal data. While traditional machine learning requires extensive training for each new task, meta-learning aims to develop models that leverage prior experience to accelerate future learning. This comprehensive guide explores the principles, algorithms, and applications of meta-learning.
The Meta-Learning Paradigm
What Is Meta-Learning?
Consider how humans learn. A child who has learned to recognize dogs, cats, and birds can quickly learn to identify a new animal from just a few examples. We don’t start from scratch each time—we leverage our understanding of what features matter and how to learn new categories.
Meta-learning attempts to instill this capability in machines:
- Traditional ML: Learn a single task from many examples
- Meta-learning: Learn how to learn, enabling rapid adaptation to new tasks
The Two Levels of Learning
Meta-learning operates on two levels:
Inner Loop (Base Learning): Learning a specific task with few examples
Outer Loop (Meta Learning): Learning across many tasks to improve base learning
“python
# Conceptual meta-learning structure
def meta_learning():
meta_model = initialize_model()
for meta_iteration in range(num_iterations):
# Sample batch of tasks
tasks = sample_tasks(task_distribution)
meta_gradients = []
for task in tasks:
# Inner loop: adapt to task
adapted_model = inner_loop_adapt(meta_model, task.support_set)
# Evaluate on query set
loss = evaluate(adapted_model, task.query_set)
# Collect gradients for meta-update
meta_gradients.append(compute_gradients(loss))
# Outer loop: update meta-model
meta_model = meta_update(meta_model, meta_gradients)
`
Task Distribution and Episodes
Meta-learning trains on distributions of tasks, not individual examples:
Task: A learning problem (e.g., classify these 5 new species)
Episode: One training instance consisting of:
- Support Set: Few labeled examples for adaptation (like training data)
- Query Set: Examples to evaluate adapted performance (like test data)
`python
class MetaLearningTask:
def __init__(self, classes, k_shot, q_query):
self.classes = classes # e.g., 5 classes for 5-way classification
self.k_shot = k_shot # e.g., 1 or 5 examples per class
self.q_query = q_query # query examples per class
self.support_set = None # (k_shot * classes) examples
self.query_set = None # (q_query * classes) examples
@classmethod
def sample_from_dataset(cls, dataset, n_way, k_shot, q_query):
"""Sample an N-way K-shot task from a dataset."""
task = cls(n_way, k_shot, q_query)
# Randomly select N classes
selected_classes = random.sample(dataset.classes, n_way)
support_images, support_labels = [], []
query_images, query_labels = [], []
for new_label, cls in enumerate(selected_classes):
# Get all images of this class
class_images = dataset.get_images_for_class(cls)
# Randomly select k_shot + q_query images
selected = random.sample(class_images, k_shot + q_query)
support_images.extend(selected[:k_shot])
support_labels.extend([new_label] * k_shot)
query_images.extend(selected[k_shot:])
query_labels.extend([new_label] * q_query)
task.support_set = (support_images, support_labels)
task.query_set = (query_images, query_labels)
return task
`
Approaches to Meta-Learning
Meta-learning methods can be categorized into three main approaches:
1. Metric-Based Meta-Learning
Learn an embedding space where classification can be done by comparing distances.
2. Optimization-Based Meta-Learning
Learn initial parameters or optimization procedures that enable fast adaptation.
3. Model-Based Meta-Learning
Use models with external memory or architectures designed for rapid adaptation.
Metric-Based Meta-Learning
Core Idea
Learn to embed examples in a space where similar classes are close and different classes are far. New classes can be classified by comparing to embedded support examples.
Siamese Networks
Compare pairs of examples to determine if they're from the same class:
`python
class SiameseNetwork(nn.Module):
def __init__(self, encoder):
super().__init__()
self.encoder = encoder
def forward(self, x1, x2):
# Embed both inputs
z1 = self.encoder(x1)
z2 = self.encoder(x2)
# Compute distance
distance = torch.abs(z1 - z2)
# Binary classification: same class or not
return self.classifier(distance)
def one_shot_prediction(self, query, support_set):
"""Predict by finding most similar support example."""
query_embed = self.encoder(query)
min_distance = float('inf')
prediction = None
for support_image, support_label in support_set:
support_embed = self.encoder(support_image)
distance = torch.sum((query_embed - support_embed) ** 2)
if distance < min_distance:
min_distance = distance
prediction = support_label
return prediction
`
Matching Networks
Use attention over support set to classify queries:
`python
class MatchingNetwork(nn.Module):
def __init__(self, encoder):
super().__init__()
self.encoder = encoder
def forward(self, support_images, support_labels, query_images):
# Embed support and query sets
support_embeddings = self.encoder(support_images) # [N*K, D]
query_embeddings = self.encoder(query_images) # [Q, D]
# Compute cosine similarity attention
support_embeddings = F.normalize(support_embeddings, dim=1)
query_embeddings = F.normalize(query_embeddings, dim=1)
# Attention: [Q, N*K]
attention = torch.mm(query_embeddings, support_embeddings.t())
attention = F.softmax(attention, dim=1)
# Weighted sum of support labels (one-hot)
support_labels_onehot = F.one_hot(support_labels).float()
predictions = torch.mm(attention, support_labels_onehot)
return predictions
`
Prototypical Networks
Represent each class by its mean embedding (prototype):
`python
class PrototypicalNetwork(nn.Module):
def __init__(self, encoder):
super().__init__()
self.encoder = encoder
def forward(self, support_images, support_labels, query_images):
n_way = support_labels.max() + 1
# Embed all examples
support_embeddings = self.encoder(support_images)
query_embeddings = self.encoder(query_images)
# Compute prototypes (class means)
prototypes = []
for c in range(n_way):
class_mask = (support_labels == c)
class_embeddings = support_embeddings[class_mask]
prototype = class_embeddings.mean(dim=0)
prototypes.append(prototype)
prototypes = torch.stack(prototypes) # [N, D]
# Compute distances from queries to prototypes
# Using squared Euclidean distance
dists = torch.cdist(query_embeddings, prototypes, p=2) ** 2
# Negative distances as logits (closer = higher)
logits = -dists
return logits
def compute_loss(self, support_images, support_labels,
query_images, query_labels):
logits = self.forward(support_images, support_labels, query_images)
return F.cross_entropy(logits, query_labels)
`
Training Prototypical Networks:
`python
def train_prototypical_network(model, dataset, n_way, k_shot, q_query,
num_episodes, optimizer):
model.train()
for episode in range(num_episodes):
# Sample a task
task = MetaLearningTask.sample_from_dataset(
dataset, n_way, k_shot, q_query
)
support_images, support_labels = task.support_set
query_images, query_labels = task.query_set
# Compute loss
loss = model.compute_loss(
support_images, support_labels,
query_images, query_labels
)
# Update
optimizer.zero_grad()
loss.backward()
optimizer.step()
`
Relation Networks
Learn a relation module to compare queries to prototypes:
`python
class RelationNetwork(nn.Module):
def __init__(self, encoder, relation_module):
super().__init__()
self.encoder = encoder
self.relation_module = relation_module # Learns similarity
def forward(self, support_images, support_labels, query_images):
n_way = support_labels.max() + 1
n_query = query_images.size(0)
# Embed
support_embeddings = self.encoder(support_images)
query_embeddings = self.encoder(query_images)
# Compute prototypes
prototypes = []
for c in range(n_way):
class_mask = (support_labels == c)
prototype = support_embeddings[class_mask].mean(dim=0)
prototypes.append(prototype)
prototypes = torch.stack(prototypes)
# Concatenate each query with each prototype
prototypes_expanded = prototypes.unsqueeze(0).repeat(n_query, 1, 1)
queries_expanded = query_embeddings.unsqueeze(1).repeat(1, n_way, 1)
pairs = torch.cat([queries_expanded, prototypes_expanded], dim=2)
pairs = pairs.view(-1, pairs.size(-1))
# Compute relation scores
relations = self.relation_module(pairs)
relations = relations.view(n_query, n_way)
return relations
`
Optimization-Based Meta-Learning
MAML (Model-Agnostic Meta-Learning)
MAML learns initial parameters that can be quickly adapted to new tasks through gradient descent:
`python
class MAML:
def __init__(self, model, inner_lr=0.01, meta_lr=0.001,
inner_steps=5, first_order=False):
self.model = model
self.inner_lr = inner_lr
self.meta_lr = meta_lr
self.inner_steps = inner_steps
self.first_order = first_order
self.meta_optimizer = torch.optim.Adam(
model.parameters(), lr=meta_lr
)
def inner_loop(self, model, support_set):
"""Adapt model parameters to a specific task."""
support_images, support_labels = support_set
# Clone model for inner loop
adapted_params = {name: param.clone()
for name, param in model.named_parameters()}
for step in range(self.inner_steps):
# Forward pass
logits = self.forward_with_params(
model, support_images, adapted_params
)
loss = F.cross_entropy(logits, support_labels)
# Compute gradients
grads = torch.autograd.grad(
loss, adapted_params.values(),
create_graph=not self.first_order
)
# Update adapted parameters
adapted_params = {
name: param - self.inner_lr * grad
for (name, param), grad
in zip(adapted_params.items(), grads)
}
return adapted_params
def forward_with_params(self, model, x, params):
"""Forward pass using given parameters instead of model's."""
# Implementation depends on model architecture
# Typically use functional API
pass
def meta_train_step(self, tasks):
"""One step of meta-training."""
self.meta_optimizer.zero_grad()
meta_loss = 0
for task in tasks:
# Adapt to task
adapted_params = self.inner_loop(self.model, task.support_set)
# Evaluate on query set
query_images, query_labels = task.query_set
logits = self.forward_with_params(
self.model, query_images, adapted_params
)
loss = F.cross_entropy(logits, query_labels)
meta_loss += loss
meta_loss /= len(tasks)
# Meta update
meta_loss.backward()
self.meta_optimizer.step()
return meta_loss.item()
`
MAML with Higher-Order Derivatives (full MAML):
`python
# Using the 'higher' library for cleaner implementation
import higher
def maml_train_step(model, meta_optimizer, tasks, inner_lr, inner_steps):
meta_optimizer.zero_grad()
meta_loss = 0
for task in tasks:
support_images, support_labels = task.support_set
query_images, query_labels = task.query_set
# Create differentiable copy of model
with higher.innerloop_ctx(
model,
torch.optim.SGD(model.parameters(), lr=inner_lr)
) as (fmodel, diffopt):
# Inner loop adaptation
for _ in range(inner_steps):
logits = fmodel(support_images)
loss = F.cross_entropy(logits, support_labels)
diffopt.step(loss)
# Query loss with adapted model
query_logits = fmodel(query_images)
task_loss = F.cross_entropy(query_logits, query_labels)
meta_loss += task_loss
meta_loss /= len(tasks)
meta_loss.backward()
meta_optimizer.step()
return meta_loss.item()
`
First-Order MAML (FOMAML)
Ignores second-order derivatives for efficiency:
`python
def fomaml_inner_loop(model, support_set, inner_lr, inner_steps):
"""First-order MAML: ignore second derivatives."""
support_images, support_labels = support_set
# Create copy of parameters
fast_weights = [p.clone() for p in model.parameters()]
for step in range(inner_steps):
# Forward with fast weights
logits = forward_with_weights(model, support_images, fast_weights)
loss = F.cross_entropy(logits, support_labels)
# Compute gradients (no higher-order)
grads = torch.autograd.grad(loss, fast_weights)
# Update fast weights
fast_weights = [w - inner_lr * g for w, g in zip(fast_weights, grads)]
return fast_weights
`
Reptile
A simpler alternative that averages task-adapted parameters:
`python
class Reptile:
def __init__(self, model, inner_lr=0.01, meta_lr=0.1, inner_steps=5):
self.model = model
self.inner_lr = inner_lr
self.meta_lr = meta_lr
self.inner_steps = inner_steps
def train_step(self, task):
# Store initial parameters
initial_params = [p.clone() for p in self.model.parameters()]
# Inner loop: regular training on task
optimizer = torch.optim.SGD(
self.model.parameters(), lr=self.inner_lr
)
support_images, support_labels = task.support_set
for step in range(self.inner_steps):
logits = self.model(support_images)
loss = F.cross_entropy(logits, support_labels)
optimizer.zero_grad()
loss.backward()
optimizer.step()
# Meta update: move initial params toward adapted params
with torch.no_grad():
for initial, current in zip(initial_params, self.model.parameters()):
# Interpolate between initial and adapted
current.copy_(
initial + self.meta_lr * (current - initial)
)
`
Meta-SGD
Learn per-parameter learning rates:
`python
class MetaSGD(nn.Module):
def __init__(self, model):
super().__init__()
self.model = model
# Learnable learning rates (one per parameter)
self.lr_params = nn.ParameterList([
nn.Parameter(torch.ones_like(p) * 0.01)
for p in model.parameters()
])
def inner_loop(self, support_set, inner_steps=1):
support_images, support_labels = support_set
adapted_params = list(self.model.parameters())
for step in range(inner_steps):
logits = self.forward_with_params(support_images, adapted_params)
loss = F.cross_entropy(logits, support_labels)
grads = torch.autograd.grad(loss, adapted_params, create_graph=True)
# Update with learned learning rates
adapted_params = [
p - lr * g
for p, lr, g in zip(adapted_params, self.lr_params, grads)
]
return adapted_params
`
Model-Based Meta-Learning
Memory-Augmented Neural Networks (MANN)
Use external memory to store and retrieve task-specific information:
`python
class MemoryAugmentedNN(nn.Module):
def __init__(self, input_dim, hidden_dim, memory_size, memory_dim):
super().__init__()
self.controller = nn.LSTM(input_dim + memory_dim, hidden_dim)
self.memory = None
self.memory_size = memory_size
self.memory_dim = memory_dim
# Memory operations
self.read_head = nn.Linear(hidden_dim, memory_dim)
self.write_head = nn.Linear(hidden_dim, memory_dim)
def reset_memory(self, batch_size):
self.memory = torch.zeros(batch_size, self.memory_size, self.memory_dim)
def forward(self, x, prev_output):
# Concatenate input with previous memory read
controller_input = torch.cat([x, prev_output], dim=-1)
# Controller step
hidden, _ = self.controller(controller_input)
# Read from memory
read_key = self.read_head(hidden)
read_weights = F.softmax(
torch.bmm(read_key.unsqueeze(1), self.memory.transpose(1, 2)),
dim=-1
)
read_output = torch.bmm(read_weights, self.memory).squeeze(1)
# Write to memory
write_content = self.write_head(hidden)
# LRUA (Least Recently Used Access) for write location
self.memory = self.update_memory(write_content)
return hidden, read_output
`
Meta Networks (MetaNet)
Generate task-specific network weights:
`python
class MetaNetwork(nn.Module):
def __init__(self, base_model, meta_model):
super().__init__()
self.base_model = base_model
self.meta_model = meta_model # Generates weights for base model
def forward(self, support_set, query_images):
# Generate task-specific parameters from support set
task_embedding = self.embed_task(support_set)
generated_weights = self.meta_model(task_embedding)
# Apply generated weights to classify queries
return self.base_model(query_images, generated_weights)
def embed_task(self, support_set):
"""Create task embedding from support examples."""
images, labels = support_set
embeddings = self.encoder(images)
# Aggregate by class
task_embedding = []
for c in labels.unique():
class_embed = embeddings[labels == c].mean(dim=0)
task_embedding.append(class_embed)
return torch.cat(task_embedding)
`
Hypernetworks
Networks that generate weights for other networks:
`python
class HyperNetwork(nn.Module):
def __init__(self, input_dim, target_shapes):
super().__init__()
self.target_shapes = target_shapes
total_params = sum(np.prod(s) for s in target_shapes)
self.hyper = nn.Sequential(
nn.Linear(input_dim, 256),
nn.ReLU(),
nn.Linear(256, 512),
nn.ReLU(),
nn.Linear(512, total_params)
)
def forward(self, task_embedding):
flat_params = self.hyper(task_embedding)
# Split into individual weight tensors
params = []
offset = 0
for shape in self.target_shapes:
size = np.prod(shape)
param = flat_params[offset:offset+size].view(shape)
params.append(param)
offset += size
return params
`
Advanced Topics
Task Augmentation
Generate more training tasks through augmentation:
`python
def augment_task(task, augmentation_fn):
"""Apply augmentation to create new tasks."""
augmented_tasks = []
# Rotate classes
for perm in itertools.permutations(range(task.n_way)):
new_task = task.copy()
new_task.relabel(perm)
augmented_tasks.append(new_task)
# Augment images within task
for _ in range(5):
new_task = task.copy()
new_task.support_set = augmentation_fn(task.support_set)
augmented_tasks.append(new_task)
return augmented_tasks
`
Meta-Learning with Unlabeled Data
Semi-supervised meta-learning:
`python
class SemiSupervisedProtoNet(nn.Module):
def __init__(self, encoder):
super().__init__()
self.encoder = encoder
def forward(self, support_set, unlabeled_set, query_images):
support_images, support_labels = support_set
n_way = support_labels.max() + 1
# Initial prototypes from support set
support_embeddings = self.encoder(support_images)
prototypes = self.compute_prototypes(support_embeddings, support_labels, n_way)
# Refine with unlabeled data
unlabeled_embeddings = self.encoder(unlabeled_set)
for _ in range(5): # Iterative refinement
# Soft-assign unlabeled to prototypes
dists = torch.cdist(unlabeled_embeddings, prototypes)
soft_labels = F.softmax(-dists, dim=1)
# Update prototypes with soft-labeled data
for c in range(n_way):
class_support = support_embeddings[support_labels == c]
weighted_unlabeled = (soft_labels[:, c:c+1] * unlabeled_embeddings).sum(0)
weight_sum = soft_labels[:, c].sum() + class_support.size(0)
prototypes[c] = (class_support.sum(0) + weighted_unlabeled) / weight_sum
# Classify queries
query_embeddings = self.encoder(query_images)
dists = torch.cdist(query_embeddings, prototypes)
return -dists
`
Cross-Domain Meta-Learning
Training on one domain, testing on another:
`python
class CrossDomainMetaLearner:
def __init__(self, encoder, domain_discriminator):
self.encoder = encoder
self.domain_discriminator = domain_discriminator
def train_step(self, source_tasks, target_unlabeled):
# Standard meta-learning on source domain
meta_loss = self.meta_train(source_tasks)
# Domain adversarial loss for domain-invariant features
source_features = self.encoder(source_tasks.all_images)
target_features = self.encoder(target_unlabeled)
domain_loss = self.domain_adversarial_loss(
source_features, target_features
)
total_loss = meta_loss + 0.1 * domain_loss
return total_loss
`
Task-Agnostic Meta-Learning
Learn representations that work for any task type:
`python
class TAML(nn.Module):
"""Task-Agnostic Meta-Learning."""
def __init__(self, encoder):
super().__init__()
self.encoder = encoder
# Task-specific heads generated on the fly
self.head_generator = nn.Linear(encoder.output_dim, encoder.output_dim * 64)
def forward(self, support_set, query_images, task_type):
# Generate task-specific classification head
task_embedding = self.compute_task_embedding(support_set)
head_weights = self.head_generator(task_embedding)
# Apply encoder and generated head
query_features = self.encoder(query_images)
if task_type == 'classification':
return self.classify(query_features, head_weights)
elif task_type == 'regression':
return self.regress(query_features, head_weights)
`
Benchmarks and Evaluation
Common Benchmarks
Omniglot: 1,623 characters from 50 alphabets
- Typical: 20-way 1-shot
miniImageNet: 100 classes, 600 images each
- Typical: 5-way 1-shot or 5-shot
tieredImageNet: Larger split of ImageNet
- Non-overlapping train/test super-classes
Meta-Dataset: Multiple datasets with varying domains
Evaluation Protocol
`python
def evaluate_meta_learner(model, test_dataset, n_way, k_shot, num_episodes=1000):
model.eval()
accuracies = []
for _ in range(num_episodes):
task = MetaLearningTask.sample_from_dataset(
test_dataset, n_way, k_shot, q_query=15
)
with torch.no_grad():
predictions = model.predict(task.support_set, task.query_set[0])
accuracy = (predictions == task.query_set[1]).float().mean()
accuracies.append(accuracy.item())
mean_acc = np.mean(accuracies)
ci95 = 1.96 * np.std(accuracies) / np.sqrt(num_episodes)
return mean_acc, ci95
`
Practical Considerations
Choosing a Method
| Scenario | Recommended Approach |
|----------|---------------------|
| Simple, fast | Prototypical Networks |
| Best performance | MAML with sufficient compute |
| Memory efficient | FOMAML or Reptile |
| Very few examples | Matching Networks |
| Complex task space | Model-based methods |
Common Pitfalls
- Task distribution mismatch: Train/test task distributions should be similar
- Overfitting to base classes: Ensure good generalization
- Computational cost: Full MAML requires significant memory
- Hyperparameter sensitivity: Inner/outer learning rates matter
Tips for Success
`python
# Best practices
training_config = {
'n_way': 5,
'k_shot': 1, # or 5
'meta_batch_size': 4, # tasks per meta-update
'inner_lr': 0.01,
'outer_lr': 0.001,
'inner_steps': 5,
'episodes': 60000,
'eval_every': 1000,
'early_stopping_patience': 10
}
# Data augmentation helps
augmentation = transforms.Compose([
transforms.RandomCrop(84, padding=8),
transforms.RandomHorizontalFlip(),
transforms.ColorJitter(0.4, 0.4, 0.4),
transforms.ToTensor()
])
`
Applications
Few-Shot Image Classification
The canonical meta-learning application.
Drug Discovery
Learn to predict drug properties from few examples:
`python
# Each task: predict property for a new molecular scaffold
# Support: 5-10 molecules with measured property
# Query: predict for related molecules
`
Robotics
Rapidly adapt robot policies to new tasks:
`python
# Each task: new manipulation goal
# Support: few demonstrations
# Query: execute in new configurations
`
Natural Language Processing
Few-shot text classification, relation extraction:
`python
# Each task: new text classification problem
# Support: 5 examples per class
# Query: classify new documents
`
Personalization
Adapt models to individual users with minimal data:
`python
# Each task: one user's preferences
# Support: user's few interactions
# Query: personalized recommendations
“
Conclusion
Meta-learning represents a paradigm shift in machine learning, moving from task-specific optimization to learning the learning process itself. By training on distributions of tasks, meta-learning systems can rapidly adapt to new challenges with minimal data.
Key takeaways:
- Learn to learn: Meta-learning optimizes for fast adaptation, not just performance
- Episodes, not examples: Training operates on tasks, not individual samples
- Three approaches: Metric-based (learn similarity), optimization-based (learn initialization), model-based (learn memory/generation)
- Trade-offs exist: Speed vs. accuracy, simplicity vs. flexibility
- Broad applications: Vision, NLP, robotics, drug discovery, personalization
As AI systems are deployed in more diverse and dynamic environments, the ability to rapidly adapt becomes increasingly important. Meta-learning provides a principled framework for achieving this adaptability, making it one of the most exciting frontiers in artificial intelligence research.
