SYNTOLOGY HomeExplorerAtlasCodeMethodologyAboutDevelopersFeedPricing
Paper · 2303.05760 · ICCV · 2023

GameFormer: Game-theoretic Modeling and Learning of Transformer-based Interactive Prediction and Planning for Autonomous Driving

Chen Lv, Zhiyu Huang, Haochen Liu

arXiv · PDF · Open in the Atlas

Code that ran

11 of 16 samples (functions and classes) lifted from this paper's linked repositories executed on a synthesized input in Syntology's jail (0 of them constructed an object rather than computing a result; 1 honoured the contract we drafted, 0 violated it and 6 have no contract verdict; 4 failures of our instrument; 5 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/2303.05760.json · badge: /api/ran/2303.05760.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
MCZhi/GameFormer-Planner community (classifier label)
classifier basis not recorded on the link
11 ran · 5 no recorded run
FunctionStatusWhere it lives
annotate_occupancy Ran
ran on a synthesized input
MCZhi/GameFormer-Planner/Planner/planner_utils.py
code served (permissive licence) · get_code("290321a202342cc2")
How it ran

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

import numpy as np
import scipy.spatial.distance

# Create occupancy array
# The function indexes into it with a boolean mask, so it needs to be a numpy array
occupancy = np.zeros((10,), dtype=np.int32)

# Create ego_path - should be Nx2 or larger array with x,y coordinates
# The function uses ego_path[:, :2] so it takes first 2 columns
ego_path = np.array([
    [0.0, 1.0, 5.0, 10.0],
    [2.0, 3.0, 6.0, 11.0],
    [4.0, 5.0, 7.0, 12.0],
    [6.0, 7.0, 8.0, 13.0],
    [8.0, 9.0, 9.0, 14.0],
    [10.0, 11.0, 10.0, 15.0],
    [12.0, 13.0, 11.0, 16.0],
    [14.0, 15.0, 12.0, 17.0],
    [16.0, 17.0, 13.0, 18.0],
    [18.0, 19.0, 14.0, 19.0],
], dtype=np.float32)

# Create red_light_lane - should be Mx2 array with x,y coordinates
# Using small size (< 80) to trigger the pass branch
red_light_lane = np.array([
    [5.0, 6.0],
    [5.1, 6.1],
    [5.2, 6.2],
], dtype=np.float32)

ARGS = {
    "occupancy": occupancy,
    "ego_path": ego_path,
    "red_light_lane": red_light_lane,
}
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 ndarray, ndim 1, dtype family int, shape (10,) — shape (10,) 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
annotate_speed Ran
ran on a synthesized input
MCZhi/GameFormer-Planner/Planner/planner_utils.py
code served (permissive licence) · get_code("fcb62ec99b519182")
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, 1) 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

# Construct ref_path: a numpy array with shape (n, 4)
# The function uses ref_path[:, 3] to extract the 4th column
# and checks argmax of absolute values > 1/10
# Let's create a path with some turning behavior
ref_path = np.array([
    [1.0, 2.0, 3.0, 0.05],
    [1.1, 2.1, 3.1, 0.08],
    [1.2, 2.2, 3.2, 0.12],  # This row has value > 1/10, so turning starts here
    [1.3, 2.3, 3.3, 0.15],
    [1.4, 2.4, 3.4, 0.20],
])

# speed_limit is a scalar float
speed_limit = 10.0

ARGS = {
    "ref_path": ref_path,
    "speed_limit": speed_limit,
}
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, 1) — shape (5, 1) 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
bernstein_poly Ran
ran, honoured the contract we drafted
MCZhi/GameFormer-Planner/Planner/bezier_path.py
code served (permissive licence) · get_code("cb5cb6d0e7e6b54e")
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 float64, ndim 0, 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 scipy.special

# bernstein_poly takes:
# n: int (polynom degree)
# i: int (index)
# t: float (parameter value between 0 and 1)

ARGS = {
    "n": 5,
    "i": 2,
    "t": 0.3
}
Setup block drafted by
a language model, Claude Haiku 4.5, prompt python_fixture_v1, through the batch API
Imports
scipy — import names as written, not package names to install; a name the repository itself provides is not a package
Returned
type float64, ndim 0, dtype family float — no output shape is stated: observe_signature.py recorded float ndim 0, which disagrees with the fixture run
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
calc_4points_bezier_path Ran
ran; our contract draft was wrong, not the code
MCZhi/GameFormer-Planner/Planner/bezier_path.py
code served (permissive licence) · get_code("dbd18e4b11cb39be")
How it ran

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

import numpy as np
import scipy.special

