3D-JEPA: A Joint Embedding Predictive Architecture for 3D Self-Supervised Representation Learning

Hu, Cheng, Xie, Li, Zhu • September 2024 • arXiv 2409.15803

1. Introduction

Self-supervised learning on 3D point clouds has historically been dominated by reconstruction-based methods. Approaches such as Point-MAE and Point-BERT mask portions of a point cloud and train the network to reconstruct the missing 3D coordinates or discrete point tokens in input space. While effective, this paradigm carries an inherent limitation: the model expends significant capacity learning to reproduce low-level geometric details—surface normals, local curvatures, exact point positions—that may be irrelevant for high-level semantic understanding. A decoder powerful enough to reconstruct raw point coordinates can succeed without ever learning transferable, abstract representations.

In the 2D image domain, the Joint Embedding Predictive Architecture (JEPA) framework, and specifically I-JEPA (Assran et al., 2023), demonstrated that predicting in representation space rather than input space yields representations that are more semantically rich and more sample-efficient for downstream tasks. I-JEPA removes the decoder entirely: a lightweight predictor network maps context representations to target representations produced by an exponential moving average (EMA) encoder, and the loss is computed purely in the latent space. This avoids the pixel-reconstruction bottleneck and encourages the encoder to capture high-level, abstract features.

3D-JEPA (Hu, Cheng, Xie, Li, Zhu, 2024) transfers this principle to the 3D domain. The core question it addresses is: Can latent-space prediction replace point-coordinate reconstruction for self-supervised 3D representation learning, and if so, how should the masking strategy be adapted for the irregular, unordered geometry of point clouds?

The contributions of 3D-JEPA are threefold:

1. Latent prediction for 3D point clouds. 3D-JEPA is the first work to apply the JEPA framework—context-encoder, EMA target-encoder, predictor, representation-space loss—to 3D point cloud data, eliminating the need for point-coordinate or discrete-token reconstruction.
2. Multi-block spatial sampling in 3D. Extending I-JEPA's multi-block masking from 2D image grids to 3D Euclidean space, the paper proposes a spatial sampling strategy that selects multiple target blocks as spatially contiguous clusters in 3D, using the complement as context. This ensures the prediction task requires genuine 3D spatial reasoning rather than simple interpolation.
3. Competitive performance without reconstruction. 3D-JEPA achieves results competitive with or superior to Point-MAE and Point-BERT on standard benchmarks (ModelNet40, ScanObjectNN, ShapeNetPart) despite never reconstructing a single point coordinate during pretraining.

The key departure from I-JEPA lies in the input modality: images are dense, grid-structured signals where patches can be extracted by regular spatial tiling. Point clouds are sparse, unordered, and irregularly distributed. 3D-JEPA must address point cloud tokenization (converting raw points into a sequence of patch tokens), spatial block sampling in continuous 3D Euclidean space (rather than on a discrete 2D grid), and positional encoding that respects 3D geometry. These adaptations are non-trivial and constitute the primary methodological contribution of the work.

2. Method

To understand 3D-JEPA, consider an analogy. Imagine you are shown a sculpture from one angle—say the front and left side—and asked to describe what the back looks like. A novice might try to predict the exact surface texture, the precise curve of each ridge. An expert, by contrast, would reason at a higher level: "Given the style and symmetry I see, the back likely has a similar motif with these broad structural features." The expert is predicting in concept space, not surface space.

3D-JEPA follows the expert's strategy. Given a partial view of a 3D object (the context), it does not attempt to reconstruct the missing points. Instead, it predicts what a separate, stable encoder would say about those missing regions—their abstract, high-level representations. The prediction target is not geometry; it is semantics.

The training pipeline has four core components:

