SYNTOLOGY HomeExplorerAtlasCodeMethodologyAboutDevelopersFeedPricing
Paper · 2006.14606 · 2020

Global Convergence and Generalization Bound of Gradient-Based Meta-Learning with Deep Neural Nets

arXiv · PDF · Open in the Atlas

Code that ran

18 of 22 samples (functions and classes) lifted from this paper's linked repositories executed on a synthesized input in Syntology's jail (0 of them constructed an object rather than computing a result; 1 honoured the contract we drafted, 0 violated it and 11 have no contract verdict; 6 failures of our instrument; 4 no recorded run), measured 2026-11-22; 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/2006.14606.json · badge: /api/ran/2006.14606.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
AI-secure/Meta-Neural-Kernel canonical (classifier label)
classifier basis: census
18 ran · 4 no recorded run
FunctionStatusWhere it lives
NTK Ran
ran on a synthesized input
AI-secure/Meta-Neural-Kernel/support/tools.py
code served (permissive licence) · get_code("13e36d5238769ad6")
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 2, dtype family float, shape (3, 3) 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 math

# Set random seed for reproducibility
np.random.seed(0)

# Create a small input matrix X
# Shape: (n_samples, n_features) = (3, 4)
# The function uses X to compute S = X @ X.T, which should be (3, 3)
X = np.random.randn(3, 4).astype(np.float32)

# d_max: maximum depth for the NTK computation
d_max = 2

# fix_dep: threshold for when to start accumulating H into K
fix_dep = 0

# normalize: whether to normalize the resulting kernel
normalize = False

ARGS = {
    "X": X,
    "d_max": d_max,
    "fix_dep": fix_dep,
    "normalize": normalize
}
Setup block drafted by
a language model, Claude Haiku 4.5, prompt python_fixture_v1, through the batch API
Imports
numpy — import names as written, not package names to install; a name the repository itself provides is not a package
Returned
type ndarray, ndim 2, dtype family float, shape (3, 3) — shape (3, 3) 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
cat_list_to_tensor Ran
ran, honoured the contract we drafted
AI-secure/Meta-Neural-Kernel/hypergrad/CG_torch.py
code served (permissive licence) · get_code("3ed1406329714c3f")
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 Tensor, ndim 1, dtype family float, shape (29,) 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)

# The function expects list_tx to be a list of tensors
# It flattens each tensor and concatenates them
list_tx = [
    torch.randn(2, 4),      # First tensor: shape (2, 4)
    torch.randn(3, 5),      # Second tensor: shape (3, 5)
    torch.randn(6),         # Third tensor: shape (6,)
]

ARGS = {
    "list_tx": list_tx,
}
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 Tensor, ndim 1, dtype family float, shape (29,) — shape (29,) 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
cg Ran
ran; our contract draft was wrong, not the code
AI-secure/Meta-Neural-Kernel/hypergrad/CG_torch.py
code served (permissive licence) · get_code("31f282d2a7c181bb")
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 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)

# Define a simple linear operator function that takes a list of tensors
# and returns a list of tensors (simulating matrix-vector multiplication)
def linear_operator(x_list):
    """
    Simple linear operator: Ax where A is a small matrix.
    Takes list of tensors, returns list of tensors.
    """
    result = []
    for x in x_list:
        # Simple operation: multiply by 2 (acts like a diagonal matrix)
        result.append(2.0 * x)
    return result

# Create the b vector as a list of small tensors
b = [
    torch.randn(4),
    torch.randn(3),
]

ARGS = {
    "Ax": linear_operator,
    "b": b,
    "max_iter": 100,
    "epsilon": 1e-05,
}
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 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
exists_kernel_element Ran
ran on a synthesized input
AI-secure/Meta-Neural-Kernel/support/ConvNTK.py
code served (permissive licence) · get_code("83f4ab415a5aad0b")
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 bool, 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 os
import tempfile

# Create a temporary directory to use as the path for testing
temp_dir = tempfile.mkdtemp()

