SYNTOLOGY HomeExplorerAtlasCodeMethodologyAboutDevelopersFeedPricing
Paper · 1703.03400 · 2017

Model-Agnostic Meta-Learning for Fast Adaptation of Deep Networks

Sergey Levine, Chelsea Finn, Pieter Abbeel

arXiv · PDF · Open in the Atlas

Code that ran

103 of 154 samples (functions and classes) lifted from this paper's linked repositories executed on a synthesized input in Syntology's jail (35 of them constructed an object rather than computing a result; 6 honoured the contract we drafted, 1 violated it and 61 have no contract verdict; 35 failures of our instrument; 51 no recorded run); 1 of them was also run on the host, not in the jail, by the peer-agreement lane that set its level, measured 2026-11-21; repository links from the Papers with Code archive attributed under CC BY-SA, no affiliation; bodies inline only under a permissive licence as GitHub detects it. Not a reproduction of the paper's results.

"Ran" means the function executed on a synthesized input and returned a value. It is not a reproduction of the paper's results. This record, dated, as JSON: /api/ran/1703.03400.json · badge: /api/ran/1703.03400.svg

Each repository's role is a label: a classifier's output recorded on the link, or, where no role is recorded, what the Papers with Code archive marked. The line under it names its basis. Neither says who wrote the code.

RepositoryRoleRan
cbfinn/maml canonical (classifier label)
classifier basis not recorded on the link
1 ran · 0 no recorded run
dkalpakchi/ReproducingSCAPytorch community
not in the paper's declared repositories
8 ran · 5 no recorded run
crashmoon/MAML-Pytorch-Multi-GPUs community
Papers with Code archive
7 ran · 0 no recorded run
Octavio-Pappalardo/MAML_for_RL_pytorch community (classifier label)
classifier basis not recorded on the link
7 ran · 0 no recorded run
AntreasAntoniou/HowToTrainYourMAMLPytorch community
Papers with Code archive
6 ran · 3 no recorded run
nyu-larx/attack_metarl community
not in the paper's declared repositories
5 ran · 3 no recorded run
MaximeVandegar/Papers-in-100-Lines-of-Code community
not in the paper's declared repositories
5 ran · 0 no recorded run
ido90/roml-maml community
not in the paper's declared repositories
4 ran · 4 no recorded run
mikehuisman/revisiting-learned-optimizers community
not in the paper's declared repositories
4 ran · 2 no recorded run
learnables/learn2learn community
not in the paper's declared repositories
4 ran · 1 no recorded run
MoritzTaylor/maml-rl-tf2 community (classifier label)
classifier basis not recorded on the link
4 ran · 1 no recorded run
LKLQQ/LEO community (classifier label)
classifier basis not recorded on the link
4 ran · 0 no recorded run
fmu2/PyTorch-MAML community
not in the paper's declared repositories
3 ran · 1 no recorded run
lif31up/model-agnostic-meta-learning community
not in the paper's declared repositories
3 ran · 1 no recorded run
KamalM8/Few-Shot-learning-Fashion community
Papers with Code archive
3 ran · 1 no recorded run
shunzh/pytorch-maml-rl community
not in the paper's declared repositories
3 ran · 1 no recorded run
theneuralbeing/maml community
not in the paper's declared repositories
3 ran · 0 no recorded run
katerakelly/pytorch-maml community (classifier label)
classifier basis not recorded on the link
3 ran · 0 no recorded run
lgcollins/tr-maml community
not in the paper's declared repositories
2 ran · 3 no recorded run
Zhiwei-Z/SeqPromp community
Papers with Code archive
2 ran · 2 no recorded run
dragen1860/MAML-Pytorch-RL community
not in the paper's declared repositories
2 ran · 1 no recorded run
hfahrudin/reptile_implement_tf2 community
not in the paper's declared repositories
2 ran · 0 no recorded run
SinghJasdeep/Projecting-Conflicting-Gradients community (classifier label)
classifier basis not recorded on the link
2 ran · 0 no recorded run
iclavera/meta-mb community (classifier label)
classifier basis not recorded on the link
1 ran · 3 no recorded run
clrrrr/promp_plus community
Papers with Code archive
1 ran · 2 no recorded run
FunctionStatusWhere it lives
td_target Ran
ran, honoured the contract we drafted
iclavera/meta-mb/meta_mb/algos/sac.py
code served (permissive licence) · get_code("31deb9c7be58e00c")
How it ran

Ran in Syntology's jail on this synthesized input (drafted by a language model, Claude Haiku 4.5, prompt python_fixture_v1) and returned Tensor, ndim 2, dtype family float, shape (2, 4) as a later run recorded it. The image it ran in was not recorded. The comparison behind this sample's level is a different run: the peer-agreement lane ran it again on the host, not in the jail (report dated 2026-09-04T23:10:55Z). If your copy returns the same type, ndim and shape on these inputs, it matched what we observed; nothing here checks that. It does NOT mean the output is correct: nothing has compared it to the paper.

import torch
import numpy as np

torch.manual_seed(0)

# Construct arguments for td_target(reward, discount, next_value)
# The function computes: reward + discount * next_value
# All parameters are numeric values or tensors

reward = torch.tensor([[1.0, 2.0, 3.0, 4.0],
                       [5.0, 6.0, 7.0, 8.0]])  # shape (2, 4)

discount = 0.99  # scalar discount factor

next_value = torch.tensor([[0.5, 0.6, 0.7, 0.8],
                           [0.9, 1.0, 1.1, 1.2]])  # shape (2, 4)

ARGS = {
    "reward": reward,
    "discount": discount,
    "next_value": next_value
}
Setup block drafted by
a language model, Claude Haiku 4.5, prompt python_fixture_v1
Imports
numpy, torch — import names as written, not package names to install; a name the repository itself provides is not a package
Returned
type Tensor, ndim 2, dtype family float, shape (2, 4) — shape (2, 4) as a later run recorded it
dtype family
int means an integer dtype; float means any other dtype the instrument saw, bool and complex included (fixture_check.py records only these two families)
Environment
image not recorded; re-verify against syntology-harvest-sandbox:v5-deps; not recorded for this sample: the harness installs a cuda-to-cpu shim (cuda_shim.py) before every sample and no run records whether a sample needed it; seed: none by the harness; any seed is in the setup block
Axes Ran
ran on a synthesized input · constructed an object; no result was computed
ido90/roml-maml/MAML.py
pointer only (licence: NONE) · get_code("34f35211dea92750")
How it ran

The body of this sample is withheld: GitHub detected no licence in this paper's repository, ido90/roml-maml when it was checked. The setup block that called it is withheld with it, because it is written against that body. source_path and origin say where the code lives, to read under the repository's own terms. A run is recorded.

BaseLearner Ran
ran on a synthesized input · constructed an object; no result was computed
learnables/learn2learn/learn2learn/algorithms/maml.py
code served (permissive licence) · get_code("77bf690edcbd2974")
How it ran

Ran in Syntology's sandbox on this synthesized input (drafted by a language model, Claude Haiku 4.5, prompt python_fixture_v1, through the batch API) and returned an instance of its own class, BaseLearner: the run constructed the object and did not call it, so no result was computed. The image it ran in was not recorded. If your copy returns the same type on these inputs, it matched what we observed; nothing here checks that. It does NOT mean the output is correct: nothing has compared it to the paper.

import torch
from torch import nn

torch.manual_seed(0)

# Create a simple module to pass as the 'module' parameter
class SimpleModule(nn.Module):
    def __init__(self):
        super(SimpleModule, self).__init__()
        self.linear = nn.Linear(4, 3)
    
    def forward(self, x):
        return self.linear(x)

# Instantiate the simple module
simple_module = SimpleModule()

# Define the ARGS dictionary with all parameters for BaseLearner
ARGS = {
    'module': simple_module
}
Setup block drafted by
a language model, Claude Haiku 4.5, prompt python_fixture_v1, through the batch API
Imports
torch — import names as written, not package names to install; a name the repository itself provides is not a package
Returned
type BaseLearner — the run constructed an instance of its own class and did not call it; no shape is stated — the instrument coerces any output to an array; for a BaseLearner output the recorded ndim 0 and dtype family float describe that coercion, not the output, and are not stated
Environment
image not recorded; re-verify against syntology-harvest-sandbox:v5-deps; not recorded for this sample: the harness installs a cuda-to-cpu shim (cuda_shim.py) before every sample and no run records whether a sample needed it; seed: none by the harness; any seed is in the setup block
BatchNorm Ran
ran on a synthesized input
dkalpakchi/ReproducingSCAPytorch/few_shot_learning_system.py
code served (permissive licence) · get_code("ea8b6ed6450139f9")
How it ran

Ran in Syntology's sandbox on this synthesized input (drafted by a language model, class construct-then-call prompt, model not recorded) and returned Tensor, ndim 4, dtype family float; no output shape is stated. The image it ran in was not recorded. If your copy returns the same type and ndim on these inputs, it matched what we observed; nothing here checks that. It does NOT mean the output is correct: nothing has compared it to the paper.

import torch
import torch.nn as nn
import torch.nn.functional as F
from copy import copy

class BatchNorm(nn.Module):

    def __init__(self, num_features, device, args, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True, meta_batch_norm=True, no_learnable_params=False, use_per_step_bn_statistics=False):
        super(BatchNorm, self).__init__()
        self.eps = eps
        self.device = device
        self.momentum = momentum
        self.weight = nn.Parameter(torch.ones(num_features))
        self.bias = nn.Parameter(torch.zeros(num_features))
        self.use_per_step_bn_statistics = use_per_step_bn_statistics
        self.running_mean = nn.Parameter(torch.zeros(num_features), requires_grad=False)
        self.running_var = nn.Parameter(torch.ones(num_features), requires_grad=False)
        self.backup_running_mean = torch.zeros(self.running_mean.shape)
        self.backup_running_var = torch.ones(self.running_var.shape)

    def forward(self, x, num_step, params=None, training=False, backup_running_statistics=False):
        if params:
            weight = params['weight']
            bias = params['bias']
        else:
            weight = self.weight
            bias = self.bias
        if backup_running_statistics and self.use_per_step_bn_statistics:
            self.backup_running_mean.data = copy(self.running_mean.data)
            self.backup_running_var.data = copy(self.running_var.data)
        if training:
            m1 = x.mean((0, 2, 3))
            m2 = (x ** 2).mean((0, 2, 3))
            self.running_mean.data = (1 - self.momentum) * self.running_mean + self.momentum * m1
            self.running_var.data = (1 - self.momentum) * self.running_var + self.momentum * (m2 - m1 ** 2)
        return F.batch_norm(x, self.running_mean, self.running_var, weight, bias, False, self.momentum, self.eps)

    def restore_backup_stats(self):
        """
        Resets batch statistics to their backup values which are collected after each forward pass.
        """
        if self.use_per_step_bn_statistics:
            self.running_mean = nn.Parameter(self.backup_running_mean.to(device=self.device), requires_grad=False)
            self.running_var = nn.Parameter(self.backup_running_var.to(device=self.device), requires_grad=False)


INIT_ARGS = {
    'num_features': 4,
    'device': 'cpu',
    'args': {},
    'eps': 1e-05,
    'momentum': 0.1,
    'affine': True,
    'track_running_stats': True,
    'meta_batch_norm': True,
    'no_learnable_params': False,
    'use_per_step_bn_statistics': True,
}

ARGS = {
    'x': torch.randn(2, 4, 3, 3),
    'num_step': 1,
    'params': None,
    'training': True,
    'backup_running_statistics': True,
}

if __name__ == '__main__':
    bn = BatchNorm(**INIT_ARGS)
    output = bn(**ARGS)
    print("Output shape:", output.shape)
    print("Output:", output)
Setup block drafted by
a language model, class construct-then-call prompt, model not recorded
Imports
torch — import names as written, not package names to install; a name the repository itself provides is not a package
Returned
type Tensor, ndim 4, dtype family float — no output shape is stated: observe_signature.py observed this class with its constructor sizes canonicalised where it could, which the node does not record, so its shape is not stated as this setup block's
dtype family
int means an integer dtype; float means any other dtype the instrument saw, bool and complex included (fixture_check.py records only these two families)
Environment
image not recorded; re-verify against syntology-harvest-sandbox:v5-deps; not recorded for this sample: the harness installs a cuda-to-cpu shim (cuda_shim.py) before every sample and no run records whether a sample needed it; seed: torch and numpy seeded to 0 by the harness immediately before the class was constructed from INIT_ARGS (fixture_check.py)
BatchNorm2d Ran
ran on a synthesized input · constructed an object; no result was computed
fmu2/PyTorch-MAML/models/maml.py
pointer only (licence: NONE) · get_code("8bdb2b9d394d85bf")
How it ran

