SYNTOLOGY HomeExplorerAtlasCodeMethodologyAboutDevelopersFeedPricing
Paper · 1706.02413 · 2017

PointNet++: Deep Hierarchical Feature Learning on Point Sets in a Metric Space

Charles Li, Yi Hao, Su Leonidas, J Guibas

arXiv · PDF · Open in the Atlas

Code that ran

36 of 67 samples (functions and classes) lifted from this paper's linked repositories executed on a synthesized input in Syntology's jail (31 of them constructed an object rather than computing a result; 0 honoured the contract we drafted, 0 violated it and 33 have no contract verdict; 3 failures of our instrument; 31 no recorded run), measured 2026-11-21; 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/1706.02413.json · badge: /api/ran/1706.02413.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
zyang-ur/SAT community
not in the paper's declared repositories
10 ran · 3 no recorded run
referit3d/referit3d community
not in the paper's declared repositories
8 ran · 4 no recorded run
tao-tao-tao-tao-tao/diffusion_suction community
not in the paper's declared repositories
6 ran · 4 no recorded run
hoangcuongbk80/VoteGrasp community
Papers with Code archive
2 ran · 3 no recorded run
Ghailen-Ben-Achour/PointNet2_Segmentation community
Papers with Code archive
2 ran · 1 no recorded run
yanx27/Pointnet_Pointnet2_pytorch community
not in the paper's declared repositories
2 ran · 0 no recorded run
AsahiLiu/PointDetectron community
Papers with Code archive
1 ran · 2 no recorded run
zaiweizhang/H3DNet community
not in the paper's declared repositories
1 ran · 2 no recorded run
asalarpour/Point_GN community
Papers with Code archive
1 ran · 2 no recorded run
curryyuan/x-trans2cap community
Papers with Code archive
1 ran · 1 no recorded run
nickgkan/butd_detr community
not in the paper's declared repositories
1 ran · 1 no recorded run
zhh6425/LocalContextPropagation community
not in the paper's declared repositories
1 ran · 1 no recorded run
dfki-av/mikasa-3dvg community
Papers with Code archive
0 ran · 2 no recorded run
sshaoshuai/Pointnet2.PyTorch community
not in the paper's declared repositories
0 ran · 2 no recorded run
thu17cyz/3DIoUMatch community
not in the paper's declared repositories
0 ran · 1 no recorded run
Harut0726/votenet community
Papers with Code archive
0 ran · 1 no recorded run
dgriffiths3/pointnet2-tensorflow2 community
Papers with Code archive
0 ran · 1 no recorded run
FunctionStatusWhere it lives
BallQuery Ran
ran on a synthesized input · constructed an object; no result was computed
zyang-ur/SAT/referit3d/external_tools/pointnet2/pointnet2_modules.py
code served (permissive licence) · get_code("fb26ce705d6a2cb9")
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, BallQuery: 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
from unittest.mock import MagicMock

torch.manual_seed(0)

# Mock the _ext module since ball_query is a C++ extension
import sys
from unittest.mock import MagicMock

_ext = MagicMock()
# Mock the ball_query function to return a tensor of shape (B, npoint, nsample)
_ext.ball_query = MagicMock(return_value=torch.zeros((2, 3, 5), dtype=torch.int64))

# Inject mock into the module namespace
sys.modules['_ext'] = _ext

# Define parameters for BallQuery.forward()
radius = 0.5
nsample = 5
xyz = torch.randn(2, 4, 3)  # (B=2, N=4, 3)
new_xyz = torch.randn(2, 3, 3)  # (B=2, npoint=3, 3)

ARGS = {
    'radius': radius,
    'nsample': nsample,
    'xyz': xyz,
    'new_xyz': new_xyz
}
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 BallQuery — 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 BallQuery 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
BallQuery Ran
ran on a synthesized input · constructed an object; no result was computed
hoangcuongbk80/VoteGrasp/pointnet2/pointnet2_modules.py
pointer only (licence: NONE) · get_code("fdd72fc42b06427f")
How it ran

The body of this sample is withheld: GitHub detected no licence in this paper's repository, hoangcuongbk80/VoteGrasp when it was checked. 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.

BatchNorm2d Ran
ran on a synthesized input · constructed an object; no result was computed
zyang-ur/SAT/referit3d/external_tools/pointnet2/pointnet2_modules.py
code served (permissive licence) · get_code("1eb36d9951cd4e0a")
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, BatchNorm2d: 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_size': 16,
    'name': '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 BatchNorm2d — 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 BatchNorm2d output the recorded ndim 1 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
BatchNorm2d Ran
ran on a synthesized input · constructed an object; no result was computed
referit3d/referit3d/referit3d/models/backbone/point_net_pp.py
code served (permissive licence) · get_code("f9032ebfafd355b4")
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, BatchNorm2d: 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 BatchNorm2d class takes in_size and name as parameters
# in_size: int - the number of input channels
# name: str - a prefix for the module name (default '')

ARGS = {
    'in_size': 16,
    'name': '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 BatchNorm2d — 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 BatchNorm2d output the recorded ndim 1 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
Conv2d Ran
ran on a synthesized input · constructed an object; no result was computed
zyang-ur/SAT/referit3d/external_tools/pointnet2/pointnet2_modules.py
code served (permissive licence) · get_code("196a75317b3cf7d1")
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, Conv2d: 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_size': 3,
    'out_size': 16,
    'kernel_size': (3, 3),
    'stride': (1, 1),
    'padding': (1, 1),
    'activation': nn.ReLU(inplace=True),
    'bn': False,
    'init': nn.init.kaiming_normal_,
    'bias': True,
    'preact': False,
    'name': 'conv_'
}
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 Conv2d — 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 Conv2d output the recorded ndim 1 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
Conv2d Ran
ran on a synthesized input · constructed an object; no result was computed
tao-tao-tao-tao-tao/diffusion_suction/train/models/backbone2/pointnet2/pointnet2_backbone.py
pointer only (licence: NONE) · get_code("13cd8bfa92565fb3")
How it ran

The body of this sample is withheld: GitHub detected no licence in this paper's repository, tao-tao-tao-tao-tao/diffusion_suction when it was checked. 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.

Conv2d Ran
ran on a synthesized input · constructed an object; no result was computed
referit3d/referit3d/referit3d/models/backbone/point_net_pp.py
code served (permissive licence) · get_code("11786f1c29af0e47")
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, Conv2d: 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
from typing import Tuple

torch.manual_seed(0)

# Define ARGS dict with all parameters for Conv2d.__init__
ARGS = {
    'in_size': 3,
    'out_size': 16,
    'kernel_size': (3, 3),
    'stride': (1, 1),
    'padding': (1, 1),
    'activation': nn.ReLU(inplace=True),
    'bn': False,
    'init': nn.init.kaiming_normal_,
    'bias': True,
    'preact': False,
    'name': 'test_conv_'
}
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 Conv2d — 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 Conv2d output the recorded ndim 1 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
FurthestPointSampling Ran
ran on a synthesized input · constructed an object; no result was computed
zyang-ur/SAT/referit3d/external_tools/pointnet2/pointnet2_modules.py
code served (permissive licence) · get_code("f038cc7c8955a963")
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, FurthestPointSampling: 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)

# Create a mock _ext module that has the furthest_point_sampling function
class MockExt:
    @staticmethod
    def furthest_point_sampling(xyz, npoint):
        """Mock implementation of furthest point sampling"""
        B, N, _ = xyz.shape
        # Return a tensor of shape (B, npoint) with valid indices
        return torch.randint(0, N, (B, npoint))

# Inject the mock into the module namespace
import sys
from types import ModuleType
_ext = MockExt()