# Create some test .npy files to make the function's file existence checks meaningful
test_file_1 = os.path.join(temp_dir, "0-0.npy")
test_file_2 = os.path.join(temp_dir, "1-2.npy")

# Create empty placeholder files
with open(test_file_1, 'w') as f:
    f.write('')
with open(test_file_2, 'w') as f:
    f.write('')

ARGS = {
    'i': 0,
    'j': 0,
    'path': temp_dir + '/'
}
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 bool, 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
find_classes Ran
ran; our contract draft was wrong, not the code
AI-secure/Meta-Neural-Kernel/support/omniglot_loaders.py
code served (permissive licence) · get_code("7c477c388fa699a2")
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, 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 os
import tempfile
import shutil

# Create a temporary directory structure with some PNG files
temp_root = tempfile.mkdtemp()

# Create subdirectories with the structure: root/category/subcategory/
os.makedirs(os.path.join(temp_root, 'category1', 'subdir1'), exist_ok=True)
os.makedirs(os.path.join(temp_root, 'category1', 'subdir2'), exist_ok=True)
os.makedirs(os.path.join(temp_root, 'category2', 'subdir3'), exist_ok=True)

# Create some dummy PNG files
with open(os.path.join(temp_root, 'category1', 'subdir1', 'image1.png'), 'w') as f:
    f.write('dummy')
with open(os.path.join(temp_root, 'category1', 'subdir2', 'image2.png'), 'w') as f:
    f.write('dummy')
with open(os.path.join(temp_root, 'category2', 'subdir3', 'image3.png'), 'w') as f:
    f.write('dummy')

# Add a non-PNG file to test filtering
with open(os.path.join(temp_root, 'category1', 'subdir1', 'notimage.txt'), 'w') as f:
    f.write('dummy')

ARGS = {
    'root_dir': temp_root
}
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 list, ndim 2, dtype family float — a list output has no array shape of its own; none is stated
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
gd_step Ran
ran; our contract draft was wrong, not the code
AI-secure/Meta-Neural-Kernel/hypergrad/diff_optimizers.py
pointer only (licence: MIT); the stored copy get_code serves, from cats1520cakes/Q-Detection-A-Quantum-Classical-Hybrid-Poisoning-Attack-Detection-Method, is pointer only (licence: NONE) · get_code("3ffa7e0c883965f8")
How it ran

The body of this sample is withheld: this paper's link allows the body inline (MIT), but get_code serves the stored copy, first harvested from cats1520cakes/Q-Detection-A-Quantum-Classical-Hybrid-Poisoning-Attack-Detection-Method, and GitHub detected no licence in that repository 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.

get_cnn_omniglot Ran
ran; our contract draft was wrong, not the code
AI-secure/Meta-Neural-Kernel/imaml_utils.py
code served (permissive licence) · get_code("2b7ea8d2c1a114db")
How it ran

Ran in Syntology's sandbox on this synthesized input (drafted by a language model, Claude Sonnet 4.5, prompt python_fixture_v1) and returned Sequential. 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 math
from torch import nn

torch.manual_seed(0)

# The function get_cnn_omniglot takes two parameters:
# - hidden_size: an integer for the number of hidden units in conv layers
# - n_classes: an integer for the number of output classes

hidden_size = 8
n_classes = 5

ARGS = {
    'hidden_size': hidden_size,
    'n_classes': n_classes
}
Setup block drafted by
a language model, Claude Sonnet 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 Sequential — a Sequential 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
heavy_ball_step Ran
ran on a synthesized input
AI-secure/Meta-Neural-Kernel/hypergrad/diff_optimizers.py
code served (permissive licence) · get_code("d533144f406f4f80")
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 tuple. 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)

# Create small tensors for parameters
# These need to require grad so autograd.grad works
param1 = torch.tensor([1.0, 2.0, 3.0, 4.0], requires_grad=True)
param2 = torch.tensor([5.0, 6.0, 7.0, 8.0], requires_grad=True)
params = [param1, param2]

