SYNTOLOGY HomeExplorerAtlasCodeMethodologyAboutDevelopersFeedPricing
Paper · 2306.13643 · ICCV · 2023

LightGlue: Local Feature Matching at Light Speed

Marc Pollefeys, Paul-Edouard Sarlin, Philipp Lindenberger, Microsoft Mixed

arXiv · PDF · Open in the Atlas

Code that ran

33 of 40 samples (functions and classes) lifted from this paper's linked repositories executed on a synthesized input in Syntology's jail (4 of them constructed an object rather than computing a result; 0 honoured the contract we drafted, 0 violated it and 23 have no contract verdict; 10 failures of our instrument; 7 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/2306.13643.json · badge: /api/ran/2306.13643.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
cvg/lightglue canonical (classifier label)
classifier basis: census
16 ran · 0 no recorded run
cvg/LightGlue community
Papers with Code archive
10 ran · 4 no recorded run
fabio-sim/LightGlue-ONNX community
Papers with Code archive
7 ran · 3 no recorded run
FunctionStatusWhere it lives
Attention Ran
ran on a synthesized input
cvg/LightGlue/lightglue/lightglue.py
code served (permissive licence) · get_code("a08f05b65312af52")
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 3, dtype family float, shape (2, 3, 6) 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 warnings
from typing import Callable, List, Optional, Tuple
import torch
import torch.nn.functional as F
from torch import nn

# Mock the globals that the class expects
FLASH_AVAILABLE = False
FlashCrossAttention = None

class Attention(nn.Module):

    def __init__(self, allow_flash: bool) -> None:
        super().__init__()
        if allow_flash and (not FLASH_AVAILABLE):
            warnings.warn('FlashAttention is not available. For optimal speed, consider installing torch >= 2.0 or flash-attn.', stacklevel=2)
        self.enable_flash = allow_flash and FLASH_AVAILABLE
        self.has_sdp = hasattr(F, 'scaled_dot_product_attention')
        if allow_flash and FlashCrossAttention:
            self.flash_ = FlashCrossAttention()
        if self.has_sdp:
            torch.backends.cuda.enable_flash_sdp(allow_flash)

    def forward(self, q, k, v, mask: Optional[torch.Tensor]=None) -> torch.Tensor:
        if q.shape[-2] == 0 or k.shape[-2] == 0:
            return q.new_zeros((*q.shape[:-1], v.shape[-1]))
        if self.enable_flash and q.device.type == 'cuda':
            if self.has_sdp:
                args = [x.half().contiguous() for x in [q, k, v]]
                v = F.scaled_dot_product_attention(*args, attn_mask=mask).to(q.dtype)
                return v if mask is None else v.nan_to_num()
            else:
                assert mask is None
                q, k, v = [x.transpose(-2, -3).contiguous() for x in [q, k, v]]
                m = self.flash_(q.half(), torch.stack([k, v], 2).half())
                return m.transpose(-2, -3).to(q.dtype).clone()
        elif self.has_sdp:
            args = [x.contiguous() for x in [q, k, v]]
            v = F.scaled_dot_product_attention(*args, attn_mask=mask)
            return v if mask is None else v.nan_to_num()
        else:
            s = q.shape[-1] ** (-0.5)
            sim = torch.einsum('...id,...jd->...ij', q, k) * s
            if mask is not None:
                sim.masked_fill(~mask, -float('inf'))
            attn = F.softmax(sim, -1)
            return torch.einsum('...ij,...jd->...id', attn, v)


INIT_ARGS = {
    'allow_flash': False,
}

ARGS = {
    'q': torch.randn(2, 3, 4),
    'k': torch.randn(2, 5, 4),
    'v': torch.randn(2, 5, 6),
    'mask': None,
}

if __name__ == '__main__':
    attention = Attention(**INIT_ARGS)
    output = attention(**ARGS)
    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 3, dtype family float, shape (2, 3, 6) — shape (2, 3, 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: torch and numpy seeded to 0 by the harness immediately before the class was constructed from INIT_ARGS (fixture_check.py)
CrossBlock Ran
ran on a synthesized input · constructed an object; no result was computed
fabio-sim/LightGlue-ONNX/lightglue_dynamo/models/lightglue.py
code served (permissive licence) · get_code("d8cc2fdd4e6e8b77")
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, CrossBlock: 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 = {
    "embed_dim": 4,
    "num_heads": 2,
    "bias": 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 CrossBlock — 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 CrossBlock 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
LearnableFourierPositionalEncoding Ran
ran on a synthesized input · constructed an object; no result was computed
fabio-sim/LightGlue-ONNX/lightglue_dynamo/models/lightglue.py
code served (permissive licence) · get_code("b7828f594fbf256c")
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, LearnableFourierPositionalEncoding: 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)

# Parameters for LearnableFourierPositionalEncoding
M = 8  # input dimension for position vector
descriptor_dim = 16  # must be divisible by num_heads
num_heads = 4  # number of heads
gamma = 1.0  # standard deviation for weight initialization

ARGS = {
    "M": M,
    "descriptor_dim": descriptor_dim,
    "num_heads": num_heads,
    "gamma": gamma,
}

# Create an instance to verify it works
model = nn.Module()
model.__class__ = type('LearnableFourierPositionalEncoding', (nn.Module,), {
    'num_heads': num_heads,
    'gamma': gamma,
})

# Test with a small position vector
x_test = torch.randn(2, M)
print(f"Input shape: {x_test.shape}")
print(f"ARGS: {ARGS}")
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 LearnableFourierPositionalEncoding — 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 LearnableFourierPositionalEncoding 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
LearnableFourierPositionalEncoding Ran
ran on a synthesized input
cvg/LightGlue/lightglue/lightglue.py
code served (permissive licence) · get_code("417b02cca4cc3fd2")
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, shape (2, 1, 2, 8) 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
from torch import nn

class LearnableFourierPositionalEncoding(nn.Module):

    def __init__(self, M: int, dim: int, F_dim: int=None, gamma: float=1.0) -> None:
        super().__init__()
        F_dim = F_dim if F_dim is not None else dim
        self.gamma = gamma
        self.Wr = nn.Linear(M, F_dim // 2, bias=False)
        nn.init.normal_(self.Wr.weight.data, mean=0, std=self.gamma ** (-2))

    def forward(self, x: torch.Tensor) -> torch.Tensor:
        """encode position vector"""
        projected = self.Wr(x)
        cosines, sines = (torch.cos(projected), torch.sin(projected))
        emb = torch.stack([cosines, sines], 0).unsqueeze(-3)
        return emb.repeat_interleave(2, dim=-1)


INIT_ARGS = {
    'M': 5,
    'dim': 8,
    'F_dim': 8,
    'gamma': 1.0,
}

ARGS = {
    'x': torch.randn(2, 5),
}

if __name__ == '__main__':
    model = LearnableFourierPositionalEncoding(**INIT_ARGS)
    output = model(**ARGS)
    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, shape (2, 1, 2, 8) — shape (2, 1, 2, 8) 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: torch and numpy seeded to 0 by the harness immediately before the class was constructed from INIT_ARGS (fixture_check.py)
MatchAssignment Ran
ran on a synthesized input · constructed an object; no result was computed
fabio-sim/LightGlue-ONNX/lightglue_dynamo/models/lightglue.py
code served (permissive licence) · get_code("d48ee5cc4cbd32b3")
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, MatchAssignment: 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)

# MatchAssignment.__init__ takes dim: int
# MatchAssignment.forward takes descriptors: torch.Tensor
# The forward method:
#   - calls self.final_proj(descriptors) -> applies Linear(dim, dim)
#   - calls self.matchability(descriptors) -> applies Linear(dim, 1)
#   - indexes descriptors with [0::2] and [1::2], so needs even number of samples
#   - computes mdescriptors[0::2] @ mdescriptors[1::2].transpose(1, 2)
#     where mdescriptors has shape (batch, seq_len, dim)
#   - calls sigmoid_log_double_softmax(similarities, z)
#     where similarities is (batch//2, seq_len, seq_len)
#     and z is (batch, seq_len, 1)

# For descriptors shape: (batch, seq_len, dim)
# We need batch to be even for [0::2] and [1::2] indexing
# Let's use batch=2 (even), seq_len=3, dim=4

dim = 4
batch = 2
seq_len = 3

# Create descriptors tensor: (batch, seq_len, dim)
descriptors = torch.randn(batch, seq_len, dim)

ARGS = {
    "dim": dim,
}
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 MatchAssignment — 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 MatchAssignment 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
MatchAssignment Ran
ran on a synthesized input
cvg/LightGlue/lightglue/lightglue.py
code served (permissive licence) · get_code("b47a54dd8d0e3728")
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 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.functional as F
from torch import nn

def sigmoid_log_double_softmax(sim: torch.Tensor, z0: torch.Tensor, z1: torch.Tensor) -> torch.Tensor:
    """create the log assignment matrix from logits and similarity"""
    b, m, n = sim.shape
    certainties = F.logsigmoid(z0) + F.logsigmoid(z1).transpose(1, 2)
    scores0 = F.log_softmax(sim, 2)
    scores1 = F.log_softmax(sim.transpose(-1, -2).contiguous(), 2).transpose(-1, -2)
    scores = sim.new_full((b, m + 1, n + 1), 0)
    scores[:, :m, :n] = scores0 + scores1 + certainties
    scores[:, :-1, -1] = F.logsigmoid(-z0.squeeze(-1))
    scores[:, -1, :-1] = F.logsigmoid(-z1.squeeze(-1))
    return scores

class MatchAssignment(nn.Module):

    def __init__(self, dim: int) -> None:
        super().__init__()
        self.dim = dim
        self.matchability = nn.Linear(dim, 1, bias=True)
        self.final_proj = nn.Linear(dim, dim, bias=True)

    def forward(self, desc0: torch.Tensor, desc1: torch.Tensor):
        """build assignment matrix from descriptors"""
        mdesc0, mdesc1 = (self.final_proj(desc0), self.final_proj(desc1))
        _, _, d = mdesc0.shape
        mdesc0, mdesc1 = (mdesc0 / d ** 0.25, mdesc1 / d ** 0.25)
        sim = torch.einsum('bmd,bnd->bmn', mdesc0, mdesc1)
        z0 = self.matchability(desc0)
        z1 = self.matchability(desc1)
        scores = sigmoid_log_double_softmax(sim, z0, z1)
        return (scores, sim)

    def get_matchability(self, desc: torch.Tensor):
        return torch.sigmoid(self.matchability(desc)).squeeze(-1)


INIT_ARGS = {
    'dim': 4
}

ARGS = {
    'desc0': torch.randn(2, 3, 4),
    'desc1': torch.randn(2, 5, 4)
}

if __name__ == '__main__':
    model = MatchAssignment(**INIT_ARGS)
    scores, sim = model(**ARGS)
    print(f"scores shape: {scores.shape}")
    print(f"sim shape: {sim.shape}")
    print(f"scores: {scores}")
    print(f"sim: {sim}")
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 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: torch and numpy seeded to 0 by the harness immediately before the class was constructed from INIT_ARGS (fixture_check.py)
SelfBlock Ran
ran on a synthesized input
fabio-sim/LightGlue-ONNX/lightglue_dynamo/models/lightglue.py
code served (permissive licence) · get_code("be7cd4498eab4bc0")
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 3, 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

def multi_head_attention(q: torch.Tensor, k: torch.Tensor, v: torch.Tensor, num_heads: int) -> torch.Tensor:
    b, n, d = q.shape
    head_dim = d // num_heads
    q, k, v = (t.reshape((b, n, num_heads, head_dim)).transpose(1, 2) for t in (q, k, v))
    return F.scaled_dot_product_attention(q, k, v).transpose(1, 2).reshape((b, n, d))

class SelfBlock(nn.Module):
    embed_dim: int
    num_heads: int
    head_dim: int

    def __init__(self, embed_dim: int, num_heads: int, bias: bool=True) -> None:
        super().__init__()
        self.embed_dim = embed_dim
        self.num_heads = num_heads
        self.head_dim = embed_dim // num_heads
        self.Wqkv = nn.Linear(embed_dim, 3 * embed_dim, bias=bias)
        self.out_proj = nn.Linear(embed_dim, embed_dim, bias=bias)
        self.ffn = nn.Sequential(nn.Linear(2 * embed_dim, 2 * embed_dim), nn.LayerNorm(2 * embed_dim, elementwise_affine=True), nn.GELU(), nn.Linear(2 * embed_dim, embed_dim))

    def forward(self, x: torch.Tensor, encoding: torch.Tensor) -> torch.Tensor:
        b, n, _ = x.shape
        qkv: torch.Tensor = self.Wqkv(x)
        qkv = qkv.reshape((b, n, self.num_heads, self.head_dim, 3)).transpose(1, 2)
        qk, v = (qkv[..., :2], qkv[..., 2])
        qk = self.apply_cached_rotary_emb(encoding, qk)
        q, k = (qk[..., 0], qk[..., 1])
        q, k, v = (tensor.transpose(1, 2).reshape(b, n, self.embed_dim) for tensor in (q, k, v))
        context = multi_head_attention(q, k, v, self.num_heads)
        message = self.out_proj(context)
        return x + self.ffn(torch.concat([x, message], 2))

    def rotate_half(self, qk: torch.Tensor) -> torch.Tensor:
        qk = qk.unflatten(-2, (-1, 2))
        qk = torch.stack((-qk[..., 1, :], qk[..., 0, :]), dim=-2)
        return qk.flatten(-3, -2)

    def apply_cached_rotary_emb(self, encoding: torch.Tensor, qk: torch.Tensor) -> torch.Tensor:
        return qk * encoding[0].unsqueeze(-1) + self.rotate_half(qk) * encoding[1].unsqueeze(-1)


INIT_ARGS = {
    'embed_dim': 4,
    'num_heads': 2,
    'bias': True,
}

ARGS = {
    'x': torch.randn(2, 3, 4),
    'encoding': (torch.randn(2, 2, 3, 2), torch.randn(2, 2, 3, 2)),
}

if __name__ == '__main__':
    block = SelfBlock(**INIT_ARGS)
    output = block(**ARGS)
    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 3, 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)
SelfBlock Ran
ran on a synthesized input
cvg/LightGlue/lightglue/lightglue.py
code served (permissive licence) · get_code("2caf26511a6409ff")
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 3, dtype family float; no output shape is stated. 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 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
import warnings

# Mock the globals that Attention class expects
FLASH_AVAILABLE = False
FlashCrossAttention = None

# Define the helper functions and classes from the provided code
def rotate_half(x: torch.Tensor) -> torch.Tensor:
    x = x.unflatten(-1, (-1, 2))
    x1, x2 = x.unbind(dim=-1)
    return torch.stack((-x2, x1), dim=-1).flatten(start_dim=-2)

def apply_cached_rotary_emb(freqs: torch.Tensor, t: torch.Tensor) -> torch.Tensor:
    return t * freqs[0] + rotate_half(t) * freqs[1]

class Attention(nn.Module):
    def __init__(self, allow_flash: bool) -> None:
        super().__init__()
        if allow_flash and (not FLASH_AVAILABLE):
            warnings.warn('FlashAttention is not available. For optimal speed, consider installing torch >= 2.0 or flash-attn.', stacklevel=2)
        self.enable_flash = allow_flash and FLASH_AVAILABLE
        self.has_sdp = hasattr(F, 'scaled_dot_product_attention')
        if allow_flash and FlashCrossAttention:
            self.flash_ = FlashCrossAttention()
        if self.has_sdp:
            torch.backends.cuda.enable_flash_sdp(allow_flash)

    def forward(self, q, k, v, mask=None) -> torch.Tensor:
        if q.shape[-2] == 0 or k.shape[-2] == 0:
            return q.new_zeros((*q.shape[:-1], v.shape[-1]))
        if self.enable_flash and q.device.type == 'cuda':
            if self.has_sdp:
                args = [x.half().contiguous() for x in [q, k, v]]
                v = F.scaled_dot_product_attention(*args, attn_mask=mask).to(q.dtype)
                return v if mask is None else v.nan_to_num()
            else:
                assert mask is None
                q, k, v = [x.transpose(-2, -3).contiguous() for x in [q, k, v]]
                m = self.flash_(q.half(), torch.stack([k, v], 2).half())
                return m.transpose(-2, -3).to(q.dtype).clone()
        elif self.has_sdp:
            args = [x.contiguous() for x in [q, k, v]]
            v = F.scaled_dot_product_attention(*args, attn_mask=mask)
            return v if mask is None else v.nan_to_num()
        else:
            s = q.shape[-1] ** (-0.5)
            sim = torch.einsum('...id,...jd->...ij', q, k) * s
            if mask is not None:
                sim.masked_fill(~mask, -float('inf'))
            attn = F.softmax(sim, -1)
            return torch.einsum('...ij,...jd->...id', attn, v)

class SelfBlock(nn.Module):
    def __init__(self, embed_dim: int, num_heads: int, flash: bool=False, bias: bool=True) -> None:
        super().__init__()
        self.embed_dim = embed_dim
        self.num_heads = num_heads
        assert self.embed_dim % num_heads == 0
        self.head_dim = self.embed_dim // num_heads
        self.Wqkv = nn.Linear(embed_dim, 3 * embed_dim, bias=bias)
        self.inner_attn = Attention(flash)
        self.out_proj = nn.Linear(embed_dim, embed_dim, bias=bias)
        self.ffn = nn.Sequential(nn.Linear(2 * embed_dim, 2 * embed_dim), nn.LayerNorm(2 * embed_dim, elementwise_affine=True), nn.GELU(), nn.Linear(2 * embed_dim, embed_dim))

    def forward(self, x: torch.Tensor, encoding: torch.Tensor, mask=None) -> torch.Tensor:
        qkv = self.Wqkv(x)
        qkv = qkv.unflatten(-1, (self.num_heads, -1, 3)).transpose(1, 2)
        q, k, v = (qkv[..., 0], qkv[..., 1], qkv[..., 2])
        q = apply_cached_rotary_emb(encoding, q)
        k = apply_cached_rotary_emb(encoding, k)
        context = self.inner_attn(q, k, v, mask=mask)
        message = self.out_proj(context.transpose(1, 2).flatten(start_dim=-2))
        return x + self.ffn(torch.cat([x, message], -1))

# Setup arguments
INIT_ARGS = {
    'embed_dim': 4,
    'num_heads': 2,
    'flash': False,
    'bias': True,
}

# For forward: x has shape (batch, seq_len, embed_dim)
# encoding has shape (2, seq_len, head_dim) for rotary embeddings
# mask is optional
ARGS = {
    'x': torch.randn(2, 3, 4),
    'encoding': torch.randn(2, 3, 2),
    'mask': None,
}

# Construct and call
if __name__ == '__main__':
    model = SelfBlock(**INIT_ARGS)
    output = model(**ARGS)
    print(f"Output shape: {output.shape}")
    print(f"Expected shape: {ARGS['x'].shape}")
    assert output.shape == ARGS['x'].shape, f"Shape mismatch: {output.shape} vs {ARGS['x'].shape}"
    print("Success!")
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 3, 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)
TokenConfidence Ran
ran on a synthesized input · constructed an object; no result was computed
fabio-sim/LightGlue-ONNX/lightglue_dynamo/models/lightglue.py
code served (permissive licence) · get_code("1c0939b0051d6ca5")
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, TokenConfidence: 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 TokenConfidence(nn.Module):

    def __init__(self, dim: int) -> None:
        super().__init__()
        self.token = nn.Sequential(nn.Linear(dim, 1), nn.Sigmoid())

    def forward(self, desc0: torch.Tensor, desc1: torch.Tensor) -> tuple[torch.Tensor, torch.Tensor]:
        """get confidence tokens"""
        return (self.token(desc0.detach()).squeeze(-1), self.token(desc1.detach()).squeeze(-1))