The body of this sample is withheld: GitHub detected no licence in this paper's repository, fmu2/PyTorch-MAML when it was checked. The setup block that called it is withheld with it, because it is written against that body. source_path and origin say where the code lives, to read under the repository's own terms. A run is recorded.

BatchNorm2d_fw Ran
ran on a synthesized input
crashmoon/MAML-Pytorch-Multi-GPUs/meta_learner.py
pointer only (licence: NONE) · get_code("ef054b436c8098d9")
How it ran

The body of this sample is withheld: GitHub detected no licence in this paper's repository, crashmoon/MAML-Pytorch-Multi-GPUs when it was checked. The setup block that called it is withheld with it, because it is written against that body. source_path and origin say where the code lives, to read under the repository's own terms. A run is recorded.

BottleneckLayer Ran
ran on a synthesized input · constructed an object; no result was computed
dkalpakchi/ReproducingSCAPytorch/few_shot_learning_system.py
code served (permissive licence) · get_code("609db509762535cb")
How it ran

Ran in Syntology's sandbox on this synthesized input (drafted by a language model, Claude Haiku 4.5, prompt python_fixture_v1, through the batch API) and returned an instance of its own class, BottleneckLayer: the run constructed the object and did not call it, so no result was computed. The image it ran in was not recorded. If your copy returns the same type on these inputs, it matched what we observed; nothing here checks that. It does NOT mean the output is correct: nothing has compared it to the paper.

import torch
import torch.nn as nn

torch.manual_seed(0)

class BatchNormStandIn(nn.Module):
    def __init__(self, num_features, device, args):
        super(BatchNormStandIn, self).__init__()
        self.num_features = num_features
        self.device = device
        self.args = args
        self.weight = nn.Parameter(torch.ones(num_features))
        self.bias = nn.Parameter(torch.zeros(num_features))
        self.running_mean = torch.zeros(num_features)
        self.running_var = torch.ones(num_features)
        self.backup_running_mean = None
        self.backup_running_var = None
    
    def forward(self, x, num_step, params=None, training=False, backup_running_statistics=False):
        if backup_running_statistics:
            self.backup_running_mean = self.running_mean.clone()
            self.backup_running_var = self.running_var.clone()
        if params:
            weight = params.get('weight', self.weight)
            bias = params.get('bias', self.bias)
        else:
            weight = self.weight
            bias = self.bias
        return nn.functional.batch_norm(
            x, 
            self.running_mean if not training else None,
            self.running_var if not training else None,
            weight=weight,
            bias=bias,
            training=training,
            momentum=0.1,
            eps=1e-5
        )
    
    def restore_backup_stats(self):
        if self.backup_running_mean is not None:
            self.running_mean = self.backup_running_mean
        if self.backup_running_var is not None:
            self.running_var = self.backup_running_var

ARGS = {
    'in_channels': 4,
    'device': torch.device('cpu'),
    'args': {},
    'batch_norm_cls': BatchNormStandIn
}
Setup block drafted by
a language model, Claude Haiku 4.5, prompt python_fixture_v1, through the batch API
Imports
torch — import names as written, not package names to install; a name the repository itself provides is not a package
Returned
type BottleneckLayer — the run constructed an instance of its own class and did not call it; no shape is stated — the instrument coerces any output to an array; for a BottleneckLayer output the recorded ndim 0 and dtype family float describe that coercion, not the output, and are not stated
Environment
image not recorded; re-verify against syntology-harvest-sandbox:v5-deps; not recorded for this sample: the harness installs a cuda-to-cpu shim (cuda_shim.py) before every sample and no run records whether a sample needed it; seed: none by the harness; any seed is in the setup block
CNN_MAML Ran
ran on a synthesized input · constructed an object; no result was computed
lif31up/model-agnostic-meta-learning/models/ConvNet.py
code served (permissive licence) · get_code("ef83f512b95bdb2e")
How it ran

Ran in Syntology's sandbox on this synthesized input (drafted by a language model, Claude Haiku 4.5, prompt python_fixture_v1, through the batch API) and returned an instance of its own class, CNN_MAML: the run constructed the object and did not call it, so no result was computed. The image it ran in was not recorded. If your copy returns the same type on these inputs, it matched what we observed; nothing here checks that. It does NOT mean the output is correct: nothing has compared it to the paper.

import torch
import torch.nn as nn
import torchvision as tv
from torch.utils.data import TensorDataset

torch.manual_seed(0)

# Create a minimal transform
transform = tv.transforms.Compose([
    tv.transforms.Resize((28, 28)),
    tv.transforms.Grayscale(num_output_channels=1),
    tv.transforms.ToTensor(),
    tv.transforms.Normalize(mean=[0.5], std=[0.5])
])

# Create a minimal imageset stand-in
class DummyImageSet:
    def __init__(self):
        self.data = [torch.randn(1, 28, 28) for _ in range(10)]
        self.targets = [0, 1, 0, 1, 2, 3, 2, 3, 4, 4]
    
    def __len__(self):
        return len(self.data)
    
    def __getitem__(self, idx):
        return self.data[idx], self.targets[idx]

def get_imageset():
    return DummyImageSet()

# Create a minimal Config
class Config:
    def __init__(self):
        self.input_channels = 1
        self.hidden_channels = 32
        self.output_channels = 5
        self.n_convs = 4
        self.kernel_size = 3
        self.padding = 1
        self.stride = 1
        self.bias = True
        self.iterations = 100
        self.alpha = 0.001
        self.eps = 1e-05
        self.epochs = 30
        self.beta = 0.0001
        self.batch_size = 2
        self.n_way = 5
        self.k_shot = 5
        self.n_query = 5
        self.save_to = './models'
        self.transform = transform
        self.imageset = get_imageset()
        self.dummy = torch.zeros(1, self.input_channels, 28, 28)

config = Config()

ARGS = {
    'config': config
}
Setup block drafted by
a language model, Claude Haiku 4.5, prompt python_fixture_v1, through the batch API
Imports
torch, torchvision — import names as written, not package names to install; a name the repository itself provides is not a package
Returned
type CNN_MAML — the run constructed an instance of its own class and did not call it; no shape is stated — the instrument coerces any output to an array; for a CNN_MAML output the recorded ndim 0 and dtype family float describe that coercion, not the output, and are not stated
Environment
image not recorded; re-verify against syntology-harvest-sandbox:v5-deps; not recorded for this sample: the harness installs a cuda-to-cpu shim (cuda_shim.py) before every sample and no run records whether a sample needed it; seed: none by the harness; any seed is in the setup block
Conv2d Ran
ran on a synthesized input
dkalpakchi/ReproducingSCAPytorch/few_shot_learning_system.py
code served (permissive licence) · get_code("b0978ebdb0ce3ed2")
How it ran

Ran in Syntology's sandbox on this synthesized input (drafted by a language model, class construct-then-call prompt, model not recorded) and returned Tensor, ndim 4, dtype family float; no output shape is stated. The image it ran in was not recorded. If your copy returns the same type and ndim on these inputs, it matched what we observed; nothing here checks that. It does NOT mean the output is correct: nothing has compared it to the paper.

import torch
import torch.nn as nn
import torch.nn.functional as F

class Conv2d(nn.Module):

    def __init__(self, in_channels, out_channels, kernel_size, padding=0):
        super(Conv2d, self).__init__()
        self.in_channels = in_channels
        self.out_channels = out_channels
        self.kernel_size = kernel_size
        self.padding = padding
        self.weight = nn.Parameter(torch.Tensor(out_channels, in_channels, *kernel_size))
        self.bias = nn.Parameter(torch.Tensor(out_channels))
        self.reset_parameters()

    def reset_parameters(self):
        nn.init.xavier_uniform_(self.weight)
        nn.init.zeros_(self.bias)

    def forward(self, x, num_step, params=None, training=False, backup_running_statistics=False):
        if params:
            weight = params['weight']
            bias = params['bias']
        else:
            weight = self.weight
            bias = self.bias
        return F.conv2d(x, weight, bias=bias, padding=self.padding)


INIT_ARGS = {
    'in_channels': 3,
    'out_channels': 4,
    'kernel_size': (3, 3),
    'padding': 1
}

ARGS = {
    'x': torch.randn(2, 3, 8, 8),
    'num_step': 1,
    'params': None,
    'training': False,
    'backup_running_statistics': False
}

if __name__ == '__main__':
    model = Conv2d(**INIT_ARGS)
    output = model(**ARGS)
    print(f"Output shape: {output.shape}")
    print(f"Expected shape: (2, 4, 8, 8)")
Setup block drafted by
a language model, class construct-then-call prompt, model not recorded
Imports
torch — import names as written, not package names to install; a name the repository itself provides is not a package
Returned
type Tensor, ndim 4, dtype family float — no output shape is stated: observe_signature.py observed this class with its constructor sizes canonicalised where it could, which the node does not record, so its shape is not stated as this setup block's
dtype family
int means an integer dtype; float means any other dtype the instrument saw, bool and complex included (fixture_check.py records only these two families)
Environment
image not recorded; re-verify against syntology-harvest-sandbox:v5-deps; not recorded for this sample: the harness installs a cuda-to-cpu shim (cuda_shim.py) before every sample and no run records whether a sample needed it; seed: torch and numpy seeded to 0 by the harness immediately before the class was constructed from INIT_ARGS (fixture_check.py)
Conv2d_fw Ran
ran on a synthesized input
crashmoon/MAML-Pytorch-Multi-GPUs/meta_learner.py
pointer only (licence: NONE) · get_code("260ae4e7be8f8d1b")
How it ran

The body of this sample is withheld: GitHub detected no licence in this paper's repository, crashmoon/MAML-Pytorch-Multi-GPUs when it was checked. The setup block that called it is withheld with it, because it is written against that body. source_path and origin say where the code lives, to read under the repository's own terms. A run is recorded.

Conv4 Ran
ran on a synthesized input
crashmoon/MAML-Pytorch-Multi-GPUs/meta_learner.py
pointer only (licence: NONE) · get_code("f8d3ba63fa4d3088")
How it ran

The body of this sample is withheld: GitHub detected no licence in this paper's repository, crashmoon/MAML-Pytorch-Multi-GPUs when it was checked. The setup block that called it is withheld with it, because it is written against that body. source_path and origin say where the code lives, to read under the repository's own terms. A run is recorded.

ConvBlock Ran
ran on a synthesized input · constructed an object; no result was computed
crashmoon/MAML-Pytorch-Multi-GPUs/meta_learner.py
pointer only (licence: NONE) · get_code("6e452cdc0fadf441")
How it ran

The body of this sample is withheld: GitHub detected no licence in this paper's repository, crashmoon/MAML-Pytorch-Multi-GPUs when it was checked. The setup block that called it is withheld with it, because it is written against that body. source_path and origin say where the code lives, to read under the repository's own terms. A run is recorded.

ConvNet Ran
ran on a synthesized input · constructed an object; no result was computed
crashmoon/MAML-Pytorch-Multi-GPUs/meta_learner.py
pointer only (licence: NONE) · get_code("5d78dd8984d02527")
How it ran

The body of this sample is withheld: GitHub detected no licence in this paper's repository, crashmoon/MAML-Pytorch-Multi-GPUs when it was checked. The setup block that called it is withheld with it, because it is written against that body. source_path and origin say where the code lives, to read under the repository's own terms. A run is recorded.

Critic Ran
ran on a synthesized input · constructed an object; no result was computed
dkalpakchi/ReproducingSCAPytorch/few_shot_learning_system.py
code served (permissive licence) · get_code("5011b08348e5492e")
How it ran

Ran in Syntology's sandbox on this synthesized input (drafted by a language model, Claude Haiku 4.5, prompt python_fixture_v1, through the batch API) and returned an instance of its own class, Critic: the run constructed the object and did not call it, so no result was computed. The image it ran in was not recorded. If your copy returns the same type on these inputs, it matched what we observed; nothing here checks that. It does NOT mean the output is correct: nothing has compared it to the paper.

import torch
import torch.nn as nn
import math

torch.manual_seed(0)

# Define the Critic class
class Critic(nn.Module):

    def __init__(self, n_classes=5, n_theta=None):
        super(Critic, self).__init__()
        self.__n_classes = n_classes
        self.__n_theta = n_theta
        self.__kernel_size = 2
        for i in range(5):
            setattr(self, f'_conv{i}', nn.Conv1d(in_channels=i * 8 + 1, out_channels=8, kernel_size=self.__kernel_size, dilation=2 ** i, padding=math.floor(2 ** (i - 1) * (self.__kernel_size - 1))))
        out = 5 * 8 + 1
        if n_theta is None:
            self._fc1 = nn.Linear(out * self.__n_classes, out * self.__n_classes)
            self._fc2 = nn.Linear(out * self.__n_classes, 1)
        else:
            self._fc1 = nn.Linear(out * (self.__n_classes + self.__n_theta), 2)
            self._fc2 = nn.Linear(2, 1)

    def conv_forward(self, x):
        x = x.unsqueeze(1)
        x1 = torch.nn.functional.pad(x, (0, 1))
        for i in range(5):
            layer = getattr(self, f'_conv{i}')
            y = torch.nn.functional.relu(layer(x1 if i == 0 else x))
            x = torch.cat((x, y), 1)
        return x.flatten(1)

    def forward(self, predictions, params=None):
        if params is not None:
            x = torch.cat([predictions, params.expand(params.shape[0] * predictions.shape[0], -1)], dim=1)
        else:
            x = predictions
        x = self.conv_forward(x)
        x = torch.nn.functional.relu(self._fc1(x))
        return self._fc2(x).mean()