# Create auxiliary parameters (previous parameter values for momentum)
aux_param1 = torch.tensor([0.9, 1.9, 2.9, 3.9], requires_grad=False)
aux_param2 = torch.tensor([4.9, 5.9, 6.9, 7.9], requires_grad=False)
aux_params = [aux_param1, aux_param2]

# Create a simple scalar loss that depends on params
loss = (params[0] ** 2).sum() + (params[1] ** 2).sum()

# Define other arguments
step_size = 0.01
momentum = 0.9
create_graph = True

ARGS = {
    'params': params,
    'aux_params': aux_params,
    'loss': loss,
    'step_size': step_size,
    'momentum': momentum,
    'create_graph': create_graph
}
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 tuple — a tuple 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
index_classes Ran
ran; our contract draft was wrong, not the code
AI-secure/Meta-Neural-Kernel/support/omniglot_loaders.py
pointer only (licence: MIT); the stored copy get_code serves, from KaiSUN1/SeAl, is pointer only (licence: NONE) · get_code("82506bf89d625519")
How it ran

The body of this sample is withheld: this paper's link allows the body inline (MIT), but get_code serves the stored copy, first harvested from KaiSUN1/SeAl, and GitHub detected no licence in that repository 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.

inner_loop Ran
ran; our contract draft was wrong, not the code
AI-secure/Meta-Neural-Kernel/imaml_utils.py
code served (permissive licence) · get_code("67807e9ca0f086f6")
How it ran

Ran in Syntology's sandbox on this synthesized input (drafted by a language model, Claude Sonnet 4.5, prompt python_fixture_v1) and returned list, ndim 1, 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

torch.manual_seed(0)

# Create a simple optimizer class that matches the interface used in inner_loop
class SimpleOptimizer:
    def __init__(self):
        self.curr_loss = torch.tensor(0.5)
    
    def get_opt_params(self, params):
        # Return the params as-is or a copy
        if isinstance(params, dict):
            return {k: v.clone() if isinstance(v, torch.Tensor) else v for k, v in params.items()}
        elif isinstance(params, torch.Tensor):
            return params.clone()
        return params
    
    def __call__(self, params, hparams, create_graph=False):
        # Simulate an optimization step
        # Update curr_loss to simulate progress
        self.curr_loss = self.curr_loss * 0.9
        
        if isinstance(params, dict):
            new_params = {}
            for k, v in params.items():
                if isinstance(v, torch.Tensor):
                    # Simple gradient descent-like update
                    new_params[k] = v - 0.01 * torch.randn_like(v)
                else:
                    new_params[k] = v
            return new_params
        elif isinstance(params, torch.Tensor):
            return params - 0.01 * torch.randn_like(params)
        return params

# Create hparams (hyperparameters) - can be a dict or simple object
hparams = {
    'lr': 0.01,
    'momentum': 0.9
}

# Create params - typically model parameters
params = {
    'weight': torch.randn(4, 3),
    'bias': torch.randn(3)
}

# Create optimizer instance
optim = SimpleOptimizer()

# Number of steps
n_steps = 5

# Log interval
log_interval = 2

# Create graph flag
create_graph = False

ARGS = {
    'hparams': hparams,
    'params': params,
    'optim': optim,
    'n_steps': n_steps,
    'log_interval': log_interval,
    'create_graph': create_graph
}
Setup block drafted by
a language model, Claude Sonnet 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 list, ndim 1, dtype family float — a list output has no array shape of its own; none is stated
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
load_label_embeddings Ran
ran on a synthesized input
AI-secure/Meta-Neural-Kernel/meta_cntk_utils.py
code served (permissive licence) · get_code("f1815f9eb0daf1fd")
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 dict. 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 pickle
import os
import tempfile

# Create a temporary directory for the saved models
temp_dir = tempfile.mkdtemp()
os.makedirs(os.path.join(temp_dir, 'saved_models'), exist_ok=True)

# Create mock embedding dictionaries and save them
embedding_dict_regular = {
    'task_0': [0.1, 0.2, 0.3],
    'task_1': [0.4, 0.5, 0.6],
}