# Create valid arguments
xyz = torch.randn(2, 4, 3)  # (B=2, N=4, 3) - batch of 2, 4 points, 3D coordinates
npoint = 2  # int32 - sample 2 points (less than N=4)

ARGS = {
    "xyz": xyz,
    "npoint": npoint,
}
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 FurthestPointSampling — 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 FurthestPointSampling 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
FurthestPointSampling Ran
ran on a synthesized input · constructed an object; no result was computed
hoangcuongbk80/VoteGrasp/pointnet2/pointnet2_modules.py
pointer only (licence: NONE) · get_code("018e0e61ae702455")
How it ran

The body of this sample is withheld: GitHub detected no licence in this paper's repository, hoangcuongbk80/VoteGrasp when it was checked. 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.

GatherOperation Ran
ran on a synthesized input · constructed an object; no result was computed
zyang-ur/SAT/referit3d/external_tools/pointnet2/pointnet2_modules.py
code served (permissive licence) · get_code("3c75be14968690dc")
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, GatherOperation: 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
from unittest.mock import MagicMock

torch.manual_seed(0)

# Mock the _ext module since it's a C++ extension that won't be available
_ext = MagicMock()

# Create mock functions that return appropriately shaped tensors
def mock_gather_points(features, idx):
    B, C, npoint = features.size(0), features.size(1), idx.size(1)
    return torch.randn(B, C, npoint)

def mock_gather_points_grad(grad_out, idx, N):
    B, C = grad_out.size(0), grad_out.size(1)
    return torch.randn(B, C, N)

_ext.gather_points = mock_gather_points
_ext.gather_points_grad = mock_gather_points_grad

# Define the GatherOperation class (from the function signature)
from torch.autograd import Function

class GatherOperation(Function):

    @staticmethod
    def forward(ctx, features, idx):
        """

        Parameters
        ----------
        features : torch.Tensor
            (B, C, N) tensor

        idx : torch.Tensor
            (B, npoint) tensor of the features to gather

        Returns
        -------
        torch.Tensor
            (B, C, npoint) tensor
        """
        _, C, N = features.size()
        ctx.for_backwards = (idx, C, N)
        return _ext.gather_points(features, idx)

    @staticmethod
    def backward(ctx, grad_out):
        idx, C, N = ctx.for_backwards
        grad_features = _ext.gather_points_grad(grad_out.contiguous(), idx, N)
        return (grad_features, None)

# Construct valid arguments
B = 2
C = 4
N = 8
npoint = 5

features = torch.randn(B, C, N)
idx = torch.randint(0, N, (B, npoint))

ARGS = {
    'features': features,
    'idx': idx
}
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 GatherOperation — 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 GatherOperation 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
GroupAll Ran
ran on a synthesized input · constructed an object; no result was computed
zyang-ur/SAT/referit3d/external_tools/pointnet2/pointnet2_modules.py
code served (permissive licence) · get_code("994fead02ef5cbd6")
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, GroupAll: 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 GroupAll(nn.Module):
    """
    Groups all features
    Parameters
    ---------
    """

    def __init__(self, use_xyz=True):
        super(GroupAll, self).__init__()
        self.use_xyz = use_xyz

    def forward(self, xyz, new_xyz, features=None):
        """
        Parameters
        ----------
        xyz : torch.Tensor
            xyz coordinates of the features (B, N, 3)
        new_xyz : torch.Tensor
            Ignored
        features : torch.Tensor
            Descriptors of the features (B, C, N)

        Returns
        -------
        new_features : torch.Tensor
            (B, C + 3, 1, N) tensor
        """
        grouped_xyz = xyz.transpose(1, 2).unsqueeze(2)
        if features is not None:
            grouped_features = features.unsqueeze(2)
            if self.use_xyz:
                new_features = torch.cat([grouped_xyz, grouped_features], dim=1)
            else:
                new_features = grouped_features
        else:
            new_features = grouped_xyz
        return new_features


# Create test tensors
batch_size = 2
num_points = 4
feature_dim = 5

xyz = torch.randn(batch_size, num_points, 3)
new_xyz = torch.randn(batch_size, num_points, 3)
features = torch.randn(batch_size, feature_dim, num_points)

ARGS = {
    "use_xyz": True,
}
Setup block drafted by
a language model, Claude Haiku 4.5, prompt python_fixture_v1, through the batch API
Imports
torch — import names as written, not package names to install; a name the repository itself provides is not a package
Returned
type GroupAll — 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 GroupAll 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
GroupAll Ran
ran on a synthesized input · constructed an object; no result was computed
tao-tao-tao-tao-tao/diffusion_suction/train/models/backbone2/pointnet2/pointnet2_backbone.py
pointer only (licence: NONE) · get_code("bdb62dc3b4da8637")
How it ran

The body of this sample is withheld: GitHub detected no licence in this paper's repository, tao-tao-tao-tao-tao/diffusion_suction when it was checked. 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.

GroupAll Ran
ran on a synthesized input · constructed an object; no result was computed
curryyuan/x-trans2cap/lib/pointnet2/pointnet2_modules.py
code served (permissive licence) · get_code("445cffa437113b80")
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, GroupAll: 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 GroupAll(nn.Module):
    """
    Groups all features

    Parameters
    ---------
    """

    def __init__(self, use_xyz=True, ret_grouped_xyz=False):
        super(GroupAll, self).__init__()
        self.use_xyz = use_xyz
        self.ret_grouped_xyz = ret_grouped_xyz

    def forward(self, xyz, new_xyz, features=None):
        """
        Parameters
        ----------
        xyz : torch.Tensor
            xyz coordinates of the features (B, N, 3)
        new_xyz : torch.Tensor
            Ignored
        features : torch.Tensor
            Descriptors of the features (B, C, N)

        Returns
        -------
        new_features : torch.Tensor
            (B, C + 3, 1, N) tensor
        """
        grouped_xyz = xyz.transpose(1, 2).unsqueeze(2)
        if features is not None:
            grouped_features = features.unsqueeze(2)
            if self.use_xyz:
                new_features = torch.cat([grouped_xyz, grouped_features], dim=1)
            else:
                new_features = grouped_features
        else:
            new_features = grouped_xyz
        if self.ret_grouped_xyz:
            return (new_features, grouped_xyz)
        else:
            return new_features


# Construct test data
batch_size = 2
num_points = 4
feature_dim = 5

xyz = torch.randn(batch_size, num_points, 3)
new_xyz = torch.randn(batch_size, 1, 3)
features = torch.randn(batch_size, feature_dim, num_points)

ARGS = {
    "use_xyz": True,
    "ret_grouped_xyz": False,
}
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 GroupAll — 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 GroupAll 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
GroupAll Ran
ran on a synthesized input · constructed an object; no result was computed
referit3d/referit3d/referit3d/models/backbone/point_net_pp.py
code served (permissive licence) · get_code("ff97c3b6610cf824")
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, GroupAll: 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
from torch import nn

torch.manual_seed(0)

class GroupAll(nn.Module):
    """
    Groups all features
    Parameters
    ---------
    """

    def __init__(self, use_xyz=True):
        super(GroupAll, self).__init__()
        self.use_xyz = use_xyz

    def forward(self, xyz, new_xyz, features=None):
        """
        Parameters
        ----------
        xyz : torch.Tensor
            xyz coordinates of the features (B, N, 3)
        new_xyz : torch.Tensor
            Ignored
        features : torch.Tensor
            Descriptors of the features (B, C, N)

        Returns
        -------
        new_features : torch.Tensor
            (B, C + 3, 1, N) tensor
        """
        grouped_xyz = xyz.transpose(1, 2).unsqueeze(2)
        if features is not None:
            grouped_features = features.unsqueeze(2)
            if self.use_xyz:
                new_features = torch.cat([grouped_xyz, grouped_features], dim=1)
            else:
                new_features = grouped_features
        else:
            new_features = grouped_xyz
        return new_features