# Create test arguments
predictions = torch.randn(2, 4)
params = torch.randn(1, 3)
n_classes = 4
n_theta = 3

ARGS = {
    'n_classes': n_classes,
    'n_theta': n_theta
}
Setup block drafted by
a language model, Claude Haiku 4.5, prompt python_fixture_v1, through the batch API
Imports
torch — import names as written, not package names to install; a name the repository itself provides is not a package
Returned
type Critic — the run constructed an instance of its own class and did not call it; no shape is stated — the instrument coerces any output to an array; for a Critic output the recorded ndim 0 and dtype family float describe that coercion, not the output, and are not stated
Environment
image not recorded; re-verify against syntology-harvest-sandbox:v5-deps; not recorded for this sample: the harness installs a cuda-to-cpu shim (cuda_shim.py) before every sample and no run records whether a sample needed it; seed: none by the harness; any seed is in the setup block
DenseBlockUnit Ran
ran on a synthesized input · constructed an object; no result was computed
dkalpakchi/ReproducingSCAPytorch/few_shot_learning_system.py
code served (permissive licence) · get_code("d84b7628e44a934d")
How it ran

Ran in Syntology's sandbox on this synthesized input (drafted by a language model, Claude Haiku 4.5, prompt python_fixture_v1, through the batch API) and returned an instance of its own class, DenseBlockUnit: the run constructed the object and did not call it, so no result was computed. The image it ran in was not recorded. If your copy returns the same type on these inputs, it matched what we observed; nothing here checks that. It does NOT mean the output is correct: nothing has compared it to the paper.

import torch
import torch.nn as nn

torch.manual_seed(0)

# Stand-in batch norm class that matches the expected interface
class MockBatchNorm(nn.Module):
    def __init__(self, num_features, device, args):
        super(MockBatchNorm, self).__init__()
        self.num_features = num_features
        self.device = device
        self.args = args
        self.weight = nn.Parameter(torch.ones(num_features))
        self.bias = nn.Parameter(torch.zeros(num_features))
        self.running_mean = torch.zeros(num_features)
        self.running_var = torch.ones(num_features)
        self.backup_running_mean = torch.zeros(num_features)
        self.backup_running_var = torch.ones(num_features)
    
    def forward(self, x, num_step, params=None, training=False, backup_running_statistics=False):
        if backup_running_statistics:
            self.backup_running_mean = self.running_mean.clone()
            self.backup_running_var = self.running_var.clone()
        
        if params:
            weight = params.get('weight', self.weight)
            bias = params.get('bias', self.bias)
        else:
            weight = self.weight
            bias = self.bias
        
        # Simple batch norm implementation
        if training:
            mean = x.mean(dim=(0, 2, 3), keepdim=True)
            var = x.var(dim=(0, 2, 3), keepdim=True, unbiased=False)
            self.running_mean = 0.9 * self.running_mean + 0.1 * mean.squeeze()
            self.running_var = 0.9 * self.running_var + 0.1 * var.squeeze()
        else:
            mean = self.running_mean.view(1, -1, 1, 1)
            var = self.running_var.view(1, -1, 1, 1)
        
        x_norm = (x - mean) / (torch.sqrt(var) + 1e-5)
        return weight.view(1, -1, 1, 1) * x_norm + bias.view(1, -1, 1, 1)
    
    def restore_backup_stats(self):
        self.running_mean = self.backup_running_mean.clone()
        self.running_var = self.backup_running_var.clone()

# Stand-in args
class MockArgs:
    def __init__(self):
        self.param1 = "value1"

# Create the arguments
in_channels = 4
device = torch.device('cpu')
args = MockArgs()
batch_norm_cls = MockBatchNorm

ARGS = {
    'in_channels': in_channels,
    'device': device,
    'args': args,
    'batch_norm_cls': batch_norm_cls
}
Setup block drafted by
a language model, Claude Haiku 4.5, prompt python_fixture_v1, through the batch API
Imports
torch — import names as written, not package names to install; a name the repository itself provides is not a package
Returned
type DenseBlockUnit — the run constructed an instance of its own class and did not call it; no shape is stated — the instrument coerces any output to an array; for a DenseBlockUnit output the recorded ndim 0 and dtype family float describe that coercion, not the output, and are not stated
Environment
image not recorded; re-verify against syntology-harvest-sandbox:v5-deps; not recorded for this sample: the harness installs a cuda-to-cpu shim (cuda_shim.py) before every sample and no run records whether a sample needed it; seed: none by the harness; any seed is in the setup block
GradientBasedMetaLearner Ran
ran on a synthesized input · constructed an object; no result was computed
nyu-larx/attack_metarl/maml_rl/metalearners/maml_trpo.py
code served (permissive licence) · get_code("65320d46ade5b2da")
How it ran

Ran in Syntology's sandbox on this synthesized input (drafted by a language model, Claude Haiku 4.5, prompt python_fixture_v1, through the batch API) and returned an instance of its own class, GradientBasedMetaLearner: the run constructed the object and did not call it, so no result was computed. The image it ran in was not recorded. If your copy returns the same type on these inputs, it matched what we observed; nothing here checks that. It does NOT mean the output is correct: nothing has compared it to the paper.

import torch
import torch.nn as nn
import asyncio

torch.manual_seed(0)

class SimplePolicy(nn.Module):
    def __init__(self, input_dim=4, output_dim=3):
        super().__init__()
        self.linear = nn.Linear(input_dim, output_dim)
    
    def forward(self, x):
        return self.linear(x)

policy = SimplePolicy(input_dim=4, output_dim=3)

train_episodes = [
    (torch.randn(2, 4), torch.randn(2, 3)),
    (torch.randn(2, 4), torch.randn(2, 3)),
]

valid_episodes = [
    (torch.randn(2, 4), torch.randn(2, 3)),
    (torch.randn(2, 4), torch.randn(2, 3)),
]

ARGS = {
    'policy': policy,
    'device': 'cpu',
}
Setup block drafted by
a language model, Claude Haiku 4.5, prompt python_fixture_v1, through the batch API
Imports
torch — import names as written, not package names to install; a name the repository itself provides is not a package
Returned
type GradientBasedMetaLearner — the run constructed an instance of its own class and did not call it; no shape is stated — the instrument coerces any output to an array; for a GradientBasedMetaLearner output the recorded ndim 0 and dtype family float describe that coercion, not the output, and are not stated
Environment
image not recorded; re-verify against syntology-harvest-sandbox:v5-deps; not recorded for this sample: the harness installs a cuda-to-cpu shim (cuda_shim.py) before every sample and no run records whether a sample needed it; seed: none by the harness; any seed is in the setup block
IdentityTransformLoss Ran
ran on a synthesized input
KamalM8/Few-Shot-learning-Fashion/few_shot/maml.py
code served (permissive licence) · get_code("9d71c45dd9887865")
How it ran

Ran in Syntology's sandbox on this synthesized input (drafted by a language model, class construct-then-call prompt, model not recorded) and returned Tensor, ndim 0, dtype family float; no output shape is stated. The image it ran in was not recorded. If your copy returns the same type and ndim on these inputs, it matched what we observed; nothing here checks that. It does NOT mean the output is correct: nothing has compared it to the paper.

import torch
import torch.nn as nn
from torch.autograd import Variable

class IdentityTransformLoss(nn.Module):
    """Get nuclear norm"""

    def __init__(self):
        """ """
        nn.Module.__init__(self)

    def forward(self, transform):
        y = Variable(torch.Tensor([[1, 0, 0], [0, 1, 0]]))[None].double()
        y = y.to(transform.device)
        loss = 0
        loss = (transform - y) ** 2
        loss = loss.sum(1).mean()
        return loss


INIT_ARGS = {}

ARGS = {
    'transform': torch.randn(4, 2, 3, dtype=torch.double)
}

if __name__ == '__main__':
    model = IdentityTransformLoss(**INIT_ARGS)
    output = model(**ARGS)
    print(f"Loss output: {output}")
    print(f"Output shape: {output.shape}")
Setup block drafted by
a language model, class construct-then-call prompt, model not recorded
Imports
torch — import names as written, not package names to install; a name the repository itself provides is not a package
Returned
type Tensor, ndim 0, dtype family float — no output shape is stated: observe_signature.py observed this class with its constructor sizes canonicalised where it could, which the node does not record, so its shape is not stated as this setup block's
dtype family
int means an integer dtype; float means any other dtype the instrument saw, bool and complex included (fixture_check.py records only these two families)
Environment
image not recorded; re-verify against syntology-harvest-sandbox:v5-deps; not recorded for this sample: the harness installs a cuda-to-cpu shim (cuda_shim.py) before every sample and no run records whether a sample needed it; seed: torch and numpy seeded to 0 by the harness immediately before the class was constructed from INIT_ARGS (fixture_check.py)
LSLRGradientDescentLearningRule Ran
ran on a synthesized input · constructed an object; no result was computed
AntreasAntoniou/HowToTrainYourMAMLPytorch/few_shot_learning_system.py
pointer only (licence: NOASSERTION) · get_code("2831361f8df0f5f8")
How it ran

The body of this sample is withheld: GitHub could not classify the licence of this paper's repository, AntreasAntoniou/HowToTrainYourMAMLPytorch (NOASSERTION). The setup block that called it is withheld with it, because it is written against that body. source_path and origin say where the code lives, to read under the repository's own terms. A run is recorded.

Learner Ran
ran on a synthesized input · constructed an object; no result was computed
damedollaforthree/nrml/meta.py
code served (permissive licence) · get_code("6f410bc3b799fb12")
How it ran

Ran in Syntology's sandbox on this synthesized input (drafted by a language model, Claude Haiku 4.5, prompt python_fixture_v1, through the batch API) and returned an instance of its own class, Learner: the run constructed the object and did not call it, so no result was computed. The image it ran in was not recorded. The code mentions cuda, and the harness aliases cuda to the CPU for every sample; whether this run needed that is not recorded. If your copy returns the same type on these inputs, it matched what we observed; nothing here checks that. It does NOT mean the output is correct: nothing has compared it to the paper.

import torch
import numpy as np
from torch import nn

torch.manual_seed(0)

# Create a minimal config for the Learner
# Config is a list of (name, param) tuples
config = [
    ('conv2d', [16, 3, 3, 3, 1, 1]),      # out_ch, in_ch, kernel, kernel, stride, padding
    ('bn', [16]),                          # num_features
    ('relu', []),
    ('conv2d', [32, 16, 3, 3, 1, 1]),
    ('bn', [32]),
    ('relu', []),
    ('flatten', []),
    ('linear', [64, 32*7*7]),             # out_features, in_features
    ('relu', []),
    ('linear', [5, 64]),                  # num_class, in_features
]

# Create placeholder functions for p_task and p_meta
# These are expected to be callable objects
class DummyTaskLoss:
    def __call__(self, logits, labels):
        return torch.tensor(0.0)

class DummyMetaLoss:
    def __call__(self, logits, labels):
        return torch.tensor(0.0)

p_task = DummyTaskLoss()
p_meta = DummyMetaLoss()

ARGS = {
    'config': config,
    'imgc': 3,                  # image channels (1 or 3)
    'imgsz': 28,                # image size (28 or 84)
    'p_task': p_task,           # task loss function
    'p_meta': p_meta,           # meta loss function
    'num_class': 5,             # number of classes
}
Setup block drafted by
a language model, Claude Haiku 4.5, prompt python_fixture_v1, through the batch API
Imports
numpy, torch — import names as written, not package names to install; a name the repository itself provides is not a package
Returned
type Learner — the run constructed an instance of its own class and did not call it; no shape is stated — the instrument coerces any output to an array; for a Learner output the recorded ndim 0 and dtype family float describe that coercion, not the output, and are not stated
Environment
image not recorded; re-verify against syntology-harvest-sandbox:v5-deps; not recorded for this sample: the harness installs a cuda-to-cpu shim (cuda_shim.py) before every sample and no run records whether a sample needed it; seed: none by the harness; any seed is in the setup block
Learner Ran
ran on a synthesized input · constructed an object; no result was computed
csyanbin/MAML-Pytorch-Multi-GPUs/meta.py
pointer only (licence: NONE) · get_code("23f25fc3752e2b12")
How it ran

