SYNTOLOGY HomeExplorerAtlasCodeMethodologyAboutDevelopersFeedPricing
Paper · 2109.05885 · ICCV · 2021

Graph-Based 3D Multi-Person Pose Estimation Using Multi-View Images

Lei Bai, Dong Liu, Wanli Ouyang, Chen Qian, Wentao Liu, Size Wu, Jin Sheng

arXiv · PDF · Open in the Atlas

Code that ran

19 of 22 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, 1 violated it and 11 have no contract verdict; 7 failures of our instrument; 3 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/2109.05885.json · badge: /api/ran/2109.05885.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
microsoft/voxelpose-pytorch community
Papers with Code archive
19 ran · 3 no recorded run
FunctionStatusWhere it lives
Basic3DBlock Ran
ran on a synthesized input · constructed an object; no result was computed
microsoft/voxelpose-pytorch/lib/models/multi_person_posenet.py
code served (permissive licence) · get_code("e879f43ac29c8209")
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, Basic3DBlock: 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_planes': 3,
    'out_planes': 16,
    'kernel_size': 3
}
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 Basic3DBlock — 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 Basic3DBlock 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
EncoderDecorder Ran
ran on a synthesized input · constructed an object; no result was computed
microsoft/voxelpose-pytorch/lib/models/multi_person_posenet.py
code served (permissive licence) · get_code("e8bb60b582c2affd")
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, EncoderDecorder: 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)

# EncoderDecorder.__init__ takes no parameters except self
# The forward method expects input x to be a 5D tensor (batch, channels, depth, height, width)
# Looking at the architecture:
# - Input x has 32 channels (skip_res1 processes it without channel change)
# - After encoder_pool1: spatial dims halved
# - After encoder_res1: 32 -> 64 channels
# - After encoder_pool2: spatial dims halved again
# - After encoder_res2: 64 -> 128 channels
# - Decoder upsamples back and concatenates with skip connections

# Create a small input tensor: batch=2, channels=32, depth=4, height=3, width=3
# This must have 32 input channels based on skip_res1(x) expecting 32 channels
x = torch.randn(2, 32, 4, 3, 3)

ARGS = {}
Setup block drafted by
a language model, Claude Haiku 4.5, prompt python_fixture_v1, through the batch API
Imports
torch — import names as written, not package names to install; a name the repository itself provides is not a package
Returned
type EncoderDecorder — 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 EncoderDecorder 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
PerJointL1Loss Ran
ran on a synthesized input
microsoft/voxelpose-pytorch/lib/models/multi_person_posenet.py
code served (permissive licence) · get_code("6107a2be532d1330")
How it ran

Ran in Syntology's sandbox on this synthesized input (drafted by a language model, class construct-then-call prompt, model not recorded) and returned Tensor, ndim 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 torch
import torch.nn as nn

INIT_ARGS = {}

ARGS = {
    'output': torch.randn(2, 3, 4),
    'target': torch.randn(2, 3, 4),
    'use_target_weight': True,
    'target_weight': torch.ones(2, 3, 1)
}

class PerJointL1Loss(nn.Module):

    def __init__(self):
        super(PerJointL1Loss, self).__init__()
        self.criterion = nn.L1Loss(reduction='mean')

    def forward(self, output, target, use_target_weight=False, target_weight=None):
        if use_target_weight:
            batch_size = output.size(0)
            num_joints = output.size(1)
            pred = output.reshape((batch_size, num_joints, -1))
            gt = target.reshape((batch_size, num_joints, -1))
            loss = self.criterion(pred.mul(target_weight), gt.mul(target_weight))
        else:
            loss = self.criterion(output, target)
        return loss

if __name__ == '__main__':
    model = PerJointL1Loss(**INIT_ARGS)
    result = model(**ARGS)
    print(f"Loss output: {result}")
    print(f"Loss shape: {result.shape}")
Setup block drafted by
a language model, class construct-then-call prompt, model not recorded
Imports
torch — import names as written, not package names to install; a name the repository itself provides is not a package
Returned
type Tensor, ndim 0, dtype family float — no output shape is stated: observe_signature.py observed this class with its constructor sizes canonicalised where it could, which the node does not record, so its shape is not stated as this setup block's
dtype family
int means an integer dtype; float means any other dtype the instrument saw, bool and complex included (fixture_check.py records only these two families)
Environment
image not recorded; re-verify against syntology-harvest-sandbox:v5-deps; not recorded for this sample: the harness installs a cuda-to-cpu shim (cuda_shim.py) before every sample and no run records whether a sample needed it; seed: torch and numpy seeded to 0 by the harness immediately before the class was constructed from INIT_ARGS (fixture_check.py)
PerJointMSELoss Ran
ran on a synthesized input
microsoft/voxelpose-pytorch/lib/models/multi_person_posenet.py
code served (permissive licence) · get_code("9d1c5d2a5a6c24e6")
How it ran