def bernstein_poly(n, i, t):
    return scipy.special.comb(n, i) * t ** i * (1 - t) ** (n - i)

def bezier(t, control_points):
    n = len(control_points) - 1
    return np.sum([bernstein_poly(n, i, t) * control_points[i] for i in range(n + 1)], axis=0)

def calc_bezier_path(control_points, n_points=100):
    traj = []
    for t in np.linspace(0, 1, n_points):
        traj.append(bezier(t, control_points))
    return np.array(traj)

def calc_4points_bezier_path(sx, sy, syaw, ex, ey, eyaw, offset, n_points=100):
    dist = np.hypot(sx - ex, sy - ey) / offset
    control_points = np.array([[sx, sy], [sx + dist * np.cos(syaw), sy + dist * np.sin(syaw)], [ex - dist * np.cos(eyaw), ey - dist * np.sin(eyaw)], [ex, ey]])
    path = calc_bezier_path(control_points, n_points=n_points)
    return (path, control_points)

ARGS = {
    "sx": 0.0,
    "sy": 0.0,
    "syaw": 0.0,
    "ex": 10.0,
    "ey": 10.0,
    "eyaw": np.pi / 4,
    "offset": 2.0,
    "n_points": 50
}
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
calc_bezier_path Ran
ran; our contract draft was wrong, not the code
MCZhi/GameFormer-Planner/Planner/bezier_path.py
code served (permissive licence) · get_code("4821a6353f2620ba")
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 (50, 2) as a later run recorded it. The image it ran in was not recorded. If your copy returns the same type, ndim and shape on these inputs, it matched what we observed; nothing here checks that. It does NOT mean the output is correct: nothing has compared it to the paper.

import numpy as np
import scipy.special

def bernstein_poly(n, i, t):
    """
    Bernstein polynom.

    :param n: (int) polynom degree
    :param i: (int)
    :param t: (float)
    :return: (float)
    """
    return scipy.special.comb(n, i) * t ** i * (1 - t) ** (n - i)

def bezier(t, control_points):
    """
    Return one point on the bezier curve.

    :param t: (float) number in [0, 1]
    :param control_points: (numpy array)
    :return: (numpy array) Coordinates of the point
    """
    n = len(control_points) - 1
    return np.sum([bernstein_poly(n, i, t) * control_points[i] for i in range(n + 1)], axis=0)

def calc_bezier_path(control_points, n_points=100):
    """
    Compute bezier path (trajectory) given control points.

    :param control_points: (numpy array)
    :param n_points: (int) number of points in the trajectory
    :return: (numpy array)
    """
    traj = []
    for t in np.linspace(0, 1, n_points):
        traj.append(bezier(t, control_points))
    return np.array(traj)

# Create control points for a Bezier curve
# Using 4 control points in 2D space (x, y coordinates)
control_points = np.array([
    [0.0, 0.0],
    [1.0, 2.0],
    [3.0, 2.0],
    [4.0, 0.0]
])

ARGS = {
    "control_points": control_points,
    "n_points": 50
}
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 ndarray, ndim 2, dtype family float, shape (50, 2) — shape (50, 2) 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
convert_to_model_inputs Ran
ran; our contract draft was wrong, not the code
MCZhi/GameFormer-Planner/Planner/observation.py
code served (permissive licence) · get_code("8a7f01d886d3a4bf")
How it ran

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

import torch

torch.manual_seed(0)

# The function expects:
# 1. data: a dict where values have .float() and .unsqueeze(0) methods
#    (i.e., torch tensors)
# 2. device: a torch device object

# Create sample data dict with small tensors
data = {
    'input_ids': torch.randint(0, 10, (2, 4)).float(),
    'attention_mask': torch.ones(2, 4).float(),
    'token_type_ids': torch.zeros(2, 4).float(),
}

device = torch.device('cpu')

ARGS = {
    'data': data,
    'device': device,
}
Setup block drafted by
a language model, Claude Haiku 4.5, prompt python_fixture_v1, through the batch API
Imports
torch — import names as written, not package names to install; a name the repository itself provides is not a package
Returned
type dict — a dict output has no array shape of its own; none is stated — the instrument coerces any output to an array; for a dict output the recorded ndim 0 and dtype family float describe that coercion, not the output, and are not stated
Environment
image not recorded; re-verify against syntology-harvest-sandbox:v5-deps; not recorded for this sample: the harness installs a cuda-to-cpu shim (cuda_shim.py) before every sample and no run records whether a sample needed it; seed: none by the harness; any seed is in the setup block
global_velocity_to_local Ran
ran; our contract draft was wrong, not the code
MCZhi/GameFormer-Planner/GameFormer/data_utils.py
code served (permissive licence) · get_code("0950505f865f0908")
How it ran

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