The body of this sample is withheld: GitHub detected no licence in this paper's repository, csyanbin/MAML-Pytorch-Multi-GPUs when it was checked. The setup block that called it is withheld with it, because it is written against that body. source_path and origin say where the code lives, to read under the repository's own terms. A run is recorded.

LearnerConv Ran
ran on a synthesized input · constructed an object; no result was computed
potsawee/maml/models/miniimagenet.py
pointer only (licence: NONE) · get_code("93c4edf2272400b5")
How it ran

The body of this sample is withheld: GitHub detected no licence in this paper's repository, potsawee/maml when it was checked. The setup block that called it is withheld with it, because it is written against that body. source_path and origin say where the code lives, to read under the repository's own terms. A run is recorded.

Linear_fw Ran
ran on a synthesized input
crashmoon/MAML-Pytorch-Multi-GPUs/meta_learner.py
pointer only (licence: NONE) · get_code("d53073ad75a7ff00")
How it ran

The body of this sample is withheld: GitHub detected no licence in this paper's repository, crashmoon/MAML-Pytorch-Multi-GPUs when it was checked. The setup block that called it is withheld with it, because it is written against that body. source_path and origin say where the code lives, to read under the repository's own terms. A run is recorded.

MAML Ran
ran on a synthesized input · constructed an object; no result was computed
ido90/roml-maml/MAML.py
pointer only (licence: NONE) · get_code("c930e1b84447e6cb")
How it ran

The body of this sample is withheld: GitHub detected no licence in this paper's repository, ido90/roml-maml when it was checked. The setup block that called it is withheld with it, because it is written against that body. source_path and origin say where the code lives, to read under the repository's own terms. A run is recorded.

MAML Ran
ran on a synthesized input · constructed an object; no result was computed
lgcollins/tr-maml/sinusoid/maml.py
pointer only (licence: NONE) · get_code("c5becc80cbb51e3d")
How it ran

The body of this sample is withheld: GitHub detected no licence in this paper's repository, lgcollins/tr-maml when it was checked. The setup block that called it is withheld with it, because it is written against that body. source_path and origin say where the code lives, to read under the repository's own terms. A run is recorded.

MAML Ran
ran on a synthesized input · constructed an object; no result was computed
CocoJam/MAML/MAML.py
pointer only (licence: NONE) · get_code("9639920d1e2bc40a")
How it ran

The body of this sample is withheld: GitHub detected no licence in this paper's repository, CocoJam/MAML when it was checked. The setup block that called it is withheld with it, because it is written against that body. source_path and origin say where the code lives, to read under the repository's own terms. A run is recorded.

MAMLClassifier Ran
ran on a synthesized input · constructed an object; no result was computed
theneuralbeing/maml/model.py
pointer only (licence: NONE) · get_code("b3c76271d8b0eb64")
How it ran

The body of this sample is withheld: GitHub detected no licence in this paper's repository, theneuralbeing/maml when it was checked. The setup block that called it is withheld with it, because it is written against that body. source_path and origin say where the code lives, to read under the repository's own terms. A run is recorded.

MAMLmodel Ran
ran on a synthesized input · constructed an object; no result was computed
hfahrudin/reptile_implement_tf2/MAML.py
code served (permissive licence) · get_code("e3ee206f6ec04d58")
How it ran

Ran in Syntology's sandbox on this synthesized input (drafted by a language model, Claude Haiku 4.5, prompt python_fixture_v1, through the batch API) and returned an instance of its own class, MAMLmodel: the run constructed the object and did not call it, so no result was computed. The image it ran in was not recorded. If your copy returns the same type on these inputs, it matched what we observed; nothing here checks that. It does NOT mean the output is correct: nothing has compared it to the paper.

import tensorflow as tf
import tensorflow.keras as keras
import numpy as np

# Set seeds for reproducibility
tf.random.set_seed(0)
np.random.seed(0)

# Build a simple model that matches the expected interface
class SimpleModel(keras.Model):
    def __init__(self):
        super(SimpleModel, self).__init__()
        # Initialize weights to match forward_func expectations
        # forward_func expects: weights[0], weights[1], weights[2], weights[3], weights[4], weights[5]
        # It does: matmul(inp, w[0]) + w[1], relu, matmul(..., w[2]) + w[3], relu, matmul(..., w[4]) + w[5]
        
        # Input dim: 4, hidden dim: 3, output dim: 2
        self.w0 = self.add_weight(name='w0', shape=(4, 3), initializer='glorot_uniform', trainable=True)
        self.w1 = self.add_weight(name='w1', shape=(3,), initializer='zeros', trainable=True)
        self.w2 = self.add_weight(name='w2', shape=(3, 3), initializer='glorot_uniform', trainable=True)
        self.w3 = self.add_weight(name='w3', shape=(3,), initializer='zeros', trainable=True)
        self.w4 = self.add_weight(name='w4', shape=(3, 2), initializer='glorot_uniform', trainable=True)
        self.w5 = self.add_weight(name='w5', shape=(2,), initializer='zeros', trainable=True)
    
    def call(self, inp, training=False):
        hidden = tf.matmul(inp, self.w0) + self.w1
        hidden = tf.nn.relu(hidden)
        hidden = tf.matmul(hidden, self.w2) + self.w3
        hidden = tf.nn.relu(hidden)
        output = keras.activations.linear(tf.matmul(hidden, self.w4) + self.w5)
        return output
    
    @property
    def trainable_variables(self):
        return [self.w0, self.w1, self.w2, self.w3, self.w4, self.w5]

# Create the model
model = SimpleModel()

# Create sample data for meta-training
# Each batch element is (xs, ys, xt, yt) for support and target sets
def create_sample_batch(batch_size=2, support_size=2, target_size=2, input_dim=4, output_dim=2):
    batch_data = []
    for _ in range(batch_size):
        xs = tf.constant(np.random.randn(support_size, input_dim).astype(np.float32))
        ys = tf.constant(np.random.randn(support_size, output_dim).astype(np.float32))
        xt = tf.constant(np.random.randn(target_size, input_dim).astype(np.float32))
        yt = tf.constant(np.random.randn(target_size, output_dim).astype(np.float32))
        batch_data.append((xs, ys, xt, yt))
    
    # Stack into tensors for tf.map_fn
    xs_all = tf.stack([b[0] for b in batch_data])
    ys_all = tf.stack([b[1] for b in batch_data])
    xt_all = tf.stack([b[2] for b in batch_data])
    yt_all = tf.stack([b[3] for b in batch_data])
    
    return (xs_all, ys_all, xt_all, yt_all)

# Create data iterator
ds_iter = [create_sample_batch(batch_size=2) for _ in range(3)]

ARGS = {
    'model': model,
    'inner_update': 5,
    'meta_batch_size': 2
}
Setup block drafted by
a language model, Claude Haiku 4.5, prompt python_fixture_v1, through the batch API
Imports
numpy, tensorflow — import names as written, not package names to install; a name the repository itself provides is not a package
Returned
type MAMLmodel — the run constructed an instance of its own class and did not call it; no shape is stated — the instrument coerces any output to an array; for a MAMLmodel output the recorded ndim 0 and dtype family float describe that coercion, not the output, and are not stated
Environment
image not recorded; re-verify against syntology-harvest-sandbox:v5-deps; not recorded for this sample: the harness installs a cuda-to-cpu shim (cuda_shim.py) before every sample and no run records whether a sample needed it; seed: none by the harness; any seed is in the setup block
MetaBatchNormLayer Ran
ran on a synthesized input · constructed an object; no result was computed
AntreasAntoniou/HowToTrainYourMAMLPytorch/few_shot_learning_system.py
pointer only (licence: NOASSERTION) · get_code("87ad94fd897e556d")
How it ran

The body of this sample is withheld: GitHub could not classify the licence of this paper's repository, AntreasAntoniou/HowToTrainYourMAMLPytorch (NOASSERTION). The setup block that called it is withheld with it, because it is written against that body. source_path and origin say where the code lives, to read under the repository's own terms. A run is recorded.

MetaBatchNormLayer Ran
ran on a synthesized input · constructed an object; no result was computed
dkalpakchi/ReproducingSCAPytorch/few_shot_learning_system.py
code served (permissive licence) · get_code("51af2ebd778ea8d5")
How it ran

Ran in Syntology's sandbox on this synthesized input (drafted by a language model, Claude Haiku 4.5, prompt python_fixture_v1, through the batch API) and returned an instance of its own class, MetaBatchNormLayer: the run constructed the object and did not call it, so no result was computed. The image it ran in was not recorded. If your copy returns the same type on these inputs, it matched what we observed; nothing here checks that. It does NOT mean the output is correct: nothing has compared it to the paper.

import torch
import torch.nn as nn

torch.manual_seed(0)

class Args:
    def __init__(self):
        self.learnable_bn_gamma = True
        self.learnable_bn_beta = True
        self.number_of_training_steps_per_iter = 3
        self.num_critic_updates = 2
        self.enable_inner_loop_optimizable_bn_params = False

ARGS = {
    'num_features': 4,
    'device': torch.device('cpu'),
    'args': Args(),
    'eps': 1e-05,
    'momentum': 0.1,
    'affine': True,
    'track_running_stats': True,
    'meta_batch_norm': True,
    'no_learnable_params': False,
    'use_per_step_bn_statistics': False
}
Setup block drafted by
a language model, Claude Haiku 4.5, prompt python_fixture_v1, through the batch API
Imports
torch — import names as written, not package names to install; a name the repository itself provides is not a package
Returned
type MetaBatchNormLayer — the run constructed an instance of its own class and did not call it; no shape is stated — the instrument coerces any output to an array; for a MetaBatchNormLayer output the recorded ndim 0 and dtype family float describe that coercion, not the output, and are not stated
Environment
image not recorded; re-verify against syntology-harvest-sandbox:v5-deps; not recorded for this sample: the harness installs a cuda-to-cpu shim (cuda_shim.py) before every sample and no run records whether a sample needed it; seed: none by the harness; any seed is in the setup block
MetaConv2dLayer Ran
ran on a synthesized input · constructed an object; no result was computed
AntreasAntoniou/HowToTrainYourMAMLPytorch/few_shot_learning_system.py
pointer only (licence: NOASSERTION) · get_code("cdc8953f39812984")
How it ran

The body of this sample is withheld: GitHub could not classify the licence of this paper's repository, AntreasAntoniou/HowToTrainYourMAMLPytorch (NOASSERTION). The setup block that called it is withheld with it, because it is written against that body. source_path and origin say where the code lives, to read under the repository's own terms. A run is recorded.

MetaLayerNormLayer Ran
ran on a synthesized input · constructed an object; no result was computed
AntreasAntoniou/HowToTrainYourMAMLPytorch/few_shot_learning_system.py
pointer only (licence: NOASSERTION) · get_code("8edf11cc4b58def8")
How it ran

The body of this sample is withheld: GitHub could not classify the licence of this paper's repository, AntreasAntoniou/HowToTrainYourMAMLPytorch (NOASSERTION). The setup block that called it is withheld with it, because it is written against that body. source_path and origin say where the code lives, to read under the repository's own terms. A run is recorded.

MetaLearner Ran
ran on a synthesized input · constructed an object; no result was computed
dragen1860/Reptile-Pytorch/meta.py
pointer only (licence: NONE) · get_code("9815cdb73b01463a")
How it ran

The body of this sample is withheld: GitHub detected no licence in this paper's repository, dragen1860/Reptile-Pytorch when it was checked. The setup block that called it is withheld with it, because it is written against that body. source_path and origin say where the code lives, to read under the repository's own terms. A run is recorded.

MetaLearner Ran
ran on a synthesized input · constructed an object; no result was computed
crashmoon/MAML-Pytorch-Multi-GPUs/meta_learner.py
pointer only (licence: NONE) · get_code("3f8474018a3a2204")
How it ran

The body of this sample is withheld: GitHub detected no licence in this paper's repository, crashmoon/MAML-Pytorch-Multi-GPUs when it was checked. The setup block that called it is withheld with it, because it is written against that body. source_path and origin say where the code lives, to read under the repository's own terms. A run is recorded.

MetaLearner Ran
ran on a synthesized input · constructed an object; no result was computed
JeonMinkyu/MAML_Pytorch/meta.py
pointer only (licence: NONE) · get_code("7d550f79f6439186")
How it ran

The body of this sample is withheld: GitHub detected no licence in this paper's repository, JeonMinkyu/MAML_Pytorch when it was checked. The setup block that called it is withheld with it, because it is written against that body. source_path and origin say where the code lives, to read under the repository's own terms. A run is recorded.

MetaLearner Ran
ran on a synthesized input · constructed an object; no result was computed
novicestone/meta-cetm/models/maml.py
code served (permissive licence) · get_code("2a31274d3bff46a8")
How it ran

