SYNTOLOGY HomeExplorerAtlasCodeMethodologyAboutDevelopersFeedPricing
Paper · 2203.07628 · ECCV · 2022

P-STMO: Pre-Trained Spatial Temporal Many-to-One Model for 3D Human Pose Estimation

Siwei Ma, Zhenhua Liu, Wen Gao, Xinfeng Zhang, Wenkang Shan, Shanshe Wang

arXiv · PDF · Open in the Atlas

Code that ran

9 of 11 samples (functions and classes) lifted from this paper's linked repositories executed on a synthesized input in Syntology's jail (6 of them constructed an object rather than computing a result; 0 honoured the contract we drafted, 0 violated it and 7 have no contract verdict; 2 failures of our instrument; 2 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.07628.json · badge: /api/ran/2203.07628.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
paTRICK-swk/P-STMO community
Papers with Code archive
8 ran · 2 no recorded run
copy not recorded community
not in the paper's declared repositories
1 ran · 0 no recorded run
FunctionStatusWhere it lives
Encoder Ran
ran on a synthesized input · constructed an object; no result was computed
paTRICK-swk/P-STMO/model/stmo_pretrain.py
code served (permissive licence) · get_code("1aaaa9db258f9346")
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, Encoder: 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 copy

torch.manual_seed(0)

class LayerNorm(nn.Module):

    def __init__(self, features, eps=1e-06):
        super(LayerNorm, self).__init__()
        self.a_2 = nn.Parameter(torch.ones(features))
        self.b_2 = nn.Parameter(torch.zeros(features))
        self.eps = eps

    def forward(self, x):
        mean = x.mean(-1, keepdim=True)
        std = x.std(-1, keepdim=True)
        return self.a_2 * (x - mean) / (std + self.eps) + self.b_2

def clones(module, N):
    return nn.ModuleList([copy.deepcopy(module) for _ in range(N)])

class Encoder(nn.Module):

    def __init__(self, layer, N):
        super(Encoder, self).__init__()
        self.layers = clones(layer, N)
        self.norm = LayerNorm(layer.size)

    def forward(self, x, mask):
        for layer in self.layers:
            x = layer(x, mask)
        return x

class MockEncoderLayer(nn.Module):
    def __init__(self, size):
        super(MockEncoderLayer, self).__init__()
        self.size = size
    
    def forward(self, x, mask):
        return x

# Create a mock encoder layer with size=4
layer = MockEncoderLayer(size=4)

# Number of layers
N = 2

ARGS = {
    'layer': layer,
    'N': N
}
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 Encoder — 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 Encoder 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
EncoderLayer Ran
ran on a synthesized input · constructed an object; no result was computed
paTRICK-swk/P-STMO/model/stmo_pretrain.py
code served (permissive licence) · get_code("1e31c11931ce7561")
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, EncoderLayer: 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 copy

torch.manual_seed(0)

class LayerNorm(nn.Module):

    def __init__(self, features, eps=1e-06):
        super(LayerNorm, self).__init__()
        self.a_2 = nn.Parameter(torch.ones(features))
        self.b_2 = nn.Parameter(torch.zeros(features))
        self.eps = eps

    def forward(self, x):
        mean = x.mean(-1, keepdim=True)
        std = x.std(-1, keepdim=True)
        return self.a_2 * (x - mean) / (std + self.eps) + self.b_2

class SublayerConnection(nn.Module):

    def __init__(self, size, dropout):
        super(SublayerConnection, self).__init__()
        self.norm = LayerNorm(size)
        self.dropout = nn.Dropout(dropout)

    def forward(self, x, sublayer):
        return x + self.dropout(sublayer(self.norm(x)))

def clones(module, N):
    return nn.ModuleList([copy.deepcopy(module) for _ in range(N)])

class EncoderLayer(nn.Module):

    def __init__(self, size, self_attn, feed_forward, dropout):
        super(EncoderLayer, self).__init__()
        self.self_attn = self_attn
        self.feed_forward = feed_forward
        self.sublayer = clones(SublayerConnection(size, dropout), 2)
        self.size = size

    def forward(self, x, mask):
        x = self.sublayer[0](x, lambda x: self.self_attn(x, x, x, mask))
        return self.sublayer[1](x, self.feed_forward)

class MockSelfAttention(nn.Module):
    def __init__(self, size):
        super(MockSelfAttention, self).__init__()
        self.size = size
    
    def forward(self, q, k, v, mask):
        return v

class MockFeedForward(nn.Module):
    def __init__(self, size):
        super(MockFeedForward, self).__init__()
        self.linear = nn.Linear(size, size)
    
    def forward(self, x):
        return self.linear(x)

size = 4
self_attn = MockSelfAttention(size)
feed_forward = MockFeedForward(size)
dropout = 0.1

ARGS = {
    'size': size,
    'self_attn': self_attn,
    'feed_forward': feed_forward,
    '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 EncoderLayer — 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 EncoderLayer 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
FCBlock Ran
ran on a synthesized input · constructed an object; no result was computed
paTRICK-swk/P-STMO/model/stmo_pretrain.py
code served (permissive licence) · get_code("3dd75f638909b681")
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, FCBlock: 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 = {
    'channel_in': 4,
    'channel_out': 5,
    'linear_size': 6,
    'block_num': 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 FCBlock — 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 FCBlock 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
Linear Ran
ran on a synthesized input · constructed an object; no result was computed
paTRICK-swk/P-STMO/model/stmo_pretrain.py
code served (permissive licence) · get_code("106e2299d93b5ed7")
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, Linear: 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 = {
    'linear_size': 4,
    'p_dropout': 0.25,
}

# Create an instance to verify it works
model = nn.Module.__new__(nn.Module)
model.__class__ = type('Linear', (nn.Module,), {
    '__init__': lambda self, linear_size, p_dropout=0.25: (
        nn.Module.__init__(self),
        setattr(self, 'l_size', linear_size),
        setattr(self, 'relu', nn.LeakyReLU(0.2, inplace=True)),
        setattr(self, 'dropout', nn.Dropout(p_dropout)),
        setattr(self, 'w1', nn.Conv1d(linear_size, linear_size, kernel_size=1)),
        setattr(self, 'batch_norm1', nn.BatchNorm1d(linear_size)),
        setattr(self, 'w2', nn.Conv1d(linear_size, linear_size, kernel_size=1)),
        setattr(self, 'batch_norm2', nn.BatchNorm1d(linear_size)),
    )[-1],
    'forward': lambda self, x: (
        lambda y: (
            lambda y: (
                lambda y: (
                    lambda y: (
                        lambda y: (
                            lambda y: (
                                lambda y: (x + y)
                            )(self.dropout(y))
                        )(self.relu(y))
                    )(self.batch_norm2(y))
                )(self.w2(y))
            )(self.dropout(y))
        )(self.relu(y))
    )(self.batch_norm1(self.w1(x)))
})

linear_size = ARGS['linear_size']
p_dropout = ARGS['p_dropout']

module = nn.Module.__new__(nn.Module)
module.__class__ = type('Linear', (nn.Module,), {
    '__init__': lambda self, linear_size, p_dropout=0.25: (
        nn.Module.__init__(self),
        setattr(self, 'l_size', linear_size),
        setattr(self, 'relu', nn.LeakyReLU(0.2, inplace=True)),
        setattr(self, 'dropout', nn.Dropout(p_dropout)),
        setattr(self, 'w1', nn.Conv1d(linear_size, linear_size, kernel_size=1)),
        setattr(self, 'batch_norm1', nn.BatchNorm1d(linear_size)),
        setattr(self, 'w2', nn.Conv1d(linear_size, linear_size, kernel_size=1)),
        setattr(self, 'batch_norm2', nn.BatchNorm1d(linear_size)),
    )[-1],
    'forward': lambda self, x: (
        lambda y: (
            lambda y: (
                lambda y: (
                    lambda y: (
                        lambda y: (
                            lambda y: (
                                lambda y: (x + y)
                            )(self.dropout(y))
                        )(self.relu(y))
                    )(self.batch_norm2(y))
                )(self.w2(y))
            )(self.dropout(y))
        )(self.relu(y))
    )(self.batch_norm1(self.w1(x)))
})

module.__init__(linear_size, p_dropout)

x_test = torch.randn(2, 4, 3)
output = module.forward(x_test)
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 Linear — 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 Linear 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
MultiHeadedAttention Ran
ran on a synthesized input · constructed an object; no result was computed
paTRICK-swk/P-STMO/model/stmo_pretrain.py
code served (permissive licence) · get_code("9bc6abc38072722f")
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, MultiHeadedAttention: 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 copy

torch.manual_seed(0)

# Define the helper functions and class from the provided code
def attention(query, key, value, mask=None, dropout=None):
    d_k = query.size(-1)
    scores = torch.matmul(query, key.transpose(-2, -1)) / math.sqrt(d_k)
    if mask is not None:
        scores = scores.masked_fill(mask == 0, -1000000000.0)
    p_attn = torch.nn.functional.softmax(scores, dim=-1)
    if dropout is not None:
        p_attn = dropout(p_attn)
    return (torch.matmul(p_attn, value), p_attn)

def clones(module, N):
    return nn.ModuleList([copy.deepcopy(module) for _ in range(N)])

class MultiHeadedAttention(nn.Module):

    def __init__(self, h, d_model, dropout=0.1):
        super(MultiHeadedAttention, self).__init__()
        assert d_model % h == 0
        self.d_k = d_model // h
        self.h = h
        self.linears = clones(nn.Linear(d_model, d_model), 4)
        self.attn = None
        self.dropout = nn.Dropout(p=dropout)

    def forward(self, query, key, value, mask=None):
        if mask is not None:
            mask = mask.unsqueeze(1)
        nbatches = query.size(0)
        query, key, value = [l(x).view(nbatches, -1, self.h, self.d_k).transpose(1, 2) for l, x in zip(self.linears, (query, key, value))]
        x, self.attn = attention(query, key, value, mask=mask, dropout=self.dropout)
        x = x.transpose(1, 2).contiguous().view(nbatches, -1, self.h * self.d_k)
        return self.linears[-1](x)

# Prepare test inputs
batch_size = 2
seq_len = 3
d_model = 4
h = 2

query = torch.randn(batch_size, seq_len, d_model)
key = torch.randn(batch_size, seq_len, d_model)
value = torch.randn(batch_size, seq_len, d_model)
mask = torch.ones(batch_size, seq_len, seq_len)

ARGS = {
    "h": 2,
    "d_model": 4,
    "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 MultiHeadedAttention — 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 MultiHeadedAttention 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
PositionwiseFeedForward Ran
ran on a synthesized input
paTRICK-swk/P-STMO/model/stmo_pretrain.py
code served (permissive licence) · get_code("cb80183aeec842d5")
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 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

INIT_ARGS = {
    'd_model': 4,
    'd_ff': 8,
    'dropout': 0.1
}

ARGS = {
    'x': torch.randn(2, 4)
}

if __name__ == '__main__':
    model = nn.Module()
    model.__class__ = type('PositionwiseFeedForward', (nn.Module,), {
        '__init__': lambda self, d_model, d_ff, dropout=0.1: (
            super(type(self), self).__init__(),
            setattr(self, 'w_1', nn.Linear(d_model, d_ff)),
            setattr(self, 'w_2', nn.Linear(d_ff, d_model)),
            setattr(self, 'gelu', nn.ReLU()),
            setattr(self, 'dropout', nn.Dropout(dropout))
        )[-1],
        'forward': lambda self, x: self.w_2(self.dropout(self.gelu(self.w_1(x))))
    })
    
    model = nn.Module()
    
    class PositionwiseFeedForward(nn.Module):
        def __init__(self, d_model, d_ff, dropout=0.1):
            super(PositionwiseFeedForward, self).__init__()
            self.w_1 = nn.Linear(d_model, d_ff)
            self.w_2 = nn.Linear(d_ff, d_model)
            self.gelu = nn.ReLU()
            self.dropout = nn.Dropout(dropout)

        def forward(self, x):
            return self.w_2(self.dropout(self.gelu(self.w_1(x))))
    
    model = PositionwiseFeedForward(**INIT_ARGS)
    output = model(**ARGS)
    print(f"Output shape: {output.shape}")
    print(f"Output: {output}")
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 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: torch and numpy seeded to 0 by the harness immediately before the class was constructed from INIT_ARGS (fixture_check.py)
Transformer Ran
ran on a synthesized input · constructed an object; no result was computed
paTRICK-swk/P-STMO/model/stmo_pretrain.py
code served (permissive licence) · get_code("56c8855e69bdbfe5")
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, Transformer: 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 copy

torch.manual_seed(0)

# Define ARGS dict with all parameters for Transformer.__init__
ARGS = {
    'n_layers': 2,
    'd_model': 16,
    'd_ff': 32,
    'h': 4,
    'dropout': 0.1,
    'length': 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 Transformer — 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 Transformer 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
attention Ran
ran; our contract draft was wrong, not the code
paTRICK-swk/P-STMO/model/stmo_pretrain.py
code served (permissive licence) · get_code("cbe07626e47b77c3")
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) 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 as nn
import torch.nn.functional as F
import math

torch.manual_seed(0)

# Create small tensors for query, key, value
# Using distinct dimensions: batch=2, seq_len=3, d_k=4
batch_size = 2
seq_len = 3
d_k = 4

query = torch.randn(batch_size, seq_len, d_k)
key = torch.randn(batch_size, seq_len, d_k)
value = torch.randn(batch_size, seq_len, d_k)

# Create a mask (optional parameter)
# mask should be broadcastable to scores shape (batch, seq_len, seq_len)
mask = torch.ones(batch_size, seq_len, seq_len)

# Create a dropout layer (optional parameter)
# The function calls dropout(p_attn), so it needs to be callable
dropout = nn.Dropout(p=0.1)

ARGS = {
    "query": query,
    "key": key,
    "value": value,
    "mask": mask,
    "dropout": dropout
}
Setup block drafted by
a language model, Claude Haiku 4.5, prompt python_fixture_v1
Imports
torch — import names as written, not package names to install; a name the repository itself provides is not a package
Returned
type 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
clones Ran
ran; our contract draft was wrong, not the code
this paper's copy was not recorded; identical code first harvested from yonilc/ecct
pointer only · get_code("d2d810cddae9f875")
How it ran

The body of this sample is withheld: this paper's copy of the code was not recorded (its link names no repository or source path), so no licence was read for it. The setup block that called it is withheld with it, because it is written against that body. source_path and origin say where the code lives, to read under the repository's own terms. A run is recorded.

Model_MAE Not yet run
unverified (harvested, no recorded run)
paTRICK-swk/P-STMO/model/stmo_pretrain.py
code served (permissive licence) · get_code("75538e6a2c58ef23")
How it ran

no invocation recorded.

Transformer_dec Not yet run
unverified (harvested, no recorded run)
paTRICK-swk/P-STMO/model/stmo_pretrain.py
code served (permissive licence) · get_code("a135de1a158f5ac6")
How it ran

no invocation recorded.

Also present in other papers' code

Of 11 samples lifted from this paper's linked repositories, 11 carry a function identity and 0 do not. Of the 11 distinct functions with an identity, 4 are also present in other papers whose code we hold (4 with at least one paper dated earlier, 2 the same month, 4 later) and 7 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
clones
brick of this paper's assembly: helper
79 other papers
40 dated earlier, 4 the same month, 35 later · 11 only as an assembly brick
1411.4555 (2014-11)
Show and Tell: A Neural Image Caption Generator
1612.00563 (2016-12)
Self-critical Sequence Training for Image Captioning
1706.03762 (2017-06)
Attention Is All You Need
and 76 more not named here
attention
brick of this paper's assembly: helper
27 other papers
16 dated earlier, 1 the same month, 10 later
1411.4555 (2014-11)
Show and Tell: A Neural Image Caption Generator
1609.08144 (2016-09)
Google's Neural Machine Translation System: Bridging the Gap between Human and Machine Translation
1612.00563 (2016-12)
Self-critical Sequence Training for Image Captioning
and 24 more not named here
EncoderLayer
brick of this paper's assembly: helper
3 other papers
2 dated earlier, 1 later · 1 only as an assembly brick
1706.03762 (2017-06)
Attention Is All You Need
2103.04256 (2021-03)
Robust Point Cloud Registration Framework Based on Deep Graph Matching
2404.13478 (2024-04)
Deep SE(3)-Equivariant Geometric Reasoning for Precise Placement Tasks
MultiHeadedAttention
brick of this paper's assembly: model
3 other papers
2 dated earlier, 1 later
1706.03762 (2017-06)
Attention Is All You Need
2010.16056 (2020-10)
Generating Radiology Reports via Memory-driven Transformer
2411.07527 (2024-11)
Prompt-enhanced Network for Hateful Meme Classification

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 introduces a novel Pre-trained Spatial Temporal Many-to-One (P-STMO) model for 2D-to-3D human pose estimation task. To reduce the difficulty of capturing spatial and temporal information, we divide this task into two stages: pre-training (Stage I) and fine-tuning (Stage II). In Stage I, a self-supervised pre-training sub-task, termed masked pose modeling, is proposed. The human joints in the input sequence are randomly masked in both spatial and temporal domains. A general form of denoising auto-encoder is exploited to recover the original 2D poses and the encoder is capable of capturing spatial and temporal dependencies in this way. In Stage II, the pre-trained encoder is loaded to STMO model and fine-tuned. The encoder is followed by a many-to-one frame aggregator to predict the 3D pose in the current frame. Especially, an MLP block is utilized as the spatial feature extractor in STMO, which yields better performance than other methods. In addition, a temporal downsampling strategy is proposed to diminish data redundancy. Extensive experiments on two benchmarks show that our method outperforms state-of-the-art methods with fewer parameters and less computational overhead. For example, our P-STMO model achieves 42.1mm MPJPE on Human3.6M dataset when using 2D poses from CPN as inputs. Meanwhile, it brings a 1.5-7.1× speedup to state-of-the-art methods. Code is available at https://github.com/paTRICK-swk/P-STMO.

For agents

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

get_harvested_code_for_paper("2203.07628")
get_code_for_paper("2203.07628")
have("2203.07628")

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

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

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

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

Connect an agent — have() is free.