# Construct arguments for TokenConfidence.__init__
dim = 4

ARGS = {
    "dim": dim,
}
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 TokenConfidence — 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 TokenConfidence 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
TokenConfidence Ran
ran on a synthesized input
cvg/LightGlue/lightglue/lightglue.py
code served (permissive licence) · get_code("57de8d63639644e2")
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 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
from torch import nn

class TokenConfidence(nn.Module):

    def __init__(self, dim: int) -> None:
        super().__init__()
        self.token = nn.Sequential(nn.Linear(dim, 1), nn.Sigmoid())

    def forward(self, desc0: torch.Tensor, desc1: torch.Tensor):
        """get confidence tokens"""
        return (self.token(desc0.detach()).squeeze(-1), self.token(desc1.detach()).squeeze(-1))


INIT_ARGS = {
    'dim': 4
}

ARGS = {
    'desc0': torch.randn(2, 4),
    'desc1': torch.randn(3, 4)
}

if __name__ == '__main__':
    model = TokenConfidence(**INIT_ARGS)
    output = model(**ARGS)
    print("Output shapes:", output[0].shape, output[1].shape)
    print("Output values:", 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 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: torch and numpy seeded to 0 by the harness immediately before the class was constructed from INIT_ARGS (fixture_check.py)
apply_cached_rotary_emb Ran
ran; our contract draft was wrong, not the code
cvg/LightGlue/lightglue/lightglue.py
code served (permissive licence) · get_code("127ac20ae2475310")
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 2, dtype family float, shape (2, 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

torch.manual_seed(0)

# Analyze the function:
# - apply_cached_rotary_emb takes freqs and t as parameters
# - freqs is indexed with [0] and [1], so it's a sequence/tensor with at least 2 elements
# - t is passed to rotate_half which does unflatten(-1, (-1, 2)), so last dim must be even
# - t is multiplied with freqs[0] and rotate_half(t) is multiplied with freqs[1]
# - This suggests freqs is a tuple/list of 2 tensors, or a 3D tensor where first dim is 2

# Let's construct:
# - t: shape (2, 4) - batch size 2, last dim 4 (even, required for unflatten)
# - freqs: tuple of 2 tensors, each shape (2, 4) to match t for broadcasting

t = torch.randn(2, 4)
freqs = (torch.randn(2, 4), torch.randn(2, 4))

ARGS = {
    "freqs": freqs,
    "t": t,
}
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 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
batch_to_device Ran
ran on a synthesized input
cvg/lightglue/lightglue/utils.py
code served (permissive licence) · get_code("80f11116ef08b1e5")
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 torch
import collections.abc as collections
from typing import Callable, List, Optional, Tuple, Union

torch.manual_seed(0)

# Create a batch dict with nested tensors and various data structures
batch = {
    'input_ids': torch.randn(2, 4),
    'attention_mask': torch.randn(2, 4),
    'labels': torch.randn(2, 3),
    'nested': {
        'tensor_a': torch.randn(2, 5),
        'tensor_b': torch.randn(2, 6),
    },
    'list_of_tensors': [torch.randn(2, 7), torch.randn(2, 8)],
    'scalar_value': 42,
    'string_value': 'some_text',
    'mixed_list': [
        torch.randn(2, 3),
        'string_in_list',
        {'nested_dict': torch.randn(2, 4)}
    ]
}

ARGS = {
    'batch': batch,
    'device': 'cpu',
    'non_blocking': 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 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
cm_BlRdGn Ran
ran on a synthesized input
cvg/lightglue/lightglue/viz2d.py
code served (permissive licence) · get_code("8dd996cdd1db911e")
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 3, dtype family float, shape (2, 4, 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 numpy as np

# Analyze the function: cm_BlRdGn takes x_ as input
# x_ is used with:
# - np.clip(x_, 0, 1) - so it should be array-like with numeric values
# - x_[..., None] - indexing that adds a dimension
# - np.where(x_[..., None] < 0, cn, c) - comparison and conditional
# The function expects values roughly in range [-1, 1] based on the colormap logic

# Create a small test array with values in [-1, 1] range
x_input = np.array([
    [-0.8, -0.5, 0.0, 0.5],
    [0.2, -0.3, 0.7, 1.0]
], dtype=np.float32)

ARGS = {
    "x_": x_input
}
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 3, dtype family float, shape (2, 4, 4) — shape (2, 4, 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
cm_RdGn Ran
ran on a synthesized input
cvg/lightglue/lightglue/viz2d.py
code served (permissive licence) · get_code("736e2b86a021d585")
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 (5, 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

# Analyze the function cm_RdGn:
# - Takes parameter x (should be array-like, values between 0 and 1)
# - Uses np.clip, array operations, broadcasting
# - Returns a numpy array with RGB values

# Create a small test array with values in [0, 1]
x = np.array([0.0, 0.25, 0.5, 0.75, 1.0])

ARGS = {
    "x": x
}
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 (5, 3) — shape (5, 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
cm_prune Ran
ran on a synthesized input
cvg/lightglue/lightglue/viz2d.py
code served (permissive licence) · get_code("305ee29b4e31eae6")
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 (5, 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)

# Analyzing cm_prune:
# - Takes x_ which can be a torch.Tensor or numpy array
# - Calls max(x_) on it
# - Uses np.where on it
# - Passes result to cm_BlRdGn which expects numpy array

# Create test data: a 1D array/tensor with some values
x_test = np.array([1.0, 5.0, 3.0, 9.0, 2.0])

ARGS = {
    "x_": x_test
}
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 2, dtype family float, shape (5, 4) — shape (5, 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
filter_dog_point Ran
ran on a synthesized input
cvg/lightglue/lightglue/sift.py
code served (permissive licence) · get_code("8d37ad51dbe2ac79")
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 (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 numpy as np
import torch

torch.manual_seed(0)

# Create valid arguments for filter_dog_point
points = np.array([[10.5, 20.3], [15.2, 25.8], [5.1, 10.9], [30.4, 35.6]])  # (4, 2)
scales = np.array([1.0, 2.5, 1.8, 3.2])  # (4,)
angles = np.array([0.5, 1.2, -0.8, 1.5])  # (4,)
image_shape = (50, 60)  # (height, width)
nms_radius = 2
scores = np.array([0.9, 0.7, 0.8, 0.95])  # (4,)

ARGS = {
    "points": points,
    "scales": scales,
    "angles": angles,
    "image_shape": image_shape,
    "nms_radius": nms_radius,
    "scores": scores,
}
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 int, 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
filter_matches Ran
ran; the contract check could not run (RAISES, DEP_MISSING or TIMEOUT)
fabio-sim/LightGlue-ONNX/lightglue_dynamo/models/lightglue.py
code served (permissive licence) · get_code("f485836d645eb208")
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)

# scores should be a tensor of shape [B, N, N] (log assignment matrix)
# B = batch size, N = number of points
# The function calls max(2), max(1), and uses indices/values
# Small example: batch_size=2, N=4
scores = torch.randn(2, 4, 4)

# threshold is a float used for comparison with exp(mscores)
threshold = 0.1

ARGS = {
    "scores": scores,
    "threshold": threshold,
}
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
filter_matches Ran
ran; the contract check could not run (RAISES, DEP_MISSING or TIMEOUT)
cvg/LightGlue/lightglue/lightglue.py
code served (permissive licence) · get_code("43dbd6f5401d29db")
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 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)

# The function expects:
# - scores: torch.Tensor of shape [B, M+1, N+1] (log assignment matrix)
# - th: float (threshold)

# Create a small batch of log assignment matrices
# Shape: [B=2, M+1=5, N+1=4] where B is batch size, M and N are dimensions
B, M, N = 2, 4, 3
scores = torch.randn(B, M + 1, N + 1)

# Threshold value
th = 0.5

ARGS = {
    "scores": scores,
    "th": th,
}
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 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
get_conv Ran
ran on a synthesized input
cvg/lightglue/lightglue/aliked.py
code served (permissive licence) · get_code("c862b64639150d6c")
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 DeformableConv2d. 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
from torch.nn.modules.utils import _pair

torch.manual_seed(0)

ARGS = {
    'inplanes': 3,
    'planes': 16,
    'kernel_size': 3,
    'stride': 1,
    'padding': 1,
    'bias': False,
    'conv_type': 'dcn',
    'mask': True,
}
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 DeformableConv2d — a DeformableConv2d output has no array shape of its own; none is stated — the instrument coerces any output to an array; for a DeformableConv2d 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
get_patches Ran
ran on a synthesized input
cvg/lightglue/lightglue/aliked.py
code served (permissive licence) · get_code("c909ca701cba5a2b")
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, 4, 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 torch

torch.manual_seed(0)

# Construct the arguments for get_patches

# tensor: torch.Tensor with shape (c, h, w)
# Using c=4, h=8, w=8 for a small image tensor
tensor = torch.randn(4, 8, 8)

# required_corners: torch.Tensor with shape (batch, 2)
# Each row is an (x, y) coordinate in the image
# Using batch size 2, with coordinates within image bounds
required_corners = torch.tensor([[4.0, 4.0], [2.0, 6.0]], dtype=torch.float32)

# ps: int - patch size
ps = 3

ARGS = {
    'tensor': tensor,
    'required_corners': required_corners,
    'ps': ps
}
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, 4, 3, 3) — shape (2, 4, 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
map_tensor Ran
ran on a synthesized input
cvg/lightglue/lightglue/utils.py
code served (permissive licence) · get_code("6cf207b8475b5658")
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 torch
import collections.abc as collections

torch.manual_seed(0)

# Define a simple function to apply to tensors
def tensor_transform(t):
    return t * 2

# Create test data structures with nested tensors
nested_structure = {
    'tensor1': torch.randn(2, 4),
    'nested': {
        'tensor2': torch.randn(3, 5),
        'list': [torch.randn(2, 4), torch.randn(1, 3)]
    },
    'string_value': 'hello',
    'other': 42
}

ARGS = {
    'input_': nested_structure,
    'func': tensor_transform
}
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 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
measure Ran
ran on a synthesized input
cvg/lightglue/benchmark.py
code served (permissive licence) · get_code("2bd5dd5a07a0f3be")
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. 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 torch.nn as nn
import numpy as np
import time

torch.manual_seed(0)

class SimpleMatcher(nn.Module):
    """Minimal matcher that takes data and returns output."""
    def __init__(self):
        super().__init__()
        self.linear = nn.Linear(4, 3)
    
    def forward(self, data):
        return self.linear(data)

# Create a small tensor (batch_size=2, features=4)
matcher = SimpleMatcher()
data = torch.randn(2, 4)

# Use CPU device
device = torch.device('cpu')

ARGS = {
    'matcher': matcher,
    'data': data,
    'device': device,
    'r': 5
}
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 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
multi_head_attention Ran
ran; the contract check could not run (RAISES, DEP_MISSING or TIMEOUT)
fabio-sim/LightGlue-ONNX/lightglue_dynamo/models/lightglue.py
code served (permissive licence) · get_code("7350588d723a13e5")
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 3, dtype family float, shape (2, 3, 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.functional as F

torch.manual_seed(0)

# Set up small tensors for multi-head attention
batch_size = 2
seq_len = 3
d_model = 4
num_heads = 2

# Create query, key, value tensors
# Shape: (batch_size, seq_len, d_model)
q = torch.randn(batch_size, seq_len, d_model)
k = torch.randn(batch_size, seq_len, d_model)
v = torch.randn(batch_size, seq_len, d_model)

ARGS = {
    "q": q,
    "k": k,
    "v": v,
    "num_heads": num_heads,
}
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 3, dtype family float, shape (2, 3, 4) — shape (2, 3, 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
pad_to_length Ran
ran; the contract check could not run (RAISES, DEP_MISSING or TIMEOUT)
cvg/LightGlue/lightglue/lightglue.py
code served (permissive licence) · get_code("8751587f16cda36c")
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 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 a small tensor with shape (batch=2, seq_len=3, features=4)
# The function pads along dimension -2 (sequence length dimension)
x = torch.randn(2, 3, 4)

# Set length to pad to - should be greater than current seq_len (3)
length = 5

ARGS = {
    "x": x,
    "length": length,
}
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 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
rbd Ran
ran on a synthesized input
cvg/lightglue/lightglue/utils.py
code served (permissive licence) · get_code("1c2f9a87f4978298")
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 torch
import numpy as np

torch.manual_seed(0)

# Create a sample data dictionary with various types of elements
# The function removes the batch dimension (index 0) from tensors, arrays, and lists
data = {
    'tensor_field': torch.randn(2, 4),  # batch size 2, feature dim 4
    'numpy_field': np.random.randn(2, 3),  # batch size 2, feature dim 3
    'list_field': [[1, 2], [3, 4]],  # batch size 2
    'scalar_field': 42,  # non-batch field, should pass through unchanged
    'string_field': 'metadata',  # non-batch field, should pass through unchanged
}

ARGS = {
    'data': data
}
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 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
rotate_half Ran
ran; our contract draft was wrong, not the code
cvg/LightGlue/lightglue/lightglue.py
code served (permissive licence) · get_code("a3ec43c12656acbb")
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 2, dtype family float, shape (2, 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

torch.manual_seed(0)

# The function rotate_half takes a tensor x and performs a rotation operation
# It unflatten the last dimension into pairs, splits them, and rotates
# The input tensor should have an even last dimension

x = torch.randn(2, 4)  # batch_size=2, last_dim=4 (even number for unflatten)

ARGS = {
    "x": x
}
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 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
run_opencv_sift Ran
ran on a synthesized input
cvg/lightglue/lightglue/sift.py
code served (permissive licence) · get_code("29d472991fc656bb")
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 cv2
import numpy as np

# Create a simple test image (grayscale, uint8)
# Using a small 64x64 image with some features
test_image = np.random.randint(0, 256, (64, 64), dtype=np.uint8)
# Add some contrast to ensure detectable features
test_image[10:20, 10:20] = 255
test_image[40:50, 40:50] = 0

# Create SIFT detector
sift = cv2.SIFT_create()

ARGS = {
    "features": sift,
    "image": test_image
}
Setup block drafted by
a language model, Claude Haiku 4.5, prompt python_fixture_v1, through the batch API
Imports
cv2, numpy — 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
sample_descriptors Ran
ran; the contract check could not run (RAISES, DEP_MISSING or TIMEOUT)
cvg/lightglue/lightglue/superpoint.py
code served (permissive licence) · get_code("04a4d6560cc90824")
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 3, dtype family float, shape (2, 4, 5) 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 with distinct dimensions for clarity
# descriptors: (batch, channels, height, width)
b, c, h, w = 2, 4, 8, 6
descriptors = torch.randn(b, c, h, w)

# keypoints: (batch, num_keypoints, 2) - coordinates in original image space
# Create some random keypoints within valid range
num_keypoints = 5
keypoints = torch.rand(b, num_keypoints, 2) * torch.tensor([w * 8 - 1, h * 8 - 1]).float()

# s parameter: stride/scale factor
s = 8

ARGS = {
    'keypoints': keypoints,
    'descriptors': descriptors,
    's': s,
}
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 3, dtype family float, shape (2, 4, 5) — shape (2, 4, 5) 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
sift_to_rootsift Ran
ran on a synthesized input
cvg/lightglue/lightglue/sift.py
code served (permissive licence) · get_code("971d8cc47145eba6")
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 2, dtype family float, shape (2, 128) 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 a small SIFT-like feature tensor
# Shape: (batch_size=2, feature_dim=128) - typical for SIFT descriptors
x = torch.randn(2, 128, dtype=torch.float32)

# Ensure x has positive values since RootSIFT involves sqrt
x = torch.abs(x) + 0.1

ARGS = {
    "x": x,
    "eps": 1e-06
}
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 2, dtype family float, shape (2, 128) — shape (2, 128) 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
sigmoid_log_double_softmax Ran
ran; the contract check could not run (RAISES, DEP_MISSING or TIMEOUT)
cvg/LightGlue/lightglue/lightglue.py
code served (permissive licence) · get_code("608069c6c4b78f43")
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 3, dtype family float, shape (2, 5, 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.functional as F

torch.manual_seed(0)

# Analyze the function to determine tensor shapes:
# - sim: shape (b, m, n) - used in F.log_softmax and transpose operations
# - z0: shape (b, m, 1) - used in F.logsigmoid, squeeze(-1), transpose(1, 2)
# - z1: shape (b, n, 1) - used in F.logsigmoid, squeeze(-1), transpose(1, 2)

b, m, n = 2, 4, 3

# Create sim tensor: (batch=2, m=4, n=3)
sim = torch.randn(b, m, n)

# Create z0 tensor: (batch=2, m=4, 1)
z0 = torch.randn(b, m, 1)

# Create z1 tensor: (batch=2, n=3, 1)
z1 = torch.randn(b, n, 1)

ARGS = {
    "sim": sim,
    "z0": z0,
    "z1": z1,
}
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 3, dtype family float, shape (2, 5, 4) — shape (2, 5, 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
simple_nms Ran
ran on a synthesized input
cvg/lightglue/lightglue/aliked.py
code served (permissive licence) · get_code("5c5360d394e7680e")
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 (1, 1, 4, 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 torch

torch.manual_seed(0)

# Create a small scores tensor with shape (1, 1, 4, 3)
# This represents a batch of 1, 1 channel, 4x3 spatial dimensions
scores = torch.randn(1, 1, 4, 3)

# Set nms_radius to a small integer value
nms_radius = 1

ARGS = {
    "scores": scores,
    "nms_radius": nms_radius,
}
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 (1, 1, 4, 3) — shape (1, 1, 4, 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
simple_nms Ran
ran; the contract check could not run (RAISES, DEP_MISSING or TIMEOUT)
cvg/lightglue/lightglue/superpoint.py
code served (permissive licence) · get_code("30f2d08994bffec3")
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, 1, 4, 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 torch

torch.manual_seed(0)

# Create a small 4D tensor (batch=2, channels=1, height=4, width=3)
# for the scores parameter
scores = torch.rand(2, 1, 4, 3)

# nms_radius must be a non-negative integer
nms_radius = 1

ARGS = {
    "scores": scores,
    "nms_radius": nms_radius,
}
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, 1, 4, 3) — shape (2, 1, 4, 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
top_k_keypoints Ran
ran; the contract check could not run (RAISES, DEP_MISSING or TIMEOUT)
cvg/lightglue/lightglue/superpoint.py
code served (permissive licence) · get_code("719478e41beaad68")
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 testing
# keypoints: shape (num_keypoints, num_features)
# scores: shape (num_keypoints,)
# k: integer for top-k selection

keypoints = torch.randn(5, 4)  # 5 keypoints, 4 features each
scores = torch.randn(5)  # 5 scores
k = 2  # select top 2

ARGS = {
    "keypoints": keypoints,
    "scores": scores,
    "k": k,
}
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
CrossBlock Not yet run
unverified (harvested, no recorded run)
cvg/LightGlue/lightglue/lightglue.py
code served (permissive licence) · get_code("ee69084527f306a8")
How it ran

no invocation recorded.

LightGlue Not yet run
unverified (harvested, no recorded run)
fabio-sim/LightGlue-ONNX/lightglue_dynamo/models/lightglue.py
code served (permissive licence) · get_code("a7c63934348a934f")
How it ran

no invocation recorded.

LightGlue Not yet run
unverified (harvested, no recorded run)
cvg/LightGlue/lightglue/lightglue.py
code served (permissive licence) · get_code("e3b3b3c0e63763bd")
How it ran

no invocation recorded.

TransformerLayer Not yet run
unverified (harvested, no recorded run)
fabio-sim/LightGlue-ONNX/lightglue_dynamo/models/lightglue.py
code served (permissive licence) · get_code("ab4f90d2792e9808")
How it ran

no invocation recorded.

TransformerLayer Not yet run
unverified (harvested, no recorded run)
cvg/LightGlue/lightglue/lightglue.py
code served (permissive licence) · get_code("0a5c71b088578afa")
How it ran

no invocation recorded.

normalize_keypoints Not yet run
unverified (harvested, no recorded run)
cvg/LightGlue/lightglue/lightglue.py
code served (permissive licence) · get_code("996031e8e332cf27")
How it ran

no invocation recorded.

sigmoid_log_double_softmax Not yet run
unverified (harvested, no recorded run)
fabio-sim/LightGlue-ONNX/lightglue_dynamo/models/lightglue.py
code served (permissive licence) · get_code("7eb939455e9a0658")
How it ran

no invocation recorded.

Also present in other papers' code

Of 40 samples lifted from this paper's linked repositories, 40 carry a function identity and 0 do not. Of the 40 distinct functions with an identity, 5 are also present in other papers whose code we hold (1 with at least one paper dated earlier, 0 the same month, 5 later) and 35 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
apply_cached_rotary_emb
brick of this paper's assembly: helper
2 other papers
2 later
2507.02581 (2025-07)
Structure-aware Semantic Discrepancy and Consistency for 3D Medical Image Self-supervised Learning
2605.14654 (2026-05)
Beyond Instance-Level Self-Supervision in 3D Multi-Modal Medical Imaging
rotate_half
brick of this paper's assembly: helper
2 other papers
2 later
2507.02581 (2025-07)
Structure-aware Semantic Discrepancy and Consistency for 3D Medical Image Self-supervised Learning
2605.14654 (2026-05)
Beyond Instance-Level Self-Supervision in 3D Multi-Modal Medical Imaging
simple_nms 2 other papers
1 dated earlier, 1 later
2304.03608 (2023-04)
ALIKED: A Lighter Keypoint and Descriptor Extraction Network via Deformable Transformation
2601.18252 (2026-01)
Co-PLNet: A Collaborative Point-Line Network for Prompt-Guided Wireframe Parsing
sample_descriptors 1 other paper
1 later
2601.18252 (2026-01)
Co-PLNet: A Collaborative Point-Line Network for Prompt-Guided Wireframe Parsing
top_k_keypoints 1 other paper
1 later
2407.11668 (2024-07)
Learning to Make Keypoints Sub-Pixel Accurate

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

We introduce LightGlue, a deep neural network that learns to match local features across images. We revisit multiple design decisions of SuperGlue, the state of the art in sparse matching, and derive simple but effective improvements. Cumulatively, they make LightGlue more efficient -in terms of both memory and computation, more accurate, and much easier to train. One key property is that LightGlue is adaptive to the difficulty of the problem: the inference is much faster on image pairs that are intuitively easy to match, for example because of a larger visual overlap or limited appearance change. This opens up exciting prospects for deploying deep matchers in latency-sensitive applications like 3D reconstruction. The code and trained models are publicly available at github.com/cvg/LightGlue.

For agents

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

get_harvested_code_for_paper("2306.13643")
get_code_for_paper("2306.13643")
have("2306.13643")

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

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

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

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

Connect an agent — have() is free.