| swish |
Ran ran; our contract draft was wrong, not the code |
levymsn/CQA-CRCT/CRCT/backbone/vilbert.py code served (permissive licence) · get_code("0f786c407fb1ee4c") How it ranRan in Syntology's jail on this synthesized input (drafted by a language model, Claude Haiku 4.5, prompt python_fixture_v1) and returned Tensor, ndim 2, dtype family float, shape (2, 4) as a later run recorded it. The image it ran in was not recorded. The comparison behind this sample's level is a different run: the peer-agreement lane ran it again on the host, not in the jail (report dated 2026-09-04T22:33:52Z). 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 swish takes a single parameter 'x' which is used with:
# - torch.sigmoid(x) - requires a tensor
# - x * ... - requires a tensor that supports multiplication
# So x should be a tensor
x = torch.randn(2, 4)
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
|
| OCR_oracle |
Ran ran on a synthesized input |
levymsn/CQA-CRCT/Detector/feature_extraction/bbox_match.py code served (permissive licence) · get_code("bdbd56ae5703372f") 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 numpy as np
import scipy.optimize
# Create sample bounding boxes in format [x1, y1, x2, y2]
# Ground truth bounding boxes (3 boxes)
gt_bboxes = np.array([
[10, 10, 50, 50],
[100, 100, 150, 150],
[200, 200, 250, 250]
], dtype=np.float32)
# Predicted bounding boxes (2 boxes)
pred_bboxes = np.array([
[12, 12, 48, 48],
[105, 105, 145, 145]
], dtype=np.float32)
# Predicted class labels (matching number of predicted boxes)
pred_class = np.array([1, 2], dtype=np.int32)
# Ground truth text labels (matching number of ground truth boxes)
gt_text = np.array(['hello', 'world', 'test'], dtype=object)
# Create feature dictionaries
pred_feats = {
'bboxes': pred_bboxes,
'class': pred_class
}
gt_feats = {
'bboxes': gt_bboxes,
'text': gt_text
}
ARGS = {
'pred_feats': pred_feats,
'gt_feats': gt_feats
}
- Setup block drafted by
- a language model, Claude Haiku 4.5, prompt python_fixture_v1, through the batch API
- Imports
- numpy, scipy — 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
|
| bbox_iou |
Ran ran on a synthesized input |
levymsn/CQA-CRCT/Detector/feature_extraction/bbox_match.py code served (permissive licence) · get_code("a9517dd6b8183083") 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 float, ndim 0, dtype family float, shape () as a later run recorded it. The image it ran in was not recorded. If your copy returns the same type, ndim and shape on these inputs, it matched what we observed; nothing here checks that. It does NOT mean the output is correct: nothing has compared it to the paper.
import torch
torch.manual_seed(0)
# bbox_iou expects two bounding boxes in format [x1, y1, x2, y2]
# where (x1, y1) is top-left and (x2, y2) is bottom-right
boxA = [10, 20, 50, 60] # x1=10, y1=20, x2=50, y2=60
boxB = [30, 40, 70, 80] # x1=30, y1=40, x2=70, y2=80
ARGS = {
"boxA": boxA,
"boxB": boxB
}
- Setup block drafted by
- a language model, Claude Haiku 4.5, prompt python_fixture_v1, through the batch API
- Imports
- torch — import names as written, not package names to install; a name the repository itself provides is not a package
- Returned
- type float, ndim 0, dtype family float, shape () — shape () as a later run recorded it
- dtype family
- int means an integer dtype; float means any other dtype the instrument saw, bool and complex included (fixture_check.py records only these two families)
- Environment
- image not recorded; re-verify against syntology-harvest-sandbox:v5-deps; not recorded for this sample: the harness installs a cuda-to-cpu shim (cuda_shim.py) before every sample and no run records whether a sample needed it; seed: none by the harness; any seed is in the setup block
|
| color |
Ran ran on a synthesized input |
levymsn/CQA-CRCT/CRCT/Interactive_demo.py code served (permissive licence) · get_code("d801abdee9495f30") 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 str. 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.
from colorama import Fore, Back, Style
# The function takes three string parameters: text, fore, and back
# fore and back are color codes (likely from colorama.Fore and colorama.Back)
# text is the string to be colored
ARGS = {
'text': 'Hello, World!',
'fore': Fore.RED,
'back': Back.YELLOW
}
- Setup block drafted by
- a language model, Claude Haiku 4.5, prompt python_fixture_v1, through the batch API
- Imports
- colorama — import names as written, not package names to install; a name the repository itself provides is not a package
- Returned
- type str — a str output has no array shape of its own; none is stated — the instrument coerces any output to an array; for a str 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
|
| encode_input |
Ran ran on a synthesized input |
levymsn/CQA-CRCT/CRCT/utils.py code served (permissive licence) · get_code("75cd536b57d434c1") 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
import random
torch.manual_seed(0)
random.seed(0)
# Analyze the function:
# - utterances: list of lists of token ids (integers)
# - start_segment: integer (0 or 1)
# - CLS, SEP, MASK: integers (special token ids)
# - max_seq_len: integer, default 256
# - max_sep_len: integer, default 25
# - mask_prob: float, default 0.2
# The function processes utterances as lists of token ids
# Each utterance is a list of integers
# We need small utterances to keep tensors tiny
ARGS = {
"utterances": [
[101, 102, 103], # First utterance: 3 tokens
[104, 105], # Second utterance: 2 tokens
],
"start_segment": 0,
"CLS": 100,
"SEP": 102,
"MASK": 103,
"max_seq_len": 64,
"max_sep_len": 10,
"mask_prob": 0.2,
}
- Setup block drafted by
- a language model, Claude Haiku 4.5, prompt python_fixture_v1, through the batch API
- Imports
- torch — import names as written, not package names to install; a name the repository itself provides is not a package
- Returned
- type 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
|
| encode_text_input |
Ran ran on a synthesized input |
levymsn/CQA-CRCT/CRCT/utils.py code served (permissive licence) · get_code("db3e6aedce62ff71") 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
import random
import numpy as np
torch.manual_seed(0)
random.seed(0)
# Parameters for encode_text_input
utterances = [
[101, 2054, 2003, 102], # First utterance with 4 tokens
[1045, 2572, 102] # Second utterance with 3 tokens
]
locations = [
[10.5, 20.3, 30.1, 40.2], # Single location for first utterance
[[5.1, 15.2, 25.3, 35.4], [6.2, 16.3, 26.4, 36.5], [7.3, 17.4, 27.5, 37.6]] # List of locations for second utterance
]
token_types = [0, -1] # Segment IDs for each utterance
CLS = 101 # BERT CLS token ID
SEP = 102 # BERT SEP token ID
MASK = 103 # BERT MASK token ID
max_seq_len = 256
max_sep_len = 50
mask_prob = 0.15
ARGS = {
'utterances': utterances,
'locations': locations,
'token_types': token_types,
'CLS': CLS,
'SEP': SEP,
'MASK': MASK,
'max_seq_len': max_seq_len,
'max_sep_len': max_sep_len,
'mask_prob': mask_prob
}
- 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 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
|
| est |
Ran ran on a synthesized input |
levymsn/CQA-CRCT/Detector/extract_features.py code served (permissive licence) · get_code("1afc750dfbf4c84d") 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 str. 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 time
def sec_to_hhmmss(secs):
return time.strftime('[%H:%M:%S]', time.gmtime(secs))
def est(num_ready, total, total_time):
""" Returns estimated time for the process"""
avg_time = total_time / num_ready
return sec_to_hhmmss((total - num_ready) * avg_time)
ARGS = {
'num_ready': 5,
'total': 20,
'total_time': 120.0
}
- Setup block drafted by
- a language model, Claude Haiku 4.5, prompt python_fixture_v1, through the batch API
- Imports
- none outside the standard library — import names as written, not package names to install; a name the repository itself provides is not a package
- Returned
- type str — a str output has no array shape of its own; none is stated — the instrument coerces any output to an array; for a str 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
|
| fig_type_to_id |
Ran ran on a synthesized input |
levymsn/CQA-CRCT/CRCT/fig_dataloader.py code served (permissive licence) · get_code("2bda61dcb74571d3") 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 int, ndim 0, dtype family int, shape () as a later run recorded it. The image it ran in was not recorded. If your copy returns the same type, ndim and shape on these inputs, it matched what we observed; nothing here checks that. It does NOT mean the output is correct: nothing has compared it to the paper.
import torch
import torch.nn as nn
ARGS = {
'str_type': 'line'
}
- 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 int, ndim 0, dtype family int, shape () — shape () as a later run recorded it
- dtype family
- int means an integer dtype; float means any other dtype the instrument saw, bool and complex included (fixture_check.py records only these two families)
- Environment
- image not recorded; re-verify against syntology-harvest-sandbox:v5-deps; not recorded for this sample: the harness installs a cuda-to-cpu shim (cuda_shim.py) before every sample and no run records whether a sample needed it; seed: none by the harness; any seed is in the setup block
|
| forward |
Ran ran on a synthesized input |
levymsn/CQA-CRCT/CRCT/backbone/encoder_decorator.py code served (permissive licence) · get_code("c18bcab3fca0524e") 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. 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
from torch.autograd import Variable
torch.manual_seed(0)
# Create a minimal dialog_encoder that mimics the expected interface
class MockDialogEncoder(nn.Module):
def __init__(self):
super().__init__()
self.linear = nn.Linear(10, 5)
def forward(self, tokens, txt_loc, features, image_loc, sep_indices=None, sep_len=None,
token_type_ids=None, masked_lm_labels=None, attention_mask=None,
next_sentence_label=None, output_nsp_scores=False, output_lm_scores=False,
image_attention_mask=None, image_label=None, image_target=None,
gt_reg=None, areas=None):
batch_size = tokens.shape[0]
# Return tuple: (lm_loss, img_loss, nsp_loss, nsp_scores, regression, legend_loss)
lm_loss = torch.tensor(0.5)
img_loss = torch.tensor(0.3)
nsp_loss = torch.tensor(0.2)
nsp_scores = torch.randn(batch_size, 2)
# regression should be a tuple with at least: (output, loss, something, right_count)
regression = (torch.randn(batch_size, 4), torch.randn(batch_size), torch.tensor(0.1), torch.tensor(5))
legend_loss = torch.tensor(0.1)
return (lm_loss, img_loss, nsp_loss, nsp_scores, regression, legend_loss)
# Create batch dict with all required keys
batch_size = 2
seq_len = 8
img_feat_dim = 4
num_images = 3
batch = {
'tokens': torch.randint(0, 100, (batch_size, seq_len)),
'loc': torch.randint(0, 10, (batch_size, seq_len)),
'segments': torch.randint(0, 2, (batch_size, seq_len)),
'sep_indices': torch.randint(0, seq_len, (batch_size, 5)),
'mask': torch.randint(0, 2, (batch_size, seq_len)),
'hist_len': torch.randint(0, 5, (batch_size,)),
'image_feat': torch.randn(batch_size, num_images, img_feat_dim),
'image_loc': torch.randn(batch_size, num_images, 4),
'image_mask': torch.randint(0, 2, (batch_size, num_images)),
'R': torch.randn(batch_size),
'areas': torch.randn(batch_size, num_images),
'next_sentence_labels': torch.randint(0, 2, (batch_size,)),
'image_label': torch.randint(0, 2, (batch_size, num_images)),
'image_target': torch.randn(batch_size, num_images, 5),
}
# Create params dict
params = {
'device': 'cpu',
'nsp_loss_coeff': 1.0,
'reg_loss_coeff': 1.0,
}
# Create the dialog_encoder model
dialog_encoder = MockDialogEncoder()
ARGS = {
'dialog_encoder': dialog_encoder,
'batch': batch,
'params': params,
'output_nsp_scores': False,
'output_lm_scores': False,
'evaluation': False,
'sample_ids': None,
}
- 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 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
|
| gelu |
Ran ran, honoured the contract we drafted |
levymsn/CQA-CRCT/CRCT/backbone/vilbert.py pointer only (licence: MIT); the stored copy get_code serves, from tanmay1618/text_to_sql_bert, is pointer only (licence: NONE) · get_code("fdc64f4c72036ae4") How it ranThe body of this sample is withheld: this paper's link allows the body inline (MIT), but get_code serves the stored copy, first harvested from tanmay1618/text_to_sql_bert, and GitHub detected no licence in that repository when it was checked. The setup block that called it is withheld with it, because it is written against that body. source_path and origin say where the code lives, to read under the repository's own terms. A run is recorded. |
| get_box_area |
Ran ran on a synthesized input |
levymsn/CQA-CRCT/Detector/feature_extraction/pie_area.py code served (permissive licence) · get_code("6466a4bda3a5583c") 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 int, ndim 0, dtype family int, shape () as a later run recorded it. The image it ran in was not recorded. If your copy returns the same type, ndim and shape on these inputs, it matched what we observed; nothing here checks that. It does NOT mean the output is correct: nothing has compared it to the paper.
import numpy as np
class Point:
def __init__(self, x, y):
self.x = float(x)
self.y = float(y)
def __str__(self):
return f'({self.x}, {self.y})'
def get_minibox_area(x, y, r):
"""Assuming the center of the circle is at point (0,0) - top left."""
if x <= 0 or y <= 0:
return 0
if np.sqrt(x ** 2 + y ** 2) < r:
return 0
sqrt = np.sqrt(r ** 2 - y ** 2) if r ** 2 - y ** 2 > 0 else 0
q1 = Point(sqrt, y)
sqrt = np.sqrt(r ** 2 - x ** 2) if r ** 2 - x ** 2 > 0 else 0
q2 = Point(x, sqrt)
return np.arctan2(q1.y, q1.x) - np.arctan2(q2.y, q2.x)
def get_box_area(p1, p2, r, center):
n_p1 = Point(-(center.x - p1.x), center.y - p1.y)
n_p2 = Point(p2.x - center.x, -(p2.y - center.y))
boxes_xy = [(abs(n_p2.x), abs(n_p2.y)), (abs(n_p1.y), abs(n_p2.x)), (abs(n_p1.x), abs(n_p1.y)), (abs(n_p2.y), abs(n_p1.x))]
return sum([get_minibox_area(box[0], box[1], r) for box in boxes_xy])
# Construct valid arguments for get_box_area
p1 = Point(x=2.0, y=3.0)
p2 = Point(x=5.0, y=7.0)
r = 10.0
center = Point(x=4.0, y=4.0)
ARGS = {
'p1': p1,
'p2': p2,
'r': r,
'center': center
}
- 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 int, ndim 0, dtype family int, shape () — shape () as a later run recorded it
- dtype family
- int means an integer dtype; float means any other dtype the instrument saw, bool and complex included (fixture_check.py records only these two families)
- Environment
- image not recorded; re-verify against syntology-harvest-sandbox:v5-deps; not recorded for this sample: the harness installs a cuda-to-cpu shim (cuda_shim.py) before every sample and no run records whether a sample needed it; seed: none by the harness; any seed is in the setup block
|
| get_data_lst |
Ran ran on a synthesized input |
levymsn/CQA-CRCT/Detector/frcnn.py code served (permissive licence) · get_code("c4bc90aeceaf6d34") 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 list, ndim 2, dtype family float; no output shape is stated. The image it ran in was not recorded. If your copy returns the same type and ndim on these inputs, it matched what we observed; nothing here checks that. It does NOT mean the output is correct: nothing has compared it to the paper.
import torch
import numpy as np
ARGS = {
'dataset': 'plotqa'
}
- Setup block drafted by
- a language model, Claude Haiku 4.5, prompt python_fixture_v1, through the batch API
- Imports
- numpy, torch — import names as written, not package names to install; a name the repository itself provides is not a package
- Returned
- type list, ndim 2, dtype family float — a list output has no array shape of its own; none is stated
- dtype family
- int means an integer dtype; float means any other dtype the instrument saw, bool and complex included (fixture_check.py records only these two families)
- Environment
- image not recorded; re-verify against syntology-harvest-sandbox:v5-deps; not recorded for this sample: the harness installs a cuda-to-cpu shim (cuda_shim.py) before every sample and no run records whether a sample needed it; seed: none by the harness; any seed is in the setup block
|
| get_input |
Ran ran on a synthesized input |
levymsn/CQA-CRCT/Detector/extract_features.py code served (permissive licence) · get_code("4c2fad57f5285a05") 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 list, ndim 1, dtype family float; no output shape is stated. The image it ran in was not recorded. If your copy returns the same type and ndim on these inputs, it matched what we observed; nothing here checks that. It does NOT mean the output is correct: nothing has compared it to the paper.
import torch
import numpy as np
from unittest.mock import Mock, MagicMock
import tempfile
import os
import cv2
torch.manual_seed(0)
# Create a temporary test image
temp_dir = tempfile.mkdtemp()
img_path = os.path.join(temp_dir, "test_image.jpg")
test_image = np.random.randint(0, 256, (480, 640, 3), dtype=np.uint8)
cv2.imwrite(img_path, test_image)
# Create a mock transform object
class MockTransform:
def apply_image(self, image):
return image
class MockAugmentor:
def get_transform(self, image):
return MockTransform()
class MockPredictor:
def __init__(self):
self.aug = MockAugmentor()
# Construct args
args = Mock()
args.predictor = MockPredictor()
ARGS = {
'args': args,
'img_path': img_path
}
- Setup block drafted by
- a language model, Claude Haiku 4.5, prompt python_fixture_v1, through the batch API
- Imports
- cv2, numpy, torch — import names as written, not package names to install; a name the repository itself provides is not a package
- Returned
- type list, ndim 1, dtype family float — a list output has no array shape of its own; none is stated
- dtype family
- int means an integer dtype; float means any other dtype the instrument saw, bool and complex included (fixture_check.py records only these two families)
- Environment
- image not recorded; re-verify against syntology-harvest-sandbox:v5-deps; not recorded for this sample: the harness installs a cuda-to-cpu shim (cuda_shim.py) before every sample and no run records whether a sample needed it; seed: none by the harness; any seed is in the setup block
|
| get_minibox_area |
Ran ran on a synthesized input |
levymsn/CQA-CRCT/Detector/feature_extraction/pie_area.py code served (permissive licence) · get_code("c4e163630a944c0c") 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 int, ndim 0, dtype family int, shape () as a later run recorded it. The image it ran in was not recorded. If your copy returns the same type, ndim and shape on these inputs, it matched what we observed; nothing here checks that. It does NOT mean the output is correct: nothing has compared it to the paper.
import numpy as np
# The function get_minibox_area takes three parameters: x, y, and r
# All are used in arithmetic operations (sqrt, comparison, arctan2)
# They should be numeric values (int or float)
x = 5.0
y = 3.0
r = 7.0
ARGS = {
'x': x,
'y': y,
'r': r
}
- 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 int, ndim 0, dtype family int, shape () — shape () as a later run recorded it
- dtype family
- int means an integer dtype; float means any other dtype the instrument saw, bool and complex included (fixture_check.py records only these two families)
- Environment
- image not recorded; re-verify against syntology-harvest-sandbox:v5-deps; not recorded for this sample: the harness installs a cuda-to-cpu shim (cuda_shim.py) before every sample and no run records whether a sample needed it; seed: none by the harness; any seed is in the setup block
|
| get_prev_csvs |
Ran ran, honoured the contract we drafted |
levymsn/CQA-CRCT/CRCT/evaluation.py code served (permissive licence) · get_code("47060fb467fa6fd4") 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 (6,) as a later run recorded it. The image it ran in was not recorded. If your copy returns the same type, ndim and shape on these inputs, it matched what we observed; nothing here checks that. It does NOT mean the output is correct: nothing has compared it to the paper.
import tempfile
import os
import pandas as pd
import glob
# Create a temporary directory for test CSV files
temp_dir = tempfile.mkdtemp()
# Create sample CSV files matching the expected pattern
save_path = temp_dir
eval_set = "validation"
start_checkpoint = "/path/to/checkpoint_5"
# Create a few CSV files with the expected naming pattern
csv_pattern = f"{save_path}/eval_results_{eval_set}_{start_checkpoint.split('/')[-1]}_*.csv"
# Create sample CSV files
for i in range(2):
df = pd.DataFrame({
'qa_ind': [10 + i, 20 + i, 30 + i],
'score': [0.8, 0.9, 0.7]
})
csv_file = f"{save_path}/eval_results_{eval_set}_{start_checkpoint.split('/')[-1]}_{i}.csv"
df.to_csv(csv_file, index=False)
ARGS = {
'params': {
'save_path': save_path,
'eval_set': eval_set,
'start_checkpoint': start_checkpoint
}
}
- Setup block drafted by
- a language model, Claude Haiku 4.5, prompt python_fixture_v1, through the batch API
- Imports
- pandas — 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 (6,) — shape (6,) as a later run recorded it
- dtype family
- int means an integer dtype; float means any other dtype the instrument saw, bool and complex included (fixture_check.py records only these two families)
- Environment
- image not recorded; re-verify against syntology-harvest-sandbox:v5-deps; not recorded for this sample: the harness installs a cuda-to-cpu shim (cuda_shim.py) before every sample and no run records whether a sample needed it; seed: none by the harness; any seed is in the setup block
|
| list2tensorpad |
Ran ran on a synthesized input |
levymsn/CQA-CRCT/CRCT/utils.py code served (permissive licence) · get_code("28aaa97940d13fbd") 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 int, shape (1, 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
torch.manual_seed(0)
# The function takes:
# 1. inp_list: a list that will be converted to a LongTensor
# 2. max_seq_len: an integer specifying the maximum sequence length for padding
# Looking at the function body:
# - inp_list is converted to torch.LongTensor([inp_list]), so it should be a list of integers
# - max_seq_len is used in slicing operations, so it should be an integer
inp_list = [1, 2, 3, 4, 5]
max_seq_len = 8
ARGS = {
"inp_list": inp_list,
"max_seq_len": max_seq_len,
}
- 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 int, shape (1, 8) — shape (1, 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: none by the harness; any seed is in the setup block
|
| match_bboxes |
Ran ran on a synthesized input |
levymsn/CQA-CRCT/Detector/feature_extraction/bbox_match.py code served (permissive licence) · get_code("a92ad5f7ea925a5b") 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 numpy as np
import scipy.optimize
# Create small sample bounding boxes
# Format: [x1, y1, x2, y2]
bbox_gt = np.array([
[10, 10, 50, 50],
[100, 100, 150, 150]
], dtype=np.float32)
bbox_pred = np.array([
[12, 12, 48, 48],
[105, 105, 155, 155],
[200, 200, 250, 250]
], dtype=np.float32)
IOU_THRESH = 0.5
ARGS = {
"bbox_gt": bbox_gt,
"bbox_pred": bbox_pred,
"IOU_THRESH": IOU_THRESH
}
- Setup block drafted by
- a language model, Claude Haiku 4.5, prompt python_fixture_v1, through the batch API
- Imports
- numpy, scipy — 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
|
| num_sides_intersections |
Ran ran on a synthesized input |
levymsn/CQA-CRCT/Detector/feature_extraction/pie_area.py code served (permissive licence) · get_code("f604ba3b7ca1c63f") 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 int64, ndim 0, dtype family int, shape () as a later run recorded it. The image it ran in was not recorded. If your copy returns the same type, ndim and shape on these inputs, it matched what we observed; nothing here checks that. It does NOT mean the output is correct: nothing has compared it to the paper.
import numpy as np
class Point:
def __init__(self, x, y):
self.x = x
self.y = y
# Create two boxes, each with two points (corner1, corner2)
box1 = [Point(0.0, 0.0), Point(10.0, 10.0)]
box2 = [Point(0.1, 0.0), Point(10.1, 10.0)]
ARGS = {
"box1": box1,
"box2": box2
}
- 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 int64, ndim 0, dtype family int, shape () — shape () as a later run recorded it
- dtype family
- int means an integer dtype; float means any other dtype the instrument saw, bool and complex included (fixture_check.py records only these two families)
- Environment
- image not recorded; re-verify against syntology-harvest-sandbox:v5-deps; not recorded for this sample: the harness installs a cuda-to-cpu shim (cuda_shim.py) before every sample and no run records whether a sample needed it; seed: none by the harness; any seed is in the setup block
|
| sec_to_hhmmss |
Ran ran on a synthesized input |
levymsn/CQA-CRCT/Detector/extract_features.py code served (permissive licence) · get_code("88f9fb967f836af4") 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 str. 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 time
def sec_to_hhmmss(secs):
return time.strftime('[%H:%M:%S]', time.gmtime(secs))
ARGS = {
'secs': 3661
}
- Setup block drafted by
- a language model, Claude Haiku 4.5, prompt python_fixture_v1, through the batch API
- Imports
- none outside the standard library — import names as written, not package names to install; a name the repository itself provides is not a package
- Returned
- type str — a str output has no array shape of its own; none is stated — the instrument coerces any output to an array; for a str 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
|
| sequence_mask |
Ran ran on a synthesized input |
levymsn/CQA-CRCT/CRCT/backbone/encoder_decorator.py code served (permissive licence) · get_code("fefc09b926e59cdf") 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, 5) as a later run recorded it. The image it ran in was not recorded. The code mentions cuda, and the harness aliases cuda to the CPU for every sample; whether this run needed that is not recorded. If your copy returns the same type, ndim and shape on these inputs, it matched what we observed; nothing here checks that. It does NOT mean the output is correct: nothing has compared it to the paper.
import torch
from torch.autograd import Variable
torch.manual_seed(0)
# Create a sequence_length tensor with batch_size=2
# Each element represents the length of a sequence in that batch
sequence_length = torch.tensor([3, 5], dtype=torch.long)
# Create ARGS dict with all parameters
ARGS = {
"sequence_length": sequence_length,
"max_len": None
}
- Setup block drafted by
- a language model, Claude Haiku 4.5, prompt python_fixture_v1, through the batch API
- Imports
- torch — import names as written, not package names to install; a name the repository itself provides is not a package
- Returned
- type Tensor, ndim 2, dtype family float, shape (2, 5) — shape (2, 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
|
| get_class_list |
Not yet run unverified (harvested, no recorded run) |
levymsn/CQA-CRCT/Detector/frcnn.py code served (permissive licence) · get_code("bec4326b26874da0") How it ran |
| load_tf_weights_in_bert |
Not yet run unverified (harvested, no recorded run) |
levymsn/CQA-CRCT/CRCT/backbone/vilbert.py code served (permissive licence) · get_code("63126a3d0d53cf84") How it ran |
| read_command_line |
Not yet run unverified (harvested, no recorded run) |
levymsn/CQA-CRCT/CRCT/options.py code served (permissive licence) · get_code("094f5e6b965929f5") How it ran |