Ran in Syntology's sandbox on this synthesized input (drafted by a language model, class construct-then-call prompt, model not recorded) and returned Tensor, ndim 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 torch
import torch.nn as nn

class PerJointMSELoss(nn.Module):

    def __init__(self):
        super(PerJointMSELoss, self).__init__()
        self.criterion = nn.MSELoss(reduction='mean')

    def forward(self, output, target, use_target_weight=False, target_weight=None):
        if use_target_weight:
            batch_size = output.size(0)
            num_joints = output.size(1)
            heatmap_pred = output.reshape((batch_size, num_joints, -1))
            heatmap_gt = target.reshape((batch_size, num_joints, -1))
            loss = self.criterion(heatmap_pred.mul(target_weight), heatmap_gt.mul(target_weight))
        else:
            loss = self.criterion(output, target)
        return loss


INIT_ARGS = {}

ARGS = {
    'output': torch.randn(2, 3, 4, 5),
    'target': torch.randn(2, 3, 4, 5),
    'use_target_weight': False,
    'target_weight': None,
}

if __name__ == '__main__':
    model = PerJointMSELoss(**INIT_ARGS)
    result = model(**ARGS)
    print(f"Loss output: {result}")
    print(f"Loss shape: {result.shape}")
    
    model2 = PerJointMSELoss(**INIT_ARGS)
    target_weight = torch.ones(2, 3, 20)
    result2 = model2(
        output=torch.randn(2, 3, 4, 5),
        target=torch.randn(2, 3, 4, 5),
        use_target_weight=True,
        target_weight=target_weight,
    )
    print(f"Loss with weight output: {result2}")
    print(f"Loss with weight shape: {result2.shape}")
Setup block drafted by
a language model, class construct-then-call prompt, model not recorded
Imports
torch — import names as written, not package names to install; a name the repository itself provides is not a package
Returned
type Tensor, ndim 0, dtype family float — no output shape is stated: observe_signature.py observed this class with its constructor sizes canonicalised where it could, which the node does not record, so its shape is not stated as this setup block's
dtype family
int means an integer dtype; float means any other dtype the instrument saw, bool and complex included (fixture_check.py records only these two families)
Environment
image not recorded; re-verify against syntology-harvest-sandbox:v5-deps; not recorded for this sample: the harness installs a cuda-to-cpu shim (cuda_shim.py) before every sample and no run records whether a sample needed it; seed: torch and numpy seeded to 0 by the harness immediately before the class was constructed from INIT_ARGS (fixture_check.py)
Pool3DBlock Ran
ran on a synthesized input · constructed an object; no result was computed
microsoft/voxelpose-pytorch/lib/models/multi_person_posenet.py
code served (permissive licence) · get_code("ec6cfed3d98141ca")
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, Pool3DBlock: 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)

# Pool3DBlock takes pool_size as a parameter
# pool_size is used as kernel_size and stride in F.max_pool3d
# It should be an int or tuple of ints for 3D pooling

pool_size = 2

ARGS = {
    'pool_size': pool_size
}
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 Pool3DBlock — 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 Pool3DBlock 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
ProjectLayer Ran
ran on a synthesized input · constructed an object; no result was computed
microsoft/voxelpose-pytorch/lib/models/multi_person_posenet.py
code served (permissive licence) · get_code("744d63366179beb0")
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, ProjectLayer: 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 numpy as np

torch.manual_seed(0)

class MockConfig:
    def __init__(self):
        self.NETWORK = type('obj', (object,), {
            'IMAGE_SIZE': [256, 256],
            'HEATMAP_SIZE': [64, 64]
        })()
        self.MULTI_PERSON = type('obj', (object,), {
            'SPACE_SIZE': [2000, 2000, 2000],
            'INITIAL_CUBE_SIZE': [500, 500, 500],
            'SPACE_CENTER': [0, 0, 1000]
        })()

cfg = MockConfig()