# Create a GroupAll instance with use_xyz=True
group_all_module = GroupAll(use_xyz=True)

# Create tiny tensors for testing
# xyz: (B=2, N=4, 3)
xyz = torch.randn(2, 4, 3)

# new_xyz: ignored in forward, but required parameter (B=2, N=1, 3)
new_xyz = torch.randn(2, 1, 3)

# features: (B=2, C=5, N=4)
features = torch.randn(2, 5, 4)

ARGS = {
    "use_xyz": True,
}
Setup block drafted by
a language model, Claude Haiku 4.5, prompt python_fixture_v1, through the batch API
Imports
torch — import names as written, not package names to install; a name the repository itself provides is not a package
Returned
type GroupAll — 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 GroupAll 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
GroupAll Ran
ran on a synthesized input
nickgkan/butd_detr/pointnet2/pointnet2_modules.py
pointer only (licence: NOASSERTION) · get_code("b9995eaf8da14955")
How it ran

The body of this sample is withheld: GitHub could not classify the licence of this paper's repository, nickgkan/butd_detr (NOASSERTION). 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.

GroupingOperation Ran
ran on a synthesized input · constructed an object; no result was computed
zyang-ur/SAT/referit3d/external_tools/pointnet2/pointnet2_modules.py
code served (permissive licence) · get_code("4d80a2b4a0fba485")
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, GroupingOperation: 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
from unittest.mock import MagicMock

torch.manual_seed(0)

# Mock the _ext module since it's a compiled C++ extension
_ext = MagicMock()

# Create mock functions that return appropriately shaped tensors
def mock_group_points(features, idx):
    """Mock group_points: (B, C, N) + (B, npoint, nsample) -> (B, C, npoint, nsample)"""
    B, C, N = features.size()
    _, npoint, nsample = idx.size()
    return torch.randn(B, C, npoint, nsample)

def mock_group_points_grad(grad_out, idx, N):
    """Mock group_points_grad: (B, C, npoint, nsample) -> (B, C, N)"""
    B, C, npoint, nsample = grad_out.size()
    return torch.randn(B, C, N)

_ext.group_points = mock_group_points
_ext.group_points_grad = mock_group_points_grad

# Define the inputs for GroupingOperation.forward()
B = 2          # batch size
C = 4          # number of channels
N = 8          # number of points in features
npoint = 3     # number of points to group
nsample = 5    # number of samples per point

# Create features tensor: (B, C, N)
features = torch.randn(B, C, N)

# Create idx tensor: (B, npoint, nsample) with valid indices in range [0, N)
idx = torch.randint(0, N, (B, npoint, nsample))

ARGS = {
    "features": features,
    "idx": idx,
}
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 GroupingOperation — 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 GroupingOperation 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
PointNetSetAbstraction Ran
ran on a synthesized input · constructed an object; no result was computed
yanx27/Pointnet_Pointnet2_pytorch/models/pointnet2_utils.py
code served (permissive licence) · get_code("b7bc001da9322423")
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, PointNetSetAbstraction: 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 = {
    "npoint": 8,
    "radius": 0.5,
    "nsample": 16,
    "in_channel": 3,
    "mlp": [64, 128],
    "group_all": False,
}
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 PointNetSetAbstraction — 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 PointNetSetAbstraction 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
PointNetSetAbstraction Ran
ran on a synthesized input
Ghailen-Ben-Achour/PointNet2_Segmentation/models/pointnet2_cls_ssg.py
code served (permissive licence) · get_code("f66046a728fcaaa4")
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 tuple. The image it ran in was not recorded. The code mentions cuda, and the harness aliases cuda to the CPU for every sample; whether this run needed that is 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 numpy as np

# The class definition is incomplete, so we need to complete it first
class PointNetSetAbstraction(nn.Module):

    def __init__(self, npoint, radius, nsample, in_channel, mlp, group_all):
        super(PointNetSetAbstraction, self).__init__()
        self.npoint = npoint
        self.radius = radius
        self.nsample = nsample
        self.mlp_convs = nn.ModuleList()
        self.mlp_bns = nn.ModuleList()
        last_channel = in_channel
        for out_channel in mlp:
            self.mlp_convs.append(nn.Conv2d(last_channel, out_channel, 1))
            self.mlp_bns.append(nn.BatchNorm2d(out_channel))
            last_channel = out_channel
        self.group_all = group_all

    def forward(self, xyz, points):
        """
        Input:
            xyz: input points position data, [B, C, N]
            points: input points data, [B, D, N]
        Return:
            new_xyz: sampled points position data, [B, C, S]
            new_points_concat: sample points feature data, [B, D', S]
        """
        xyz = xyz.permute(0, 2, 1)
        if points is not None:
            points = points.permute(0, 2, 1)

        if self.group_all:
            new_xyz, new_points = sample_and_group_all(xyz, points)
        else:
            new_xyz, new_points = sample_and_group(self.npoint, self.radius, self.nsample, xyz, points)
        # new_xyz: sampled points position data, [B, npoint, C]
        # new_points: sampled points data, [B, npoint, nsample, C+D]
        new_points = new_points.permute(0, 3, 2, 1) # [B, C+D, nsample,npoint]
        for i, conv in enumerate(self.mlp_convs):
            bn = self.mlp_bns[i]
            new_points =  F.relu(bn(conv(new_points)))

        new_points = torch.max(new_points, 2)[0]
        new_xyz = new_xyz.permute(0, 2, 1)
        return new_xyz, new_points


INIT_ARGS = {
    'npoint': 8,
    'radius': 0.5,
    'nsample': 4,
    'in_channel': 6,  # 3 (xyz normalized) + 3 (original features)
    'mlp': [16, 32],
    'group_all': False
}

# Create input tensors
# xyz: [B, C, N] where C=3 (x, y, z coordinates), N is number of points
# points: [B, D, N] where D is feature dimension
B = 2
N = 16
C = 3
D = 3

xyz_input = torch.randn(B, C, N)
points_input = torch.randn(B, D, N)

ARGS = {
    'xyz': xyz_input,
    'points': points_input
}
Setup block drafted by
a language model, class construct-then-call prompt, model not recorded
Imports
numpy, 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: torch and numpy seeded to 0 by the harness immediately before the class was constructed from INIT_ARGS (fixture_check.py)
PointnetFPModule Ran
ran on a synthesized input · constructed an object; no result was computed
tao-tao-tao-tao-tao/diffusion_suction/train/models/backbone2/pointnet2/pointnet2_backbone.py
pointer only (licence: NONE) · get_code("88a3d7070038a37c")
How it ran

The body of this sample is withheld: GitHub detected no licence in this paper's repository, tao-tao-tao-tao-tao/diffusion_suction when it was checked. 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.

PointnetSAModuleMSG Ran
ran on a synthesized input · constructed an object; no result was computed
referit3d/referit3d/referit3d/models/backbone/point_net_pp.py
code served (permissive licence) · get_code("d53b2e702a829fb0")
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, PointnetSAModuleMSG: 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
from typing import List, Tuple

torch.manual_seed(0)

# Mock the _ext module since it's a C++ extension that won't be available
class MockExt:
    @staticmethod
    def ball_query(new_xyz, xyz, radius, nsample):
        B = new_xyz.shape[0]
        npoint = new_xyz.shape[1]
        return torch.randint(0, xyz.shape[1], (B, npoint, nsample))
    
    @staticmethod
    def furthest_point_sampling(xyz, npoint):
        B = xyz.shape[0]
        return torch.randint(0, xyz.shape[1], (B, npoint))
    
    @staticmethod
    def gather_points(features, idx):
        B, C, N = features.size()
        npoint = idx.size(1)
        return torch.randn(B, C, npoint)
    
    @staticmethod
    def gather_points_grad(grad_out, idx, N):
        B, C, npoint = grad_out.size()
        return torch.randn(B, C, N)
    
    @staticmethod
    def group_points(features, idx):
        B, C, N = features.size()
        _, npoint, nsample = idx.size()
        return torch.randn(B, C, npoint, nsample)
    
    @staticmethod
    def group_points_grad(grad_out, idx, N):
        B, C, npoint, nsample = grad_out.size()
        return torch.randn(B, C, N)

