SYNTOLOGY HomeExplorerAtlasCodeMethodologyAboutDevelopersFeedPricing
Paper · 2203.11089 · ECCV · 2022

PersFormer: 3D Lane Detection via Perspective Transformer and the OpenLane Benchmark

Junchi Yan, Hongyang Li, Yu Qiao, Yang Li, Li Chen, Chonghao Sima, Conghui He, Jiajie Xu, Jianping Shi, Zehan Zheng, Xiangwei Geng

arXiv · PDF · Open in the Atlas

Code that ran

11 of 15 samples (functions and classes) lifted from this paper's linked repositories executed on a synthesized input in Syntology's jail (8 of them constructed an object rather than computing a result; 0 honoured the contract we drafted, 0 violated it and 11 have no contract verdict; 0 failures of our instrument; 4 no recorded run), measured 2026-11-22; repository links from the Papers with Code archive attributed under CC BY-SA, no affiliation; bodies inline only under a permissive licence as GitHub detects it. Not a reproduction of the paper's results.

"Ran" means the function executed on a synthesized input and returned a value. It is not a reproduction of the paper's results. This record, dated, as JSON: /api/ran/2203.11089.json · badge: /api/ran/2203.11089.svg

Each repository's role is a label: a classifier's output recorded on the link, or, where no role is recorded, what the Papers with Code archive marked. The line under it names its basis. Neither says who wrote the code.

RepositoryRoleRan
OpenDriveLab/PersFormer_3DLane marked official in Papers with Code
Papers with Code archive
8 ran · 4 no recorded run
OpenDriveLab/OpenLane community (classifier label)
classifier basis not recorded on the link
3 ran · 0 no recorded run
FunctionStatusWhere it lives
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 ran

Ran in Syntology's sandbox on this synthesized input (drafted by a language model, Claude Haiku 4.5, prompt python_fixture_v1, through the batch API) and returned an instance of its own class, 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 ran

Ran in Syntology's sandbox on this synthesized input (drafted by a language model, Claude Haiku 4.5, prompt python_fixture_v1, through the batch API) and returned an instance of its own class, 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 ran

Ran in Syntology's sandbox on this synthesized input (drafted by a language model, Claude Haiku 4.5, prompt python_fixture_v1, through the batch API) and returned an instance of its own class, 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 ran

Ran in Syntology's sandbox on this synthesized input (drafted by a language model, Claude Haiku 4.5, prompt python_fixture_v1, through the batch API) and returned an instance of its own class, 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 ran

Ran in Syntology's sandbox on this synthesized input (drafted by a language model, Claude Haiku 4.5, prompt python_fixture_v1, through the batch API) and returned an instance of its own class, 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 ran

Ran in Syntology's sandbox on this synthesized input (drafted by a language model, Claude Haiku 4.5, prompt python_fixture_v1, through the batch API) and returned an instance of its own class, 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 ran

Ran in Syntology's sandbox on this synthesized input (drafted by a language model, Claude Haiku 4.5, prompt python_fixture_v1, through the batch API) and returned an instance of its own class, 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 ran

Ran in Syntology's sandbox on this synthesized input (drafted by a language model, Claude Haiku 4.5, prompt python_fixture_v1, through the batch API) and returned an instance of its own class, 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 ran

Ran in Syntology's sandbox on this synthesized input (drafted by a language model, Claude Haiku 4.5, prompt python_fixture_v1, through the batch API) and returned ndarray, ndim 2, dtype family float, shape (5, 3) as a later run recorded it. The image it ran in was not recorded. If your copy returns the same type, ndim and shape on these inputs, it matched what we observed; nothing here checks that. It does NOT mean the output is correct: nothing has compared it to the paper.

import numpy as np

# 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 ran

Ran in Syntology's sandbox on this synthesized input (drafted by a language model, Claude Haiku 4.5, prompt python_fixture_v1, through the batch API) and returned Tensor, ndim 2, dtype family float, shape (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 ran

Ran in Syntology's sandbox on this synthesized input (drafted by a language model, Claude Haiku 4.5, prompt python_fixture_v1, through the batch API) and returned tuple, 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

no invocation recorded.

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

no invocation recorded.

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

no invocation recorded.

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

no invocation recorded.

Also present in other papers' code

Of 15 samples lifted from this paper's linked repositories, 15 carry a function identity and 0 do not. Of the 15 distinct functions with an identity, 0 are also present in other papers whose code we hold (0 with at least one paper dated earlier, 0 the same month, 0 later) and 15 are only here among the 52,977 papers whose code Syntology holds (as of 2026-09-26).

Only here means: among the 52,977 papers whose code Syntology holds (51,887 with lifted samples, 1,090 through their assemblies only), as of 2026-09-26, no other paper's lifted samples or current assembly bricks contain an identical function body after normalisation.

Presence, not direction: an identical function body in two papers' repositories does not say who wrote it, which came from which, or that either paper's method rests on it. Matching is exact after normalisation, so a renamed or edited function is not matched. Dates are when papers appeared, not when code was written. Only .py files the harvester lifted are covered; notebooks are not read. A new-style arXiv id YYMM.NNNN dates a paper to the month 20YY-MM; otherwise Paper.year dates it to the year; otherwise it is undated. Dates are when the paper appeared, not when the code was written. Read 2026-11-22.

Repositories linked to this paper

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

Abstract

Methods for 3D lane detection have been recently proposed to address the issue of inaccurate lane layouts in many autonomous driving scenarios (uphill/downhill, bump, etc.). Previous work struggled in complex cases due to their simple designs of the spatial transformation between front view and bird's eye view (BEV) and the lack of a realistic dataset. Towards these issues, we present PersFormer: an end-toend monocular 3D lane detector with a novel Transformer-based spatial feature transformation module. Our model generates BEV features by attending to related front-view local regions with camera parameters as a reference. PersFormer adopts a unified 2D/3D anchor design and an auxiliary task to detect 2D/3D lanes simultaneously, enhancing the feature consistency and sharing the benefits of multi-task learning. Moreover, we release one of the first large-scale real-world 3D lane datasets: OpenLane, with high-quality annotation and scenario diversity. Open-Lane contains 200,000 frames, over 880,000 instance-level lanes, 14 lane categories, along with scene tags and the closed-in-path object annotations to encourage the development of lane detection and more industrialrelated autonomous driving methods. We show that PersFormer significantly outperforms competitive baselines in the 3D lane detection task on our new OpenLane dataset as well as Apollo 3D Lane Synthetic dataset, and is also on par with state-of-the-art algorithms in the 2D task on OpenLane. The project page is available at https://github.com/OpenP erceptionX/PersFormer 3DLane and OpenLane dataset is provided at https://github.com/OpenPerceptionX/OpenLane. * Equal contribution. † Correspondence author. 1 We define the height of lane line z to be the relative height concerning the zero point in the ego vehicle coordinate system (x, y, z) in BEV 3D space. The coordinate of the perspective (front view) 2D space in the image plane is referred to as (u, v).

For agents

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

get_harvested_code_for_paper("2203.11089")
get_code_for_paper("2203.11089")
have("2203.11089")

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

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

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

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

Connect an agent — have() is free.