Ran in Syntology's sandbox on this synthesized input (drafted by a language model, Claude Haiku 4.5, prompt python_fixture_v1, through the batch API) and returned an instance of its own class, MetaLearner: the run constructed the object and did not call it, so no result was computed. The image it ran in was not recorded. If your copy returns the same type on these inputs, it matched what we observed; nothing here checks that. It does NOT mean the output is correct: nothing has compared it to the paper.

import torch
from torch import nn


torch.manual_seed(0)


class SimpleBaseModel(nn.Module):
    """Minimal model that satisfies the interface expected by MetaLearner"""
    def __init__(self, vocab_size=5, hidden_size=4):
        super(SimpleBaseModel, self).__init__()
        self.linear1 = nn.Linear(vocab_size, hidden_size)
        self.linear2 = nn.Linear(hidden_size, vocab_size)
    
    def forward(self, x, fast_weights=None):
        """
        Args:
            x: tensor of shape (batch_size, vocab_size)
            fast_weights: list of parameters or None
        Returns:
            nelbo: scalar loss
            output1, output2, pred: dummy outputs (only pred is used in finetunning)
        """
        if fast_weights is not None:
            # Use fast weights (for inner loop updates)
            x = torch.nn.functional.linear(x, fast_weights[0].weight, fast_weights[0].bias)
            x = torch.nn.functional.linear(x, fast_weights[1].weight, fast_weights[1].bias)
        else:
            # Use normal model parameters
            x = self.linear1(x)
            x = torch.relu(x)
            x = self.linear2(x)
        
        # Return nelbo as sum (scalar), and dummy outputs
        nelbo = x.sum()
        pred = x
        return nelbo, None, None, pred
    
    def get_ppl(self, query, pred):
        """Compute perplexity for evaluation"""
        # Simple dummy PPL calculation
        mse = torch.mean((query - pred) ** 2)
        return float(mse)


class Args:
    """Configuration class for MetaLearner"""
    def __init__(self):
        self.meta_lr = 0.001
        self.update_lr = 0.01
        self.update_step = 2
        self.update_step_test = 2
        self.grad_clip = 0.5


# Build support and query batches
# Shape: (n_tasks, task_size, vocab_size)
n_tasks = 2
task_size = 3
vocab_size = 5

support_batches = torch.randn(n_tasks, task_size, vocab_size)
query_batches = torch.randn(n_tasks, task_size, vocab_size)

# Build the arguments dictionary
args = Args()
base_model = SimpleBaseModel(vocab_size=vocab_size, hidden_size=4)

ARGS = {
    'args': args,
    'base_model': base_model
}
Setup block drafted by
a language model, Claude Haiku 4.5, prompt python_fixture_v1, through the batch API
Imports
torch — import names as written, not package names to install; a name the repository itself provides is not a package
Returned
type MetaLearner — the run constructed an instance of its own class and did not call it; no shape is stated — the instrument coerces any output to an array; for a MetaLearner output the recorded ndim 0 and dtype family float describe that coercion, not the output, and are not stated
Environment
image not recorded; re-verify against syntology-harvest-sandbox:v5-deps; not recorded for this sample: the harness installs a cuda-to-cpu shim (cuda_shim.py) before every sample and no run records whether a sample needed it; seed: none by the harness; any seed is in the setup block
MetaLinearLayer Ran
ran on a synthesized input · constructed an object; no result was computed
AntreasAntoniou/HowToTrainYourMAMLPytorch/few_shot_learning_system.py
pointer only (licence: NOASSERTION) · get_code("89b9a544fd4f74db")
How it ran

The body of this sample is withheld: GitHub could not classify the licence of this paper's repository, AntreasAntoniou/HowToTrainYourMAMLPytorch (NOASSERTION). The setup block that called it is withheld with it, because it is written against that body. source_path and origin say where the code lives, to read under the repository's own terms. A run is recorded.

Module Ran
ran on a synthesized input · constructed an object; no result was computed
fmu2/PyTorch-MAML/models/maml.py
pointer only (licence: NONE) · get_code("a1a99ec23db1357b")
How it ran

The body of this sample is withheld: GitHub detected no licence in this paper's repository, fmu2/PyTorch-MAML when it was checked. The setup block that called it is withheld with it, because it is written against that body. source_path and origin say where the code lives, to read under the repository's own terms. A run is recorded.

OmniglotModel Ran
ran on a synthesized input · constructed an object; no result was computed
gebob19/cscd94-metalearning/model.py
pointer only (licence: NONE) · get_code("0f3d548c0cb6818a")
How it ran

The body of this sample is withheld: GitHub detected no licence in this paper's repository, gebob19/cscd94-metalearning when it was checked. The setup block that called it is withheld with it, because it is written against that body. source_path and origin say where the code lives, to read under the repository's own terms. A run is recorded.

Policy Ran
ran on a synthesized input · constructed an object; no result was computed
Zhiwei-Z/SeqPromp/meta_policy_search/meta_algos/base.py
code served (permissive licence) · get_code("0630f74816818382")
How it ran

Ran in Syntology's sandbox on this synthesized input (drafted by a language model, Claude Haiku 4.5, prompt python_fixture_v1, through the batch API) and returned an instance of its own class, Policy: the run constructed the object and did not call it, so no result was computed. The image it ran in was not recorded. If your copy returns the same type on these inputs, it matched what we observed; nothing here checks that. It does NOT mean the output is correct: nothing has compared it to the paper.

import tensorflow as tf

# Define ARGS dictionary with all required parameters for Policy.__init__
ARGS = {
    'obs_dim': 4,
    'action_dim': 3,
    'name': 'test_policy',
    'hidden_sizes': (32, 32),
    'learn_std': True,
    'hidden_nonlinearity': tf.tanh,
    'output_nonlinearity': None,
}
Setup block drafted by
a language model, Claude Haiku 4.5, prompt python_fixture_v1, through the batch API
Imports
tensorflow — import names as written, not package names to install; a name the repository itself provides is not a package
Returned
type Policy — the run constructed an instance of its own class and did not call it; no shape is stated — the instrument coerces any output to an array; for a Policy output the recorded ndim 0 and dtype family float describe that coercion, not the output, and are not stated
Environment
image not recorded; re-verify against syntology-harvest-sandbox:v5-deps; not recorded for this sample: the harness installs a cuda-to-cpu shim (cuda_shim.py) before every sample and no run records whether a sample needed it; seed: none by the harness; any seed is in the setup block
Policy Ran
ran on a synthesized input · constructed an object; no result was computed
clrrrr/promp_plus/meta_policy_search/meta_algos/base.py
code served (permissive licence) · get_code("93275e38a44a53ec")
How it ran

Ran in Syntology's sandbox on this synthesized input (drafted by a language model, Claude Haiku 4.5, prompt python_fixture_v1, through the batch API) and returned an instance of its own class, Policy: the run constructed the object and did not call it, so no result was computed. The image it ran in was not recorded. If your copy returns the same type on these inputs, it matched what we observed; nothing here checks that. It does NOT mean the output is correct: nothing has compared it to the paper.

import tensorflow as tf

ARGS = {
    'obs_dim': 5,
    'action_dim': 3,
    'name': 'test_policy',
    'hidden_sizes': (32, 32),
    'learn_std': True,
    'hidden_nonlinearity': tf.tanh,
    'output_nonlinearity': None,
}
Setup block drafted by
a language model, Claude Haiku 4.5, prompt python_fixture_v1, through the batch API
Imports
tensorflow — import names as written, not package names to install; a name the repository itself provides is not a package
Returned
type Policy — the run constructed an instance of its own class and did not call it; no shape is stated — the instrument coerces any output to an array; for a Policy output the recorded ndim 0 and dtype family float describe that coercion, not the output, and are not stated
Environment
image not recorded; re-verify against syntology-harvest-sandbox:v5-deps; not recorded for this sample: the harness installs a cuda-to-cpu shim (cuda_shim.py) before every sample and no run records whether a sample needed it; seed: none by the harness; any seed is in the setup block
Regressor Ran
ran on a synthesized input
psh150204/MAML/model.py
code served (permissive licence) · get_code("a8f78f0cacf4d49a")
How it ran

Ran in Syntology's sandbox on this synthesized input (drafted by a language model, class construct-then-call prompt, model not recorded) and returned Tensor, ndim 2, dtype family float; no output shape is stated. The image it ran in was not recorded. If your copy returns the same type and ndim on these inputs, it matched what we observed; nothing here checks that. It does NOT mean the output is correct: nothing has compared it to the paper.

import torch
import torch.nn as nn
import numpy as np

INIT_ARGS = {}

ARGS = {
    'x': torch.randn(2, 1),
    'params': None
}
Setup block drafted by
a language model, class construct-then-call prompt, model not recorded
Imports
numpy, torch — import names as written, not package names to install; a name the repository itself provides is not a package
Returned
type Tensor, ndim 2, dtype family float — no output shape is stated: observe_signature.py observed this class with its constructor sizes canonicalised where it could, which the node does not record, so its shape is not stated as this setup block's
dtype family
int means an integer dtype; float means any other dtype the instrument saw, bool and complex included (fixture_check.py records only these two families)
Environment
image not recorded; re-verify against syntology-harvest-sandbox:v5-deps; not recorded for this sample: the harness installs a cuda-to-cpu shim (cuda_shim.py) before every sample and no run records whether a sample needed it; seed: torch and numpy seeded to 0 by the harness immediately before the class was constructed from INIT_ARGS (fixture_check.py)
ResNet_MAML Ran
ran on a synthesized input · constructed an object; no result was computed
lif31up/model-agnostic-meta-learning/models/ConvNet.py
code served (permissive licence) · get_code("9eb20bff998008f7")
How it ran

Ran in Syntology's sandbox on this synthesized input (drafted by a language model, Claude Haiku 4.5, prompt python_fixture_v1, through the batch API) and returned an instance of its own class, ResNet_MAML: the run constructed the object and did not call it, so no result was computed. The image it ran in was not recorded. If your copy returns the same type on these inputs, it matched what we observed; nothing here checks that. It does NOT mean the output is correct: nothing has compared it to the paper.

import torch
import torch.nn as nn
import torchvision as tv
from torch.utils.data import Dataset

torch.manual_seed(0)

# Create a minimal transform
transform = tv.transforms.Compose([
    tv.transforms.Resize((28, 28)),
    tv.transforms.Grayscale(num_output_channels=1),
    tv.transforms.ToTensor(),
    tv.transforms.Normalize(mean=[0.5], std=[0.5])
])

# Create a minimal dataset
class DummyDataset(Dataset):
    def __init__(self, size=10, transform=None):
        self.size = size
        self.transform = transform
    
    def __len__(self):
        return self.size
    
    def __getitem__(self, idx):
        # Return (image, label) tuple
        image = torch.randn(1, 28, 28)
        label = torch.randn(5)  # output_channels = 5
        if self.transform:
            image = self.transform(image)
        return image, label

def get_imageset():
    return DummyDataset(size=20, transform=transform)

# Create Config instance
config = type('Config', (), {
    'input_channels': 1,
    'hidden_channels': 32,
    'output_channels': 5,
    'n_convs': 4,
    'kernel_size': 3,
    'padding': 1,
    'stride': 1,
    'bias': True,
    'iterations': 100,
    'alpha': 0.001,
    'eps': 1e-05,
    'epochs': 30,
    'beta': 0.0001,
    'batch_size': 8,
    'n_way': 5,
    'k_shot': 5,
    'n_query': 5,
    'save_to': './models',
    'transform': transform,
    'imageset': get_imageset(),
    'dummy': torch.zeros(1, 1, 28, 28)
})()

ARGS = {
    'config': config
}
Setup block drafted by
a language model, Claude Haiku 4.5, prompt python_fixture_v1, through the batch API
Imports
torch, torchvision — import names as written, not package names to install; a name the repository itself provides is not a package
Returned
type ResNet_MAML — the run constructed an instance of its own class and did not call it; no shape is stated — the instrument coerces any output to an array; for a ResNet_MAML output the recorded ndim 0 and dtype family float describe that coercion, not the output, and are not stated
Environment
image not recorded; re-verify against syntology-harvest-sandbox:v5-deps; not recorded for this sample: the harness installs a cuda-to-cpu shim (cuda_shim.py) before every sample and no run records whether a sample needed it; seed: none by the harness; any seed is in the setup block
Serializable Ran
ran on a synthesized input · constructed an object; no result was computed
Zhiwei-Z/SeqPromp/meta_policy_search/meta_algos/base.py
code served (permissive licence) · get_code("d5de2c8b41668dfe")
How it ran

Ran in Syntology's sandbox on this synthesized input (drafted by a language model, Claude Haiku 4.5, prompt python_fixture_v1, through the batch API) and returned an instance of its own class, Serializable: the run constructed the object and did not call it, so no result was computed. The image it ran in was not recorded. If your copy returns the same type on these inputs, it matched what we observed; nothing here checks that. It does NOT mean the output is correct: nothing has compared it to the paper.