_ext = MockExt()

# Build small stand-in modules for SA layers
class SimplePointNetModule(nn.Module):
    def __init__(self, in_channels, out_channels):
        super().__init__()
        self.mlp = nn.Sequential(
            nn.Linear(in_channels, 32),
            nn.ReLU(),
            nn.Linear(32, out_channels)
        )
    
    def forward(self, xyz, features):
        # Expect features of shape (B, C, N, nsample) or similar
        if features is None:
            return torch.randn(2, 16, 1)
        return torch.randn(2, 16, 1)

class PointnetSAModuleMSG(nn.Module):
    def __init__(self, npoint, radii, nsamples, mlps, use_xyz=True):
        super().__init__()
        self.npoint = npoint
        self.radii = radii
        self.nsamples = nsamples
        self.mlps = nn.ModuleList()
        for mlp_spec in mlps:
            self.mlps.append(SimplePointNetModule(mlp_spec[0], mlp_spec[-1]))
        self.use_xyz = use_xyz
    
    def forward(self, xyz, features):
        # xyz: (B, N, 3)
        # features: (B, C, N) or None
        B, N, _ = xyz.shape
        
        # Simulate FPS
        idx_fps = torch.randint(0, N, (B, self.npoint))
        new_xyz = xyz[torch.arange(B).unsqueeze(1), idx_fps]  # (B, npoint, 3)
        
        # For each radius/nsample pair, do ball query and grouping
        new_features_list = []
        for i, (radius, nsample) in enumerate(zip(self.radii, self.nsamples)):
            # Ball query
            idx_query = torch.randint(0, N, (B, self.npoint, nsample))
            # Group and process
            grouped = torch.randn(B, 16, self.npoint, 1)
            new_features_list.append(grouped)
        
        # Concatenate multi-scale features
        new_features = torch.cat(new_features_list, dim=1)
        return new_xyz, new_features

# Build minimal valid inputs
B = 2
N = 8
npoint = 4
C = 3

xyz = torch.randn(B, N, 3)
features = torch.randn(B, C, N)

radii = [0.1, 0.2]
nsamples = [4, 6]
mlps = [[3 + C, 16, 16], [3 + C, 16, 16]]

ARGS = {
    "npoint": npoint,
    "radii": radii,
    "nsamples": nsamples,
    "mlps": mlps,
    "use_xyz": True,
}
Setup block drafted by
a language model, Claude Haiku 4.5, prompt python_fixture_v1, through the batch API
Imports
torch — import names as written, not package names to install; a name the repository itself provides is not a package
Returned
type PointnetSAModuleMSG — 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 PointnetSAModuleMSG 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
QueryAndGroup Ran
ran on a synthesized input · constructed an object; no result was computed
tao-tao-tao-tao-tao/diffusion_suction/train/models/backbone2/pointnet2/pointnet2_backbone.py
pointer only (licence: NONE) · get_code("32e0c6849f5f0893")
How it ran

The body of this sample is withheld: GitHub detected no licence in this paper's repository, tao-tao-tao-tao-tao/diffusion_suction when it was checked. 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.

QueryAndGroup Ran
ran on a synthesized input · constructed an object; no result was computed
AsahiLiu/PointDetectron/pointnet2/pointnet2_modules.py
code served (permissive licence) · get_code("6023143b3d4c2b8e")
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, QueryAndGroup: 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)

# Create mock _ext module since the real one requires CUDA compilation
class MockExt:
    @staticmethod
    def ball_query(new_xyz, xyz, radius, nsample):
        """Mock ball_query that returns random indices"""
        B, npoint, _ = new_xyz.shape
        B, N, _ = xyz.shape
        return torch.randint(0, N, (B, npoint, nsample), dtype=torch.int32)
    
    @staticmethod
    def group_points(features, idx):
        """Mock group_points that groups features by indices"""
        B, C, N = features.shape
        B, npoint, nsample = idx.shape
        # Return grouped features of shape (B, C, npoint, nsample)
        grouped = torch.zeros(B, C, npoint, nsample)
        for b in range(B):
            for c in range(C):
                for p in range(npoint):
                    for s in range(nsample):
                        idx_val = min(idx[b, p, s].item(), N - 1)
                        grouped[b, c, p, s] = features[b, c, idx_val]
        return grouped
    
    @staticmethod
    def group_points_grad(grad_out, idx, N):
        """Mock group_points_grad"""
        B, C, npoint, nsample = grad_out.shape
        return torch.zeros(B, C, N)

_ext = MockExt()

# Define ARGS dictionary with all parameters for QueryAndGroup
ARGS = {
    "radius": 0.5,
    "nsample": 4,
    "use_xyz": True,
    "ret_grouped_xyz": False,
    "normalize_xyz": False,
    "sample_uniformly": False,
    "ret_unique_cnt": False,
    "dilation": 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 QueryAndGroup — 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 QueryAndGroup 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
QueryAndGroup Ran
ran on a synthesized input · constructed an object; no result was computed
referit3d/referit3d/referit3d/models/backbone/point_net_pp.py
code served (permissive licence) · get_code("87a6f4d31460171e")
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, QueryAndGroup: 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)

# Mock the _ext module since it's a C++ extension that won't be available
class MockExt:
    @staticmethod
    def ball_query(new_xyz, xyz, radius, nsample):
        B, npoint, _ = new_xyz.shape
        _, N, _ = xyz.shape
        return torch.randint(0, N, (B, npoint, nsample), dtype=torch.long)
    
    @staticmethod
    def group_points(features, idx):
        B, C, N = features.shape
        _, npoint, nsample = idx.shape
        return torch.randn(B, C, npoint, nsample)
    
    @staticmethod
    def group_points_grad(grad_out, idx, N):
        B, C, npoint, nsample = grad_out.shape
        return torch.randn(B, C, N)

# Inject mock extension
import sys
mock_ext = MockExt()
sys.modules['_ext'] = type(sys)('_ext')
sys.modules['_ext']._ext = mock_ext

# Now we can define _ext for the module
_ext = mock_ext

# Redefine the classes with the mock in place
from torch import nn, Tensor
import torch
from torch.autograd import Function

class BallQuery(Function):
    @staticmethod
    def forward(ctx, radius, nsample, xyz, new_xyz):
        return _ext.ball_query(new_xyz, xyz, radius, nsample)

    @staticmethod
    def backward(ctx, a=None):
        return (None, None, None, None)

class GroupingOperation(Function):
    @staticmethod
    def forward(ctx, features, idx):
        B, nfeatures, nsample = idx.size()
        _, C, N = features.size()
        ctx.for_backwards = (idx, N)
        return _ext.group_points(features, idx)

    @staticmethod
    def backward(ctx, grad_out):
        idx, N = ctx.for_backwards
        grad_features = _ext.group_points_grad(grad_out.contiguous(), idx, N)
        return (grad_features, None)

ball_query = BallQuery.apply
grouping_operation = GroupingOperation.apply