embedding_dict_random = {
    'task_0': [0.7, 0.8, 0.9],
    'task_1': [1.0, 1.1, 1.2],
}

# Save the pickle files
pickle.dump(embedding_dict_regular, 
            open(os.path.join(temp_dir, 'saved_models/tasks-5-embeddings.p'), 'wb'))
pickle.dump(embedding_dict_random,
            open(os.path.join(temp_dir, 'saved_models/tasks-5-embeddings-random_cnn.p'), 'wb'))

# Change to the temp directory so relative paths work
original_cwd = os.getcwd()
os.chdir(temp_dir)

ARGS = {
    'n_task': 5,
    'random_cnn': False,
}
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 dict — a dict output has no array shape of its own; none is stated — the instrument coerces any output to an array; for a dict 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
np2torch Ran
ran on a synthesized input
AI-secure/Meta-Neural-Kernel/maml_utils.py
code served (permissive licence) · get_code("6b36760cde85633e")
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. 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 numpy as np
import torch

torch.manual_seed(0)

# Create test arrays and tensors
array1 = np.array([[1, 2, 3, 4], [5, 6, 7, 8]], dtype=np.float32)
array2 = np.array([[[1, 2], [3, 4]], [[5, 6], [7, 8]]], dtype=np.int32)
tensor1 = torch.tensor([[1.0, 2.0], [3.0, 4.0]])

ARGS = {
    'arrays': [array1, array2, tensor1],
    'device': torch.device('cpu'),
    'label_long_type': True
}
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 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
pred_from_emb Ran
ran on a synthesized input
AI-secure/Meta-Neural-Kernel/meta_cntk_utils.py
code served (permissive licence) · get_code("3fa6ba572324395e")
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 2, dtype family int, shape (2, 1) 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

class MockDataset:
    def __init__(self):
        self.N_test = 2
        # test_Y_centroids[i] should be array-like for fitting NearestNeighbors
        # Each element is a set of centroids for test case i
        self.test_Y_centroids = [
            np.array([[1.0, 2.0, 3.0, 4.0], [5.0, 6.0, 7.0, 8.0]]),
            np.array([[2.0, 3.0, 4.0, 5.0], [6.0, 7.0, 8.0, 9.0]])
        ]

# Create embeddings with same structure: 2 test cases, each with embedding(s)
embeddings = [
    np.array([[1.5, 2.5, 3.5, 4.5]]),
    np.array([[2.5, 3.5, 4.5, 5.5]])
]

dataset = MockDataset()

ARGS = {
    "embeddings": embeddings,
    "dataset": dataset,
    "n_neighbors": 1
}
Setup block drafted by
a language model, Claude Haiku 4.5, prompt python_fixture_v1, through the batch API
Imports
numpy, sklearn — import names as written, not package names to install; a name the repository itself provides is not a package
Returned
type ndarray, ndim 2, dtype family int, shape (2, 1) — shape (2, 1) 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
remove_padding Ran
ran on a synthesized input
AI-secure/Meta-Neural-Kernel/maml_utils.py
code served (permissive licence) · get_code("09a851231e1710bd")
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 5, dtype family float, shape (2, 3, 4, 28, 28) 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)

# Test case 1: Single tensor (not a list)
single_tensor = torch.randn(2, 3, 4, 32, 32)

# Test case 2: List of tensors with matching shape
list_of_tensors = [
    torch.randn(2, 3, 4, 32, 32),
    torch.randn(2, 3, 4, 32, 32)
]

# Test case 3: List of tensors with non-matching shape (should be skipped)
mixed_list = [
    torch.randn(2, 3, 4, 32, 32),
    torch.randn(2, 3, 4, 16, 16)
]