import inspect
import sys

class Serializable(object):

    def __init__(self, *args, **kwargs):
        self.__args = args
        self.__kwargs = kwargs

    def quick_init(self, locals_):
        try:
            if object.__getattribute__(self, '_serializable_initialized'):
                return
        except AttributeError:
            pass
        if sys.version_info >= (3, 0):
            spec = inspect.getfullargspec(self.__init__)
            if spec.varkw:
                kwargs = locals_[spec.varkw]
            else:
                kwargs = dict()
        else:
            spec = inspect.getargspec(self.__init__)
            if spec.keywords:
                kwargs = locals_[spec.keywords]
            else:
                kwargs = dict()
        if spec.varargs:
            varargs = locals_[spec.varargs]
        else:
            varargs = tuple()
        in_order_args = [locals_[arg] for arg in spec.args][1:]
        self.__args = tuple(in_order_args) + varargs
        self.__kwargs = kwargs
        setattr(self, '_serializable_initialized', True)

    def __getstate__(self):
        return {'__args': self.__args, '__kwargs': self.__kwargs}

    def __setstate__(self, d):
        out = type(self)(*d['__args'], **d['__kwargs'])
        self.__dict__.update(out.__dict__)

    @classmethod
    def clone(cls, obj, **kwargs):
        assert isinstance(obj, Serializable)
        d = obj.__getstate__()
        if sys.version_info >= (3, 0):
            spec = inspect.getfullargspec(obj.__init__)
        else:
            spec = inspect.getargspec(obj.__init__)
        in_order_args = spec.args[1:]
        d['__args'] = list(d['__args'])
        for kw, val in kwargs.items():
            if kw in in_order_args:
                d['__args'][in_order_args.index(kw)] = val
            else:
                d['__kwargs'][kw] = val
        out = type(obj).__new__(type(obj))
        out.__setstate__(d)
        return out


class ConcreteSerializable(Serializable):
    def __init__(self, a, b, c=10, d=20):
        super().__init__(a, b, c=c, d=d)
        self.a = a
        self.b = b
        self.c = c
        self.d = d


obj = ConcreteSerializable(1, "test", c=30, d=40)
extra_kwargs = {"e": 50, "f": "extra"}

ARGS = {
    "obj": obj,
    "kwargs": extra_kwargs
}
Setup block drafted by
a language model, Claude Haiku 4.5, prompt python_fixture_v1, through the batch API
Imports
none outside the standard library — import names as written, not package names to install; a name the repository itself provides is not a package
Returned
type Serializable — the run constructed an instance of its own class and did not call it; no shape is stated — the instrument coerces any output to an array; for a Serializable output the recorded ndim 0 and dtype family float describe that coercion, not the output, and are not stated
Environment
image not recorded; re-verify against syntology-harvest-sandbox:v5-deps; not recorded for this sample: the harness installs a cuda-to-cpu shim (cuda_shim.py) before every sample and no run records whether a sample needed it; seed: none by the harness; any seed is in the setup block
SqueezeExciteConvLayer Ran
ran on a synthesized input
dkalpakchi/ReproducingSCAPytorch/few_shot_learning_system.py
code served (permissive licence) · get_code("5457b64a9cf91ad9")
How it ran

Ran in Syntology's sandbox on this synthesized input (drafted by a language model, class construct-then-call prompt, model not recorded) and returned Tensor, ndim 4, dtype family float; no output shape is stated. The image it ran in was not recorded. If your copy returns the same type and ndim on these inputs, it matched what we observed; nothing here checks that. It does NOT mean the output is correct: nothing has compared it to the paper.

import torch
import torch.nn as nn
import torch.nn.functional as F