import torch

torch.manual_seed(0)

# Create sample tensors
# velocity: shape (batch_size, 2) - 2D velocity vectors
velocity = torch.randn(2, 2)

# anchor_heading: shape (batch_size,) - heading angles in radians
anchor_heading = torch.randn(2)

ARGS = {
    "velocity": velocity,
    "anchor_heading": anchor_heading,
}
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, 2) — shape (2, 2) 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
planning_loss Ran
ran on a synthesized input
MCZhi/GameFormer-Planner/GameFormer/train_utils.py
code served (permissive licence) · get_code("6b60c79300dd01ee")
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 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
import torch.nn as nn

torch.manual_seed(0)

# Create small tensors for plan and ego_future
# plan: (batch_size, sequence_length, features)
# ego_future: (batch_size, sequence_length, features)
# Using batch=2, sequence_length=5, features=4 for distinct dimensions

batch_size = 2
sequence_length = 5
features = 4

plan = torch.randn(batch_size, sequence_length, features)
ego_future = torch.randn(batch_size, sequence_length, features)

ARGS = {
    "plan": plan,
    "ego_future": ego_future,
}
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 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
speed_constraint Ran
ran on a synthesized input
MCZhi/GameFormer-Planner/Planner/refinement.py
code served (permissive licence) · get_code("74f953374c54713f")
How it ran

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

import torch
import torch.nn as nn

torch.manual_seed(0)

class OptimVar:
    def __init__(self, tensor):
        self.tensor = tensor

class AuxVar:
    pass

# Create a small tensor with batch size 2 and dimension 4
ds_tensor = torch.randn(2, 4)

optim_vars = [OptimVar(ds_tensor)]
aux_vars = []

ARGS = {
    "optim_vars": optim_vars,
    "aux_vars": aux_vars
}
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, 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
speed_target Ran
ran on a synthesized input
MCZhi/GameFormer-Planner/Planner/refinement.py
code served (permissive licence) · get_code("7eac29926d6d6f7c")
How it ran

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

import torch

torch.manual_seed(0)

# Create optim_vars - a list with at least one element
# optim_vars[0] must have a .tensor attribute
class OptimVar:
    def __init__(self, tensor):
        self.tensor = tensor

ds_tensor = torch.randn(2, 4)  # batch_size=2, some_dim=4
optim_vars = [OptimVar(ds_tensor)]

# Create aux_vars - a list with at least two elements
# aux_vars[0] must have .tensor attribute with shape [batch_size, speed_limit_dim]
# aux_vars[1] must have .tensor attribute that will be clipped to [0, speed_limit_dim-1]

class AuxVar:
    def __init__(self, tensor):
        self.tensor = tensor

speed_limit_tensor = torch.randn(2, 5)  # batch_size=2, speed_limit_dim=5
s_tensor = torch.rand(2, 4) * 2  # values in [0, 2), will be multiplied by 10 then clipped

aux_vars = [
    AuxVar(speed_limit_tensor),
    AuxVar(s_tensor)
]

ARGS = {
    "optim_vars": optim_vars,
    "aux_vars": aux_vars
}
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, 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
wrap_to_pi Ran
ran on a synthesized input
MCZhi/GameFormer-Planner/Planner/planner_utils.py
code served (permissive licence) · get_code("a164c593eacff041")
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 (2, 2) as a later run recorded it. The image it ran in was not recorded. If your copy returns the same type, ndim and shape on these inputs, it matched what we observed; nothing here checks that. It does NOT mean the output is correct: nothing has compared it to the paper.

import numpy as np
import torch

# The function wrap_to_pi takes a single parameter theta
# and applies a modulo operation to wrap angles to [-pi, pi]
# It expects a numeric value or array-like input

# Create test cases with different input types
theta_scalar = np.pi + 0.5
theta_array_1d = np.array([0.0, np.pi, 2*np.pi, -np.pi])
theta_array_2d = np.array([[0.5, 1.0], [2.0, 3.0]])

# We'll use a small 2D array as the primary test case
theta_input = np.array([[0.1, np.pi + 0.2], [2*np.pi - 0.5, -np.pi - 1.0]])

ARGS = {
    "theta": theta_input
}
Setup block drafted by
a language model, Claude Haiku 4.5, prompt python_fixture_v1, through the batch API
Imports
numpy, torch — import names as written, not package names to install; a name the repository itself provides is not a package
Returned
type ndarray, ndim 2, dtype family float, shape (2, 2) — shape (2, 2) 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
acceleration Not yet run
unverified (harvested, no recorded run)
MCZhi/GameFormer-Planner/Planner/refinement.py
code served (permissive licence) · get_code("0b1d117c7cb55ec5")
How it ran