class QueryAndGroup(nn.Module):
    def __init__(self, radius, nsample, use_xyz=True, ret_grouped_xyz=False, normalize_xyz=False, sample_uniformly=False, ret_unique_cnt=False):
        super(QueryAndGroup, self).__init__()
        self.radius, self.nsample, self.use_xyz = (radius, nsample, use_xyz)
        self.ret_grouped_xyz = ret_grouped_xyz
        self.normalize_xyz = normalize_xyz
        self.sample_uniformly = sample_uniformly
        self.ret_unique_cnt = ret_unique_cnt
        if self.ret_unique_cnt:
            assert self.sample_uniformly

    def forward(self, xyz, new_xyz, features=None):
        idx = ball_query(self.radius, self.nsample, xyz, new_xyz)
        if self.sample_uniformly:
            unique_cnt = torch.zeros((idx.shape[0], idx.shape[1]))
            for i_batch in range(idx.shape[0]):
                for i_region in range(idx.shape[1]):
                    unique_ind = torch.unique(idx[i_batch, i_region, :])
                    num_unique = unique_ind.shape[0]
                    unique_cnt[i_batch, i_region] = num_unique
                    sample_ind = torch.randint(0, num_unique, (self.nsample - num_unique,), dtype=torch.long)
                    all_ind = torch.cat((unique_ind, unique_ind[sample_ind]))
                    idx[i_batch, i_region, :] = all_ind
        xyz_trans = xyz.transpose(1, 2).contiguous()
        grouped_xyz = grouping_operation(xyz_trans, idx)
        grouped_xyz -= new_xyz.transpose(1, 2).unsqueeze(-1)
        if self.normalize_xyz:
            grouped_xyz /= self.radius
        if features is not None:
            grouped_features = grouping_operation(features, idx)
            if self.use_xyz:
                new_features = torch.cat([grouped_xyz, grouped_features], dim=1)
            else:
                new_features = grouped_features
        else:
            assert self.use_xyz, 'Cannot have not features and not use xyz as a feature!'
            new_features = grouped_xyz
        ret = [new_features]
        if self.ret_grouped_xyz:
            ret.append(grouped_xyz)
        if self.ret_unique_cnt:
            ret.append(unique_cnt)
        if len(ret) == 1:
            return ret[0]
        else:
            return tuple(ret)

ARGS = {
    'radius': 0.5,
    'nsample': 4,
    'use_xyz': True,
    'ret_grouped_xyz': False,
    'normalize_xyz': False,
    'sample_uniformly': False,
    'ret_unique_cnt': False,
}
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 QueryAndGroup — 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 QueryAndGroup 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
QueryAndGroup Ran
ran on a synthesized input · constructed an object; no result was computed
zhh6425/LocalContextPropagation/pointnet2/pointnet2_modules.py
pointer only (licence: NONE) · get_code("bf4563a947bf0bd6")
How it ran

The body of this sample is withheld: GitHub detected no licence in this paper's repository, zhh6425/LocalContextPropagation when it was checked. 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.

QueryAndGroup Ran
ran on a synthesized input · constructed an object; no result was computed
zaiweizhang/H3DNet/pointnet2/pointnet2_modules.py
code served (permissive licence) · get_code("66b3e1fb36ee440b")
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, QueryAndGroup: 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)

# Mock the _ext module since it's a C++ extension that won't be available
class MockExt:
    @staticmethod
    def ball_query(new_xyz, xyz, radius, nsample):
        B, npoint, _ = new_xyz.shape
        B, N, _ = xyz.shape
        # Return mock indices of shape (B, npoint, nsample)
        return torch.randint(0, N, (B, npoint, nsample), dtype=torch.long)
    
    @staticmethod
    def group_points(features, idx):
        B, C, N = features.shape
        _, npoint, nsample = idx.shape
        # Return mock grouped features of shape (B, C, npoint, nsample)
        return torch.randn(B, C, npoint, nsample)
    
    @staticmethod
    def group_points_grad(grad_out, idx, N):
        B, C, npoint, nsample = grad_out.shape
        # Return mock gradient of shape (B, C, N)
        return torch.randn(B, C, N)

# Inject the mock module
import sys
sys.modules['_ext'] = type(sys)('_ext')
_ext = MockExt()

# Define small tensors for testing
B = 2  # batch size
N = 8  # number of features
npoint = 4  # number of query centers
C = 3  # number of feature channels
nsample = 5  # maximum samples per ball

xyz = torch.randn(B, N, 3)  # (B, N, 3) feature coordinates
new_xyz = torch.randn(B, npoint, 3)  # (B, npoint, 3) query centers
features = torch.randn(B, C, N)  # (B, C, N) feature descriptors

ARGS = {
    'radius': 0.5,
    'nsample': nsample,
    'use_xyz': True,
    'ret_grouped_xyz': False,
    'normalize_xyz': False,
    'sample_uniformly': False,
    'ret_unique_cnt': False,
    'use_feature': False,
    'ret_idx': False,
}
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 QueryAndGroup — 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 QueryAndGroup 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
SharedMLP Ran
ran on a synthesized input · constructed an object; no result was computed
zyang-ur/SAT/referit3d/external_tools/pointnet2/pointnet2_modules.py
code served (permissive licence) · get_code("3ac6212f679dac7c")
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, SharedMLP: 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
from typing import List

torch.manual_seed(0)