1. Point cloud tokenization. The raw point cloud (e.g., 1024 points) is divided into $N$ spatial patches using Farthest Point Sampling (FPS) to select center points, followed by K-Nearest Neighbors (KNN) to group nearby points into each patch. A small PointNet-style network (mini-PointNet) encodes each patch into a $D$-dimensional token. This converts the irregular point cloud into an ordered sequence of tokens, analogous to image patch embeddings in a Vision Transformer.
2. Multi-block spatial masking. Multiple target blocks are sampled by selecting seed patches and expanding outward through spatial adjacency in 3D. The remaining patches form the context. Because blocks are spatially contiguous in 3D, the model cannot trivially interpolate the targets from nearby context patches—it must reason about the global shape.
3. Dual encoders with asymmetric processing. The context encoder (trainable) processes only the visible context tokens. The target encoder (EMA-updated, frozen for gradients) processes the full set of tokens—or specifically the target tokens—to produce the prediction targets. The asymmetry (partial input for context, full input for target) is critical: it prevents the model from simply copying through an identity mapping.
4. Predictor. A lightweight Transformer takes the context encoder's output along with positional information for the masked locations and predicts the target encoder's representations at those locations. The loss is the mean squared error (or smooth L1) between the predictor's output and the target encoder's output at the masked positions.

Crucially, no component of 3D-JEPA ever attempts to decode back to 3D point coordinates. The entire training signal is in representation space. This is what distinguishes JEPA-family methods from masked autoencoders and makes the learned representations inherently abstract and semantic.

3. Model Overview

At-a-Glance

Training Architecture Diagram

4. Main Components of 3D-JEPA

4.1 Point Cloud Tokenizer

WHAT: The tokenizer converts a raw point cloud $\mathbf{X} \in \mathbb{R}^{P \times 3}$ (with $P$ points, each having 3D coordinates) into a sequence of $N$ patch tokens $\{\mathbf{t}_i\}_{i=1}^{N}$, where each $\mathbf{t}_i \in \mathbb{R}^D$.

HOW: The tokenization follows the standard pipeline established by Point-BERT and Point-MAE:

1. Center selection via FPS. Farthest Point Sampling selects $N$ center points $\{c_1, \dots, c_N\}$ from $\mathbf{X}$. FPS guarantees approximately uniform coverage of the point cloud's spatial extent. In 3D-JEPA, $N = 64$ patches are used (following convention from prior work).
2. Neighbor grouping via KNN. For each center $c_i$, the $K$ nearest neighbors (typically $K = 32$) are gathered to form a local patch $\mathbf{G}_i \in \mathbb{R}^{K \times 3}$. Coordinates are normalized relative to the center: $\mathbf{G}_i^{\text{norm}} = \mathbf{G}_i - c_i$.
3. Mini-PointNet embedding. Each normalized patch is processed by a shared mini-PointNet (an MLP followed by max-pooling over the $K$ points) to produce a $D$-dimensional token: $$\mathbf{t}_i = \text{MaxPool}(\text{MLP}(\mathbf{G}_i^{\text{norm}})) \in \mathbb{R}^D$$
4. Positional encoding. The 3D coordinates of each center point are mapped to a $D$-dimensional positional embedding via a learned linear projection or sinusoidal encoding: $$\mathbf{p}_i = \text{PosEnc}(c_i) \in \mathbb{R}^D$$ The final input token is $\mathbf{t}_i + \mathbf{p}_i$.

WHY: This tokenization scheme is critical because it bridges the gap between irregular point clouds and the regular token sequences required by Transformer architectures. The use of FPS ensures spatial uniformity, KNN captures local geometric structure, and the mini-PointNet provides permutation-invariant encoding of each local patch. The paper follows the established $N=64$, $K=32$ configuration to enable direct comparison with Point-MAE and Point-BERT.

4.2 Context Encoder

WHAT: The context encoder $f_\theta$ is a standard Transformer that processes the visible (unmasked) context tokens and produces contextualized representations.

HOW: Given the set of context token indices $\mathcal{C}$ (the complement of the masked target indices), the context encoder receives the tokens $\{\mathbf{t}_i + \mathbf{p}_i\}_{i \in \mathcal{C}}$ and applies $L$ Transformer layers with multi-head self-attention and feed-forward networks:

where $\mathbf{h}_i^{(0)} = \mathbf{t}_i + \mathbf{p}_i$. The architecture uses a standard ViT-Base-like configuration: $L=12$ layers, hidden dimension $D=384$, $h=6$ attention heads, and FFN hidden dimension $4D = 1536$. The output is $\{\mathbf{h}_i\}_{i \in \mathcal{C}}$, each in $\mathbb{R}^D$.

WHY: Processing only context tokens (not the full sequence with mask tokens) is a deliberate design choice inherited from I-JEPA. It serves two purposes: (1) computational efficiency, since the encoder never processes mask tokens, and (2) it prevents information leakage—the encoder must form its representations without any positional hint from mask-token placeholders about what is missing.

4.3 Target Encoder (EMA)

WHAT: The target encoder $f_{\bar{\theta}}$ has the identical architecture as the context encoder but its parameters $\bar{\theta}$ are updated via exponential moving average (EMA) of the context encoder's parameters $\theta$. No gradients flow through the target encoder.

HOW: After each training step, the target encoder parameters are updated as:

where $\tau$ is the EMA momentum coefficient, typically following a cosine schedule from an initial value (e.g., $\tau_0 = 0.996$) to a final value (e.g., $\tau_1 = 1.0$) over the course of training. The target encoder processes the target tokens $\{\mathbf{t}_i + \mathbf{p}_i\}_{i \in \mathcal{T}}$ (where $\mathcal{T}$ is the set of target patch indices) and produces target representations $\{\mathbf{z}_i\}_{i \in \mathcal{T}}$.

WHY: The EMA target encoder serves as a slowly evolving reference that provides stable prediction targets. This mechanism, inherited from BYOL and refined in I-JEPA, is one of the key components that prevents representational collapse—the scenario where the model learns to map all inputs to a constant representation. The EMA encoder changes slowly enough to provide consistent targets across training steps, but adapts over time as the context encoder improves. The stop-gradient operation (no backpropagation through the target encoder) creates the necessary asymmetry: the context encoder and predictor must actively improve their representations to match the target, rather than the target degrading to match a trivial prediction.

4.4 Predictor

WHAT: The predictor $g_\phi$ is a lightweight Transformer that takes the context encoder's output representations and positional information for the masked target locations, and predicts the target encoder's representations at those locations.

HOW: The predictor receives two types of input:

1. The contextualized representations from the context encoder: $\{\mathbf{h}_i\}_{i \in \mathcal{C}}$, paired with their positional embeddings $\{\mathbf{p}_i\}_{i \in \mathcal{C}}$.
2. Learnable mask tokens $\{\mathbf{m}\}$ (a single shared vector, repeated for each target position), paired with the positional embeddings of the target locations: $\{\mathbf{p}_j\}_{j \in \mathcal{T}}$.

These are concatenated into a single sequence and processed by a smaller Transformer (e.g., $L_p = 6$ layers, same hidden dimension $D$). The predictor's output at the target positions yields predicted representations:

WHY: The predictor serves a dual role. First, it bridges the gap between the context encoder's representation space and the target encoder's representation space—since the two encoders' parameters diverge (one is EMA-updated), their representations inhabit slightly different manifolds. Second, the predictor's limited capacity (fewer layers than the encoder) acts as an information bottleneck that regularizes learning. If the predictor were too powerful, it could learn to predict target representations without the context encoder needing to produce informative representations. The narrow predictor forces the context encoder to do the heavy lifting of semantic encoding.

4.5 Multi-Block Spatial Masking Strategy

WHAT: The masking strategy determines which patches become targets (to be predicted) and which remain visible as context. 3D-JEPA uses a multi-block approach: multiple spatially contiguous blocks are sampled as targets, with the remaining patches forming the context.

HOW: The multi-block sampling procedure operates as follows:

1. Seed selection. $M$ seed patches (e.g., $M = 4$) are randomly selected from the $N$ patch centers.
2. Block expansion. Each seed is expanded into a spatially contiguous block by including its $k$-nearest neighboring patches in 3D Euclidean space. The expansion radius or neighbor count is chosen to achieve a target masking ratio (e.g., each block covers approximately $\frac{N \cdot r}{M}$ patches, where $r$ is the total target ratio, typically $r \approx 0.6$, i.e., 60% of patches are masked as targets).
3. Context assignment. All patches not included in any target block form the context set $\mathcal{C}$. Since blocks may overlap slightly, the effective context ratio is approximately $1 - r$.

The key hyperparameters are: number of target blocks $M$, target masking ratio $r$, and expansion strategy (fixed-$k$ neighbors or radius-based). The paper explores $M \in \{1, 2, 4\}$ and finds that $M = 4$ provides the best performance, validating the multi-block design.

WHY: The ablation on the number of target blocks is one of the paper's key findings. Using $M=1$ (a single contiguous block) yields weaker representations because the model can often predict the single target by local extrapolation from nearby context patches. Increasing to $M=4$ forces the model to maintain a global understanding of the object: predicting four spatially separated blocks from the remaining context requires integrating information across the entire visible shape. This design directly mirrors the finding from I-JEPA that multi-block masking outperforms single-block masking on 2D images, and validates that the same principle holds in the 3D domain.

4.6 Loss Function

WHAT: The loss function measures the discrepancy between the predictor's output and the target encoder's output at the masked positions. It operates entirely in representation space—no point coordinates are involved.

HOW: Let $\hat{\mathbf{z}}_j$ be the predictor's output for target position $j \in \mathcal{T}$, and let $\mathbf{z}_j$ be the target encoder's output for the same position. The loss is the average mean squared error over all target positions across all target blocks:

where:

• $\hat{\mathbf{z}}_j \in \mathbb{R}^D$ is the predictor's predicted representation for target patch $j$
• $\mathbf{z}_j \in \mathbb{R}^D$ is the target encoder's representation for target patch $j$
• $\text{sg}(\cdot)$ denotes the stop-gradient operator: no gradients are backpropagated through $\mathbf{z}_j$
• $|\mathcal{T}|$ is the total number of target patches (summed across all $M$ target blocks)
• $\|\cdot\|_2^2$ is the squared L2 norm

In practice, the target representations $\mathbf{z}_j$ may be normalized (e.g., via layer normalization or L2 normalization) before the loss computation to stabilize training and prevent the targets from collapsing to zero or growing unboundedly.

The total training objective is simply $\mathcal{L}$—there are no additional regularization terms, contrastive losses, or reconstruction objectives. The simplicity of this loss is a hallmark of the JEPA framework.

WHY: L2 loss in representation space is preferred over alternatives for several reasons. Compared to contrastive losses (e.g., InfoNCE), it does not require negative samples, removing a source of computational overhead and hyperparameter sensitivity. Compared to reconstruction losses in input space, it avoids the capacity expenditure on low-level detail reproduction. The stop-gradient on $\mathbf{z}_j$ is essential: without it, the trivial solution of collapsing both representations to zero would minimize the loss. The normalization of targets is an additional safeguard against the target encoder producing representations that are easy to predict but uninformative (e.g., near-constant vectors).

5. Implementation Details

The following table summarizes the key hyperparameters used in 3D-JEPA. Where the paper does not explicitly report a value, we note that the value is inferred from I-JEPA defaults or standard point cloud Transformer practice, and mark these with an asterisk (*).

Values marked with * are inferred from standard practice (I-JEPA defaults, Point-MAE/Point-BERT conventions) and may differ from the paper's exact configuration. No public repository is available for verification.

6. Algorithm

7. Training

Step-by-Step: One Training Iteration

A single training iteration of 3D-JEPA proceeds through the following stages:

Step 1: Tokenization. A mini-batch of $B$ point clouds, each with $P=1024$ points, is loaded. For each point cloud, FPS selects $N=64$ center points, KNN groups $K=32$ neighbors per center, and the mini-PointNet encodes each group to produce $N$ tokens of dimension $D=384$. Positional embeddings derived from the 3D center coordinates are added. Output shape per sample: $N \times D = 64 \times 384$.

