Key Differences from MAML

While both Reptile and MAML aim to learn good initializations, Reptile differs in several ways:

• First-order approximation: Reptile avoids computing second derivatives, making it computationally cheaper.
• Implicit gradient: The update θ_i' - θ approximates the meta-gradient without explicit backpropagation through the optimization process.
• Batch normalization: Reptile often performs better with batch norm layers, as it doesn't require careful handling of second-order effects.

Practical Implementation Considerations

When implementing Reptile, several practical aspects must be considered:

where α is the inner-loop learning rate. This relationship suggests that the meta-learning rate should be scaled relative to the number of inner-loop steps k.

For stability, it's common to:

• Use Adam instead of SGD for the inner-loop optimization
• Normalize the update direction (θ_i' - θ)
• Employ gradient clipping in both inner and outer loops

Visualization of Parameter Updates

The algorithm's behavior can be visualized in parameter space. For two tasks T_1 and T_2 with optimal parameters θ_1* and θ_2*, Reptile's updates gradually move the initialization θ towards a point that minimizes the expected distance to both optima after a few gradient steps.

Convergence Properties

Reptile's convergence can be analyzed using the following bound on the expected improvement per iteration:

where μ is the strong convexity parameter, L is the smoothness constant, and σ represents gradient noise. This shows that with proper learning rate selection (ϵ < 2μ/L²), Reptile converges linearly to a neighborhood of the optimal initialization.

Applications and Performance

Reptile has shown strong performance in:

• Few-shot classification (Omniglot, Mini-ImageNet)
• Reinforcement learning with varying dynamics
• Cross-domain adaptation in NLP

Empirical results demonstrate that Reptile often matches MAML's performance while being up to 3× faster due to its avoidance of second-order computations. The algorithm particularly excels in scenarios where:

• The task distribution is broad but not extremely diverse
• Inner-loop adaptation requires only a few gradient steps
• Model architectures are relatively large

Reptile, introduced by OpenAI in 2018, is a first-order meta-learning algorithm that optimizes for fast adaptation across tasks. Unlike MAML, which explicitly computes second-order gradients, Reptile approximates the meta-update through repeated stochastic gradient steps, making it computationally efficient while retaining competitive performance.

Core Optimization Objective

Given a distribution of tasks p(T), Reptile aims to find an initial set of parameters θ that can be quickly adapted to new tasks via a few gradient steps. For each task T_i, the inner-loop optimization performs k steps of SGD:

where α is the inner-loop learning rate and ℒ_{T_i} is the task-specific loss. The key difference from MAML lies in the meta-update: instead of differentiating through the inner-loop optimization, Reptile simply moves the initial parameters toward the fine-tuned parameters θ_i':

Here, β is the meta-learning rate. This update can be interpreted as a form of weighted averaging across task-specific parameters.

Connection to First-Order MAML

When the inner-loop consists of exactly one gradient step (k=1), Reptile's update becomes:

This is mathematically equivalent to first-order MAML (FOMAML), where second derivatives are omitted. For k>1, Reptile accumulates higher-order terms through its iterative update process, though it avoids explicit Hessian computations.

Batch Update Formulation

In practice, Reptile processes mini-batches of tasks. For a batch of n tasks sampled from p(T), the meta-update becomes:

This batch formulation reduces variance in the meta-gradient estimate and leads to more stable convergence. The algorithm can be viewed as finding a point in parameter space that is simultaneously close to the optimal parameters for many related tasks.

Geometric Interpretation

Reptile's update rule induces a geometry where:

• The inner-loop gradient steps θ → θ_i' move parameters toward task-specific optima
• The outer-loop update θ ← θ + β(θ_i' - θ) contracts the parameters toward the centroid of these task-specific optima

This creates a form of implicit regularization that favors parameter regions allowing fast adaptation, similar to MAML but without explicit second-order optimization.

Practical Implementation Details

Key hyperparameters in Reptile include:

• Inner-loop steps (k): Typically 1-5 for few-shot learning
• Inner learning rate (α): Often set via grid search or adaptation
• Meta learning rate (β): Usually larger than α (e.g., 0.1-1.0)
• Batch size (n): Balances computational cost and gradient estimate quality

The algorithm's computational complexity is O(k) per task compared to MAML's O(k + k²) when considering second-order terms, making Reptile particularly attractive for large-scale meta-learning problems.

The Reptile algorithm, introduced by OpenAI, is a first-order meta-learning method designed for fast adaptation to new tasks with minimal computational overhead. Unlike MAML, which requires second-order derivatives, Reptile approximates the meta-gradient through iterative stochastic gradient descent (SGD) updates, making it computationally efficient while retaining competitive performance.

Algorithm Overview

Reptile operates by sampling a batch of tasks, performing multiple SGD steps on each task, and then updating the initial model parameters towards the final parameters obtained after task-specific training. The key steps are:

• Sample a task T_i from the task distribution p(T).
• Initialize model parameters θ.
• Perform k steps of SGD on T_i to obtain updated parameters θ_i.
• Update the initial parameters θ using the rule: θ ← θ + ε(θ_i − θ), where ε is the meta-learning rate.

Step-by-Step Implementation

Below is a PyTorch implementation of Reptile for few-shot classification. The code assumes a model f_θ, a task distribution, and an inner-loop optimizer (e.g., SGD).

import torch
import torch.optim as optim

def reptile(model, tasks, inner_steps=5, inner_lr=0.1, meta_lr=1e-3, epochs=1000):
    optimizer = optim.SGD(model.parameters(), lr=meta_lr)
    
    for epoch in range(epochs):
        initial_weights = [param.clone() for param in model.parameters()]
        
        # Sample a task
        task = sample_task(tasks)
        x, y = task.sample_data()
        
        # Inner loop: adapt to the task
        inner_optim = optim.SGD(model.parameters(), lr=inner_lr)
        for _ in range(inner_steps):
            loss = model.loss(x, y)
            inner_optim.zero_grad()
            loss.backward()
            inner_optim.step()
        
        # Outer loop: meta-update
        optimizer.zero_grad()
        for initial_param, adapted_param in zip(initial_weights, model.parameters()):
            param_diff = adapted_param - initial_param
            initial_param.grad = -param_diff  # Reptile gradient approximation
        optimizer.step()

Key Implementation Details

1. Task Sampling: Tasks should be sampled from a diverse distribution to ensure the model generalizes. For few-shot learning, each task consists of a support set (training data) and a query set (test data).

2. Inner-Loop Optimization: The number of inner steps (k) and learning rate (α) are critical hyperparameters. Smaller k speeds up training but may underfit, while larger k improves adaptation at the cost of computation.

3. Meta-Learning Rate (ε): Controls how aggressively the initial parameters are updated. A high ε can lead to instability, while a low ε slows convergence.

Practical Considerations

• Batch Normalization: Batch statistics should be computed per-task during adaptation to avoid leakage between tasks.
• Gradient Clipping: Useful to stabilize training, especially when using larger inner-loop learning rates.
• Early Stopping: Monitor validation performance to prevent overfitting to the meta-training task distribution.

Comparison with MAML

While MAML explicitly computes the meta-gradient via backpropagation through the inner-loop optimization, Reptile approximates this gradient by moving the initial parameters towards the adapted parameters. This approximation avoids the computational cost of second derivatives but can still achieve similar performance in practice.

Optimization Strategy

Reptile and MAML (Model-Agnostic Meta-Learning) both aim to learn an initial set of parameters that can be quickly adapted to new tasks, but they differ fundamentally in their optimization strategies. MAML explicitly computes second-order gradients to minimize the expected loss across tasks after one or more gradient steps. The update rule for MAML involves:

where U_θ represents the inner-loop adaptation operator, and β is the meta-learning rate. In contrast, Reptile avoids explicit second-order derivatives by simply taking multiple gradient steps per task and then moving the initial parameters toward the final adapted parameters. The Reptile update is:

where θ_k is the parameter vector after k inner-loop steps, and α is the meta-step size.

Computational Efficiency

Reptile is computationally cheaper than MAML because it does not require backpropagating through the inner-loop optimization process. MAML's reliance on second-order gradients means it must compute Hessian-vector products, which are expensive for high-dimensional parameter spaces. Reptile sidesteps this by treating the inner-loop adaptation as a black box, making it more scalable for large models.

Task Adaptation Dynamics

MAML enforces consistency in the direction of adaptation by explicitly optimizing for post-update performance. This leads to faster convergence in few-shot settings but can be sensitive to hyperparameters like the inner-loop learning rate. Reptile, on the other hand, implicitly encourages the initial parameters to lie in a region where local updates (e.g., SGD) lead to good performance, which can be more robust but may require more meta-training iterations.

Geometric Interpretation

From a geometric perspective, MAML seeks a point in parameter space where the gradient steps for different tasks align. Reptile, however, converges to a solution where the average of the task-specific parameters is optimal. This difference can be visualized as MAML finding a "central point" where gradients are useful across tasks, while Reptile averages the solutions themselves.

Practical Trade-offs

In practice, Reptile is often preferred when computational resources are limited or when the inner-loop adaptation involves non-differentiable operations. MAML excels in scenarios where precise gradient alignment is critical, such as reinforcement learning or low-data regimes. Empirical studies show Reptile performs competitively with MAML on standard few-shot benchmarks while being up to 3× faster in wall-clock time.

Computational Complexity of MAML

The computational cost of MAML arises primarily from its nested optimization structure. The outer-loop update requires computing second-order derivatives through the inner-loop optimization, leading to a time complexity of O(kn + n²), where k is the number of inner-loop steps and n is the number of model parameters. The Hessian-vector product computation dominates this cost, scaling quadratically with parameter count.

where U^k(θ) represents k steps of inner-loop adaptation. The memory footprint grows linearly with the number of tasks processed in parallel during meta-training, making large-scale deployment challenging without distributed computing resources.

Reptile's Efficiency Advantages

Reptile circumvents MAML's computational bottleneck by approximating the meta-gradient through a first-order truncated optimization:

where φ_i are the parameters after inner-loop adaptation on task i. This reduces time complexity to O(kn) by avoiding explicit second-derivative calculations. Empirical studies show Reptile achieves comparable few-shot performance to MAML while requiring 30-50% less computation time and 25% less memory during meta-training.

Memory Requirements Comparison

The memory overhead difference becomes pronounced in deep architectures:

• MAML must retain computational graphs for both inner and outer loops, doubling the memory footprint during backpropagation
• Reptile only stores the final adapted parameters, enabling larger batch sizes or more complex models within the same hardware constraints

Task Adaptation Speed

During inference (few-shot adaptation), both algorithms exhibit similar computational profiles since they perform identical inner-loop optimization. However, Reptile's meta-initialization often converges in fewer steps due to its implicit regularization properties. Benchmarks on Omniglot show:

Scalability Considerations

For large-scale meta-learning scenarios (>100k tasks), Reptile demonstrates better scaling properties due to:

• Embarrassingly parallel inner-loop adaptations
• Reduced communication overhead in distributed implementations
• Better compatibility with asynchronous optimization

The trade-off surfaces in domains requiring precise gradient alignment, where MAML's explicit meta-optimization maintains an accuracy advantage despite higher computational costs.

Computational Efficiency and Scalability

Reptile is computationally cheaper than MAML due to its avoidance of explicit second-order gradient computations. While MAML computes meta-gradients via backpropagation through the inner-loop optimization, Reptile approximates this by taking multiple stochastic gradient steps and averaging the resulting parameters. For large-scale problems or limited computational budgets, Reptile is often the better choice. For example, in distributed reinforcement learning settings, Reptile’s simplicity allows for easier parallelization across multiple tasks.

where θ represents the meta-parameters, θᵢ are task-specific parameters after inner-loop adaptation, and ϵ is the meta-learning rate. This update rule shows Reptile’s first-order nature compared to MAML’s nested optimization.

Few-Shot Learning Performance

MAML generally outperforms Reptile in few-shot classification benchmarks when sufficient compute resources are available. The explicit meta-optimization of MAML enables faster adaptation to new tasks, particularly in domains with complex loss landscapes. For instance, on Omniglot and Mini-ImageNet benchmarks, MAML achieves higher accuracy with 1-5 gradient steps compared to Reptile. However, the performance gap narrows as the number of inner-loop steps increases.

Robustness to Hyperparameters

Reptile demonstrates greater robustness to hyperparameter choices, particularly the inner-loop learning rate. MAML’s performance is sensitive to the inner-loop step size due to its reliance on accurate gradient estimates through the optimization path. In contrast, Reptile’s parameter averaging is more forgiving of suboptimal learning rates. This makes Reptile preferable in scenarios where extensive hyperparameter tuning isn’t feasible.

Continuous Adaptation Scenarios

For online or continual learning settings where tasks arrive sequentially, Reptile’s incremental update mechanism aligns naturally with streaming data. MAML’s requirement to sample batches of tasks for each meta-update makes it less suitable for non-stationary environments. Robotics applications that require continuous adaptation to changing environments often benefit from Reptile’s streaming-friendly approach.

Task Distribution Characteristics

When task distributions exhibit high variability or non-stationarity, Reptile’s implicit meta-optimization can be more stable than MAML’s explicit gradient computation. The averaging operation in Reptile acts as a regularizer against outlier tasks. However, for well-defined, narrow task distributions where precise adaptation is crucial (e.g., medical imaging with consistent modalities), MAML’s targeted optimization typically yields better results.

Implementation Complexity

MAML requires careful implementation of second-order gradient computations, often needing frameworks with advanced automatic differentiation capabilities. Reptile can be implemented with standard first-order optimizers, making it more accessible for researchers without deep expertise in meta-learning. This simplicity also translates to easier debugging and maintenance in production systems.

First-Order MAML (FOMAML)

First-Order MAML simplifies the original MAML algorithm by ignoring second-order derivatives during meta-optimization. While standard MAML computes the gradient through the gradient update (requiring Hessian-vector products), FOMAML approximates this by treating the inner-loop gradients as constants. The meta-update becomes:

where \( U_{\tau_i}(\theta) \) is the inner-loop update on task \( \tau_i \). This approximation significantly reduces computational overhead while maintaining competitive performance in many scenarios. Empirical studies show FOMAML achieves 70-90% of the performance of full MAML at 30-50% lower computational cost.

Reptile with Gradient Clipping

The standard Reptile algorithm performs well on well-conditioned problems but can diverge when task gradients vary significantly in magnitude. Gradient-clipped Reptile modifies the update rule:

where \( \text{clip}(x, \delta) = x \cdot \min(1, \delta/||x||) \) and \( \phi_i \) is the task-specific parameter after inner-loop adaptation. This variant demonstrates particular effectiveness in few-shot reinforcement learning, where reward scales can cause exploding gradients.

Bayesian MAML (BMAML)

BMAML incorporates uncertainty estimation by maintaining a distribution over model parameters rather than point estimates. The algorithm:

1. Represents parameters as \( \theta \sim \mathcal{N}(\mu, \Sigma) \)
2. Performs inner-loop updates on both mean and covariance
3. Uses the evidence lower bound (ELBO) for meta-updates

The meta-objective becomes:

where \( p(\theta) \) is a prior distribution. BMAML shows particular promise in medical imaging applications where uncertainty quantification is critical.

Multi-Step Reptile

While standard Reptile uses a single inner-loop step, the multi-step variant performs \( K \) steps of SGD per task before computing the meta-update. The key insight is that the expected value of \( \phi_i - \theta \) after \( K \) steps contains higher-order information about the loss landscape. For quadratic losses, this can be shown to approximate:

This automatically balances between first-order and second-order information without explicit Hessian computation.

Task-Conditioned MAML

This variant replaces the global parameter initialization with a learned function \( g(z_\tau) \) that generates initial parameters conditioned on task descriptors \( z_\tau \). The meta-optimization objective becomes:

In robotics applications, \( z_\tau \) might encode physical properties of different objects. This approach achieves state-of-the-art results on the Meta-World benchmark, with 15-20% higher success rates compared to standard MAML.

Comparative Analysis

The computational complexity and performance characteristics vary significantly across variants:

where \( d \) is the parameter dimension. Recent benchmarks on Omniglot and Mini-ImageNet show FOMAML and Reptile variants achieving within 2-3% accuracy of full MAML while requiring 3-5x less computation.

Meta-learning algorithms like MAML and Reptile can be enhanced by integrating them with complementary techniques, improving adaptation speed, generalization, and robustness. Below, we explore key approaches for combining these methods with other machine learning paradigms.

Hybridization with Bayesian Meta-Learning

Bayesian meta-learning provides uncertainty estimates, which can be integrated into MAML and Reptile to improve few-shot decision-making. The key idea is to model the posterior distribution over task-specific parameters θ while meta-learning the prior. For MAML, this involves modifying the inner-loop update to sample from a variational approximation:

Here, σ captures epistemic uncertainty. The outer-loop update then minimizes the expected loss under this distribution. Reptile can similarly be extended by maintaining a distribution over the initialization θ and updating it via Bayesian optimization.

Integration with Memory-Augmented Networks

Memory-augmented neural networks (MANNs), such as Neural Turing Machines or Differentiable Neural Computers, can store and retrieve task-specific information. Combining MANNs with MAML or Reptile allows for rapid adaptation by leveraging stored patterns. The memory module M is meta-trained alongside θ, with the inner loop updating both:

This is particularly effective in scenarios requiring long-term dependency modeling, such as few-shot language modeling or reinforcement learning.

Combining with Gradient-Free Optimization

For problems where gradient computation is expensive or noisy, MAML and Reptile can be paired with gradient-free optimization methods like evolutionary strategies (ES). The inner-loop adaptation can be performed using ES, while the meta-update remains gradient-based. For Reptile, this involves:

where ε is a step size and ES_Update represents an evolutionary strategy perturbation. This hybrid approach is useful in robotics and control tasks where policy gradients suffer from high variance.

Multi-Task and Transfer Learning Synergies

MAML and Reptile can be combined with multi-task learning (MTL) frameworks to leverage shared representations across tasks. The meta-parameters θ are trained jointly on multiple task distributions, with task-specific heads. The loss function becomes:

where λ balances meta-learning and MTL objectives. This is particularly effective in domains like healthcare, where tasks share underlying physiological features.

Applications in Reinforcement Learning

In reinforcement learning (RL), MAML and Reptile are often combined with policy gradient methods or Q-learning. For example, in MAML-RL, the inner-loop update performs policy gradient steps on the task-specific reward, while the outer loop meta-optimizes the initial policy. Reptile can be similarly applied by iteratively averaging policy parameters across tasks. Recent work has shown success in combining these methods with hierarchical RL for complex, sparse-reward environments.

These combinations demonstrate the flexibility of MAML and Reptile as meta-learning frameworks, capable of integrating with diverse techniques to address limitations in scalability, uncertainty, and task diversity.

Computational and Memory Constraints

Both Reptile and MAML require significant computational resources due to their nested optimization structure. MAML, in particular, involves computing second-order derivatives during meta-training, which scales quadratically with the number of parameters. For a model with N parameters, the memory requirement is O(N²), making it impractical for large architectures like modern transformers. Reptile avoids explicit second-order computations but still requires multiple inner-loop gradient steps, leading to slower convergence compared to single-task learning.

where T is the number of tasks sampled per meta-update. This constraint often forces practitioners to use smaller networks or fewer inner-loop steps, potentially limiting model capacity.

Task Distribution Sensitivity

The performance of both algorithms heavily depends on the diversity and quality of the task distribution during meta-training. If tasks are too similar, the model may fail to learn transferable features; if they are too dissimilar, the meta-optimization may not converge. This creates a delicate balancing act in task design. Empirical studies show that MAML's performance can degrade by 15-30% when task distributions deviate from the i.i.d. assumption.

Gradient Instability

The nested optimization in MAML amplifies gradient noise, particularly when using few inner-loop steps. The meta-gradient:

involves differentiating through the inner-loop optimization path. When inner-loop steps are noisy (common with small task batches), this can lead to exploding or vanishing meta-gradients. Reptile's first-order approximation provides more stable updates but sacrifices theoretical guarantees of convergence to the optimal initialization.

Few-Shot Learning Limitations

While designed for few-shot scenarios, both algorithms struggle when the number of shots drops below a critical threshold. For MAML, the minimum required shots k scale with:

where C depends on task complexity, ϵ is target error, and δ is confidence. In practice, performance degrades sharply when k < 5 for most vision benchmarks, limiting true "one-shot" applicability.

Catastrophic Forgetting in Continual Learning

When applied to continual learning settings, both algorithms exhibit catastrophic forgetting of previously learned tasks. The meta-update:

does not explicitly preserve knowledge from earlier tasks. Recent variants like ANML (a MAML extension) add regularization terms, but at the cost of 40-50% increased compute overhead. This remains an open research challenge.

Hyperparameter Sensitivity

The algorithms require careful tuning of three key hyperparameters:

• Inner-loop learning rate α
• Meta-learning rate β
• Number of inner-loop steps K

Empirical analyses show that optimal α values often lie in narrow ranges (e.g., 0.01-0.05 for MAML on Omniglot), and performance can drop by over 60% outside this window. Automated hyperparameter optimization methods struggle due to the expensive meta-training process.

Transfer Learning Gaps

While meta-learned initializations transfer well across similar domains (e.g., character recognition across alphabets), performance drops significantly when transferring between modalities (e.g., vision to speech). The representation similarity analysis reveals that only 30-40% of learned features are truly domain-agnostic, limiting real-world deployment scenarios.

• sudharsan13296/Hands-On-Meta-Learning-With-Python - GitHub — You will delve into various one-shot learning algorithms, like siamese, prototypical, relation and memory-augmented networks by implementing them in TensorFlow and Keras. As you make your way through the book, you will dive into state-of-the-art meta learning algorithms such as MAML, Reptile, and CAML.
• PDF Beyond Reptile: Meta-Learned Dot-Product Maximization between Gradients ... — 2.1 Background on Reptile and MAML Algorithms MAML The MAML algorithm, initially in-tended for multi-task few-shot learning, proposed to do ksteps of "inner" gradient updates, after which the loss was computed and minimized on the (k+1)th batch, with respect to the original weights before the kinner steps. The gradient from this loss
• PDF Memory-Based Optimization Methods for Model-Agnostic Meta-Learning and ... — In recent years, model-agnostic meta-learning (MAML) has become a popular research area. However, the stochastic optimization of MAML is still underdeveloped. Existing MAML algorithms rely on the "episode" idea by sampling a few tasks and data points to update the meta-model at each iteration. Nonetheless, these algorithms either fail to
• PDF Global Convergence of MAML and Theory-Inspired Neural Architecture ... — • Global Convergence and Induced Kernels of MAML1: We prove that with over-parameterized DNNs (i.e., DNNs with a large number of neurons in each layer), MAML is guaranteed to converge to global optima with zero train-ing loss at a linear rate. The key to our proof is to de-velop bounds on the gradient of the MAML objective,
• R Learning or Feature Reuse? Towards Understanding the Effectiveness of ... — MAML algorithm, incorporating an outer loop (for meta-training), and an inner loop (for task-specific adaptation), and there is little prior work analyzing why this central part of the MAML algorithm is practically successful. In this work, we focus on this foundational question, examining how and why MAML leads to effective few-shot learning.
• Combining Model-Agnostic Meta-Learning and Transfer Learning for ... — 3. MAML. MAML is composed of the following two training stages: meta-training and adaptation. The aim of the first stage, meta-training, is to learn the general structure of a given set of M tasks called meta-tasks and initialize a model with the generalized parameters that have been obtained. Each meta-task is associated with a dataset extracted from the corresponding task.
• [1803.02999] On First-Order Meta-Learning Algorithms - ar5iv — In this section, we describe a new first-order gradient-based meta-learning algorithm called Reptile. Like MAML, Reptile learns an initialization for the parameters of a neural network model, such that when we optimize these parameters at test time, learning is fast—i.e., the model generalizes from a small number of examples from the test task.
• (PDF) A Comprehensive Survey of Few-shot Learning: Evolution ... — Summary MAML, Reptile and their variants Model Directions for impr ovement Key Approach First order gradient Two-step gradient MAML [94] Original Inner-loop+outer-loop % "

• Hands-On-Meta-Learning-With-Python/06. MAML and it's Variants/6.2 MAML ... — Learning to Learn using One-Shot Learning, MAML, Reptile, Meta-SGD and more with Tensorflow - sudharsan13296/Hands-On-Meta-Learning-With-Python
• Learning to Learn using One-Shot Learning, MAML, Reptile, Meta-SGD and ... — The book starts with explaining the fundamentals of meta learning and takes the readers to understand the concept of learning to learn. We will learn various one-shot learning algorithms like Siamese, prototypical, relation and memory-augmented networks by implementing them in TensorFlow and Keras.
• Hands-On Meta Learning With Python - GitHub — You will delve into various one-shot learning algorithms, like siamese, prototypical, relation and memory-augmented networks by implementing them in TensorFlow and Keras. As you make your way through the book, you will dive into state-of-the-art meta learning algorithms such as MAML, Reptile, and CAML.
• MAC: a meta-learning approach for feature learning and ... - Springer — Of all the strategies, MAML [11] and its first-order approximation is the most widely used. Another algorithm, Meta-SGD [25], enhances meta-learning performance by modifying the optimization procedure itself. Recently, some articles [15, 26, 27] gained popularity by demystifying MAML's success.
• 6.2 MAML ALgorithm-checkpoint.ipynb - GitHub — Learning to Learn using One-Shot Learning, MAML, Reptile, Meta-SGD and more with Tensorflow - sudharsan13296/Hands-On-Meta-Learning-With-Python
• PDF Beyond Reptile: Meta-Learned Dot-Product Maximization between Gradients ... — Meta-learning algorithms such as MAML, Reptile, and FOMAML have led to improved performance of several neural models. The primary difference between standard gradient descent and these meta-learning approaches is that they contain as a small component the gradient for maximizing dot-product between gradients of batches, leading to improved gen ...
• [1803.02999] On First-Order Meta-Learning Algorithms - ar5iv — This family includes and generalizes first-order MAML, an approximation to MAML obtained by ignoring second-order derivatives. It also includes Reptile, a new algorithm that we introduce here, which works by repeatedly sampling a task, training on it, and moving the initialization towards the trained weights on that task.
• On First-Order Meta-Learning Algorithms - arXiv.org — This family includes and generalizes rst-order MAML, an approximation to MAML obtained by ignoring second-order derivatives. It also includes Reptile, a new algorithm that we introduce here, which works by repeatedly sampling a task, training on it, and moving the initialization towards the trained weights on that task.
• Combining Model-Agnostic Meta-Learning and Transfer Learning for ... — MAML is a meta-learning method that is applicable to various problems, such as regression, classification, and reinforcement learning [5]. The use of the first-order derivative has been recommended to enable faster training at the cost of sacrificing prediction performance. A first-order version of MAML was also proposed in [12].
• Distributed unsupervised meta-learning algorithm over multi-agent ... — Existing distributed meta-learning algorithms, such as Dif-MAML , primarily focus on supervised distributed meta-learning. Given the difficulty in obtaining labeled datasets in certain scenarios, studying distributed unsupervised meta-learning algorithms has become particularly valuable.

• sudharsan13296/Hands-On-Meta-Learning-With-Python - GitHub — You will delve into various one-shot learning algorithms, like siamese, prototypical, relation and memory-augmented networks by implementing them in TensorFlow and Keras. As you make your way through the book, you will dive into state-of-the-art meta learning algorithms such as MAML, Reptile, and CAML.
• Implementation of MAML and Reptile algorithms with a JS demo on the ... — Both MAML and Reptile attempts to solve the metalearning problem by learning an initialization for network parameters, such that the network is able to adapt to new tasks quickly. If we consider the space of network parameters, then MAML and Reptile both seek to find an optimal starting point in ...
• PDF Reptile: a Scalable Meta-learning Algorithm - GitHub Pages — a step forward and analyse behaviour of the algorithm in the Analysis section. First, they factor and compare the grads of MAML, First-Order MAML and Reptile. Second, they show (informally) that Reptile converges to a solution close (in Euclidean distance) to each task manifold of optimal solutions.
• GitHub - hfahrudin/MetaLearn-MAML_Reptile: Implements popular meta ... — The implemented algorithms include: Reptile: A simple and efficient gradient-based meta-learning method. Model-Agnostic Meta-Learning (MAML): A widely-used meta-learning algorithm for fast adaptation. MAML Enhanced: A customized version of MAML, incorporating:
• An Interactive Introduction to Model-Agnostic Meta-Learning - GitHub Pages — Now, at this point, you might have already understood how the Reptile update works, but no idea if and why it would find the same optimal initialization that MAML does! As for the if, Reptile does not (always) find the same optimal initialization that MAML would find since Reptile does not minimize the same objective. However, Reptile performs ...
• Reptile: A scalable meta-learning algorithm - OpenAI — We've developed a simple meta-learning algorithm called Reptile which works by repeatedly sampling a task, performing stochastic gradient descent on it, and updating the initial parameters towards the final parameters learned on that task. Reptile is the application of the Shortest Descent algorithm to the meta-learning setting, and is mathematically similar to first-order MAML (which is a ...
• [1803.02999] On First-Order Meta-Learning Algorithms - ar5iv — In this section, we describe a new first-order gradient-based meta-learning algorithm called Reptile. Like MAML, Reptile learns an initialization for the parameters of a neural network model, such that when we optimize these parameters at test time, learning is fast—i.e., the model generalizes from a small number of examples from the test task.
• [1803.02999] On First-Order Meta-Learning Algorithms - arXiv.org — This paper considers meta-learning problems, where there is a distribution of tasks, and we would like to obtain an agent that performs well (i.e., learns quickly) when presented with a previously unseen task sampled from this distribution. We analyze a family of algorithms for learning a parameter initialization that can be fine-tuned quickly on a new task, using only first-order derivatives ...
• 6.3 MAML in Supervised Learning.ipynb - GitHub — You signed in with another tab or window. Reload to refresh your session. You signed out in another tab or window. Reload to refresh your session. You switched accounts on another tab or window.