ARGS = {
    'args': [4, 8, 16, 32],
    'bn': False,
    'activation': nn.ReLU(inplace=True),
    'preact': False,
    'first': False,
    'name': '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 SharedMLP — 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 SharedMLP output the recorded ndim 2 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
SharedMLP Ran
ran on a synthesized input · constructed an object; no result was computed
tao-tao-tao-tao-tao/diffusion_suction/train/models/backbone2/pointnet2/pointnet2_backbone.py
pointer only (licence: NONE) · get_code("dbd9c5b5bde4b57b")
How it ran

The body of this sample is withheld: GitHub detected no licence in this paper's repository, tao-tao-tao-tao-tao/diffusion_suction when it was checked. 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.

SharedMLP Ran
ran on a synthesized input · constructed an object; no result was computed
referit3d/referit3d/referit3d/models/backbone/point_net_pp.py
code served (permissive licence) · get_code("31e40d80b30e1b2c")
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, SharedMLP: 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
from typing import List, Tuple

torch.manual_seed(0)

ARGS = {
    'args': [3, 16, 32, 64],
    'bn': True,
    'activation': nn.ReLU(inplace=True),
    'preact': False,
    'first': False,
    'name': 'shared_mlp_'
}
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 SharedMLP — the run constructed an instance of its own class and did not call it; no shape 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
_BNBase Ran
ran on a synthesized input · constructed an object; no result was computed
zyang-ur/SAT/referit3d/external_tools/pointnet2/pointnet2_modules.py
code served (permissive licence) · get_code("c164cd7b73f4eeab")
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, _BNBase: 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 _BNBase.__init__ expects:
# - in_size: an integer representing the input size
# - batch_norm: a callable that takes in_size and returns a batch norm module
# - name: a string for naming the module

# Examining the body:
# - batch_norm(in_size) is called, so batch_norm must be callable and accept in_size
# - self[0].weight and self[0].bias are accessed, so batch_norm must return something with these attributes
# - nn.init.constant_ is used to initialize weights and biases

# We'll use nn.BatchNorm1d as the batch_norm parameter since it:
# - Is callable and accepts in_size
# - Has weight and bias attributes that can be initialized with nn.init.constant_

ARGS = {
    'in_size': 16,
    'batch_norm': nn.BatchNorm1d,
    'name': '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 _BNBase — 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 _BNBase output the recorded ndim 1 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
_BNBase Ran
ran on a synthesized input · constructed an object; no result was computed
referit3d/referit3d/referit3d/models/backbone/point_net_pp.py
code served (permissive licence) · get_code("f87521261bb11483")
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, _BNBase: 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
from torch import nn

torch.manual_seed(0)

# The function uses batch_norm(in_size) to create a batch norm module
# and then accesses self[0].weight and self[0].bias to initialize them
# So batch_norm should be a callable that takes in_size and returns a module
# with weight and bias attributes

in_size = 4
batch_norm = nn.BatchNorm1d
name = 'test_'

ARGS = {
    'in_size': in_size,
    'batch_norm': batch_norm,
    'name': name
}
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 _BNBase — 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 _BNBase output the recorded ndim 1 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
_ConvBase Ran
ran on a synthesized input · constructed an object; no result was computed
zyang-ur/SAT/referit3d/external_tools/pointnet2/pointnet2_modules.py
code served (permissive licence) · get_code("baee501048c6a68c")
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, _ConvBase: 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)

# Define activation function
activation = nn.ReLU()

# Define batch norm
batch_norm = nn.BatchNorm2d

# Define conv function (for 2D convolution)
conv = nn.Conv2d

# Define initialization function
def init_func(weight):
    nn.init.kaiming_uniform_(weight)

# Construct the arguments dictionary
ARGS = {
    'in_size': 3,
    'out_size': 16,
    'kernel_size': 3,
    'stride': 1,
    'padding': 1,
    'activation': activation,
    'bn': True,
    'init': init_func,
    'conv': conv,
    'batch_norm': batch_norm,
    'bias': True,
    'preact': False,
    'name': 'conv_'
}
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 _ConvBase — 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 _ConvBase output the recorded ndim 1 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
_ConvBase Ran
ran on a synthesized input · constructed an object; no result was computed
tao-tao-tao-tao-tao/diffusion_suction/train/models/backbone2/pointnet2/pointnet2_backbone.py
pointer only (licence: NONE) · get_code("37537db27757694f")
How it ran

The body of this sample is withheld: GitHub detected no licence in this paper's repository, tao-tao-tao-tao-tao/diffusion_suction when it was checked. 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.

_ConvBase Ran
ran on a synthesized input · constructed an object; no result was computed
referit3d/referit3d/referit3d/models/backbone/point_net_pp.py
code served (permissive licence) · get_code("256c9a6ac7df5930")
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, _ConvBase: 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
from torch import nn, Tensor
import torch.nn.init as init_module

torch.manual_seed(0)

# Define a simple activation function
activation = nn.ReLU()

# Define initialization function
def init_fn(tensor):
    nn.init.kaiming_uniform_(tensor)

# Define conv and batch_norm callables
conv = nn.Conv2d
batch_norm = nn.BatchNorm2d

ARGS = {
    'in_size': 3,
    'out_size': 4,
    'kernel_size': 3,
    'stride': 1,
    'padding': 1,
    'activation': activation,
    'bn': True,
    'init': init_fn,
    'conv': conv,
    'batch_norm': batch_norm,
    'bias': True,
    'preact': False,
    'name': '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 _ConvBase — 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 _ConvBase output the recorded ndim 1 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
build_shared_mlp Ran
ran; the contract check could not run (RAISES, DEP_MISSING or TIMEOUT)
asalarpour/Point_GN/pointnet2_ops_lib/pointnet2_ops/pointnet2_modules.py
pointer only (licence: NONE) · get_code("c80f9bbb31e6cb9f")
How it ran

The body of this sample is withheld: GitHub detected no licence in this paper's repository, asalarpour/Point_GN when it was checked. 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.

sample_and_group Ran
ran; the contract check could not run (RAISES, DEP_MISSING or TIMEOUT)
yanx27/Pointnet_Pointnet2_pytorch/models/pointnet2_utils.py
code served (permissive licence) · get_code("ad5401ceab4ea9b6")
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)

# Create small point clouds
B = 2  # batch size
N = 4  # number of input points
D = 2  # feature dimension (besides xyz)

# xyz: [B, N, 3] - input point positions
xyz = torch.randn(B, N, 3)

# points: [B, N, D] - input point features
points = torch.randn(B, N, D)

# Sampling parameters
npoint = 2  # number of points to sample
radius = 0.5  # query radius
nsample = 3  # max samples per group

ARGS = {
    'npoint': npoint,
    'radius': radius,
    'nsample': nsample,
    'xyz': xyz,
    'points': points,
    'returnfps': False
}
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
sample_and_group Ran
ran; the contract check could not run (RAISES, DEP_MISSING or TIMEOUT)
Ghailen-Ben-Achour/PointNet2_Segmentation/models/pointnet2_cls_ssg.py
code served (permissive licence) · get_code("70d28914ddac1077")
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. The code mentions cuda, and the harness aliases cuda to the CPU for every sample; whether this run needed that is 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)

# Create small sample tensors
B = 2  # batch size
N = 4  # number of points
npoint = 2  # number of points to sample
radius = 1.5
nsample = 3  # max samples in local region

# xyz: input points position data, [B, N, 3]
xyz = torch.randn(B, N, 3)

# points: input points data, [B, N, D]
# D can be different from 3, using 2 for distinction
points = torch.randn(B, N, 2)

ARGS = {
    "npoint": npoint,
    "radius": radius,
    "nsample": nsample,
    "xyz": xyz,
    "points": points,
    "returnfps": False
}
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
PointNetPP Not yet run
unverified (harvested, no recorded run)
referit3d/referit3d/referit3d/models/backbone/point_net_pp.py
code served (permissive licence) · get_code("95614125c07b84a3")
How it ran

no invocation recorded.

PointNetPP Not yet run
unverified (harvested, no recorded run)
dfki-av/mikasa-3dvg/models/point_net_pp.py
pointer only (licence: NONE) · get_code("7ff6372868b293d9")
How it ran

The body of this sample is withheld: GitHub detected no licence in this paper's repository, dfki-av/mikasa-3dvg when it was checked. 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. No invocation recorded.

Pointnet2Backbone Not yet run
unverified (harvested, no recorded run)
tao-tao-tao-tao-tao/diffusion_suction/train/models/backbone2/pointnet2/pointnet2_backbone.py
pointer only (licence: NONE) · get_code("7ffe30c65652d376")
How it ran

The body of this sample is withheld: GitHub detected no licence in this paper's repository, tao-tao-tao-tao-tao/diffusion_suction when it was checked. 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. No invocation recorded.

Pointnet2Backbone Not yet run
unverified (harvested, no recorded run)
thu17cyz/3DIoUMatch/models/backbone_module.py
pointer only (licence: NONE) · get_code("86d8804e1b24718b")
How it ran

The body of this sample is withheld: GitHub detected no licence in this paper's repository, thu17cyz/3DIoUMatch when it was checked. 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. No invocation recorded.

PointnetSAModule Not yet run
unverified (harvested, no recorded run)
tao-tao-tao-tao-tao/diffusion_suction/train/models/backbone2/pointnet2/pointnet2_backbone.py
pointer only (licence: NONE) · get_code("b3b9df5e5970a1a7")
How it ran

The body of this sample is withheld: GitHub detected no licence in this paper's repository, tao-tao-tao-tao-tao/diffusion_suction when it was checked. 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. No invocation recorded.

PointnetSAModule Not yet run
unverified (harvested, no recorded run)
AsahiLiu/PointDetectron/pointnet2/pointnet2_modules.py
code served (permissive licence) · get_code("1b0bdf31bf17378b")
How it ran

no invocation recorded.

PointnetSAModule Not yet run
unverified (harvested, no recorded run)
referit3d/referit3d/referit3d/models/backbone/point_net_pp.py
code served (permissive licence) · get_code("fcea688e1b440469")
How it ran

no invocation recorded.

PointnetSAModuleMSG Not yet run
unverified (harvested, no recorded run)
zyang-ur/SAT/referit3d/external_tools/pointnet2/pointnet2_modules.py
code served (permissive licence) · get_code("a80a54dddb6349ae")
How it ran

no invocation recorded.