ARGS = {
    "arrays": single_tensor
}
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 Tensor, ndim 5, dtype family float, shape (2, 3, 4, 28, 28) — shape (2, 3, 4, 28, 28) 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
reverse_unroll Ran
ran on a synthesized input
AI-secure/Meta-Neural-Kernel/hypergrad/hypergradients.py
code served (permissive licence) · get_code("47110587d7bc352b")
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 tuple. 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 small tensors for params and hparams
# These need to be leaf tensors with requires_grad=True for gradient computation
params = [
    torch.randn(2, 4, requires_grad=True),
    torch.randn(3, 4, requires_grad=True)
]

hparams = [
    torch.randn(2, 3, requires_grad=True),
    torch.randn(4, 2, requires_grad=True)
]

# Define outer_loss function
# It takes params and hparams and returns a scalar loss
def outer_loss(params, hparams):
    # Simple loss: sum of element-wise products
    loss = torch.tensor(0.0, requires_grad=True)
    for p in params:
        loss = loss + p.sum()
    for h in hparams:
        loss = loss + h.sum()
    return loss

ARGS = {
    'params': params,
    'hparams': hparams,
    'outer_loss': outer_loss,
    'set_grad': True
}
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 tuple — a tuple 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
svm Ran
ran on a synthesized input
AI-secure/Meta-Neural-Kernel/support/tools.py
code served (permissive licence) · get_code("3f3ba82ae6dd255a")
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 int, 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
from sklearn.svm import SVC

# Create small kernel matrices (precomputed kernels)
# For SVM with precomputed kernel, K_train should be (n_samples, n_samples)
# and K_test should be (n_test_samples, n_train_samples)

np.random.seed(0)

# Training kernel matrix: (4, 4) - 4 training samples
K_train = np.random.randn(4, 4)
K_train = (K_train + K_train.T) / 2  # Make symmetric for valid kernel matrix

# Test kernel matrix: (2, 4) - 2 test samples, 4 training samples
K_test = np.random.randn(2, 4)

# Training labels: binary classification
y_train = np.array([0, 1, 0, 1])

# Regularization parameter
C = 1.0

ARGS = {
    'K_train': K_train,
    'K_test': K_test,
    'y_train': y_train,
    'C': C
}
Setup block drafted by
a language model, Claude Haiku 4.5, prompt python_fixture_v1, through the batch API
Imports
numpy, sklearn — 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 int, 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
torch2np Ran
ran on a synthesized input
AI-secure/Meta-Neural-Kernel/maml_utils.py
code served (permissive licence) · get_code("f482f7091be9fc72")
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
import numpy as np

torch.manual_seed(0)

# Create test data: a list of tensors and non-tensors
tensor1 = torch.randn(2, 4)
tensor2 = torch.randn(3, 5)
non_tensor = [1, 2, 3]
tensor3 = torch.randn(2, 3)

tensors = [tensor1, tensor2, non_tensor, tensor3]

ARGS = {
    "tensors": tensors
}
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 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
torch_momentum_step Ran
ran on a synthesized input
AI-secure/Meta-Neural-Kernel/hypergrad/diff_optimizers.py
code served (permissive licence) · get_code("6cdf7a8f1301bf5c")
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 tuple. 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)

# Create small tensors that require gradients for computing gradients through them
params = [
    torch.randn(4, 3, requires_grad=True),
    torch.randn(2, requires_grad=True)
]

# Auxiliary parameters (velocity terms for momentum, same shape as params)
aux_params = [
    torch.zeros(4, 3),
    torch.zeros(2)
]

# Create a simple loss by combining params
loss = (params[0].sum() + params[1].sum()) ** 2

# Step size for gradient descent
step_size = 0.01

# Momentum coefficient
momentum = 0.9

# create_graph flag for higher-order derivatives
create_graph = True

ARGS = {
    "params": params,
    "aux_params": aux_params,
    "loss": loss,
    "step_size": step_size,
    "momentum": momentum,
    "create_graph": create_graph
}
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 tuple — a tuple 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
NTK_torch Not yet run
unverified (harvested, no recorded run)
AI-secure/Meta-Neural-Kernel/support/tools.py
code served (permissive licence) · get_code("7ebbe4bde220a934")
How it ran

