| Attention |
Ran ran on a synthesized input |
cvg/LightGlue/lightglue/lightglue.py code served (permissive licence) · get_code("a08f05b65312af52") How it ranRan 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 ranRan 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 ranRan 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 ranRan 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 ranRan 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 ranRan 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 ranRan 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 ranRan 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 ranRan 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 ranRan 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 ranRan 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 ranRan 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 ranRan 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 ranRan 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 ranRan 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 ranRan 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 ranRan 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 ranRan 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 ranRan 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 ranRan 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 ranRan 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 ranRan 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 ranRan 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 ranRan 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 ranRan 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 ranRan 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 ranRan 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 ranRan 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 ranRan 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 ranRan 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 ranRan 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 ranRan 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 ranRan 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 |
| 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 |
| LightGlue |
Not yet run unverified (harvested, no recorded run) |
cvg/LightGlue/lightglue/lightglue.py code served (permissive licence) · get_code("e3b3b3c0e63763bd") How it ran |
| 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 |
| TransformerLayer |
Not yet run unverified (harvested, no recorded run) |
cvg/LightGlue/lightglue/lightglue.py code served (permissive licence) · get_code("0a5c71b088578afa") How it ran |
| 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 |
| 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 |