PointnetSAModuleMSG Not yet run
unverified (harvested, no recorded run)
hoangcuongbk80/VoteGrasp/pointnet2/pointnet2_modules.py
pointer only (licence: NONE) · get_code("793ed3a4ee8d7bf4")
How it ran

The body of this sample is withheld: GitHub detected no licence in this paper's repository, hoangcuongbk80/VoteGrasp when it was checked. 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. No invocation recorded.

PointnetSAModuleMSG Not yet run
unverified (harvested, no recorded run)
tao-tao-tao-tao-tao/diffusion_suction/train/models/backbone2/pointnet2/pointnet2_backbone.py
pointer only (licence: NONE) · get_code("1d8dff9fef819904")
How it ran

The body of this sample is withheld: GitHub detected no licence in this paper's repository, tao-tao-tao-tao-tao/diffusion_suction when it was checked. 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. No invocation recorded.

PointnetSAModuleMSG Not yet run
unverified (harvested, no recorded run)
AsahiLiu/PointDetectron/pointnet2/pointnet2_modules.py
code served (permissive licence) · get_code("6d3f7e94b9d2b11b")
How it ran

no invocation recorded.

PointnetSAModuleMSG Not yet run
unverified (harvested, no recorded run)
Harut0726/votenet/pointnet2/pointnet2_modules.py
code served (permissive licence) · get_code("a3e240dde91b9210")
How it ran

no invocation recorded.

PointnetSAModuleMSG Not yet run
unverified (harvested, no recorded run)
curryyuan/x-trans2cap/lib/pointnet2/pointnet2_modules.py
code served (permissive licence) · get_code("46d072d568750005")
How it ran

no invocation recorded.

PointnetSAModuleMSG Not yet run
unverified (harvested, no recorded run)
sshaoshuai/Pointnet2.PyTorch/pointnet2/pointnet2_modules.py
code served (permissive licence) · get_code("e007e97b1d9d744b")
How it ran

no invocation recorded.

PointnetSAModuleMSG Not yet run
unverified (harvested, no recorded run)
zhh6425/LocalContextPropagation/pointnet2/pointnet2_modules.py
pointer only (licence: NONE) · get_code("a7ce6f090a331749")
How it ran

The body of this sample is withheld: GitHub detected no licence in this paper's repository, zhh6425/LocalContextPropagation when it was checked. 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. No invocation recorded.

PointnetSAModuleMSG Not yet run
unverified (harvested, no recorded run)
dfki-av/mikasa-3dvg/models/point_net_pp.py
pointer only (licence: NONE) · get_code("613ddd5378be9c11")
How it ran

The body of this sample is withheld: GitHub detected no licence in this paper's repository, dfki-av/mikasa-3dvg when it was checked. 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. No invocation recorded.

PointnetSAModuleMSG Not yet run
unverified (harvested, no recorded run)
zaiweizhang/H3DNet/pointnet2/pointnet2_modules.py
code served (permissive licence) · get_code("1788ad2f156a1b3d")
How it ran

no invocation recorded.

PointnetSAModuleMSG Not yet run
unverified (harvested, no recorded run)
asalarpour/Point_GN/pointnet2_ops_lib/pointnet2_ops/pointnet2_modules.py
pointer only (licence: NONE) · get_code("843c26df3d1ce95d")
How it ran

The body of this sample is withheld: GitHub detected no licence in this paper's repository, asalarpour/Point_GN when it was checked. 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. No invocation recorded.

PointnetSAModuleMSG Not yet run
unverified (harvested, no recorded run)
nickgkan/butd_detr/pointnet2/pointnet2_modules.py
pointer only (licence: NOASSERTION) · get_code("849da9ddf3201c42")
How it ran

The body of this sample is withheld: GitHub could not classify the licence of this paper's repository, nickgkan/butd_detr (NOASSERTION). 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. No invocation recorded.

Pointnet_SA_MSG Not yet run
unverified (harvested, no recorded run)
dgriffiths3/pointnet2-tensorflow2/pnet2_layers/layers.py
pointer only (licence: NONE) · get_code("855fbabeb3a336f4")
How it ran

The body of this sample is withheld: GitHub detected no licence in this paper's repository, dgriffiths3/pointnet2-tensorflow2 when it was checked. 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. No invocation recorded.

QueryAndGroup Not yet run
unverified (harvested, no recorded run)
zyang-ur/SAT/referit3d/external_tools/pointnet2/pointnet2_modules.py
code served (permissive licence) · get_code("4d94f2dd93d310a4")
How it ran

no invocation recorded.

QueryAndGroup Not yet run
unverified (harvested, no recorded run)
hoangcuongbk80/VoteGrasp/pointnet2/pointnet2_modules.py
pointer only (licence: NONE) · get_code("5d1e43f12483593d")
How it ran

The body of this sample is withheld: GitHub detected no licence in this paper's repository, hoangcuongbk80/VoteGrasp when it was checked. 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. No invocation recorded.

_PointnetSAModuleBase Not yet run
unverified (harvested, no recorded run)
zyang-ur/SAT/referit3d/external_tools/pointnet2/pointnet2_modules.py
code served (permissive licence) · get_code("1e00adaf9c01804c")
How it ran

no invocation recorded.

_PointnetSAModuleBase Not yet run
unverified (harvested, no recorded run)
hoangcuongbk80/VoteGrasp/pointnet2/pointnet2_modules.py
pointer only (licence: NONE) · get_code("d068c3e73bb13c3c")
How it ran

The body of this sample is withheld: GitHub detected no licence in this paper's repository, hoangcuongbk80/VoteGrasp when it was checked. 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. No invocation recorded.

Showing the first 60. An agent gets every one from get_harvested_code_for_paper("1706.02413").

Also present in other papers' code