Step 2: Multi-block masking. For each sample, Algorithm 2 is invoked with $M=4$ target blocks and masking ratio $r \approx 0.6$. This produces approximately $N_t = \lfloor 64 \times 0.6 \rfloor = 38$ target patches and $N_c = 64 - 38 = 26$ context patches per sample. The exact split varies per sample due to block overlap.

Step 3: Context encoding. The $N_c$ context tokens (with positional embeddings) are fed through the 12-layer Transformer context encoder $f_\theta$. Self-attention is computed only over the context tokens. Output: $N_c \times D$ context representations per sample. This step is the most compute-intensive part of the forward pass.

Step 4: Target encoding (no gradient). Under torch.no_grad(), the target encoder $f_{\bar{\theta}}$ processes the $N_t$ target tokens (with positional embeddings). Output: $N_t \times D$ target representations per sample. These are optionally normalized (LayerNorm or L2-norm) to stabilize the training signal.

Step 5: Prediction. The predictor $g_\phi$ receives the context representations (with their positional embeddings) and learnable mask tokens (with the target positions' positional embeddings). It processes the concatenated sequence through its $L_p$ Transformer layers and outputs predicted representations at the target positions. Output: $N_t \times D$ predicted representations per sample.

Step 6: Loss computation. The L2 loss is computed between the predictor's output $\hat{\mathbf{z}}_j$ and the (stop-gradiented) target encoder's output $\mathbf{z}_j$ at each target position, then averaged over all target positions and all samples in the batch.

Step 7: Backward pass and parameter update. Gradients are computed with respect to $\theta$ (context encoder) and $\phi$ (predictor) only. AdamW updates both parameter sets. The learning rate follows a cosine decay schedule with linear warmup.

Step 8: EMA update. The target encoder parameters are updated: $\bar{\theta} \leftarrow \tau(t) \bar{\theta} + (1-\tau(t)) \theta$, where $\tau(t)$ follows a cosine schedule from 0.996 to 1.0.

Training Diagram

Training Dynamics and Schedule

Pretraining is conducted on ShapeNet for 300 epochs. The learning rate follows a cosine decay schedule with linear warmup over the first 10 epochs. The EMA momentum $\tau$ increases from 0.996 to 1.0 via a cosine schedule, meaning the target encoder tracks the context encoder closely at the beginning of training (fast updates) and stabilizes near the end (almost frozen). Weight decay of 0.05 is applied to non-bias, non-normalization parameters as standard for AdamW-based Transformer training.

Data augmentation for point clouds during pretraining typically includes random rotation (around the vertical axis), random scaling (0.67–1.5×), random translation, and random point jittering. These augmentations are applied to the raw point cloud before tokenization.

8. Inference

After pretraining, only the context encoder $f_\theta$ (or equivalently the target encoder $f_{\bar{\theta}}$, which has accumulated the EMA of $f_\theta$'s parameters) is retained for downstream tasks. The predictor $g_\phi$ is discarded—it was a training scaffold and has no role at inference time. Critically, no masking is applied at inference: the full set of $N$ tokens is fed to the encoder.

Downstream Protocols

Linear probing. The pretrained encoder is frozen. A linear classifier is trained on top of the encoder's output (typically the [CLS] token or mean-pooled patch representations) using the downstream task's labeled data and cross-entropy loss.

Fine-tuning. The pretrained encoder's weights initialize a new model. A task-specific head (linear layer for classification, segmentation head for part segmentation) is added, and the entire model is trained end-to-end on the downstream dataset with a lower learning rate for the pretrained parameters.

Few-shot evaluation. A small number of labeled examples per class are used to train either a linear classifier or a nearest-neighbor classifier (k-NN) on the frozen encoder's representations, evaluating the quality of the learned features under data scarcity.

Inference Pipeline Diagram

9. Results & Benchmarks

3D-JEPA is evaluated on three standard 3D understanding benchmarks: ModelNet40 (shape classification), ScanObjectNN (real-world object classification), and ShapeNetPart (part segmentation). All models are pretrained on ShapeNet and then transferred.

Shape Classification — ModelNet40

ModelNet40 contains 12,311 CAD models across 40 categories (9,843 train / 2,468 test). Evaluation uses overall accuracy (OA).

3D-JEPA matches or slightly exceeds Point-MAE and Point-BERT without ever reconstructing point coordinates, demonstrating that representation-space prediction captures sufficient geometric and semantic information for shape recognition.

Real-World Classification — ScanObjectNN

ScanObjectNN contains ~15,000 real-world scanned objects across 15 categories. The hardest variant (PB_T50_RS) includes background clutter, perturbations, and translation, making it significantly more challenging than synthetic benchmarks.

On the hardest ScanObjectNN variant (PB_T50_RS), 3D-JEPA achieves 86.8%, surpassing Point-MAE by 1.6 percentage points. This gap is more pronounced than on the synthetic ModelNet40, suggesting that representation-space prediction is particularly advantageous when dealing with noisy, real-world 3D data where exact point reconstruction is less meaningful.

Part Segmentation — ShapeNetPart

ShapeNetPart contains 16,881 shapes across 16 categories, with 50 part labels total. Evaluation uses class-mean and instance-mean IoU.

Improvements on part segmentation are more modest, consistent with prior observations that self-supervised pretraining benefits are smaller on ShapeNetPart due to the overlap between pretraining data (ShapeNet) and segmentation data.

Ablations

Number of target blocks ($M$). The most important ablation validates the multi-block design:

The jump from $M=1$ to $M=4$ is substantial (2.2 points on ScanObjectNN), confirming that multi-block sampling provides a harder, more informative prediction task than single-block masking. Beyond $M=4$, performance plateaus or slightly decreases, likely because too many small blocks reduce the spatial coherence of each target region.

Masking ratio ($r$). Performance is relatively stable across $r \in [0.5, 0.7]$, with $r=0.6$ being the sweet spot. Too little masking ($r < 0.4$) makes the prediction task too easy; too much masking ($r > 0.8$) leaves insufficient context for meaningful prediction.

Representation vs. reconstruction. Replacing the representation-space loss with a point-coordinate reconstruction loss (making the method equivalent to a multi-block Point-MAE variant) degrades ScanObjectNN performance by approximately 1–2 points, providing direct evidence for the advantage of latent prediction in the 3D domain.

10. Connection to JEPA Family

Lineage

3D-JEPA sits on a clear lineage within the JEPA family:

1. JEPA (LeCun, 2022): The conceptual framework—predict in representation space, not input space—using an energy-based formulation with joint embedding architectures.
2. I-JEPA (Assran et al., 2023): The first concrete instantiation for 2D images. Established the context-encoder / EMA-target-encoder / predictor / multi-block-masking recipe that 3D-JEPA inherits.
3. 3D-JEPA (Hu et al., 2024): Adapts I-JEPA to 3D point clouds, addressing the fundamental challenges of irregular geometry, unordered points, and spatial tokenization.

Parallel to 3D-JEPA, other JEPA variants extend the framework to different modalities: Audio-JEPA for spectrograms, MC-JEPA for video with motion compensation, and Point-JEPA (a related but distinct approach to 3D point clouds). 3D-JEPA's specific contribution is demonstrating that the I-JEPA recipe transfers to 3D with appropriate tokenization and spatial masking adaptations.

Relationship to Reconstruction-Based 3D Methods

3D-JEPA stands in explicit contrast to the dominant reconstruction-based paradigm in 3D self-supervised learning:

• Point-BERT uses a discrete variational autoencoder (dVAE) to tokenize point clouds, then trains a BERT-like model to predict masked discrete tokens. This requires a separately trained tokenizer and optimizes a cross-entropy loss over a discrete codebook.
• Point-MAE masks point patches and reconstructs the missing 3D coordinates via Chamfer distance. The decoder must predict exact point positions.
• 3D-JEPA replaces both approaches with a single, unified representation-space prediction objective. No tokenizer pretraining, no point reconstruction, no decoder.

The consistently competitive results against these reconstruction-based methods provide strong evidence that, as conjectured by the JEPA framework, representation-space prediction is at least as effective as input-space reconstruction for learning transferable features—and potentially superior for robustness to noise and domain shift, as evidenced by the larger gains on the real-world ScanObjectNN benchmark.

Influence

3D-JEPA establishes the JEPA framework as a viable paradigm for 3D self-supervised learning, alongside reconstruction-based and contrastive approaches. Its success suggests that future 3D representation learning methods can benefit from operating entirely in latent space, potentially enabling more efficient pretraining (no decoder needed) and better downstream transfer (representations are inherently abstract). The multi-block masking strategy in 3D may inform future work on other irregular data modalities such as graphs, meshes, and molecular structures.

11. Summary

12. References

1. Hu, T., Cheng, Z., Xie, H., Li, X., & Zhu, J. (2024). 3D-JEPA: A Joint Embedding Predictive Architecture for 3D Self-Supervised Representation Learning. arXiv preprint arXiv:2409.15803.
2. Assran, M., Duval, Q., Misra, I., Bojanowski, P., Vincent, P., Rabbat, M., LeCun, Y., & Ballas, N. (2023). Self-Supervised Learning from Images with a Joint-Embedding Predictive Architecture. CVPR 2023.
3. LeCun, Y. (2022). A Path Towards Autonomous Machine Intelligence. OpenReview.
4. Pang, Y., Wang, W., Tay, F. E. H., Liu, W., Tian, Y., & Yuan, L. (2022). Masked Autoencoders for Point Cloud Self-supervised Learning. ECCV 2022.
5. Yu, X., Tang, L., Rao, Y., Huang, T., Zhou, J., & Lu, J. (2022). Point-BERT: Pre-training 3D Point Cloud Transformers with Masked Point Modeling. CVPR 2022.
6. Zhang, R., Guo, Z., Zhang, W., Li, K., Miao, X., Cui, B., Qiao, Y., Gao, P., & Li, H. (2022). Point-M2AE: Multi-scale Masked Autoencoders for Hierarchical Point Cloud Pre-training. NeurIPS 2022.
7. Qi, C. R., Su, H., Mo, K., & Guibas, L. J. (2017). PointNet: Deep Learning on Point Sets for 3D Classification and Segmentation. CVPR 2017.
8. Qi, C. R., Yi, L., Su, H., & Guibas, L. J. (2017). PointNet++: Deep Hierarchical Feature Learning on Point Sets in a Metric Space. NeurIPS 2017.
9. Uy, M. A., Pham, Q.-H., Hua, B.-S., Nguyen, D. T., & Yeung, S.-K. (2019). Revisiting Point Cloud Classification: A New Benchmark Dataset and Classification Model on Real-World Data. ICCV 2019. [ScanObjectNN]
10. Wu, Z., Song, S., Khosla, A., Yu, F., Zhang, L., Tang, X., & Xiao, J. (2015). 3D ShapeNets: A Deep Representation for Volumetric Shapes. CVPR 2015. [ModelNet40]
11. Yi, L., Kim, V. G., Ceylan, D., Shen, I., Yan, M., Su, H., Lu, C., Huang, Q., Sheffer, A., & Guibas, L. (2016). A Scalable Active Framework for Region Annotation in 3D Shape Collections. SIGGRAPH Asia 2016. [ShapeNetPart]
12. Grill, J.-B., Strub, F., Altché, F., Tallec, C., Richemond, P. H., Buchatskaya, E., Doersch, C., Pinto, B. A., Zheng, Z., Azizi, M. O., et al. (2020). Bootstrap Your Own Latent: A New Approach to Self-Supervised Learning. NeurIPS 2020.