no invocation recorded.

calc_spline_course Not yet run
unverified (harvested, no recorded run)
MCZhi/GameFormer-Planner/Planner/cubic_spline.py
code served (permissive licence) · get_code("b035159f75f8704e")
How it ran

no invocation recorded.

extract_agent_tensor Not yet run
unverified (harvested, no recorded run)
MCZhi/GameFormer-Planner/Planner/observation.py
code served (permissive licence) · get_code("5c7a943caab0bfde")
How it ran

no invocation recorded.

imitation_loss Not yet run
unverified (harvested, no recorded run)
MCZhi/GameFormer-Planner/GameFormer/train_utils.py
code served (permissive licence) · get_code("b448c6864e6f8e25")
How it ran

no invocation recorded.

level_k_loss Not yet run
unverified (harvested, no recorded run)
MCZhi/GameFormer-Planner/GameFormer/train_utils.py
code served (permissive licence) · get_code("f1627cd7a0d4f819")
How it ran

no invocation recorded.

Also present in other papers' code

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

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

FunctionAlso present inEarliest-datedOthers named
bernstein_poly 2 other papers
2 later
2310.05885 (2023-10)
DTPP: Differentiable Joint Conditional Prediction and Cost Evaluation for Tree Policy Planning in Autonomous Driving
2406.14556 (2024-06)
Asynchronous Large Language Model Enhanced Planner for Autonomous Driving
calc_4points_bezier_path 2 other papers
2 later
2310.05885 (2023-10)
DTPP: Differentiable Joint Conditional Prediction and Cost Evaluation for Tree Policy Planning in Autonomous Driving
2406.14556 (2024-06)
Asynchronous Large Language Model Enhanced Planner for Autonomous Driving
calc_bezier_path 2 other papers
2 later
2310.05885 (2023-10)
DTPP: Differentiable Joint Conditional Prediction and Cost Evaluation for Tree Policy Planning in Autonomous Driving
2406.14556 (2024-06)
Asynchronous Large Language Model Enhanced Planner for Autonomous Driving
calc_spline_course 2 other papers
2 later
2310.05885 (2023-10)
DTPP: Differentiable Joint Conditional Prediction and Cost Evaluation for Tree Policy Planning in Autonomous Driving
2406.14556 (2024-06)
Asynchronous Large Language Model Enhanced Planner for Autonomous Driving
convert_to_model_inputs 2 other papers
2 later
2310.05885 (2023-10)
DTPP: Differentiable Joint Conditional Prediction and Cost Evaluation for Tree Policy Planning in Autonomous Driving
2406.14556 (2024-06)
Asynchronous Large Language Model Enhanced Planner for Autonomous Driving
extract_agent_tensor 2 other papers
2 later
2310.05885 (2023-10)
DTPP: Differentiable Joint Conditional Prediction and Cost Evaluation for Tree Policy Planning in Autonomous Driving
2406.14556 (2024-06)
Asynchronous Large Language Model Enhanced Planner for Autonomous Driving
global_velocity_to_local 2 other papers
2 later
2310.05885 (2023-10)
DTPP: Differentiable Joint Conditional Prediction and Cost Evaluation for Tree Policy Planning in Autonomous Driving
2406.14556 (2024-06)
Asynchronous Large Language Model Enhanced Planner for Autonomous Driving

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

Autonomous vehicles operating in complex real-world environments require accurate predictions of interactive behaviors between traffic participants. This paper tackles the interaction prediction problem by formulating it with hierarchical game theory and proposing the GameFormer model for its implementation. The model incorporates a Transformer encoder, which effectively models the relationships between scene elements, alongside a novel hierarchical Transformer decoder structure. At each decoding level, the decoder utilizes the prediction outcomes from the previous level, in addition to the shared environmental context, to iteratively refine the interaction process. Moreover, we propose a learning process that regulates an agent's behavior at the current level to respond to other agents' behaviors from the preceding level. Through comprehensive experiments on large-scale real-world driving datasets, we demonstrate the state-of-the-art accuracy of our model on the Waymo interaction prediction task. Additionally, we validate the model's capacity to jointly reason about the motion plan of the ego agent and the behaviors of multiple agents in both open-loop and closed-loop planning tests, outperforming various baseline methods. Furthermore, we evaluate the efficacy of our model on the nuPlan planning benchmark, where it achieves leading performance. Project website: https://mczhi.github.io/GameFormer/

For agents

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

get_harvested_code_for_paper("2303.05760")
get_code_for_paper("2303.05760")
have("2303.05760")

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

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

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

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

Connect an agent — have() is free.