| Doublecnv |
Ran ran on a synthesized input · constructed an object; no result was computed |
OpenDriveLab/PersFormer_3DLane/models/PersFormer.py code served (permissive licence) · get_code("3e5a266c8b4c142b") 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, Doublecnv: 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 = {
"in_channels": 3,
"out_channels": 16,
"mid_channels": 8,
}
- 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 Doublecnv — 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 Doublecnv 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
|
| Down |
Ran ran on a synthesized input · constructed an object; no result was computed |
OpenDriveLab/PersFormer_3DLane/models/PersFormer.py code served (permissive licence) · get_code("c8e163dd34a88de5") 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, Down: 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)
# Build the Doublecnv class (required dependency)
class Doublecnv(nn.Module):
"""(convolution => [BN] => ReLU) * 2"""
def __init__(self, in_channels, out_channels, mid_channels=None):
super().__init__()
if not mid_channels:
mid_channels = out_channels
self.double_conv = nn.Sequential(
nn.Conv2d(in_channels, mid_channels, kernel_size=3, padding=1, bias=False),
nn.BatchNorm2d(mid_channels),
nn.ReLU(inplace=True),
nn.Conv2d(mid_channels, out_channels, kernel_size=3, padding=1, bias=False),
nn.BatchNorm2d(out_channels),
nn.ReLU(inplace=True)
)
def forward(self, x):
return self.double_conv(x)
# Build the Down class
class Down(nn.Module):
"""Downscaling with maxpool then double conv"""
def __init__(self, in_channels, out_channels):
super().__init__()
self.maxpool_conv = nn.Sequential(
nn.MaxPool2d(2),
Doublecnv(in_channels, out_channels)
)
def forward(self, x):
return self.maxpool_conv(x)
# Create test input tensor: batch_size=2, channels=3, height=4, width=4
test_input = torch.randn(2, 3, 4, 4)
# Define arguments for Down.__init__
ARGS = {
'in_channels': 3,
'out_channels': 5
}
- 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 Down — 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 Down 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
|
| DropoutMSDeformAttn |
Ran ran on a synthesized input · constructed an object; no result was computed |
OpenDriveLab/PersFormer_3DLane/models/PersFormer.py code served (permissive licence) · get_code("1aeeb6a71a7b8167") 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, DropoutMSDeformAttn: the run constructed the object and did not call it, so no result was computed. The image it ran in was not recorded. If your copy returns the same type on these inputs, it matched what we observed; nothing here checks that. It does NOT mean the output is correct: nothing has compared it to the paper.
import torch
import torch.nn as nn
import math
import warnings
torch.manual_seed(0)
# Define the DropoutMSDeformAttn class first
def _is_power_of_2(n):
if not isinstance(n, int) or n < 0:
raise ValueError('invalid input for _is_power_of_2: {} (type: {})'.format(n, type(n)))
return n & n - 1 == 0 and n != 0
class DropoutMSDeformAttn(nn.Module):
def __init__(self, d_model=256, n_levels=4, n_heads=8, n_points=4, dropout=0.1):
"""
Multi-Scale Deformable Attention Module
:param d_model hidden dimension
:param n_levels number of feature levels
:param n_heads number of attention heads
:param n_points number of sampling points per attention head per feature level
"""
super().__init__()
if d_model % n_heads != 0:
raise ValueError('d_model must be divisible by n_heads, but got {} and {}'.format(d_model, n_heads))
_d_per_head = d_model // n_heads
if not _is_power_of_2(_d_per_head):
warnings.warn("You'd better set d_model in DropoutMSDeformAttn to make the dimension of each attention head a power of 2 which is more efficient in our CUDA implementation.")
self.im2col_step = 64
self.d_model = d_model
self.n_levels = n_levels
self.n_heads = n_heads
self.n_points = n_points
self.sampling_offsets = nn.Linear(d_model, n_heads * n_levels * n_points * 2)
self.attention_weights = nn.Linear(d_model, n_heads * n_levels * n_points)
self.value_proj = nn.Linear(d_model, d_model)
self.output_proj = nn.Linear(d_model, d_model)
self.dropout = nn.Dropout(dropout)
self._reset_parameters()
def _reset_parameters(self):
from torch.nn.init import xavier_uniform_, constant_
constant_(self.sampling_offsets.weight.data, 0.0)
thetas = torch.arange(self.n_heads, dtype=torch.float32) * (2.0 * math.pi / self.n_heads)
grid_init = torch.stack([thetas.cos(), thetas.sin()], -1)
grid_init = (grid_init / grid_init.abs().max(-1, keepdim=True)[0]).view(self.n_heads, 1, 1, 2).repeat(1, self.n_levels, self.n_points, 1)
for i in range(self.n_points):
grid_init[:, :, i, :] *= i + 1
with torch.no_grad():
self.sampling_offsets.bias = nn.Parameter(grid_init.view(-1))
constant_(self.attention_weights.weight.data, 0.0)
constant_(self.attention_weights.bias.data, 0.0)
xavier_uniform_(self.value_proj.weight.data)
constant_(self.value_proj.bias.data, 0.0)
xavier_uniform_(self.output_proj.weight.data)
constant_(self.output_proj.bias.data, 0.0)
# Now build setup arguments for the constructor
ARGS = {
'd_model': 8,
'n_levels': 2,
'n_heads': 2,
'n_points': 3,
'dropout': 0.1
}
- Setup block drafted by
- a language model, Claude Haiku 4.5, prompt python_fixture_v1, through the batch API
- Imports
- torch — import names as written, not package names to install; a name the repository itself provides is not a package
- Returned
- type DropoutMSDeformAttn — 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 DropoutMSDeformAttn 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
|
| FFN |
Ran ran on a synthesized input · constructed an object; no result was computed |
OpenDriveLab/PersFormer_3DLane/models/PersFormer.py code served (permissive licence) · get_code("b0c3559adbcc832e") 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, FFN: the run constructed the object and did not call it, so no result was computed. The image it ran in was not recorded. If your copy returns the same type on these inputs, it matched what we observed; nothing here checks that. It does NOT mean the output is correct: nothing has compared it to the paper.
import torch
import torch.nn as nn
import torch.nn.functional as F
from torch.nn.init import xavier_uniform_, constant_, uniform_, normal_
torch.manual_seed(0)
# Create a small test input tensor
# batch_size=2, d_model=256
test_input = torch.randn(2, 256)
# Create an identity tensor (optional, for testing the identity branch)
test_identity = torch.randn(2, 256)
ARGS = {
'd_model': 256,
'dim_ff': 1024,
'activation': 'relu',
'ffn_dropout': 0.1,
'add_identity': 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 FFN — 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 FFN 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
|
| IdentityMSDeformAttn |
Ran ran on a synthesized input · constructed an object; no result was computed |
OpenDriveLab/PersFormer_3DLane/models/PersFormer.py code served (permissive licence) · get_code("7b5a12f8b0e31572") 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, IdentityMSDeformAttn: the run constructed the object and did not call it, so no result was computed. The image it ran in was not recorded. If your copy returns the same type on these inputs, it matched what we observed; nothing here checks that. It does NOT mean the output is correct: nothing has compared it to the paper.
import torch
import torch.nn as nn
import math
torch.manual_seed(0)
# Parameters for IdentityMSDeformAttn
d_model = 256
n_levels = 4
n_heads = 8
n_points = 8
dropout = 0.1
# Create a small batch of data for testing
batch_size = 2
seq_len_query = 3
seq_len_input = 12 # sum of spatial dims: 2*2 + 2*2 + 2*1 + 2*1 = 12
# query: (N, Length_query, C)
query = torch.randn(batch_size, seq_len_query, d_model)
# reference_points: (N, Length_query, n_levels, 2)
# Values in [0, 1] range
reference_points = torch.rand(batch_size, seq_len_query, n_levels, 2)
# input_flatten: (N, sum of H_l * W_l, C)
input_flatten = torch.randn(batch_size, seq_len_input, d_model)
# input_spatial_shapes: (n_levels, 2) - heights and widths of each level
# Example: level 0: 2x2=4, level 1: 2x2=4, level 2: 2x1=2, level 3: 2x1=2
input_spatial_shapes = torch.tensor([[2, 2], [2, 2], [2, 1], [2, 1]], dtype=torch.long)
# input_level_start_index: cumulative indices
# [0, 4, 8, 10, 12]
input_level_start_index = torch.tensor([0, 4, 8, 10, 12], dtype=torch.long)
# input_padding_mask: (N, sum of H_l * W_l) - True for padding, False for non-padding
input_padding_mask = torch.zeros(batch_size, seq_len_input, dtype=torch.bool)
# identity: (N, Length_query, C) - optional, can be None or same as query
identity = query.clone()
ARGS = {
'd_model': d_model,
'n_levels': n_levels,
'n_heads': n_heads,
'n_points': n_points,
'dropout': dropout,
}
- 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 IdentityMSDeformAttn — 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 IdentityMSDeformAttn 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
|
| PositionEmbeddingLearned |
Ran ran on a synthesized input · constructed an object; no result was computed |
OpenDriveLab/PersFormer_3DLane/models/PersFormer.py code served (permissive licence) · get_code("7d9fec0f231cd723") 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, PositionEmbeddingLearned: 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)
# The function is PositionEmbeddingLearned.__init__ and .forward
# __init__ parameters: h, w, num_pos_feats
# forward takes: uv_feat (a tensor)
# Looking at __init__:
# - h and w are used to create Embeddings and stored as attributes
# - num_pos_feats is the embedding dimension
# Looking at forward:
# - uv_feat is a tensor with shape (batch, channels, h_dim, w_dim)
# - h, w are extracted from x.shape[-2:]
# - The embeddings need to handle indices up to h-1 and w-1
# Create a small input tensor
# The forward method extracts h, w from input shape, so we need to match
batch_size = 2
num_channels = 4
height = 5
width = 6
uv_feat = torch.randn(batch_size, num_channels, height, width)
ARGS = {
"h": height,
"w": width,
"num_pos_feats": 8
}
- 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 PositionEmbeddingLearned — 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 PositionEmbeddingLearned 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
|
| SegmentHead |
Ran ran on a synthesized input · constructed an object; no result was computed |
OpenDriveLab/PersFormer_3DLane/models/PersFormer.py code served (permissive licence) · get_code("40c69fe30813367b") 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, SegmentHead: 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)
# SegmentHead only takes one parameter: channels (default 128)
# The forward method expects an input tensor of shape (batch, channels, height, width)
# Looking at the forward method:
# - input goes through down1, down2, down3 (which halve spatial dims each time)
# - then up1, up2, up3 (which double spatial dims each time)
# - The Up modules concatenate skip connections, so we need compatible spatial dimensions
# Let's trace through with channels=128 and input (batch=2, channels=128, height=32, width=32):
# input: (2, 128, 32, 32)
# x1 = down1: (2, 256, 16, 16)
# x2 = down2: (2, 512, 8, 8)
# x3 = down3: (2, 512, 4, 4)
# x_out = up1(x3, x2): up(x3) -> (2, 256, 8, 8), cat with x2 (2, 512, 8, 8) -> (2, 768, 8, 8), conv -> (2, 256, 8, 8)
# x_out = up2(x_out, x1): up(x_out) -> (2, 128, 16, 16), cat with x1 (2, 256, 16, 16) -> (2, 384, 16, 16), conv -> (2, 128, 16, 16)
# x_out = up3(x_out, input): up(x_out) -> (2, 64, 32, 32), cat with input (2, 128, 32, 32) -> (2, 192, 32, 32), conv -> (2, 128, 32, 32)
# pred_seg_bev_map: (2, 1, 32, 32)
# Create a small test input tensor
test_input = torch.randn(2, 128, 32, 32)
ARGS = {
"channels": 128
}
- 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 SegmentHead — 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 SegmentHead 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
|
| Up |
Ran ran on a synthesized input · constructed an object; no result was computed |
OpenDriveLab/PersFormer_3DLane/models/PersFormer.py code served (permissive licence) · get_code("4550ba51e5cea42b") 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, Up: the run constructed the object and did not call it, so no result was computed. The image it ran in was not recorded. If your copy returns the same type on these inputs, it matched what we observed; nothing here checks that. It does NOT mean the output is correct: nothing has compared it to the paper.
import torch
import torch.nn as nn
import torch.nn.functional as F
torch.manual_seed(0)
class Doublecnv(nn.Module):
"""(convolution => [BN] => ReLU) * 2"""
def __init__(self, in_channels, out_channels, mid_channels=None):
super().__init__()
if not mid_channels:
mid_channels = out_channels
self.double_conv = nn.Sequential(nn.Conv2d(in_channels, mid_channels, kernel_size=3, padding=1, bias=False), nn.BatchNorm2d(mid_channels), nn.ReLU(inplace=True), nn.Conv2d(mid_channels, out_channels, kernel_size=3, padding=1, bias=False), nn.BatchNorm2d(out_channels), nn.ReLU(inplace=True))
def forward(self, x):
return self.double_conv(x)
class Up(nn.Module):
"""Upscaling then double conv"""
def __init__(self, in_channels, out_channels, bilinear=True):
super().__init__()
if bilinear:
self.up = nn.Upsample(scale_factor=2, mode='bilinear', align_corners=True)
self.conv = Doublecnv(in_channels, out_channels, in_channels // 2)
else:
self.up = nn.ConvTranspose2d(in_channels, in_channels // 2, kernel_size=2, stride=2)
self.conv = Doublecnv(in_channels, out_channels)
def forward(self, x1, x2):
x1 = self.up(x1)
diffY = x2.size()[2] - x1.size()[2]
diffX = x2.size()[3] - x1.size()[3]
x1 = F.pad(x1, [diffX // 2, diffX - diffX // 2, diffY // 2, diffY - diffY // 2])
x = torch.cat([x2, x1], dim=1)
return self.conv(x)
# Create an instance of Up to pass as argument
up_instance = Up(in_channels=16, out_channels=8, bilinear=True)
# Create dummy input tensors for forward pass
# x1: upsampled features with shape (batch, channels, height, width)
# x2: skip connection features with shape (batch, channels, height*2, width*2)
x1 = torch.randn(2, 16, 4, 3)
x2 = torch.randn(2, 8, 8, 6)
ARGS = {
'in_channels': 16,
'out_channels': 8,
'bilinear': 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 Up — 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 Up 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
|
| prune_3d_lane_by_range |
Ran ran on a synthesized input |
OpenDriveLab/OpenLane/eval/LANE_evaluation/lane3d/utils/utils.py code served (permissive licence) · get_code("85fcc376cd599f4e") 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
# Create a sample 3D lane array with shape (N, 3) where:
# - Column 0: x coordinates
# - Column 1: y coordinates (should be between 0 and 200)
# - Column 2: z coordinates (or other data)
lane_3d = np.array([
[5.0, 50.0, 10.0],
[10.0, 100.0, 15.0],
[15.0, 150.0, 20.0],
[20.0, 25.0, 25.0],
[-5.0, 75.0, 30.0],
[25.0, 175.0, 35.0],
[30.0, 210.0, 40.0], # This will be filtered out (y > 200)
[35.0, 80.0, 45.0],
], dtype=np.float32)
x_min = 0.0
x_max = 32.0
ARGS = {
"lane_3d": lane_3d,
"x_min": x_min,
"x_max": x_max,
}
- 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
|
| prune_3d_lane_by_visibility |
Ran ran on a synthesized input |
OpenDriveLab/OpenLane/eval/LANE_evaluation/lane3d/utils/utils.py code served (permissive licence) · get_code("aaff3ef48e2fb71a") 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 (1, 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)
# lane_3d is indexed with [visibility > 0, ...], so it needs to be a tensor
# with at least 2 dimensions where the first dimension corresponds to lanes
# and visibility is used as a boolean mask on that dimension
lane_3d = torch.randn(2, 4) # 2 lanes, 4 features per lane
# visibility is compared with > 0, so it should be a 1D tensor with length
# matching the first dimension of lane_3d
visibility = torch.tensor([1.0, 0.0]) # First lane visible, second not
ARGS = {
"lane_3d": lane_3d,
"visibility": visibility,
}
- Setup block drafted by
- a language model, Claude Haiku 4.5, prompt python_fixture_v1, through the batch API
- Imports
- numpy, torch — import names as written, not package names to install; a name the repository itself provides is not a package
- Returned
- type Tensor, ndim 2, dtype family float, shape (1, 4) — shape (1, 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
|
| resample_laneline_in_y |
Ran ran on a synthesized input |
OpenDriveLab/OpenLane/eval/LANE_evaluation/lane3d/utils/utils.py code served (permissive licence) · get_code("f4018ad6acc7e447") 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, 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 numpy as np
# Create input_lane: N x 2 or N x 3 ndarray with y values in ascending order
# Using N=5 points, with (x, y) coordinates
input_lane = np.array([
[1.0, 10.0],
[2.0, 15.0],
[3.0, 20.0],
[4.0, 25.0],
[5.0, 30.0]
], dtype=np.float32)
# Create y_steps: a vector of y values where we want to interpolate
y_steps = np.array([8.0, 12.0, 18.0, 22.0, 28.0, 32.0], dtype=np.float32)
# out_vis: boolean flag
out_vis = True
ARGS = {
'input_lane': input_lane,
'y_steps': y_steps,
'out_vis': out_vis
}
- 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, ndim 2, dtype family float — a tuple 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
|
| BEVHead |
Not yet run unverified (harvested, no recorded run) |
OpenDriveLab/PersFormer_3DLane/models/PersFormer.py code served (permissive licence) · get_code("9d865bc0a906acf8") How it ran |
| EncoderLayer |
Not yet run unverified (harvested, no recorded run) |
OpenDriveLab/PersFormer_3DLane/models/PersFormer.py code served (permissive licence) · get_code("b98ca5cf2d4e94de") How it ran |
| PersFormer |
Not yet run unverified (harvested, no recorded run) |
OpenDriveLab/PersFormer_3DLane/models/PersFormer.py code served (permissive licence) · get_code("4217030b0dd16d15") How it ran |
| PerspectiveTransformer |
Not yet run unverified (harvested, no recorded run) |
OpenDriveLab/PersFormer_3DLane/models/PersFormer.py code served (permissive licence) · get_code("af4a49818df9165c") How it ran |