Of 67 samples lifted from this paper's linked repositories, 67 carry a function identity and 0 do not. Of the 45 distinct functions with an identity, 29 are also present in other papers whose code we hold (0 with at least one paper dated earlier, 0 the same month, 29 later) and 16 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
GatherOperation
brick of this paper's assembly: helper
11 other papers
11 later · 10 only as an assembly brick
2103.07894 (2021-03)
Refer-it-in-RGBD: A Bottom-up Approach for 3D Visual Grounding in RGBD Images
2104.00678 (2021-04)
Group-Free 3D Object Detection via Transformers
2204.13630 (2022-04)
Rotationally Equivariant 3D Object Detection
and 8 more not named here
GroupingOperation
brick of this paper's assembly: helper
11 other papers
11 later · 10 only as an assembly brick
2103.07894 (2021-03)
Refer-it-in-RGBD: A Bottom-up Approach for 3D Visual Grounding in RGBD Images
2104.00678 (2021-04)
Group-Free 3D Object Detection via Transformers
2204.13630 (2022-04)
Rotationally Equivariant 3D Object Detection
and 8 more not named here
FurthestPointSampling
brick of this paper's assembly: helper
10 other papers
10 later · 9 only as an assembly brick
2103.07894 (2021-03)
Refer-it-in-RGBD: A Bottom-up Approach for 3D Visual Grounding in RGBD Images
2104.00678 (2021-04)
Group-Free 3D Object Detection via Transformers
2109.08141 (2021-09)
An End-to-End Transformer Model for 3D Object Detection
and 7 more not named here
QueryAndGroup
brick of this paper's assembly: helper, model
9 other papers
9 later · 7 only as an assembly brick
2103.07894 (2021-03)
Refer-it-in-RGBD: A Bottom-up Approach for 3D Visual Grounding in RGBD Images
2104.00678 (2021-04)
Group-Free 3D Object Detection via Transformers
2204.13630 (2022-04)
Rotationally Equivariant 3D Object Detection
and 6 more not named here
BallQuery
brick of this paper's assembly: helper
8 other papers
8 later · 7 only as an assembly brick
2103.07894 (2021-03)
Refer-it-in-RGBD: A Bottom-up Approach for 3D Visual Grounding in RGBD Images
2104.00678 (2021-04)
Group-Free 3D Object Detection via Transformers
2204.13630 (2022-04)
Rotationally Equivariant 3D Object Detection
and 5 more not named here
BatchNorm2d
brick of this paper's assembly: helper
8 other papers
8 later · 7 only as an assembly brick
2103.07894 (2021-03)
Refer-it-in-RGBD: A Bottom-up Approach for 3D Visual Grounding in RGBD Images
2104.00678 (2021-04)
Group-Free 3D Object Detection via Transformers
2204.13630 (2022-04)
Rotationally Equivariant 3D Object Detection
and 5 more not named here
Conv2d
brick of this paper's assembly: helper
8 other papers
8 later · 6 only as an assembly brick
2103.07894 (2021-03)
Refer-it-in-RGBD: A Bottom-up Approach for 3D Visual Grounding in RGBD Images
2104.00678 (2021-04)
Group-Free 3D Object Detection via Transformers
2204.13630 (2022-04)
Rotationally Equivariant 3D Object Detection
and 5 more not named here
SharedMLP
brick of this paper's assembly: helper, model
8 other papers
8 later · 5 only as an assembly brick
2103.07894 (2021-03)
Refer-it-in-RGBD: A Bottom-up Approach for 3D Visual Grounding in RGBD Images
2104.00678 (2021-04)
Group-Free 3D Object Detection via Transformers
2204.13630 (2022-04)
Rotationally Equivariant 3D Object Detection
and 5 more not named here
_BNBase
brick of this paper's assembly: helper
8 other papers
8 later · 7 only as an assembly brick
2103.07894 (2021-03)
Refer-it-in-RGBD: A Bottom-up Approach for 3D Visual Grounding in RGBD Images
2104.00678 (2021-04)
Group-Free 3D Object Detection via Transformers
2204.13630 (2022-04)
Rotationally Equivariant 3D Object Detection
and 5 more not named here
_ConvBase
brick of this paper's assembly: helper
8 other papers
8 later · 6 only as an assembly brick
2103.07894 (2021-03)
Refer-it-in-RGBD: A Bottom-up Approach for 3D Visual Grounding in RGBD Images
2104.00678 (2021-04)
Group-Free 3D Object Detection via Transformers
2204.13630 (2022-04)
Rotationally Equivariant 3D Object Detection
and 5 more not named here
build_shared_mlp
brick of this paper's assembly: helper
6 other papers
6 later
2210.10138 (2022-10)
Class-Level Confidence Based 3D Semi-Supervised Learning
2212.00564 (2022-12)
Leveraging Single-View Images for Unsupervised 3D Point Cloud Completion
2308.05525 (2023-08)
Robustifying Point Cloud Networks by Refocusing
and 3 more not named here
_PointnetSAModuleBase
brick of this paper's assembly: helper
4 other papers
4 later · 2 only as an assembly brick
2103.02242 (2021-03)
FFB6D: A Full Flow Bidirectional Fusion Network for 6D Pose Estimation
2207.05444 (2022-07)
Category-Level 6D Object Pose and Size Estimation using Self-Supervised Deep Prior Deformation Networks
2303.13479 (2023-03)
IST-Net: Prior-free Category-level Pose Estimation with Implicit Space Transformation
and 1 more not named here
Conv2d
brick of this paper's assembly: helper
3 other papers
3 later · 3 only as an assembly brick
2207.05444 (2022-07)
Category-Level 6D Object Pose and Size Estimation using Self-Supervised Deep Prior Deformation Networks
2303.13479 (2023-03)
IST-Net: Prior-free Category-level Pose Estimation with Implicit Space Transformation
2502.01312 (2025-02)
CleanPose: Category-Level Object Pose Estimation via Causal Learning and Knowledge Distillation
SharedMLP
brick of this paper's assembly: helper
3 other papers
3 later · 3 only as an assembly brick
2207.05444 (2022-07)
Category-Level 6D Object Pose and Size Estimation using Self-Supervised Deep Prior Deformation Networks
2303.13479 (2023-03)
IST-Net: Prior-free Category-level Pose Estimation with Implicit Space Transformation
2502.01312 (2025-02)
CleanPose: Category-Level Object Pose Estimation via Causal Learning and Knowledge Distillation
_ConvBase
brick of this paper's assembly: helper
3 other papers
3 later · 3 only as an assembly brick
2207.05444 (2022-07)
Category-Level 6D Object Pose and Size Estimation using Self-Supervised Deep Prior Deformation Networks
2303.13479 (2023-03)
IST-Net: Prior-free Category-level Pose Estimation with Implicit Space Transformation
2502.01312 (2025-02)
CleanPose: Category-Level Object Pose Estimation via Causal Learning and Knowledge Distillation
_PointnetSAModuleBase
brick of this paper's assembly: helper, model
3 other papers
3 later
2009.12606 (2020-09)
Grasp Proposal Networks: An End-to-End Solution for Visual Learning of Robotic Grasps
2403.03077 (2024-03)
MiKASA: Multi-Key-Anchor & Scene-Aware Transformer for 3D Visual Grounding
2406.11142 (2024-06)
Graspness Discovery in Clutters for Fast and Accurate Grasp Detection
BallQuery
brick of this paper's assembly: helper, sampler
2 other papers
2 later · 2 only as an assembly brick
2403.03077 (2024-03)
MiKASA: Multi-Key-Anchor & Scene-Aware Transformer for 3D Visual Grounding
2406.11142 (2024-06)
Graspness Discovery in Clutters for Fast and Accurate Grasp Detection
FurthestPointSampling
brick of this paper's assembly: helper, sampler
2 other papers
2 later · 2 only as an assembly brick
2403.03077 (2024-03)
MiKASA: Multi-Key-Anchor & Scene-Aware Transformer for 3D Visual Grounding
2406.11142 (2024-06)
Graspness Discovery in Clutters for Fast and Accurate Grasp Detection
GroupAll
brick of this paper's assembly: helper
2 other papers
2 later · 2 only as an assembly brick
2207.05444 (2022-07)
Category-Level 6D Object Pose and Size Estimation using Self-Supervised Deep Prior Deformation Networks
2303.13479 (2023-03)
IST-Net: Prior-free Category-level Pose Estimation with Implicit Space Transformation
PointNetSetAbstraction
brick of this paper's assembly: entry, model
2 other papers
2 later
2305.16963 (2023-05)
Semantic segmentation of sparse irregular point clouds for leaf/wood discrimination
2306.00777 (2023-06)
Object pop-up: Can we infer 3D objects and their poses from human interactions alone?

Shown: the 20 functions present in the most other papers. 9 more shared functions are not listed 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-21.

Repositories linked to this paper

More are linked than shown here.

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

Abstract

Few prior works study deep learning on point sets. PointNet [20] is a pioneer in this direction. However, by design PointNet does not capture local structures induced by the metric space points live in, limiting its ability to recognize fine-grained patterns and generalizability to complex scenes. In this work, we introduce a hierarchical neural network that applies PointNet recursively on a nested partitioning of the input point set. By exploiting metric space distances, our network is able to learn local features with increasing contextual scales. With further observation that point sets are usually sampled with varying densities, which results in greatly decreased performance for networks trained on uniform densities, we propose novel set learning layers to adaptively combine features from multiple scales. Experiments show that our network called PointNet++ is able to learn deep point set features efficiently and robustly. In particular, results significantly better than state-of-the-art have been obtained on challenging benchmarks of 3D point clouds.

For agents

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

get_harvested_code_for_paper("1706.02413")
get_code_for_paper("1706.02413")
have("1706.02413")

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

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

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

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

Connect an agent — have() is free.