ARGS = {
    'cfg': cfg
}
Setup block drafted by
a language model, Claude Haiku 4.5, prompt python_fixture_v1, through the batch API
Imports
cv2, numpy, torch — import names as written, not package names to install; a name the repository itself provides is not a package
Returned
type ProjectLayer — 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 ProjectLayer 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
ProposalLayer Ran
ran on a synthesized input · constructed an object; no result was computed
microsoft/voxelpose-pytorch/lib/models/multi_person_posenet.py
code served (permissive licence) · get_code("68e1c779a38301ad")
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, ProposalLayer: 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)

class Config:
    class MULTI_PERSON:
        SPACE_SIZE = [64, 64, 64]
        INITIAL_CUBE_SIZE = [8, 8, 8]
        SPACE_CENTER = [0.0, 0.0, 0.0]
        MAX_PEOPLE_NUM = 4
        THRESHOLD = 0.5
    
    class DATASET:
        ROOTIDX = 0
    
    class NETWORK:
        NUM_JOINTS = 17

cfg = Config()

ARGS = {
    'cfg': cfg
}
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 ProposalLayer — 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 ProposalLayer 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
Res3DBlock Ran
ran on a synthesized input · constructed an object; no result was computed
microsoft/voxelpose-pytorch/lib/models/multi_person_posenet.py
code served (permissive licence) · get_code("582e26415bfd114c")
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, Res3DBlock: 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_planes': 3,
    'out_planes': 16,
}
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 Res3DBlock — 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 Res3DBlock 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
SoftArgmaxLayer Ran
ran on a synthesized input
microsoft/voxelpose-pytorch/lib/models/multi_person_posenet.py
code served (permissive licence) · get_code("dc41bb35432b99fb")
How it ran

Ran in Syntology's sandbox on this synthesized input (drafted by a language model, class construct-then-call prompt, model not recorded) and returned Tensor, ndim 3, dtype family float; no output shape is stated. The image it ran in was not recorded. If your copy returns the same type and ndim on these inputs, it matched what we observed; nothing here checks that. It does NOT mean the output is correct: nothing has compared it to the paper.

import torch
import torch.nn as nn

class SimpleConfig:
    class NETWORK:
        BETA = 100.0

cfg = SimpleConfig()

INIT_ARGS = {
    'cfg': cfg
}

# Create input tensor and grids for forward pass
batch_size = 2
channel = 4
height = 3
width = 5
spatial_size = height * width

# x should be shape (batch_size, channel, height, width)
x = torch.randn(batch_size, channel, height, width)

# grids should be shape (batch_size, spatial_size, coordinate_dim)
# where coordinate_dim is typically 2 or 3 (for x,y or x,y,z coordinates)
coordinate_dim = 3
grids = torch.randn(batch_size, spatial_size, coordinate_dim)

ARGS = {
    'x': x,
    'grids': grids
}
Setup block drafted by
a language model, class construct-then-call prompt, model not recorded
Imports
torch — import names as written, not package names to install; a name the repository itself provides is not a package
Returned
type Tensor, ndim 3, dtype family float — no output shape is stated: observe_signature.py observed this class with its constructor sizes canonicalised where it could, which the node does not record, so its shape is not stated as this setup block's
dtype family
int means an integer dtype; float means any other dtype the instrument saw, bool and complex included (fixture_check.py records only these two families)
Environment
image not recorded; re-verify against syntology-harvest-sandbox:v5-deps; not recorded for this sample: the harness installs a cuda-to-cpu shim (cuda_shim.py) before every sample and no run records whether a sample needed it; seed: torch and numpy seeded to 0 by the harness immediately before the class was constructed from INIT_ARGS (fixture_check.py)
Upsample3DBlock Ran
ran on a synthesized input · constructed an object; no result was computed
microsoft/voxelpose-pytorch/lib/models/multi_person_posenet.py
code served (permissive licence) · get_code("56a3fdc52ef86408")
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, Upsample3DBlock: 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 Upsample3DBlock takes 4 parameters: in_planes, out_planes, kernel_size, stride
# It creates a ConvTranspose3d layer, so we need to provide valid integer arguments
# kernel_size must be 2 and stride must be 2 (asserted in __init__)