no invocation recorded.

fixed_point Not yet run
unverified (harvested, no recorded run)
AI-secure/Meta-Neural-Kernel/hypergrad/hypergradients.py
code served (permissive licence) · get_code("393761f8bd906b62")
How it ran

no invocation recorded.

load_dataset Not yet run
unverified (harvested, no recorded run)
AI-secure/Meta-Neural-Kernel/meta_cntk_utils.py
code served (permissive licence) · get_code("52fb157ddac8fab4")
How it ran

no invocation recorded.

reverse Not yet run
unverified (harvested, no recorded run)
AI-secure/Meta-Neural-Kernel/hypergrad/hypergradients.py
code served (permissive licence) · get_code("112545aa7657ecd8")
How it ran

no invocation recorded.

Also present in other papers' code

Of 22 samples lifted from this paper's linked repositories, 22 carry a function identity and 0 do not. Of the 22 distinct functions with an identity, 9 are also present in other papers whose code we hold (3 with at least one paper dated earlier, 0 the same month, 7 later) and 13 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
cat_list_to_tensor 6 other papers
2 dated earlier, 4 later · 2 only as an assembly brick
1803.06396 (2018-03)
Reviving and Improving Recurrent Back-Propagation
1909.04630 (2019-09)
Meta-Learning with Implicit Gradients
2010.07962 (2020-10)
Bilevel Optimization: Convergence Analysis and Enhanced Design
and 3 more not named here
cg 2 other papers
2 later
2010.07962 (2020-10)
Bilevel Optimization: Convergence Analysis and Enhanced Design
2106.04692 (2021-06)
Provably Faster Algorithms for Bilevel Optimization
gd_step 2 other papers
2 later
2010.07962 (2020-10)
Bilevel Optimization: Convergence Analysis and Enhanced Design
2507.06262 (2025-07)
Q-Detection: A Quantum-Classical Hybrid Poisoning Attack Detection Method
index_classes 2 other papers
2 later
2211.14666 (2022-11)
Synergies between Disentanglement and Sparsity: Generalization and Identifiability in Multi-Task Learning
2605.14252 (2026-05)
Not All Timesteps Matter Equally: Selective Alignment Knowledge Distillation for Spiking Neural Networks
find_classes 1 other paper
1 later
2211.14666 (2022-11)
Synergies between Disentanglement and Sparsity: Generalization and Identifiability in Multi-Task Learning
get_cnn_omniglot 1 other paper
1 dated earlier
1909.04630 (2019-09)
Meta-Learning with Implicit Gradients
heavy_ball_step 1 other paper
1 later
2010.07962 (2020-10)
Bilevel Optimization: Convergence Analysis and Enhanced Design
inner_loop 1 other paper
1 dated earlier
1909.04630 (2019-09)
Meta-Learning with Implicit Gradients
torch_momentum_step 1 other paper
1 later
2010.07962 (2020-10)
Bilevel Optimization: Convergence Analysis and Enhanced Design

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-22.

Repositories linked to this paper

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

Abstract

Gradient-based meta-learning (GBML) with deep neural nets (DNNs) has become a popular approach for few-shot learning. However, due to the non-convexity of DNNs and the bi-level optimization in GBML, the theoretical properties of GBML with DNNs remain largely unknown. In this paper, we first aim to answer the following question: Does GBML with DNNs have global convergence guarantees? We provide a positive answer to this question by proving that GBML with over-parameterized DNNs is guaranteed to converge to global optima at a linear rate. The second question we aim to address is: How does GBML achieve fast adaption to new tasks with prior experience on past tasks? To answer it, we theoretically show that GBML is equivalent to a functional gradient descent operation that explicitly propagates experience from the past tasks to new ones, and then we prove a generalization error bound of GBML with over-parameterized DNNs.

For agents

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

get_harvested_code_for_paper("2006.14606")
get_code_for_paper("2006.14606")
have("2006.14606")

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

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

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

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

Connect an agent — have() is free.