class SqueezeExciteConvLayer(nn.Module):

    def __init__(self, in_channels):
        super(SqueezeExciteConvLayer, self).__init__()
        reduced = max(in_channels // 16, 1)
        self.w1 = nn.Parameter(torch.Tensor(reduced, in_channels))
        self.w2 = nn.Parameter(torch.Tensor(in_channels, reduced))
        nn.init.xavier_uniform_(self.w1)
        nn.init.xavier_uniform_(self.w2)

    def forward(self, x, num_step, params=None, training=False, backup_running_statistics=False):
        if params:
            w1 = params['w1']
            w2 = params['w2']
        else:
            w1 = self.w1
            w2 = self.w2
        z = x.mean((-2, -1))
        z = F.relu(F.linear(z, w1))
        s = torch.sigmoid(F.linear(z, w2)).unsqueeze(2).unsqueeze(3)
        return s * x


INIT_ARGS = {
    'in_channels': 16
}

ARGS = {
    'x': torch.randn(2, 16, 4, 5),
    'num_step': 1,
    'params': None,
    'training': False,
    'backup_running_statistics': False
}

if __name__ == '__main__':
    model = SqueezeExciteConvLayer(**INIT_ARGS)
    output = model(**ARGS)
    print(f"Input shape: {ARGS['x'].shape}")
    print(f"Output shape: {output.shape}")
    print(f"Output: {output}")
Setup block drafted by
a language model, class construct-then-call prompt, model not recorded
Imports
torch — import names as written, not package names to install; a name the repository itself provides is not a package
Returned
type Tensor, ndim 4, dtype family float — no output shape is stated: observe_signature.py observed this class with its constructor sizes canonicalised where it could, which the node does not record, so its shape is not stated as this setup block's
dtype family
int means an integer dtype; float means any other dtype the instrument saw, bool and complex included (fixture_check.py records only these two families)
Environment
image not recorded; re-verify against syntology-harvest-sandbox:v5-deps; not recorded for this sample: the harness installs a cuda-to-cpu shim (cuda_shim.py) before every sample and no run records whether a sample needed it; seed: torch and numpy seeded to 0 by the harness immediately before the class was constructed from INIT_ARGS (fixture_check.py)
Task Ran
ran on a synthesized input · constructed an object; no result was computed
MaximeVandegar/Papers-in-100-Lines-of-Code/Model_Agnostic_Meta_Learning_for_Fast_Adaptation_of_Deep_Networks/maml.py
code served (permissive licence) · get_code("ec0fb012c0b639eb")
How it ran

Ran in Syntology's sandbox on this synthesized input (drafted by a language model, Claude Haiku 4.5, prompt python_fixture_v1, through the batch API) and returned an instance of its own class, Task: the run constructed the object and did not call it, so no result was computed. The image it ran in was not recorded. If your copy returns the same type on these inputs, it matched what we observed; nothing here checks that. It does NOT mean the output is correct: nothing has compared it to the paper.

import torch
import torch.nn as nn

torch.manual_seed(0)

ARGS = {
    'a': 2.5,
    'b': 1.3
}
Setup block drafted by
a language model, Claude Haiku 4.5, prompt python_fixture_v1, through the batch API
Imports
torch — import names as written, not package names to install; a name the repository itself provides is not a package
Returned
type Task — the run constructed an instance of its own class and did not call it; no shape is stated — the instrument coerces any output to an array; for a Task output the recorded ndim 0 and dtype family float describe that coercion, not the output, and are not stated
Environment
image not recorded; re-verify against syntology-harvest-sandbox:v5-deps; not recorded for this sample: the harness installs a cuda-to-cpu shim (cuda_shim.py) before every sample and no run records whether a sample needed it; seed: none by the harness; any seed is in the setup block
accuracy Ran
ran; our contract draft was wrong, not the code
mikehuisman/revisiting-learned-optimizers/algorithms/maml.py
code served (permissive licence) · get_code("6169b24cbef2d3af")
How it ran

Ran in Syntology's sandbox on this synthesized input (drafted by a language model, Claude Haiku 4.5, prompt python_fixture_v1) and returned float, ndim 0, dtype family float, shape () as a later run recorded it. The image it ran in was not recorded. If your copy returns the same type, ndim and shape on these inputs, it matched what we observed; nothing here checks that. It does NOT mean the output is correct: nothing has compared it to the paper.

import torch

torch.manual_seed(0)

# Create small tensors for predictions and ground-truth labels
# y_pred: predicted labels (batch size 2)
y_pred = torch.tensor([0, 1, 2, 1])

# y: ground-truth labels (batch size 2)
y = torch.tensor([0, 1, 2, 0])

ARGS = {
    "y_pred": y_pred,
    "y": y,
}
Setup block drafted by
a language model, Claude Haiku 4.5, prompt python_fixture_v1
Imports
torch — import names as written, not package names to install; a name the repository itself provides is not a package
Returned
type float, ndim 0, dtype family float, shape () — shape () as a later run recorded it
dtype family
int means an integer dtype; float means any other dtype the instrument saw, bool and complex included (fixture_check.py records only these two families)
Environment
image not recorded; re-verify against syntology-harvest-sandbox:v5-deps; not recorded for this sample: the harness installs a cuda-to-cpu shim (cuda_shim.py) before every sample and no run records whether a sample needed it; seed: none by the harness; any seed is in the setup block
ce_logit Ran
ran, honoured the contract we drafted
yredwood/fewshot_blogpost/lib/networks.py
pointer only (licence: NONE) · get_code("428acd76dd218c3d")
How it ran

The body of this sample is withheld: GitHub detected no licence in this paper's repository, yredwood/fewshot_blogpost when it was checked. The setup block that called it is withheld with it, because it is written against that body. source_path and origin say where the code lives, to read under the repository's own terms. A run is recorded.

clone_module Ran
ran; our contract draft was wrong, not the code
learnables/learn2learn/learn2learn/algorithms/maml.py
code served (permissive licence) · get_code("bbe0a23f6db14d65")
How it ran

Ran in Syntology's sandbox on this synthesized input (drafted by a language model, Claude Haiku 4.5, prompt python_fixture_v1, through the batch API) and returned SimpleModule. The image it ran in was not recorded. If your copy returns the same type on these inputs, it matched what we observed; nothing here checks that. It does NOT mean the output is correct: nothing has compared it to the paper.

import torch
import torch.nn as nn

torch.manual_seed(0)

# Create a simple nested module with parameters and buffers
class SimpleModule(nn.Module):
    def __init__(self):
        super().__init__()
        self.linear = nn.Linear(4, 3)
        self.register_buffer('my_buffer', torch.randn(2, 3, requires_grad=True))
    
    def forward(self, x):
        return self.linear(x)

# Create the module to be cloned
module = SimpleModule()

# Define ARGS dict with all parameters
ARGS = {
    'module': module,
    'memo': None
}
Setup block drafted by
a language model, Claude Haiku 4.5, prompt python_fixture_v1, through the batch API
Imports
torch — import names as written, not package names to install; a name the repository itself provides is not a package
Returned
type SimpleModule — a SimpleModule output has no array shape of its own; none is stated — the instrument coerces any output to an array; for a SimpleModule output the recorded ndim 0 and dtype family float describe that coercion, not the output, and are not stated
Environment
image not recorded; re-verify against syntology-harvest-sandbox:v5-deps; not recorded for this sample: the harness installs a cuda-to-cpu shim (cuda_shim.py) before every sample and no run records whether a sample needed it; seed: none by the harness; any seed is in the setup block
combine_gradients Ran
ran on a synthesized input
Octavio-Pappalardo/MAML_for_RL_pytorch/FO-MAML_distributed/TRPO_and_adapt_loss.py
code served (permissive licence) · get_code("d72142a564b3e983")
How it ran

Ran in Syntology's sandbox on this synthesized input (drafted by a language model, Claude Haiku 4.5, prompt python_fixture_v1, through the batch API) and returned list. The image it ran in was not recorded. If your copy returns the same type on these inputs, it matched what we observed; nothing here checks that. It does NOT mean the output is correct: nothing has compared it to the paper.

import torch

torch.manual_seed(0)

# The function expects a list of gradients, where each element is a list of tensors
# We'll create multiple gradient lists (simulating gradients from different sources)
# Each gradient list contains tensors of the same shape

# Create 3 sets of gradients, each with 2 parameter tensors
gradient_set_1 = [
    torch.randn(4, 3),  # gradient for parameter 1
    torch.randn(2, 5),  # gradient for parameter 2
]

gradient_set_2 = [
    torch.randn(4, 3),  # gradient for parameter 1
    torch.randn(2, 5),  # gradient for parameter 2
]

gradient_set_3 = [
    torch.randn(4, 3),  # gradient for parameter 1
    torch.randn(2, 5),  # gradient for parameter 2
]

gradient_list = [gradient_set_1, gradient_set_2, gradient_set_3]

ARGS = {
    "gradient_list": gradient_list,
}
Setup block drafted by
a language model, Claude Haiku 4.5, prompt python_fixture_v1, through the batch API
Imports
torch — import names as written, not package names to install; a name the repository itself provides is not a package
Returned
type list — a list output has no array shape of its own; none is stated
Environment
image not recorded; re-verify against syntology-harvest-sandbox:v5-deps; not recorded for this sample: the harness installs a cuda-to-cpu shim (cuda_shim.py) before every sample and no run records whether a sample needed it; seed: none by the harness; any seed is in the setup block
compute_accuracy Ran
ran on a synthesized input
SinghJasdeep/Projecting-Conflicting-Gradients/maml/utils.py
code served (permissive licence) · get_code("58242025465b988c")
How it ran

Ran in Syntology's sandbox on this synthesized input (drafted by a language model, Claude Haiku 4.5, prompt python_fixture_v1, through the batch API) and returned float, ndim 0, dtype family float, shape () as a later run recorded it. The image it ran in was not recorded. If your copy returns the same type, ndim and shape on these inputs, it matched what we observed; nothing here checks that. It does NOT mean the output is correct: nothing has compared it to the paper.

import torch

torch.manual_seed(0)

# Create small tensors for testing
# logits: shape (batch_size=2, num_classes=4) - raw model outputs
logits = torch.randn(2, 4)

# targets: shape (batch_size=2,) - ground truth class indices
targets = torch.tensor([0, 2], dtype=torch.long)

ARGS = {
    "logits": logits,
    "targets": targets,
}
Setup block drafted by
a language model, Claude Haiku 4.5, prompt python_fixture_v1, through the batch API
Imports
torch — import names as written, not package names to install; a name the repository itself provides is not a package
Returned
type float, ndim 0, dtype family float, shape () — shape () as a later run recorded it
dtype family
int means an integer dtype; float means any other dtype the instrument saw, bool and complex included (fixture_check.py records only these two families)
Environment
image not recorded; re-verify against syntology-harvest-sandbox:v5-deps; not recorded for this sample: the harness installs a cuda-to-cpu shim (cuda_shim.py) before every sample and no run records whether a sample needed it; seed: none by the harness; any seed is in the setup block
conjugate_gradient Ran
ran; our contract draft was wrong, not the code
nyu-larx/attack_metarl/maml_rl/metalearners/maml_trpo.py
code served (permissive licence) · get_code("c4daaf04c83ccbd2")
How it ran

Ran in Syntology's sandbox on this synthesized input (drafted by a language model, Claude Haiku 4.5, prompt python_fixture_v1, through the batch API) and returned Tensor, ndim 1, dtype family float, shape (4,) as a later run recorded it. The image it ran in was not recorded. If your copy returns the same type, ndim and shape on these inputs, it matched what we observed; nothing here checks that. It does NOT mean the output is correct: nothing has compared it to the paper.

import torch
import torch.nn as nn

torch.manual_seed(0)

# f_Ax is a callable that takes a tensor and returns a tensor
# It's used as: z = f_Ax(p).detach()
# So we need a function that applies a matrix-vector product

# Create a simple linear operator as f_Ax
class LinearOperator(nn.Module):
    def __init__(self, matrix):
        super().__init__()
        self.register_buffer('matrix', matrix)
    
    def forward(self, x):
        return torch.matmul(self.matrix, x)

# Create a small positive definite matrix for the linear operator
# A simple way: create a symmetric positive definite matrix
A = torch.randn(4, 4)
A = A @ A.T  # Make it symmetric positive definite
operator = LinearOperator(A)

# b is the target vector (right-hand side)
# Used in: torch.dot(r, r), torch.dot(p, z), etc.
# So it should be a 1D tensor
b = torch.randn(4)

# f_Ax is called with p as argument
def f_Ax(p):
    return operator(p)

ARGS = {
    'f_Ax': f_Ax,
    'b': b,
    'cg_iters': 10,
    'residual_tol': 1e-10
}
Setup block drafted by
a language model, Claude Haiku 4.5, prompt python_fixture_v1, through the batch API
Imports
torch — import names as written, not package names to install; a name the repository itself provides is not a package
Returned
type Tensor, ndim 1, dtype family float, shape (4,) — shape (4,) as a later run recorded it
dtype family
int means an integer dtype; float means any other dtype the instrument saw, bool and complex included (fixture_check.py records only these two families)
Environment
image not recorded; re-verify against syntology-harvest-sandbox:v5-deps; not recorded for this sample: the harness installs a cuda-to-cpu shim (cuda_shim.py) before every sample and no run records whether a sample needed it; seed: none by the harness; any seed is in the setup block
conjugate_gradient Ran
ran on a synthesized input
MoritzTaylor/maml-rl-tf2/maml_rl/optimizers/conjugate_gradient_optimizer.py
code served (permissive licence) · get_code("fa6e636313bab28d")
How it ran

Ran in Syntology's sandbox on this synthesized input (drafted by a language model, Claude Haiku 4.5, prompt python_fixture_v1, through the batch API) and returned ndarray, ndim 1, dtype family float, shape (4,) as a later run recorded it. The image it ran in was not recorded. If your copy returns the same type, ndim and shape on these inputs, it matched what we observed; nothing here checks that. It does NOT mean the output is correct: nothing has compared it to the paper.

import torch
import numpy as np

torch.manual_seed(0)

# Create a simple vector b as a torch tensor
b = torch.randn(4)

# Define f_Ax: a function that takes a vector p and returns A @ p
# We'll use a simple matrix A for this
A = torch.randn(4, 4)

def f_Ax(p):
    """Matrix-vector product: returns A @ p as a torch tensor"""
    # p is a numpy array, convert to tensor, multiply, convert back
    p_tensor = torch.from_numpy(p).float()
    result = A @ p_tensor
    return result

# Define a simple callback function
def callback(x):
    """Simple callback that does nothing"""
    pass

ARGS = {
    'f_Ax': f_Ax,
    'b': b,
    'cg_iters': 10,
    'callback': callback,
    'verbose': False,
    'residual_tol': 1e-10
}
Setup block drafted by
a language model, Claude Haiku 4.5, prompt python_fixture_v1, through the batch API
Imports
numpy, torch — import names as written, not package names to install; a name the repository itself provides is not a package
Returned
type ndarray, ndim 1, dtype family float, shape (4,) — shape (4,) as a later run recorded it
dtype family
int means an integer dtype; float means any other dtype the instrument saw, bool and complex included (fixture_check.py records only these two families)
Environment
image not recorded; re-verify against syntology-harvest-sandbox:v5-deps; not recorded for this sample: the harness installs a cuda-to-cpu shim (cuda_shim.py) before every sample and no run records whether a sample needed it; seed: none by the harness; any seed is in the setup block
conjugate_gradient_np_old Ran
ran on a synthesized input
MoritzTaylor/maml-rl-tf2/maml_rl/optimizers/conjugate_gradient_optimizer.py
code served (permissive licence) · get_code("a9ccffea4b0a614b")
How it ran

Ran in Syntology's sandbox on this synthesized input (drafted by a language model, Claude Haiku 4.5, prompt python_fixture_v1, through the batch API) and returned ndarray, ndim 1, dtype family float, shape (2,) as a later run recorded it. The image it ran in was not recorded. If your copy returns the same type, ndim and shape on these inputs, it matched what we observed; nothing here checks that. It does NOT mean the output is correct: nothing has compared it to the paper.

import numpy as np
import torch

torch.manual_seed(0)

# The function takes:
# - Ax: a callable that applies a linear operator to a vector
# - b: a tensor-like object with a .numpy() method
# - cg_iters: int (default 10)
# - EPS: float (default 1e-10)

# Create a simple linear operator function
def linear_operator(p):
    """Simple linear operator: multiply by a matrix"""
    # p is a numpy array, return A @ p
    A = np.array([[2.0, 0.5], [0.5, 1.0]])
    return A @ p

# Create b as a torch tensor (it has .numpy() method)
b = torch.tensor([1.0, 2.0], dtype=torch.float32)

ARGS = {
    "Ax": linear_operator,
    "b": b,
    "cg_iters": 10,
    "EPS": 1e-10
}
Setup block drafted by
a language model, Claude Haiku 4.5, prompt python_fixture_v1, through the batch API
Imports
numpy, torch — import names as written, not package names to install; a name the repository itself provides is not a package
Returned
type ndarray, ndim 1, dtype family float, shape (2,) — shape (2,) as a later run recorded it
dtype family
int means an integer dtype; float means any other dtype the instrument saw, bool and complex included (fixture_check.py records only these two families)
Environment
image not recorded; re-verify against syntology-harvest-sandbox:v5-deps; not recorded for this sample: the harness installs a cuda-to-cpu shim (cuda_shim.py) before every sample and no run records whether a sample needed it; seed: none by the harness; any seed is in the setup block
conjugate_gradient_tf Ran
ran on a synthesized input
MoritzTaylor/maml-rl-tf2/maml_rl/optimizers/conjugate_gradient_optimizer.py
code served (permissive licence) · get_code("efcef47843a31b3b")
How it ran

Ran in Syntology's sandbox on this synthesized input (drafted by a language model, Claude Haiku 4.5, prompt python_fixture_v1, through the batch API) and returned EagerTensor, ndim 1, dtype family float, shape (2,) as a later run recorded it. The image it ran in was not recorded. If your copy returns the same type, ndim and shape on these inputs, it matched what we observed; nothing here checks that. It does NOT mean the output is correct: nothing has compared it to the paper.

import tensorflow as tf
import numpy as np

# Define a simple linear operator function that computes A @ p
def create_matrix_vector_product(matrix):
    """Create a function that computes matrix-vector product"""
    def Ax(p):
        return tf.matmul(tf.reshape(matrix, [matrix.shape[0], matrix.shape[1]]), 
                         tf.reshape(p, [p.shape[0], 1]))[:, 0]
    return Ax

# Create a small positive definite matrix (2x2 for tiny test)
# Use a simple symmetric positive definite matrix
A_np = np.array([[4.0, 1.0], [1.0, 3.0]], dtype=np.float32)
A_matrix = tf.constant(A_np, dtype=tf.float32)

# Create the Ax function (matrix-vector product operator)
Ax = create_matrix_vector_product(A_matrix)

# Create a small vector b (size 2)
b = tf.constant([1.0, 2.0], dtype=tf.float32)

# Test parameters
cg_iters = 10
residual_tol = 1e-10

ARGS = {
    "Ax": Ax,
    "b": b,
    "cg_iters": cg_iters,
    "residual_tol": residual_tol
}
Setup block drafted by
a language model, Claude Haiku 4.5, prompt python_fixture_v1, through the batch API
Imports
numpy, tensorflow — import names as written, not package names to install; a name the repository itself provides is not a package
Returned
type EagerTensor, ndim 1, dtype family float, shape (2,) — shape (2,) as a later run recorded it
dtype family
int means an integer dtype; float means any other dtype the instrument saw, bool and complex included (fixture_check.py records only these two families)
Environment
image not recorded; re-verify against syntology-harvest-sandbox:v5-deps; not recorded for this sample: the harness installs a cuda-to-cpu shim (cuda_shim.py) before every sample and no run records whether a sample needed it; seed: none by the harness; any seed is in the setup block
conv2d Ran
ran; our contract draft was wrong, not the code
katerakelly/pytorch-maml/src/layers.py
code served (permissive licence) · get_code("b92731b55be235fa")
How it ran

Ran in Syntology's sandbox on this synthesized input (drafted by a language model, Claude Haiku 4.5, prompt python_fixture_v1, through the batch API) and returned Tensor, ndim 4, dtype family float, shape (2, 5, 2, 2) as a later run recorded it. The image it ran in was not recorded. The code mentions cuda, and the harness aliases cuda to the CPU for every sample; whether this run needed that is not recorded. If your copy returns the same type, ndim and shape on these inputs, it matched what we observed; nothing here checks that. It does NOT mean the output is correct: nothing has compared it to the paper.

import torch
import torch.nn as nn
from torch.nn import functional as F

torch.manual_seed(0)

# Create tiny input tensor: batch=2, channels=3, height=4, width=4
input_tensor = torch.randn(2, 3, 4, 4)

# Create weight tensor for conv2d: out_channels=5, in_channels/groups=3, kernel_h=3, kernel_w=3
weight_tensor = torch.randn(5, 3, 3, 3)

# Create bias tensor: out_channels=5
bias_tensor = torch.randn(5)

ARGS = {
    'input': input_tensor,
    'weight': weight_tensor,
    'bias': bias_tensor,
    'stride': 1,
    'padding': 0,
    'dilation': 1,
    'groups': 1
}
Setup block drafted by
a language model, Claude Haiku 4.5, prompt python_fixture_v1, through the batch API
Imports
torch — import names as written, not package names to install; a name the repository itself provides is not a package
Returned
type Tensor, ndim 4, dtype family float, shape (2, 5, 2, 2) — shape (2, 5, 2, 2) as a later run recorded it
dtype family
int means an integer dtype; float means any other dtype the instrument saw, bool and complex included (fixture_check.py records only these two families)
Environment
image not recorded; re-verify against syntology-harvest-sandbox:v5-deps; not recorded for this sample: the harness installs a cuda-to-cpu shim (cuda_shim.py) before every sample and no run records whether a sample needed it; seed: none by the harness; any seed is in the setup block
conv_block Ran
ran; our contract draft was wrong, not the code
theneuralbeing/maml/model.py
pointer only (licence: NONE) · get_code("0119024a5f2c09b7")
How it ran

The body of this sample is withheld: GitHub detected no licence in this paper's repository, theneuralbeing/maml when it was checked. The setup block that called it is withheld with it, because it is written against that body. source_path and origin say where the code lives, to read under the repository's own terms. A run is recorded.

create_nshot_task_label Ran
ran, honoured the contract we drafted
KamalM8/Few-Shot-learning-Fashion/few_shot/maml.py
code served (permissive licence) · get_code("82bdff06f37e069f")
How it ran

Ran in Syntology's sandbox on this synthesized input (drafted by a language model, Claude Haiku 4.5, prompt python_fixture_v1, through the batch API) and returned Tensor, ndim 1, dtype family int, shape (6,) as a later run recorded it. The image it ran in was not recorded. If your copy returns the same type, ndim and shape on these inputs, it matched what we observed; nothing here checks that. It does NOT mean the output is correct: nothing has compared it to the paper.

import torch

torch.manual_seed(0)

ARGS = {
    "k": 3,
    "q": 2,
}
Setup block drafted by
a language model, Claude Haiku 4.5, prompt python_fixture_v1, through the batch API
Imports
torch — import names as written, not package names to install; a name the repository itself provides is not a package
Returned
type Tensor, ndim 1, dtype family int, shape (6,) — shape (6,) as a later run recorded it
dtype family
int means an integer dtype; float means any other dtype the instrument saw, bool and complex included (fixture_check.py records only these two families)
Environment
image not recorded; re-verify against syntology-harvest-sandbox:v5-deps; not recorded for this sample: the harness installs a cuda-to-cpu shim (cuda_shim.py) before every sample and no run records whether a sample needed it; seed: none by the harness; any seed is in the setup block
cross_entropy Ran
ran, violated the contract we drafted
minseop-aitrics/FewshotLearning/MAML/lib/networks.py
pointer only (licence: NONE) · get_code("826e48b56e489fae")
How it ran

The body of this sample is withheld: GitHub detected no licence in this paper's repository, minseop-aitrics/FewshotLearning when it was checked. The setup block that called it is withheld with it, because it is written against that body. source_path and origin say where the code lives, to read under the repository's own terms. A run is recorded.

detach_distribution Ran
ran; our contract draft was wrong, not the code
nyu-larx/attack_metarl/maml_rl/metalearners/maml_trpo.py
code served (permissive licence) · get_code("2459a4e7bc46e742")
How it ran

Ran in Syntology's sandbox on this synthesized input (drafted by a language model, Claude Haiku 4.5, prompt python_fixture_v1, through the batch API) and returned Categorical. The image it ran in was not recorded. If your copy returns the same type on these inputs, it matched what we observed; nothing here checks that. It does NOT mean the output is correct: nothing has compared it to the paper.

import torch
from torch.distributions import Categorical, Independent, Normal

torch.manual_seed(0)

# Test case 1: Categorical distribution
categorical_dist = Categorical(logits=torch.randn(2, 4))

# Test case 2: Normal distribution
normal_dist = Normal(loc=torch.randn(2, 4), scale=torch.abs(torch.randn(2, 4)) + 0.1)

# Test case 3: Independent distribution wrapping Normal
independent_dist = Independent(
    Normal(loc=torch.randn(2, 3, 4), scale=torch.abs(torch.randn(2, 3, 4)) + 0.1),
    reinterpreted_batch_ndims=1
)

# Test with Categorical
ARGS = {
    'pi': categorical_dist
}
Setup block drafted by
a language model, Claude Haiku 4.5, prompt python_fixture_v1, through the batch API
Imports
torch — import names as written, not package names to install; a name the repository itself provides is not a package
Returned
type Categorical — a Categorical output has no array shape of its own; none is stated — the instrument coerces any output to an array; for a Categorical output the recorded ndim 0 and dtype family float describe that coercion, not the output, and are not stated
Environment
image not recorded; re-verify against syntology-harvest-sandbox:v5-deps; not recorded for this sample: the harness installs a cuda-to-cpu shim (cuda_shim.py) before every sample and no run records whether a sample needed it; seed: none by the harness; any seed is in the setup block
detach_distribution Ran
ran; our contract draft was wrong, not the code
shunzh/pytorch-maml-rl/maml_rl/metalearner.py
code served (permissive licence) · get_code("159ae31bd6bceefb")
How it ran

Ran in Syntology's sandbox on this synthesized input (drafted by a language model, Claude Haiku 4.5, prompt python_fixture_v1) and returned Categorical. The image it ran in was not recorded. If your copy returns the same type on these inputs, it matched what we observed; nothing here checks that. It does NOT mean the output is correct: nothing has compared it to the paper.

import torch
from torch.distributions import Categorical, Normal

torch.manual_seed(0)

# Test with Categorical distribution
logits_categorical = torch.randn(2, 4)
pi_categorical = Categorical(logits=logits_categorical)

# Test with Normal distribution
loc_normal = torch.randn(2, 4)
scale_normal = torch.abs(torch.randn(2, 4)) + 0.1  # ensure positive scale
pi_normal = Normal(loc=loc_normal, scale=scale_normal)

# Create ARGS dict with both distribution types
# We'll test with Categorical first
ARGS = {
    "pi": pi_categorical
}
Setup block drafted by
a language model, Claude Haiku 4.5, prompt python_fixture_v1
Imports
torch — import names as written, not package names to install; a name the repository itself provides is not a package
Returned
type Categorical — a Categorical output has no array shape of its own; none is stated — the instrument coerces any output to an array; for a Categorical output the recorded ndim 0 and dtype family float describe that coercion, not the output, and are not stated
Environment
image not recorded; re-verify against syntology-harvest-sandbox:v5-deps; not recorded for this sample: the harness installs a cuda-to-cpu shim (cuda_shim.py) before every sample and no run records whether a sample needed it; seed: none by the harness; any seed is in the setup block

Showing the first 60. An agent gets every one from get_harvested_code_for_paper("1703.03400").

Also present in other papers' code

Of 154 samples lifted from this paper's linked repositories, 154 carry a function identity and 0 do not. Of the 151 distinct functions with an identity, 19 are also present in other papers whose code we hold (2 with at least one paper dated earlier, 2 the same month, 17 later) and 132 are only here among the 52,977 papers whose code Syntology holds (as of 2026-09-26).

Only here means: among the 52,977 papers whose code Syntology holds (51,887 with lifted samples, 1,090 through their assemblies only), as of 2026-09-26, no other paper's lifted samples or current assembly bricks contain an identical function body after normalisation.

FunctionAlso present inEarliest-datedOthers named
layer_init 28 other papers
2 dated earlier, 25 later, 1 undated · 2 only as an assembly brick
1611.02779 (2016-11)
RL$^2$: Fast Reinforcement Learning via Slow Reinforcement Learning
1611.05763 (2016-11)
Learning to reinforcement learn
1803.11485 (2018-03)
QMIX: Monotonic Value Function Factorisation for Deep Multi-Agent Reinforcement Learning
and 25 more not named here
merge 28 other papers
7 dated earlier, 21 later
1406.1078 (2014-06)
Learning Phrase Representations using RNN Encoder-Decoder for Statistical Machine Translation
1409.3215 (2014-09)
Sequence to Sequence Learning with Neural Networks
1512.00567 (2015-12)
Rethinking the Inception Architecture for Computer Vision
and 25 more not named here
td_target 8 other papers
8 later
1812.05905 (2018-12)
Soft Actor-Critic Algorithms and Applications
1906.08253 (2019-06)
When to Trust Your Model: Model-Based Policy Optimization
2006.13916 (2020-06)
Off-Dynamics Reinforcement Learning: Training for Transfer with Domain Classifiers
and 5 more not named here
set_torch_seed
brick of this paper's assembly: helper
6 other papers
6 later · 1 only as an assembly brick
1810.09502 (2018-10)
How to train your MAML
1905.10295 (2019-05)
Learning to learn via Self-Critique
1906.05895 (2019-06)
Learning to Forget for Meta-Learning
and 3 more not named here
get_images 3 other papers
3 later
1806.03836 (2018-06)
Bayesian Model-Agnostic Meta-Learning
1807.08912 (2018-07)
Meta-Learning Priors for Efficient Online Bayesian Regression
2105.05757 (2021-05)
Exploring the Similarity of Representations in Model-Agnostic Meta-Learning
compute_accuracy 2 other papers
2 later
2003.05856 (2020-03)
Online Fast Adaptation and Knowledge Accumulation: a New Approach to Continual Learning
2201.10777 (2022-01)
Meta-learning Spiking Neural Networks with Surrogate Gradient Descent
magic_box 2 other papers
2 later
1810.06784 (2018-10)
ProMP: Proximal Meta-Policy Search
2105.13524 (2021-05)
Improving Generalization in Meta-RL with Imaginary Tasks from Latent Dynamics Mixture
IdentityTransformLoss
brick of this paper's assembly: helper
1 other paper
1 the same month · 1 only as an assembly brick
1703.05175 (2017-03)
Prototypical Networks for Few-shot Learning
MetaConvNormLayerReLU
brick of this paper's assembly: model
1 other paper
1 later
2203.12768 (2022-03)
Multidimensional Belief Quantification for Label-Efficient Meta-Learning
MetaLayerNormLayer
brick of this paper's assembly: model
1 other paper
1 later
2203.12768 (2022-03)
Multidimensional Belief Quantification for Label-Efficient Meta-Learning
VGGReLUNormNetwork
brick of this paper's assembly: model
1 other paper
1 later
2203.12768 (2022-03)
Multidimensional Belief Quantification for Label-Efficient Meta-Learning
conv2d 1 other paper
1 later
2310.07015 (2023-10)
Neural Relational Inference with Fast Modular Meta-learning
create_nshot_task_label
brick of this paper's assembly: helper
1 other paper
1 later
2010.06498 (2020-10)
Cross-Domain Few-Shot Learning by Representation Fusion
get_imageset
brick of this paper's assembly: helper
1 other paper
1 the same month · 1 only as an assembly brick
1703.05175 (2017-03)
Prototypical Networks for Few-shot Learning
linear 1 other paper
1 later
2310.07015 (2023-10)
Neural Relational Inference with Fast Modular Meta-learning
make_env 1 other paper
1 later
2501.11039 (2025-01)
Model Predictive Task Sampling for Efficient and Robust Adaptation
parse_yaml 1 other paper
1 later
1909.11942 (2019-09)
ALBERT: A Lite BERT for Self-supervised Learning of Language Representations
relu 1 other paper
1 later
2310.07015 (2023-10)
Neural Relational Inference with Fast Modular Meta-learning
tensors_to_device 1 other paper
1 later
2003.05856 (2020-03)
Online Fast Adaptation and Knowledge Accumulation: a New Approach to Continual Learning

Presence, not direction: an identical function body in two papers' repositories does not say who wrote it, which came from which, or that either paper's method rests on it. Matching is exact after normalisation, so a renamed or edited function is not matched. Dates are when papers appeared, not when code was written. Only .py files the harvester lifted are covered; notebooks are not read. A new-style arXiv id YYMM.NNNN dates a paper to the month 20YY-MM; otherwise Paper.year dates it to the year; otherwise it is undated. Dates are when the paper appeared, not when the code was written. Read 2026-11-21.

Repositories linked to this paper

More are linked than shown here.

Some links come from the archived Papers with Code dataset (CC BY-SA 4.0): attribution and licence.

Abstract

We propose an algorithm for meta-learning that is model-agnostic, in the sense that it is compatible with any model trained with gradient descent and applicable to a variety of different learning problems, including classification, regression, and reinforcement learning. The goal of meta-learning is to train a model on a variety of learning tasks, such that it can solve new learning tasks using only a small number of training samples. In our approach, the parameters of the model are explicitly trained such that a small number of gradient steps with a small amount of training data from a new task will produce good generalization performance on that task. In effect, our method trains the model to be easy to fine-tune. We demonstrate that this approach leads to state-of-the-art performance on two fewshot image classification benchmarks, produces good results on few-shot regression, and accelerates fine-tuning for policy gradient reinforcement learning with neural network policies.

For agents

The same record, over MCP at https://syntology.ai/mcp:

get_harvested_code_for_paper("1703.03400")
get_code_for_paper("1703.03400")
have("1703.03400")

The run record, dated, one paper per request, free:

curl https://syntology.ai/api/ran/1703.03400.json

A badge for a README (the split and the date, never a ratio):

[![Syntology run record](https://syntology.ai/api/ran/1703.03400.svg)](https://syntology.ai/paper/1703.03400)

Connect an agent — have() is free.