ARGS = {
    "in_planes": 3,
    "out_planes": 5,
    "kernel_size": 2,
    "stride": 2
}
Setup block drafted by
a language model, Claude Haiku 4.5, prompt python_fixture_v1, through the batch API
Imports
torch — import names as written, not package names to install; a name the repository itself provides is not a package
Returned
type Upsample3DBlock — 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 Upsample3DBlock 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
V2VNet Ran
ran on a synthesized input · constructed an object; no result was computed
microsoft/voxelpose-pytorch/lib/models/multi_person_posenet.py
code served (permissive licence) · get_code("a27e057355474941")
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, V2VNet: 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 = {
    "input_channels": 1,
    "output_channels": 2,
}
Setup block drafted by
a language model, Claude Haiku 4.5, prompt python_fixture_v1, through the batch API
Imports
torch — import names as written, not package names to install; a name the repository itself provides is not a package
Returned
type V2VNet — 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 V2VNet output the recorded ndim 0 and dtype family float describe that coercion, not the output, and are not stated
Environment
image not recorded; re-verify against syntology-harvest-sandbox:v5-deps; not recorded for this sample: the harness installs a cuda-to-cpu shim (cuda_shim.py) before every sample and no run records whether a sample needed it; seed: none by the harness; any seed is in the setup block
get_3rd_point Ran
ran; the contract check could not run (RAISES, DEP_MISSING or TIMEOUT)
microsoft/voxelpose-pytorch/lib/models/multi_person_posenet.py
code served (permissive licence) · get_code("1adda80cee295b0e")
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 float, shape (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

# The function get_3rd_point takes two parameters: a and b
# Both are used with subtraction (a - b) and indexing operations
# They should be array-like objects with at least 2 elements
# The function computes a perpendicular point based on two input points

a = np.array([3.0, 4.0], dtype=np.float32)
b = np.array([1.0, 2.0], dtype=np.float32)

ARGS = {
    "a": a,
    "b": b
}
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 1, dtype family float, shape (2,) — shape (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
get_dir Ran
ran, violated the contract we drafted
microsoft/voxelpose-pytorch/lib/models/multi_person_posenet.py
code served (permissive licence) · get_code("5d546e1ecbee1866")
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 list, ndim 1, dtype family float; no output shape is stated. The image it ran in was not recorded. If your copy returns the same type and ndim on these inputs, it matched what we observed; nothing here checks that. It does NOT mean the output is correct: nothing has compared it to the paper.

import numpy as np

# Analyze the function:
# - src_point: used with indexing [0] and [1], so it needs to be indexable with 2 elements
# - rot_rad: used with np.sin() and np.cos(), so it should be a scalar number

# Create test arguments
src_point = [1.0, 2.0]  # A simple 2D point
rot_rad = np.pi / 4     # A rotation angle in radians

ARGS = {
    "src_point": src_point,
    "rot_rad": rot_rad
}
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 list, ndim 1, dtype family float — a list output has no array shape of its own; none is stated
dtype family
int means an integer dtype; float means any other dtype the instrument saw, bool and complex included (fixture_check.py records only these two families)
Environment
image not recorded; re-verify against syntology-harvest-sandbox:v5-deps; not recorded for this sample: the harness installs a cuda-to-cpu shim (cuda_shim.py) before every sample and no run records whether a sample needed it; seed: none by the harness; any seed is in the setup block
get_index Ran
ran; our contract draft was wrong, not the code
microsoft/voxelpose-pytorch/lib/models/multi_person_posenet.py
code served (permissive licence) · get_code("346171f4d8f86b44")
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 3, dtype family int, shape (2, 3, 21) as a later run recorded it. The image it ran in was not recorded. If your copy returns the same type, ndim and shape on these inputs, it matched what we observed; nothing here checks that. It does NOT mean the output is correct: nothing has compared it to the paper.

import torch

torch.manual_seed(0)

# Construct indices tensor
# Shape: (batch_size=2, num_people=3, flattened_indices)
# The function expects indices that reference positions in a 3D space
# Let's create indices that fit within a shape like (4, 5, 6)
batch_size = 2
num_people = 3
num_indices = 7

# Create valid flat indices that when decoded will fit in shape (4, 5, 6)
# Max flat index = 4*5*6 - 1 = 119
indices = torch.randint(0, 120, (batch_size, num_people, num_indices))

# Construct shape tuple
# This represents a 3D space with dimensions (depth=4, height=5, width=6)
shape = (4, 5, 6)

ARGS = {
    "indices": indices,
    "shape": shape,
}
Setup block drafted by
a language model, Claude Haiku 4.5, prompt python_fixture_v1, through the batch API
Imports
torch — import names as written, not package names to install; a name the repository itself provides is not a package
Returned
type Tensor, ndim 3, dtype family int, shape (2, 3, 21) — shape (2, 3, 21) 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
max_pool Ran
ran; our contract draft was wrong, not the code
microsoft/voxelpose-pytorch/lib/models/multi_person_posenet.py
code served (permissive licence) · get_code("6c9fb0f42d59408f")
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 5, dtype family float, shape (2, 3, 4, 5, 6) as a later run recorded it. The image it ran in was not recorded. If your copy returns the same type, ndim and shape on these inputs, it matched what we observed; nothing here checks that. It does NOT mean the output is correct: nothing has compared it to the paper.

import torch
import torch.nn.functional as F

torch.manual_seed(0)

# Create a small 3D input tensor for max_pool3d
# Shape: (batch=2, channels=3, depth=4, height=5, width=6)
inputs = torch.randn(2, 3, 4, 5, 6)

# Define the kernel size parameter
kernel = 3

ARGS = {
    "inputs": inputs,
    "kernel": kernel,
}
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 5, dtype family float, shape (2, 3, 4, 5, 6) — shape (2, 3, 4, 5, 6) as a later run recorded it
dtype family
int means an integer dtype; float means any other dtype the instrument saw, bool and complex included (fixture_check.py records only these two families)
Environment
image not recorded; re-verify against syntology-harvest-sandbox:v5-deps; not recorded for this sample: the harness installs a cuda-to-cpu shim (cuda_shim.py) before every sample and no run records whether a sample needed it; seed: none by the harness; any seed is in the setup block
nms Ran
ran; our contract draft was wrong, not the code
microsoft/voxelpose-pytorch/lib/models/multi_person_posenet.py
code served (permissive licence) · get_code("09efa3ac3e5d405e")
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 torch
import torch.nn.functional as F

torch.manual_seed(0)

# The function nms takes:
# 1. root_cubes: a 5D tensor (batch_size, channels, depth, height, width)
#    - Used in max_pool which applies F.max_pool3d
#    - Reshaped to (batch_size, -1) for topk
#    - Indexed with topk_index to get shape for get_index
# 2. max_num: an integer for topk selection

# Create a small 5D tensor: (batch=2, channels=1, depth=4, height=3, width=5)
root_cubes = torch.randn(2, 1, 4, 3, 5)

# Create max_num as an integer
max_num = 5

ARGS = {
    "root_cubes": root_cubes,
    "max_num": max_num,
}
Setup block drafted by
a language model, Claude Haiku 4.5, prompt python_fixture_v1, through the batch API
Imports
torch — import names as written, not package names to install; a name the repository itself provides is not a package
Returned
type tuple — a tuple output has no array shape of its own; none is stated
Environment
image not recorded; re-verify against syntology-harvest-sandbox:v5-deps; not recorded for this sample: the harness installs a cuda-to-cpu shim (cuda_shim.py) before every sample and no run records whether a sample needed it; seed: none by the harness; any seed is in the setup block
project_point_radial Ran
ran; our contract draft was wrong, not the code
microsoft/voxelpose-pytorch/lib/models/multi_person_posenet.py
code served (permissive licence) · get_code("b2016bca44e2e224")
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)

# N=2 points in world coordinates, 3D
x = torch.randn(2, 3)

# 3x3 Camera rotation matrix
R = torch.eye(3)

# 3x1 Camera translation parameters
T = torch.randn(3, 1)

# scalar Camera focal length
f = torch.tensor(500.0)

# 2x1 Camera center
c = torch.randn(2, 1)

# 3x1 Camera radial distortion coefficients
k = torch.randn(3, 1)

# 2x1 Camera tangential distortion coefficients
p = torch.randn(2, 1)

ARGS = {
    'x': x,
    'R': R,
    'T': T,
    'f': f,
    'c': c,
    'k': k,
    'p': p
}
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
project_pose Ran
ran; the contract check could not run (RAISES, DEP_MISSING or TIMEOUT)
microsoft/voxelpose-pytorch/lib/models/multi_person_posenet.py
code served (permissive licence) · get_code("6b380ea1a8788e2f")
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
import numpy as np

torch.manual_seed(0)

# Create a small camera dictionary with all required parameters
camera = {
    'R': np.eye(3, dtype=np.float32),  # 3x3 identity rotation matrix
    'T': np.array([[0.0], [0.0], [0.5]], dtype=np.float32),  # 3x1 translation
    'fx': 500.0,  # focal length x
    'fy': 500.0,  # focal length y
    'cx': 320.0,  # principal point x
    'cy': 240.0,  # principal point y
    'k': np.array([[0.1], [0.01], [0.001]], dtype=np.float32),  # 3x1 radial distortion
    'p': np.array([[0.001], [0.0005]], dtype=np.float32),  # 2x1 tangential distortion
}

# Create a small batch of 3D points in world coordinates (2 points, 3D)
x = torch.tensor([
    [1.0, 2.0, 5.0],
    [0.5, -1.0, 4.0]
], dtype=torch.float32)

ARGS = {
    'x': x,
    'camera': camera,
}
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 (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
unfold_camera_param Ran
ran; our contract draft was wrong, not the code
microsoft/voxelpose-pytorch/lib/models/multi_person_posenet.py
code served (permissive licence) · get_code("ad30051ce03d273d")
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 torch

torch.manual_seed(0)

# Construct a valid camera dictionary with all required parameters
camera = {
    'R': torch.eye(3).numpy(),  # 3x3 rotation matrix
    'T': torch.randn(3, 1).numpy(),  # 3x1 translation vector
    'fx': 500.0,  # focal length x
    'fy': 500.0,  # focal length y
    'cx': 320.0,  # principal point x
    'cy': 240.0,  # principal point y
    'k': torch.randn(4).numpy(),  # 4 distortion coefficients (k1, k2, k3, k4)
    'p': torch.randn(2).numpy(),  # 2 tangential distortion coefficients (p1, p2)
}

ARGS = {
    'camera': camera,
    'device': None,
}
Setup block drafted by
a language model, Claude Haiku 4.5, prompt python_fixture_v1, through the batch API
Imports
torch — import names as written, not package names to install; a name the repository itself provides is not a package
Returned
type 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
CuboidProposalNet Not yet run
unverified (harvested, no recorded run)
microsoft/voxelpose-pytorch/lib/models/multi_person_posenet.py
code served (permissive licence) · get_code("238c684df17d3359")
How it ran

no invocation recorded.

MultiPersonPoseNet Not yet run
unverified (harvested, no recorded run)
microsoft/voxelpose-pytorch/lib/models/multi_person_posenet.py
code served (permissive licence) · get_code("b5635deb75d47f46")
How it ran

no invocation recorded.

PoseRegressionNet Not yet run
unverified (harvested, no recorded run)
microsoft/voxelpose-pytorch/lib/models/multi_person_posenet.py
code served (permissive licence) · get_code("c3f2cff95d086457")
How it ran

no invocation recorded.

Also present in other papers' code

Of 22 samples lifted from this paper's linked repositories, 22 carry a function identity and 0 do not. Of the 22 distinct functions with an identity, 1 are also present in other papers whose code we hold (1 with at least one paper dated earlier, 0 the same month, 1 later) and 21 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
get_dir
brick of this paper's assembly: helper
7 other papers
4 dated earlier, 3 later · 1 only as an assembly brick
1906.07155 (2019-06)
MMDetection: Open MMLab Detection Toolbox and Benchmark
1908.07919 (2019-08)
Deep High-Resolution Representation Learning for Visual Recognition
2105.04154 (2021-05)
Unsupervised Human Pose Estimation through Transforming Shape Templates
and 4 more not named here

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

This paper studies the task of estimating the 3D human poses of multiple persons from multiple calibrated camera views. Following the top-down paradigm, we decompose the task into two stages, i.e. person localization and pose estimation. Both stages are processed in coarse-to-fine manners. And we propose three task-specific graph neural networks for effective message passing. For 3D person localization, we first use Multi-view Matching Graph Module (MMG) to learn the cross-view association and recover coarse human proposals. The Center Refinement Graph Module (CRG) further refines the results via flexible pointbased prediction. For 3D pose estimation, the Pose Regression Graph Module (PRG) learns both the multi-view geometry and structural relations between human joints. Our approach achieves state-of-the-art performance on CMU Panoptic and Shelf datasets with significantly lower computation complexity.

For agents

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

get_harvested_code_for_paper("2109.05885")
get_code_for_paper("2109.05885")
have("2109.05885")

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

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

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

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

Connect an agent — have() is free.