Upload 37 mesh papers and MinerU parsed corpus

Includes source PDFs, Markdown, extracted figures, structured JSON, layout-check PDFs, research notes, manifest, README files, and reproduction scripts. Excludes MinerU source, environments, model cache, logs, retries, and duplicate origin PDFs.

.gitattributes

@@ -58,3 +58,7 @@ saved_model/**/* filter=lfs diff=lfs merge=lfs -text
 # Video files - compressed
 *.mp4 filter=lfs diff=lfs merge=lfs -text
 *.webm filter=lfs diff=lfs merge=lfs -text
+papers/markdown/2311.15475_MeshGPT_Generating_Triangle_Meshes_with_Decoder-Only_Transformers/hybrid_auto/2311.15475_MeshGPT_Generating_Triangle_Meshes_with_Decoder-Only_Transformers_layout.pdf filter=lfs diff=lfs merge=lfs -text
+papers/markdown/2405.13745_NeurCross_A_Neural_Approach_to_Computing_Cross_Fields_for_Quad_Mesh_Generation/hybrid_auto/2405.13745_NeurCross_A_Neural_Approach_to_Computing_Cross_Fields_for_Quad_Mesh_Generation_layout.pdf filter=lfs diff=lfs merge=lfs -text
+papers/markdown/2405.20853_MeshXL_Neural_Coordinate_Field_for_Generative_3D_Foundation_Models/hybrid_auto/2405.20853_MeshXL_Neural_Coordinate_Field_for_Generative_3D_Foundation_Models_layout.pdf filter=lfs diff=lfs merge=lfs -text
+papers/markdown/2406.10163_MeshAnything_Artist-Created_Mesh_Generation_with_Autoregressive_Transformers/hybrid_auto/2406.10163_MeshAnything_Artist-Created_Mesh_Generation_with_Autoregressive_Transformers_layout.pdf filter=lfs diff=lfs merge=lfs -text

MINERU_SETUP.md

@@ -0,0 +1,32 @@
+# MinerU deployment notes
+
+- Source: `tools/MinerU`, commit `79d6d8d79fb8f3ddba5cc34c07a16f0ec36f56c7`
+- Environment: `tools/.envs/mineru` (Python 3.12)
+- Versions: MinerU 3.4.4, PyTorch 2.11.0+cu130, vLLM 0.20.2
+- Model cache: `tools/model_cache`
+- Tested hardware: 8 x NVIDIA H100 NVL 96GB; driver 595.71.05
+- Smoke output: `mineru_test_output/smoke_meshgpt`
+- Smoke log: `mineru_test_output/logs/smoke_meshgpt.log`
+
+Highest-quality local command for research PDFs:
+
+```bash
+CUDA_VISIBLE_DEVICES=0 \
+HF_HOME=/data/chenxing/code/docs/tools/model_cache \
+MODELSCOPE_CACHE=/data/chenxing/code/docs/tools/model_cache/modelscope \
+/data/chenxing/code/docs/tools/.envs/mineru/bin/mineru \
+  -p INPUT.pdf -o OUTPUT \
+  -b hybrid-engine --effort high --image-analysis true \
+  --formula true --table true
+```
+
+Eight-GPU batch conversion (one persistent process and model instance per shard):
+
+```bash
+./mineru_convert_8gpu.sh papers/pdfs papers/markdown
+```
+
+`hybrid-engine` is preferable for born-digital papers: native text extraction limits
+OCR/VLM hallucination, while the high-effort VLM path analyzes figures/charts and
+retains formulas and tables. Outputs include Markdown, extracted images, content-list
+JSON, middle JSON, and a layout PDF for visual QA.

README.md

@@ -0,0 +1,81 @@
+---
+language:
+- en
+- zh
+license: other
+pretty_name: Mesh Foundation Papers — MinerU Parsed Corpus
+tags:
+- 3d
+- mesh-generation
+- quadrilateral-mesh
+- triangle-mesh
+- document-ai
+- mineru
+---
+
+# Mesh Foundation Papers — MinerU Parsed Corpus
+
+This repository contains a research corpus of 37 public mesh-generation and
+quad-meshing papers published between November 2023 and July 2026, together
+with high-quality MinerU parsing outputs.
+
+本仓库收录 37 篇 Mesh 生成、三角网格和四边网格相关公开论文，以及使用
+MinerU 高质量模式生成的 Markdown、图片、结构化 JSON 和版面校验文件，便于
+异地下载、全文检索和后续综述研究。
+
+## Contents
+
+- `papers/pdfs/`: 37 source PDFs downloaded from official arXiv endpoints.
+- `papers/markdown/`: one directory per paper containing:
+  - parsed Markdown;
+  - extracted figures and tables under `images/`;
+  - `content_list` / `content_list_v2` JSON;
+  - intermediate and model JSON;
+  - original and layout-check PDFs.
+- `papers/manifest.csv`: title, arXiv metadata, source URL and local filename.
+- `papers/README.md`: download and integrity notes.
+- `research/`: Chinese research notes covering the 2023–2026 timeline,
+  triangle-vs-quad modeling differences and a curated figure index.
+- `scripts/fetch_papers.py`: reproducible downloader.
+- `MINERU_SETUP.md` and `mineru_convert_8gpu.sh`: parsing environment notes and
+  the eight-GPU batch command. MinerU itself, model weights and environments
+  are intentionally not included.
+
+## Parsing configuration
+
+- MinerU 3.4.4
+- Model: MinerU2.5-Pro-2605-1.2B
+- Backend: `hybrid-engine`
+- Quality: `--effort high`
+- Figure analysis, formulas and tables enabled
+- Hardware used: 8 × NVIDIA H100 NVL 96GB
+
+## Integrity summary
+
+- 37/37 source PDFs verified with readable PDF metadata
+- 643 source pages in total
+- 37 non-empty Markdown documents
+- 37 `content_list_v2` JSON files
+- 37 layout-check PDFs
+- 1,904 extracted JPG assets
+- no broken local image references detected in the generated Markdown
+
+## Notes and limitations
+
+- The papers and figures remain copyrighted by their respective authors and
+  publishers. Consult each arXiv record and paper for its applicable license
+  before redistribution or commercial use.
+- This repository is provided as a research convenience and does not relicense
+  the source papers.
+- Many 2026 entries are preprints. Claims in `research/` should be treated as a
+  literature synthesis rather than independently verified consensus.
+- MinerU output may contain extraction errors. Verify exact quotations,
+  equations and numerical results against the source PDF/layout PDF.
+
+## Reproduce
+
+```bash
+python scripts/fetch_papers.py
+./mineru_convert_8gpu.sh papers/pdfs papers/markdown
+```
+

mineru_convert_8gpu.sh

@@ -0,0 +1,64 @@
+#!/usr/bin/env bash
+set -euo pipefail
+
+if [[ $# -ne 2 ]]; then
+  echo "Usage: $0 INPUT_PDF_DIR OUTPUT_DIR" >&2
+  exit 2
+fi
+
+input_dir=$(realpath "$1")
+output_dir=$(realpath -m "$2")
+env_dir=/data/chenxing/code/docs/tools/.envs/mineru
+cache_dir=/data/chenxing/code/docs/tools/model_cache
+
+mkdir -p "$output_dir" "$output_dir/logs"
+work_dir=$(mktemp -d "$output_dir/.shards.XXXXXXXX")
+trap 'rm -rf -- "$work_dir"' EXIT
+
+mapfile -d '' pdfs < <(find "$input_dir" -maxdepth 1 -type f -iname '*.pdf' -print0 | sort -z)
+if [[ ${#pdfs[@]} -eq 0 ]]; then
+  echo "No PDFs found in $input_dir" >&2
+  exit 1
+fi
+
+for gpu in {0..7}; do
+  mkdir -p "$work_dir/$gpu"
+done
+
+for i in "${!pdfs[@]}"; do
+  gpu=$((i % 8))
+  ln -s "${pdfs[$i]}" "$work_dir/$gpu/$(basename "${pdfs[$i]}")"
+done
+
+pids=()
+for gpu in {0..7}; do
+  if find "$work_dir/$gpu" -type l -print -quit | grep -q .; then
+    env CUDA_VISIBLE_DEVICES="$gpu" \
+      HF_HOME="$cache_dir" \
+      MODELSCOPE_CACHE="$cache_dir/modelscope" \
+      "$env_dir/bin/mineru" \
+        -p "$work_dir/$gpu" \
+        -o "$output_dir" \
+        -b hybrid-engine \
+        --effort high \
+        --image-analysis true \
+        --formula true \
+        --table true \
+        >"$output_dir/logs/gpu-$gpu.log" 2>&1 &
+    pids+=("$!")
+  fi
+done
+
+status=0
+for pid in "${pids[@]}"; do
+  if ! wait "$pid"; then
+    status=1
+  fi
+done
+
+if [[ $status -ne 0 ]]; then
+  echo "At least one shard failed; inspect $output_dir/logs/gpu-*.log" >&2
+  exit "$status"
+fi
+
+echo "Converted ${#pdfs[@]} PDFs into $output_dir"

papers/README.md

@@ -0,0 +1,33 @@
+# Mesh 论文 PDF 语料
+
+本目录收录用户清单中的 37 篇论文，来源均为 arXiv 官方页面与 PDF 端点。
+
+## 目录
+
+- `pdfs/`：37 个 PDF，以 `arXiv_ID_规范题名.pdf` 命名。
+- `manifest.csv`：逐篇记录请求日期、请求题名、arXiv 规范题名、首次发布日期、下载状态、来源 URL、文件名和题名匹配度。
+- 下载及核验脚本位于仓库的 `scripts/fetch_papers.py`。
+
+## 完整性核验
+
+- 清单记录：37 条；状态全部为 `downloaded`。
+- 唯一性：37 个 arXiv ID/source URL 均不重复，37 个文件名均不重复。
+- 文件签名：全部以 `%PDF-` 开始，文件末尾均含 `%%EOF`。
+- 可读性：全部 37 个文件可由 Poppler `pdfinfo` 解析，合计 643 页；单篇 10–36 页，无零页或解析失败文件。
+- 当前总大小约 886 MiB。
+
+## 日期说明
+
+清单括号日期被视为用户提供的归档月份，而 `published` 是 arXiv API 返回的首次发布日期。唯一跨月差异是 **Mesh-Pro**：请求月份为 `26.03`，arXiv 首次发布日期为 `2026-02-28`。题名精确一致，因此仍确认是目标论文。
+
+## 复跑
+
+在仓库根目录执行：
+
+```bash
+python3 scripts/fetch_papers.py
+```
+
+脚本通过 arXiv 官方 API 按题名查询，仅接受规范化题名相似度至少 0.72 的结果，并维护 `manifest.csv`。已存在的 PDF 不会重复下载。
+
+后续 Markdown 转换应以 `manifest.csv` 作为索引，建议每篇输出到以 arXiv ID 命名的独立目录，保留图片、表格和页码映射，避免同名论文（尤其两篇 MeshFlow）输出互相覆盖。

papers/manifest.csv

@@ -0,0 +1,38 @@
+requested_date,requested_title,verified_title,published,status,source_url,filename,note
+23.11,MeshGPT: Generating Triangle Meshes with Decoder-Only Transformers,MeshGPT: Generating Triangle Meshes with Decoder-Only Transformers,2023-11-27,downloaded,https://arxiv.org/abs/2311.15475,2311.15475_MeshGPT_Generating_Triangle_Meshes_with_Decoder-Only_Transformers.pdf,match=1.000
+24.05,NeurCross: a neural approach to computing cross fields for quad mesh generation,NeurCross: A Neural Approach to Computing Cross Fields for Quad Mesh Generation,2024-05-22,downloaded,https://arxiv.org/abs/2405.13745,2405.13745_NeurCross_A_Neural_Approach_to_Computing_Cross_Fields_for_Quad_Mesh_Generation.pdf,match=1.000
+24.05,MeshXL: neural coordinate field for generative 3D foundation models,MeshXL: Neural Coordinate Field for Generative 3D Foundation Models,2024-05-31,downloaded,https://arxiv.org/abs/2405.20853,2405.20853_MeshXL_Neural_Coordinate_Field_for_Generative_3D_Foundation_Models.pdf,match=1.000
+24.06,MeshAnything: artist-created mesh generation with autoregressive transformers,MeshAnything: Artist-Created Mesh Generation with Autoregressive Transformers,2024-06-14,downloaded,https://arxiv.org/abs/2406.10163,2406.10163_MeshAnything_Artist-Created_Mesh_Generation_with_Autoregressive_Transformers.pdf,match=1.000
+24.08,MeshAnything V2: artist-created mesh generation with adjacent mesh tokenization,MeshAnything V2: Artist-Created Mesh Generation With Adjacent Mesh Tokenization,2024-08-05,downloaded,https://arxiv.org/abs/2408.02555,2408.02555_MeshAnything_V2_Artist-Created_Mesh_Generation_With_Adjacent_Mesh_Tokenization.pdf,match=1.000
+24.09,EdgeRunner: auto-regressive auto-encoder for artistic mesh generation,EdgeRunner: Auto-regressive Auto-encoder for Artistic Mesh Generation,2024-09-26,downloaded,https://arxiv.org/abs/2409.18114,2409.18114_EdgeRunner_Auto-regressive_Auto-encoder_for_Artistic_Mesh_Generation.pdf,match=1.000
+24.11,Scaling mesh generation via compressive tokenization,Scaling Mesh Generation via Compressive Tokenization,2024-11-11,downloaded,https://arxiv.org/abs/2411.07025,2411.07025_Scaling_Mesh_Generation_via_Compressive_Tokenization.pdf,match=1.000
+24.12,"Meshtron: high-fidelity, artist-like 3D mesh generation at scale","Meshtron: High-Fidelity, Artist-Like 3D Mesh Generation at Scale",2024-12-12,downloaded,https://arxiv.org/abs/2412.09548,2412.09548_Meshtron_High-Fidelity_Artist-Like_3D_Mesh_Generation_at_Scale.pdf,match=1.000
+25.01,Nautilus: locality-aware autoencoder for scalable mesh generation,Nautilus: Locality-aware Autoencoder for Scalable Mesh Generation,2025-01-24,downloaded,https://arxiv.org/abs/2501.14317,2501.14317_Nautilus_Locality-aware_Autoencoder_for_Scalable_Mesh_Generation.pdf,match=1.000
+25.03,TreeMeshGPT: artistic mesh generation with autoregressive tree sequencing,TreeMeshGPT: Artistic Mesh Generation with Autoregressive Tree Sequencing,2025-03-14,downloaded,https://arxiv.org/abs/2503.11629,2503.11629_TreeMeshGPT_Artistic_Mesh_Generation_with_Autoregressive_Tree_Sequencing.pdf,match=1.000
+25.03,DeepMesh: auto-regressive artist-mesh creation with reinforcement learning,DeepMesh: Auto-Regressive Artist-mesh Creation with Reinforcement Learning,2025-03-19,downloaded,https://arxiv.org/abs/2503.15265,2503.15265_DeepMesh_Auto-Regressive_Artist-mesh_Creation_with_Reinforcement_Learning.pdf,match=1.000
+25.03,MeshCraft: exploring efficient and controllable mesh generation with flow-based DiTs,MeshCraft: Exploring Efficient and Controllable Mesh Generation with Flow-based DiTs,2025-03-29,downloaded,https://arxiv.org/abs/2503.23022,2503.23022_MeshCraft_Exploring_Efficient_and_Controllable_Mesh_Generation_with_Flow-based_DiTs.pdf,match=1.000
+25.05,Mesh-RFT: enhancing mesh generation via fine-grained reinforcement fine-tuning,Mesh-RFT: Enhancing Mesh Generation via Fine-grained Reinforcement Fine-Tuning,2025-05-22,downloaded,https://arxiv.org/abs/2505.16761,2505.16761_Mesh-RFT_Enhancing_Mesh_Generation_via_Fine-grained_Reinforcement_Fine-Tuning.pdf,match=1.000
+25.06,CrossGen: learning and generating cross fields for quad meshing,CrossGen: Learning and Generating Cross Fields for Quad Meshing,2025-06-08,downloaded,https://arxiv.org/abs/2506.07020,2506.07020_CrossGen_Learning_and_Generating_Cross_Fields_for_Quad_Meshing.pdf,match=1.000
+25.07,Topology-preserved auto-regressive mesh generation in the manner of weaving silk,Topology-Preserved Auto-regressive Mesh Generation in the Manner of Weaving Silk,2025-07-03,downloaded,https://arxiv.org/abs/2507.02477,2507.02477_Topology-Preserved_Auto-regressive_Mesh_Generation_in_the_Manner_of_Weaving_Silk.pdf,match=1.000
+25.08,VertexRegen: mesh generation with continuous level of detail,VertexRegen: Mesh Generation with Continuous Level of Detail,2025-08-12,downloaded,https://arxiv.org/abs/2508.09062,2508.09062_VertexRegen_Mesh_Generation_with_Continuous_Level_of_Detail.pdf,match=1.000
+25.08,FastMesh: Efficient Artistic Mesh Generation via Component Decoupling,FastMesh: Efficient Artistic Mesh Generation via Component Decoupling,2025-08-26,downloaded,https://arxiv.org/abs/2508.19188,2508.19188_FastMesh_Efficient_Artistic_Mesh_Generation_via_Component_Decoupling.pdf,match=1.000
+25.09,QuadGPT: Native Quadrilateral Mesh Generation with Autoregressive Models,QuadGPT: Native Quadrilateral Mesh Generation with Autoregressive Models,2025-09-25,downloaded,https://arxiv.org/abs/2509.21420,2509.21420_QuadGPT_Native_Quadrilateral_Mesh_Generation_with_Autoregressive_Models.pdf,match=1.000
+25.09,ARMesh: autoregressive mesh generation via next-level-of-detail prediction,ARMesh: Autoregressive Mesh Generation via Next-Level-of-Detail Prediction,2025-09-25,downloaded,https://arxiv.org/abs/2509.20824,2509.20824_ARMesh_Autoregressive_Mesh_Generation_via_Next-Level-of-Detail_Prediction.pdf,match=1.000
+25.09,MeshMosaic: scaling artist mesh generation via local-to-global assembly,MeshMosaic: Scaling Artist Mesh Generation via Local-to-Global Assembly,2025-09-24,downloaded,https://arxiv.org/abs/2509.19995,2509.19995_MeshMosaic_Scaling_Artist_Mesh_Generation_via_Local-to-Global_Assembly.pdf,match=1.000
+25.10,"Topology sculptor, shape refiner: discrete diffusion model for high-fidelity 3D meshes generation","Topology Sculptor, Shape Refiner: Discrete Diffusion Model for High-Fidelity 3D Meshes Generation",2025-10-24,downloaded,https://arxiv.org/abs/2510.21264,2510.21264_Topology_Sculptor_Shape_Refiner_Discrete_Diffusion_Model_for_High-Fidelity_3D_Meshes_Generation.pdf,match=1.000
+25.12,MeshRipple: structured autoregressive generation of artist-meshes,MeshRipple: Structured Autoregressive Generation of Artist-Meshes,2025-12-08,downloaded,https://arxiv.org/abs/2512.07514,2512.07514_MeshRipple_Structured_Autoregressive_Generation_of_Artist-Meshes.pdf,match=1.000
+26.03,LATO: 3D Mesh Flow Matching with Structured TOpology Preserving LAtents,LATO: 3D Mesh Flow Matching with Structured TOpology Preserving LAtents,2026-03-06,downloaded,https://arxiv.org/abs/2603.06357,2603.06357_LATO_3D_Mesh_Flow_Matching_with_Structured_TOpology_Preserving_LAtents.pdf,match=1.000
+26.03,Mesh-pro: asynchronous advantage-guided ranking preference optimization for artist-style quadrilateral mesh generation,Mesh-Pro: Asynchronous Advantage-guided Ranking Preference Optimization for Artist-style Quadrilateral Mesh Generation,2026-02-28,downloaded,https://arxiv.org/abs/2603.00526,2603.00526_Mesh-Pro_Asynchronous_Advantage-guided_Ranking_Preference_Optimization_for_Artist-style_Quadrilateral_Mesh_Generation.pdf,match=1.000
+26.03,FACE: a face-based autoregressive representation for high-fidelity and efficient mesh generation,FACE: A Face-based Autoregressive Representation for High-Fidelity and Efficient Mesh Generation,2026-03-02,downloaded,https://arxiv.org/abs/2603.01515,2603.01515_FACE_A_Face-based_Autoregressive_Representation_for_High-Fidelity_and_Efficient_Mesh_Generation.pdf,match=1.000
+26.03,TopGen: learning structural layouts and cross-fields for quadrilateral mesh generation,TopGen: Learning Structural Layouts and Cross-Fields for Quadrilateral Mesh Generation,2026-03-11,downloaded,https://arxiv.org/abs/2603.10606,2603.10606_TopGen_Learning_Structural_Layouts_and_Cross-Fields_for_Quadrilateral_Mesh_Generation.pdf,match=1.000
+26.03,TopoMesh: high-fidelity mesh autoencoding via topological unification,TopoMesh: High-Fidelity Mesh Autoencoding via Topological Unification,2026-03-25,downloaded,https://arxiv.org/abs/2603.24278,2603.24278_TopoMesh_High-Fidelity_Mesh_Autoencoding_via_Topological_Unification.pdf,match=1.000
+26.04,Strips as tokens: artist mesh generation with native UV segmentation,Strips as Tokens: Artist Mesh Generation with Native UV Segmentation,2026-04-10,downloaded,https://arxiv.org/abs/2604.09132,2604.09132_Strips_as_Tokens_Artist_Mesh_Generation_with_Native_UV_Segmentation.pdf,match=1.000
+26.04,SQuadGen: generating simple quad layouts via chart distance fields,SQuadGen: Generating Simple Quad Layouts via Chart Distance Fields,2026-04-30,downloaded,https://arxiv.org/abs/2604.27329,2604.27329_SQuadGen_Generating_Simple_Quad_Layouts_via_Chart_Distance_Fields.pdf,match=1.000
+26.05,QuadLink: autoregressive quad-dominant mesh generation via point-relation learning,QuadLink: Autoregressive Quad-Dominant Mesh Generation via Point-Relation Learning,2026-05-16,downloaded,https://arxiv.org/abs/2605.16813,2605.16813_QuadLink_Autoregressive_Quad-Dominant_Mesh_Generation_via_Point-Relation_Learning.pdf,match=1.000
+26.06,MeshFlow: Efficient Artistic Mesh Generation via MeshVAE and Flow-based Diffusion Transformer,MeshFlow: Efficient Artistic Mesh Generation via MeshVAE and Flow-based Diffusion Transformer,2026-06-03,downloaded,https://arxiv.org/abs/2606.04621,2606.04621_MeshFlow_Efficient_Artistic_Mesh_Generation_via_MeshVAE_and_Flow-based_Diffusion_Transformer.pdf,match=1.000
+26.06,TriFlow: generating artist-like 3D mesh topology via nearest-vertex vector fields,TriFlow: Generating Artist-Like 3D Mesh Topology via Nearest-Vertex Vector Fields,2026-06-18,downloaded,https://arxiv.org/abs/2606.20131,2606.20131_TriFlow_Generating_Artist-Like_3D_Mesh_Topology_via_Nearest-Vertex_Vector_Fields.pdf,match=1.000
+26.06,MeshFlow: mesh generation with equivariant flow matching,MeshFlow: Mesh Generation with Equivariant Flow Matching,2026-06-22,downloaded,https://arxiv.org/abs/2606.23489,2606.23489_MeshFlow_Mesh_Generation_with_Equivariant_Flow_Matching.pdf,match=1.000
+26.06,Mesh BDF: barycentric dominance field for 3D native mesh generation,Mesh BDF: Barycentric Dominance Field for 3D Native Mesh Generation,2026-06-30,downloaded,https://arxiv.org/abs/2606.31777,2606.31777_Mesh_BDF_Barycentric_Dominance_Field_for_3D_Native_Mesh_Generation.pdf,match=1.000
+26.07,Nexus: native mesh generation with diffusion,Nexus: Native Mesh Generation with Diffusion,2026-07-15,downloaded,https://arxiv.org/abs/2607.13563,2607.13563_Nexus_Native_Mesh_Generation_with_Diffusion.pdf,match=1.000
+26.07,LATO.2: factorized 3D mesh generation with vertex and topology flow,LATO.2: Factorized 3D Mesh Generation with Vertex and Topology Flow,2026-07-12,downloaded,https://arxiv.org/abs/2607.10623,2607.10623_LATO.2_Factorized_3D_Mesh_Generation_with_Vertex_and_Topology_Flow.pdf,match=1.000
+26.07,Meshy T2: fast native mesh generation with flow matching,Meshy T2: Fast Native Mesh Generation with Flow Matching,2026-07-28,downloaded,https://arxiv.org/abs/2607.28675,2607.28675_Meshy_T2_Fast_Native_Mesh_Generation_with_Flow_Matching.pdf,match=1.000

papers/markdown/2311.15475_MeshGPT_Generating_Triangle_Meshes_with_Decoder-Only_Transformers/hybrid_auto/2311.15475_MeshGPT_Generating_Triangle_Meshes_with_Decoder-Only_Transformers.md

@@ -0,0 +1,642 @@
+# MeshGPT: Generating Triangle Meshes with Decoder-Only Transformers
+
+Yawar Siddiqui<sup>1</sup> Antonio Alliegro<sup>2</sup> Alexey Artemov<sup>1</sup>
+
+Tatiana Tommasi<sup>2</sup> Daniele Sirigatti<sup>3</sup> Vladislav Rosov<sup>3</sup> Angela Dai<sup>1</sup> Matthias Nießner<sup>1</sup>
+
+Technical University of Munich<sup>1</sup> Politecnico di Torino<sup>2</sup> AUDI AG<sup>3</sup>
+
+![](images/3545e4e678461da72e464d2647815436fc502f261b64157952c11a9676ecbf7e.jpg)
+
+<details>
+<summary>flowchart</summary>
+
+```mermaid
+graph LR
+  A["Shape Dataset"] --> B["Face Encoder"]
+  B --> C["Embedding Codebook"]
+  C --> D["Token Decoder"]
+  D --> E["GPT-Style Transformer"]
+  E --> F["MeshGPT: Autoregressive Mesh Generation"]
+```
+</details>
+
+Figure 1. Our method creates triangle meshes by autoregressively sampling from a transformer model that has been trained to produce tokens from a learned geometric vocabulary. These tokens can then be decoded into the faces of a triangle mesh. Our method generates clean, coherent, and compact meshes, characterized by sharp edges and high fidelity.
+
+## Abstract
+
+We introduce MeshGPT, a new approach for generating triangle meshes that reflects the compactness typical of artist-created meshes, in contrast to dense triangle meshes extracted by iso-surfacing methods from neural fields. Inspired by recent advances in powerful large language models, we adopt a sequence-based approach to autoregressively generate triangle meshes as sequences of triangles. Wefirst learn a vocabulary oflatent quantized embeddings, using graph convolutions, which inform these embeddings ofthe local mesh geometry and topology. These embeddings are sequenced and decoded into triangles by a decoder, ensuring that they can effectively reconstruct the mesh. A transformer is then trained on this learned vocabulary to predict the index of the next embedding given previous embeddings. Once trained, our model can be autoregressively sampled to generate new triangle meshes, directly generating compact meshes with sharp edges, more closely imitating the efficient triangulation patterns of human-crafted meshes. MeshGPT demonstrates a notable improvement over state of the art mesh generation methods, with a 9% increase in shape coverage and a 30-point enhancement in FID scores across various categories.
+
+## 1. Introduction
+
+Triangle meshes are the main representation for 3D geometry in computer graphics. They are the predominant representation for 3D assets used in video games, movies, and virtual reality interfaces. Compared to alternative 3D shape representations such as point clouds or voxels, meshes provide a more coherent surface representation; they are more controllable, easier to manipulate, more compact, and fit directly into modern rendering pipelines, attaining high visual quality with far fewer primitives. In this paper, we tackle the task of automated generation of triangle meshes, streamlining the process of crafting 3D assets.
+
+Recently, 3D vision research has seen great interest in generative 3D models using representations such as voxels [3, 62], point clouds [37, 67, 68], and neural fields [14, 19, 31, 35, 41]. However, these representations must then be converted into meshes through a post-process for use in downstream applications, for instance by iso-surfacing with Marching Cubes [36]. Unfortunately, this results in dense, over-tessellated meshes that often exhibit oversmoothing and bumpy artifacts from the iso-surfacing, as shown in Figure 2. In contrast, artist-modeled 3D meshes are compact in representation, while maintaining sharp details with much fewer triangles.
+
+Thus, we propose MeshGPT<sup>1</sup> to generate a mesh representation directly, as a set of triangles. Inspired by powerful recent advances in generative models for language, we adopt a direct sequence generation approach to synthesize triangle meshes as sequences of triangles. Following text generation paradigms, we first learn a vocabulary of triangles. Triangles are encoded into latent quantized embeddings through an encoder. To encourage learned triangle embeddings to maintain local geometric and topological features, we employ a graph convolutional encoder. These triangle embeddings are then decoded by a ResNet [22] decoder that processes the sequence of tokens representing a triangle to produce its vertex coordinates. We can then train a GPT-based architecture on this learned vocabulary to autoregressively produce sequences of triangles representing a mesh. Experiments across multiple categories of the ShapeNet dataset demonstrate that our method significantly improves 3D mesh generation quality in comparison with state of the art, with an average 9% increase in shape coverage and a 30-point improvement in FID scores.
+
+![](images/9c49a05ead13fc277ddba7a5d49bbf787caf1c0d5ba8613e0e8d8d464e85ac30.jpg)  
+Figure 2. Meshes generated by our method (top) for chairs, tables, benches, and lamps when trained on ShapeNet [5]. MeshGPT meshes tend to be compact, with the ability to represent both sharp details and curved boundaries. This contrasts with neural fieldbased approaches that yield dense triangulations not easily simplified through decimation (bottom).
+
+In summary, our contributions are:
+
+• A new generative formulation for meshes as a sequence of triangles, tailoring a GPT-inspired decoder-only transformer, to produce compact meshes with sharp edges.  
+• Triangles are represented as a vocabulary of latent geometric tokens to enable coherent mesh generation in an autoregressive fashion.
+
+## 2. Related Work
+
+Voxel-based 3D Shape Generation. Early shape generation approaches generated shapes as a grid of low-resolution voxels [3, 9, 26, 62] or, more recently, as high-resolution grids using efficient representations such as Octrees [57] and sparse voxels [50], with generative models such as GANs [17]. These methods pioneered the extension of 2D generative techniques into the 3D domain. However, the voxel representation inherently constrains them with gridlike artifacts and high memory requirements, limiting their practical utility in capturing fine details and complex geometries.
+
+Point Cloud Generation. Methods in this category represent 3D shapes by point samples on their surfaces, aiming to learn point distributions across shape datasets. Early works involved GANs for synthesizing point locations [30, 54, 59] and latent shape codes [1]. Flow-based [64] and gradient field-based models [4] also yield impressive results. Recently, diffusion-based techniques have been adapted for point cloud generation [44, 67, 68], showing competitive performance in shape generation. However, point clouds, while useful, are not the ideal format for downstream applications requiring 3D content, as converting them to meshes, which apart from being non-trivial [42, 47, 51, 65], can often fail to accurately reflect the characteristics of the underlying mesh datasets.
+
+Neural Implicit Fields. Implicit representation of shapes as volumetric functions (e.g., signed distance functions) has become popular for encoding arbitrary topologies at any resolution [39, 45]. Various implicit generative methods have shown impressive performance using adversarial [6, 53] and diffusion-based [8, 14, 41] models. Diffusion-based neural field synthesis in MLP weight spaces [13] and triplanes [55] have also been explored, alongside leveraging image-based models for optimizing NeRFs [25, 34, 48, 63]. However, like point clouds, these methods require mesh conversion [12, 32, 36, 49, 53] for downstream applications, often leading to dense meshes that don’t capture the properties of the underlying datasets (e.g., edge lengths, dihedral angles). In contrast, we directly fit a generative model to triangulated meshes, explicitly modeling the training data, resulting in clean, compact and coherent meshes as outputs.
+
+3D Mesh Generation. While several discriminative approaches capable of learning signals directly on mesh structure were proposed over the recent years [16, 21, 23, 33, 40, 52, 56], direct mesh generation remains underexplored. Mesh generation has been approached with various learning-based methods [7, 11, 18, 43]. AtlasNet [18] and BSPNet [7], for example, produce mesh patches and compact meshes through binary space partitioning, respectively. However, as we demonstrate in Sec. 4, these struggle with accurately capturing shape detail.
+
+Closely related to our work, PolyGen [43] employs two autoregressively trained networks to create explicit mesh structures. In contrast, our method utilizes a single decoderonly network, representing triangles through learned tokens for a more streamlined generation process compared to PolyGen’s separate vertex-and-face sequence approach. Additionally, we observe that PolyGen’s vertex generator, oblivious to face generation, and the face generator, not exposed to the generated vertex distribution during training, exhibit limited robustness during inference.
+
+## 3. Method
+
+Inspired by advancements in large language models, we develop a sequence-based approach to autoregressively generate triangle meshes as sequences of triangles. We first learn a vocabulary of geometric embeddings from a large collection of 3D object meshes, enabling triangles to be encoded to and decoded from this embedding. We then train a transformer for mesh generation as autoregressive nextindex prediction over the learned vocabulary embeddings.
+
+To learn the triangle vocabulary, we employ a graph convolution encoder operating on triangles of a mesh and their neighborhood to extract geometrically rich features that capture the intricate details of 3D shapes. These features are quantized as embeddings of a codebook using residual quantization [27, 38], effectively reducing sequence lengths of the mesh representation. These embeddings are sequenced and then decoded by a 1D ResNet [22] guided by a reconstruction loss. This phase lays the groundwork for the subsequent training of the transformer.
+
+We then train a GPT-style decoder-only transformer, which leverages these quantized geometric embeddings. Given a sequence of geometric embeddings extracted from the triangles of a mesh, the transformer is trained to predict the codebook index of the next embedding in the sequence. Once trained, the transformer can be auto-regressively sampled to predict sequences of embeddings. These embeddings can then be decoded to generate novel and diverse mesh structures that display efficient, irregular triangulations similar to human-crafted meshes.
+
+## 3.1. Learning Quantized Triangle Embeddings
+
+Autoregressive generative models, such as transformers, synthesize sequences of tokens where each new token is conditioned on previously generated tokens. For generating meshes using transformers, we must then define the ordering convention of generation, along with the tokens.
+
+For sequence ordering, Polygen [43] suggests a convention where faces are ordered based on their lowest vertex index, followed by the next lowest, and so forth. Vertices are sorted in $z - y - x$ order (z representing the vertical axis), progressing from lowest to highest. Within each face, indices are cyclically permuted to place the lowest index first. In our method, we also adopt this sequencing approach.
+
+To define the tokens to generate, we consider a practical approach to represent a mesh M for autoregressive generation: a sequence of triangles,
+
+$$
+\mathcal {M} := (f _ {1}, f _ {2}, f _ {3}, \dots , f _ {N}), \tag {1}
+$$
+
+with N faces (triangles), $f _ { i } \in \mathbb { R } ^ { n _ { \mathrm { i n } } }$ having $n _ { \mathrm { i n } }$ features. A simple approach to describe each triangle is as its three vertices, comprising nine total coordinates. Upon discretization, these coordinates can be treated as tokens. The sequence length in this case would be 9N.
+
+![](images/68bf00eef4f292ec6f6d2b982ffb3ea487e15df8e5bbe5ed3e13d7f0d3653820.jpg)
+
+<details>
+<summary>flowchart</summary>
+
+```mermaid
+graph LR
+  InputMesh["Input Mesh"] -->|"| F| × C_in"| GraphConv["Graph Convolutional Encoder"]
+  ReconstructedMesh["Reconstructed Mesh"] -->|"| F| × 9"| ResNetDecoder["ResNet Decoder"]
+  GraphConv -->|"| F| × C_e"| ResidualFaceQuant["Residual Face Quantization Module"]
+  ResNetDecoder --> SequenceOfFaces["Sequence Of Faces"]
+  SequenceOfFaces -->|"| F| × C_e"| ResidualFaceQuant
+  ResidualFaceQuant -->|"| F| ×"| ResidualFaceQuantModule["Residual Face Quantization Module"]
+  ResidualFaceQuantModule -->|"C_e"| SumResidualFeatures["Sum Residual Features"]
+  ResidualFaceQuantModule -->|"D × C_e"| Reshape["Reshape"]
+  Reshape --> FeatureCodebook["Feature Codebook"]
+  FeatureCodebook --> MeanAcrossSharedVertices["Mean across Shared Vertices"]
+  MeanAcrossSharedVertices --> SplitFeature["Split Feature"]
+  SplitFeature -->|"C_e"| SumResidualFeatures
+```
+</details>
+
+Figure 3. We employ a graph convolutional encoder to process mesh faces, leveraging geometric neighborhood information to capture strong features representing intricate details of 3D shapes. These features are then quantized into codebook embeddings using residual quantization [27, 38]. In contrast to naive vector quantization, this ensures better reconstruction quality. The quantized embeddings are subsequently sequenced and decoded through a 1D ResNet [22], guided by a reconstruction loss.
+
+However, we observe two major challenges when using coordinates directly as tokens. First, the sequence lengths become excessively long, as each face is represented by nine values. This length does not scale well with transformer architectures, which often have limited context windows. Second, representing discrete positions of a triangle as tokens fails to capture geometric patterns effectively. This is because such a representation lacks information about neighboring triangles and does not incorporate any priors from mesh distributions.
+
+To address the aforementioned challenges, we propose to learn geometric embeddings from a collection of triangular meshes, utilizing an encoder-decoder architecture with residual vector quantization at its bottleneck (Fig. 3).
+
+The network’s encoder E employs graph convolutions on mesh faces, where each face forms a node and neighboring faces are connected by undirected edges. The input face node features are comprised of the nine positionally encoded coordinates of its vertices, face normal, angles between its edges, and area. These features undergo processing through a stack of SAGEConv [20] layers, extracting a feature vector for each face. This graph convolutional approach enables the extraction of geometrically enriched features $z _ { i } \in \mathbb { R } ^ { n _ { \mathrm { z } } }$ for each face,
+
+$$
+\mathbf {Z} = (z _ {1}, z _ {2}, \dots , z _ {N}) = E (\mathcal {M}), \tag {2}
+$$
+
+fusing neighborhood information into the learned embeddings.
+
+For quantization, we employ residual vector quantization (RQ) [38]. We found that using a single code per face is insufficient for accurate reconstruction. Instead, we use a stack of D codes per face. Further, we find that instead of directly using D codes per face, it is more effective to first divide the feature channels among the vertices, aggregate the features by shared vertex indices, and then quantize these vertex-based features, giving $\frac { \mathrm { D } } { 3 }$ codes per vertex, and therefore effectively D codes per face. This leads to sequences that are easier to learn for the transformer trained subsequently (see Tab. 3 and Fig. 10 for comparison). Formally, given a codebook C, RQ with depth D represents features Z as
+
+$$
+\mathbf {T} = (t _ {1}, t _ {2}, \dots , t _ {N}) = \mathrm{RQ} (\mathbf {Z}; \mathcal {C}, D), \tag {3}
+$$
+
+$$
+t _ {i} = (t _ {i} ^ {1}, t _ {i} ^ {2}, \dots , t _ {i} ^ {D}), \tag {4}
+$$
+
+where $t _ { i }$ is a stack of tokens, each token $t _ { i } ^ { d }$ being an index to an embedding $\mathbf { e } ( t _ { i } ^ { d } )$ in the codebook C.
+
+The decoder then decodes the quantized face embeddings to triangles. First, the stack of D features is reduced to a single feature per face through summation across embeddings and concatenation across vertices,
+
+$$
+\hat {\mathbf {Z}} = (\hat {z} _ {1}, \dots , \hat {z} _ {N}), \text {with} \hat {z} _ {i} = \oplus_ {v = 0} ^ {2} \sum_ {d = 1} ^ {\frac {D}{3}} \mathbf {e} (t _ {i} ^ {3. v + d}). \tag {5}
+$$
+
+The face embeddings are arranged in the previously described order, and a 1D ResNet34 decoding head G processes the resulting sequence to output the reconstructed mesh ${ \hat { \mathcal { M } } } = G ( { \hat { \mathbf { Z } } } )$ with 9 coordinates representing each face. We observe that predicting these coordinates as discrete variables, i.e. as a probability distribution over a set of discrete values, leads to a more accurate reconstruction compared to regressing them as real values (Fig. 4). A cross-entropy loss on the discrete mesh coordinates and a commitment loss for the embeddings guides the reconstruction process. More details can be found in supplementary.
+
+![](images/ee8d3956b2fa1fe0a598529c608460da65258fd9b5188ac3e5354bbc23759131.jpg)
+
+<details>
+<summary>natural_image</summary>
+
+Three 3D wireframe models of a chair: one with real-valued outputs, one with discrete outputs, and the ground truth (no text or symbols on the models themselves)
+</details>
+
+Figure 4. Our method utilizes a ResNet [22] decoder that outputs mesh faces as a distribution over discretized coordinate values (center), as opposed to regression of continuous values (left). This significantly reduces floating face artifacts, leading to reconstructions that more closely resemble the ground truth (right).
+
+After training, the graph encoder E and codebook C are incorporated into the transformer training, using T from Eq. 3 as the token sequence. With $| \mathbf { T } | = D N$ , this sequence is more concise than the naive 9N-length tokenization when $D \ < \ 9 .$ Thus, we obtain geometrically rich embeddings with shorter sequence lengths, overcoming our initial challenges and paving the way for efficient mesh generation.
+
+## 3.2. Mesh Generation with Transformers
+
+![](images/72cb966cd94dd8b5076080c802a06cda11de1a0168b09a46a1aa9944576b1ec9.jpg)
+
+<details>
+<summary>flowchart</summary>
+
+```mermaid
+graph LR
+  A["Face Graph + Input Features"] --> B["Graph Convolutional Encoder"]
+  B --> C["Residual Face Quantization Module"]
+  C --> D["Sequence & Flatten"]
+  D --> E["GPT-Style Transformer"]
+  E --> F["Predicted Codebook Indices"]
+  F --> G["GT Codebook Indices"]
+  G --> H["CE Loss"]
+```
+</details>
+
+Figure 5. We employ a transformer to generate mesh sequences as token indices from a pre-learned codebook vocabulary. During training, a graph encoder extracts features from mesh faces, which are quantized into a set of face embeddings. These embeddings are flattened, bookended with start and end tokens, and fed into a GPTstyle transformer. This decoder predicts the subsequent codebook index for each embedding, optimized via cross-entropy loss.
+
+We employ a decoder-only transformer architecture from the GPT family of models to predict meshes as sequences of indices from the learned codebook in Sec. 3.1. The input to this transformer consists of embeddings $\mathbf { e } ( t _ { i } ^ { d } )$ extracted from the mesh M using the GraphConv encoder E and quantized using RQ (Eq. 3). The embeddings are prefixed and suffixed with a learned start and end embedding. Additionally, learned discrete positional encodings are added, indicating the position of each face in the sequence and the index of each embedding within the face. The features then pass through a stack of multiheaded self-attention layers, where the transformer is trained to predict the codebook index of the next embedding in the sequence (Fig. 5). Essentially, we maximize the log probability of the training sequences with respect to the transformer parameters θ,
+
+$$
+\prod_ {i = 1} ^ {N} \prod_ {d = 1} ^ {D} p (t _ {i} ^ {d} \mid \mathbf {e} (t _ {<   i} ^ {d}), \mathbf {e} (t _ {i} ^ {<   d}); \theta). \tag {6}
+$$
+
+Once the transformer is trained, it can autoregressively generate a sequence of tokens, starting with a start token and continuing until a stop token is encountered using beam sampling. The codebook embeddings indexed by this sequence of tokens is then decoded by decoder G to produce the generated mesh. As this output initially forms a ‘triangle soup’ with duplicate vertices for neighboring faces, we apply a simple post-processing operation to merge close vertices (e.g., with MeshLab), to yield the final mesh.
+
+## 3.3. Implementation Details
+
+In learning the triangle vocabulary, our residual quantization layer features a depth of 2, yielding D = 6 embeddings per face, each with dimension 192. The codebook is dynamically updated using an exponential moving average of the clustered features. Following [29], we incorporate stochastic sampling of codes and employ a shared codebook across all levels. The decoder predicts the coordinates of the faces across 128 classes, resulting in a discretization of space to 128<sup>3</sup> possible values. This encoder-decoder network is trained using 2 A100 GPUs for ≈ 2 days.
+
+For our transformer, we use a GPT2-medium model, equipped with a context window of up to 4608 embeddings. The model is trained on 4 A100 GPUs, for ≈ 5 days.
+
+Both the encoder-decoder network and the transformer are written using the Pytorch [46] and are trained utilizing the ADAM optimizer [28]. We set the learning rate at 1 × $1 0 ^ { - 4 }$ and use an effective batch size of 64.
+
+## 4. Experiments
+
+## 4.1. Dataset and Metrics
+
+Data. We present our results on the ShapeNetV2 dataset. Both the encoder-decoder network and the GPT model are trained across all 55 categories of this dataset. Additionally, we fine-tune the GPT model specifically on four categories: Chair, Table, Bench, and Lamp. The results are reported on these categories. During training, we employ augmentation techniques including random shifts and random scaling to enhance the diversity of the training meshes. Similar to Polygen [43], we also apply planar decimation to further augment the shapes. To ensure that the entire mesh fits into the transformer’s context window, we select only those meshes for training that have fewer than 800 faces post-decimation. Detailed information regarding the augmentation processes, decimation techniques, and data splits are provided in the supplementary material.
+
+Metrics. Evaluating the unconditional synthesis of 3D shapes presents challenges due to the absence of direct ground truth correspondence. Hence, we utilize established metrics for assessment, consistent with previous works [37, 67, 68]. These include Minimum Matching Distance (MMD), Coverage (COV), and 1-Nearest-Neighbor Accuracy (1-NNA). For MMD, lower is better; for COV, higher is better; for 1-NNA, 50% is the optimal. We use a Chamfer Distance (CD) distance measure for computing these metrics in 3D. More details about these metrics can be found in the supplementary.
+
+The aforementioned metrics effectively measure the quality of shapes but do not address the visual similarity of the generated meshes to the real distribution. To assess this aspect, we render both the generated meshes and the
+
+<table><tr><td>Class</td><td>Method</td><td>COV↑</td><td>MMD↓</td><td>1-NNA</td><td>FID↓</td><td>KID↓</td><td>|V|</td><td>|F|</td></tr><tr><td rowspan="6">Chair</td><td>AtlasNet [18]</td><td>9.03</td><td>4.05</td><td>95.13</td><td>170.71</td><td>0.169</td><td>2500</td><td>4050</td></tr><tr><td>BSPNet [7]</td><td>16.48</td><td>3.62</td><td>91.75</td><td>46.73</td><td>0.030</td><td>673</td><td>1165</td></tr><tr><td>Polygen [43]</td><td>31.22</td><td>4.41</td><td>93.56</td><td>61.10</td><td>0.043</td><td>248</td><td>603</td></tr><tr><td>GET3D [14]</td><td>40.85</td><td>3.56</td><td>83.04</td><td>81.45</td><td>0.054</td><td>13725</td><td>27457</td></tr><tr><td>GET3D*</td><td>38.75</td><td>3.57</td><td>84.07</td><td>78.29</td><td>0.065</td><td>199</td><td>399</td></tr><tr><td>MeshGPT</td><td>43.28</td><td>3.29</td><td>75.51</td><td>18.46</td><td>0.010</td><td>125</td><td>228</td></tr><tr><td rowspan="6">Table</td><td>AtlasNet [18]</td><td>7.16</td><td>3.85</td><td>96.30</td><td>161.38</td><td>0.150</td><td>2500</td><td>4050</td></tr><tr><td>BSPNet [7]</td><td>16.83</td><td>3.14</td><td>93.58</td><td>30.78</td><td>0.017</td><td>420</td><td>699</td></tr><tr><td>Polygen [43]</td><td>32.99</td><td>3.00</td><td>88.65</td><td>38.53</td><td>0.029</td><td>147</td><td>454</td></tr><tr><td>GET3D [14]</td><td>41.70</td><td>2.78</td><td>85.54</td><td>93.93</td><td>0.076</td><td>13767</td><td>27537</td></tr><tr><td>GET3D*</td><td>37.95</td><td>2.85</td><td>81.93</td><td>50.46</td><td>0.037</td><td>199</td><td>399</td></tr><tr><td>MeshGPT</td><td>45.68</td><td>2.36</td><td>72.88</td><td>6.24</td><td>0.002</td><td>99</td><td>187</td></tr><tr><td rowspan="4">Bench</td><td>AtlasNet [18]</td><td>20.53</td><td>2.47</td><td>90.58</td><td>189.39</td><td>0.163</td><td>2500</td><td>4050</td></tr><tr><td>BSPNet [7]</td><td>28.74</td><td>2.05</td><td>88.44</td><td>59.11</td><td>0.030</td><td>457</td><td>756</td></tr><tr><td>Polygen [43]</td><td>51.92</td><td>1.97</td><td>76.98</td><td>49.34</td><td>0.031</td><td>172</td><td>430</td></tr><tr><td>MeshGPT</td><td>55.23</td><td>1.44</td><td>68.24</td><td>8.72</td><td>0.001</td><td>159</td><td>291</td></tr><tr><td rowspan="4">Lamp</td><td>AtlasNet [18]</td><td>19.97</td><td>4.68</td><td>91.85</td><td>177.91</td><td>0.139</td><td>2500</td><td>4050</td></tr><tr><td>BSPNet [7]</td><td>18.38</td><td>5.32</td><td>93.13</td><td>112.65</td><td>0.077</td><td>587</td><td>1011</td></tr><tr><td>Polygen [43]</td><td>47.86</td><td>4.18</td><td>81.42</td><td>52.48</td><td>0.025</td><td>185</td><td>558</td></tr><tr><td>MeshGPT</td><td>53.88</td><td>3.94</td><td>65.73</td><td>19.91</td><td>0.004</td><td>150</td><td>288</td></tr></table>
+
+Table 1. Quantitative comparison on the task of unconditional mesh generation on a subset of categories from the ShapeNet [5] dataset. GET3D\* refers to meshes simplified to 400 faces using QEM [15]. MMD values are multiplied by 10<sup>3</sup>. We outperform the baselines on shape quality, visual and compactness metrics.
+
+ShapeNet meshes as images from eight different viewpoints using Blender, applying a metallic material to emphasize the geometric structures. Subsequently, we calculate the FID (Frechet Inception Distance) and KID (Kernel Incep-´ tion Distance) scores for these image sets. For both FID and KID, lower scores indicate better performance. We further report compactness as the average number of vertices and faces in the generated meshes.
+
+## 4.2. Results
+
+We benchmark our approach against leading mesh generation methods: Polygen [43], which generates polygonal meshes by first generating vertices followed by faces conditioned on the vertices; BSPNet [7], which represents a mesh through convex decompositions; and AtlasNet [18], which represents a 3D mesh as a deformation of multiple 2D planes. We additionally compare with a state-of-the-art neural field-based method, GET3D [14], that creates shapes as 3D signed distance fields (SDFs) from which a mesh is extracted by differentiable marching tetrahedra. For BSP-Net and AtlasNet, which are built on autoencoder backbones, we follow [1] to fit a Gaussian mixture model with 32 components to enable unconditional sampling of shapes.
+
+As shown in Fig. 6, Fig. 7 and Tab. 1, our method outperforms all baselines in all four categories. Our method can generate sharp and compact meshes with high geometric details. Compared to Polygen, our approach creates shapes with more intricate details. Additionally, Polygen’s separate training for vertex and face models, with the latter only exposed to ground truth vertex distributions, makes it more susceptible to error accumulation during inference. Atlas-Net often suffers from folding artifacts, resulting in lower diversity and shape quality. BSPNet’s use of BSP tree of planes tends to produce blocky shapes with unusual triangulation patterns. GET3D generates good high-level shape structures, but over-triangulated and with imperfect flat surfaces. Simplifying GET3D-generated meshes with algorithms such as QEM [15] results in a loss of fine structures.
+
+![](images/76068c6dfb1898f16de88ae3f72de3ea3ccab75df28511e16f84b9e6bd9d5116.jpg)
+
+<details>
+<summary>text_image</summary>
+
+GT Samples
+AtlasNet	BSPNetGET3DGET3D-QEMPolygenOurs
+100000000000000000000000000000000000000000000000000000000000000000000000000
+</details>
+
+Figure 6. Qualitative comparison of Chair and Table meshes from ShapeNet [5]. Our approach produces compact meshes with sharp geometric details. In contrast, baselines often either miss these details, produce over-triangulated meshes, or output too simplistic shapes.
+
+User Study. We further conducted a user study, in Tab. 2, to assess generated mesh quality. 49 participants were shown pairs of four meshes, randomly selected from our method and each baseline method. Additionally, users were presented with ground truth ShapeNet meshes for comparison. Participants were asked their preference between our method and the baseline in terms of both overall shape quality and similarity of triangulation patterns to the ground truth meshes. This resulted in 784 total question responses. Our method was significantly preferred over Atlas-Net, Polygen, and BSPNet in both shape and triangulation quality. Moreover, a majority of users (68%) favored our method over neural field-based GET3D in shape quality, with even higher preference (73%) for triangulation quality. This underscores our ability to generate high-quality meshes that align with human users’ preferences. Further user study details are provided in the supplemental.
+
+![](images/45b493818f6537a57fadcb2454130c2c50c5a184adc6d1ed712e535a4a05c269.jpg)
+
+<details>
+<summary>text_image</summary>
+
+GT Samples
+AtlasNet	BSPNet	Polygen	Ours
+</details>
+
+Figure 7. Qualitative comparison of Bench and Lamp meshes from the ShapeNet [5] dataset. Compared to baselines, our method produces valid meshes with high geometric fidelity.
+
+<table><tr><td>Preference</td><td>AtlasNet [18]</td><td>BSPNet [7]</td><td>Polygen [43]</td><td>GET3D [14]</td></tr><tr><td>Our Shape</td><td>82.65%</td><td>78.57%</td><td>85.71%</td><td>68.37%</td></tr><tr><td>Our Triangulation</td><td>84.69%</td><td>71.43%</td><td>84.69%</td><td>73.47%</td></tr></table>
+
+Table 2. Percentage of users who prefer our method over the baselines in terms of shape quality and the triangulation quality. Our generated meshes are preferred significantly more often.
+
+<table><tr><td>Method</td><td>COV↑</td><td>MMD↓</td><td>1-NNA</td><td>FID↓</td><td>KID↓</td></tr><tr><td>w/o Learned Tokens</td><td>27.50</td><td>4.51</td><td>93.15</td><td>40.20</td><td>0.024</td></tr><tr><td>w/o Encoder Features</td><td>39.24</td><td>3.43</td><td>84.48</td><td>30.35</td><td>0.017</td></tr><tr><td>w/o Pretraining</td><td>36.97</td><td>3.73</td><td>84.69</td><td>27.54</td><td>0.014</td></tr><tr><td>w/o Sequence Compression</td><td>30.98</td><td>4.15</td><td>88.98</td><td>38.76</td><td>0.023</td></tr><tr><td>w/o per Vertex Quantization</td><td>23.57</td><td>5.49</td><td>98.35</td><td>74.94</td><td>0.050</td></tr><tr><td>MeshGPT</td><td>43.28</td><td>3.29</td><td>75.51</td><td>18.46</td><td>0.010</td></tr></table>
+
+Table 3. Ablations of our design choices on the Chair category of the ShapeNet [5] dataset. As highlighted by the drop in performance by removing any of them, each of these contribute to the final method.
+
+Shape Novelty Analysis. We investigate whether our method can generate novel shapes that extend beyond the training dataset, ensuring the model is not merely retrieving existing shapes. Following the methodology in previous studies [13, 24], we generate 500 shapes using our model. For each generated shape, we identify the top three nearest neighbors from the training set based on Chamfer Distance (CD). To ensure a fair distance computation, accounting for potential discrepancies due to scale or shift in the augmented generations, we normalize all generated and train shapes to be centered within [0, 1]<sup>3</sup>.
+
+![](images/c529395af6d980051ddecada4916f283df5a930f3e3dfe3b5e19f6ee6a2f96a9.jpg)
+
+<details>
+<summary>bar</summary>
+
+| Chamfer Distance (x10^3) | Proportion of Generated Shapes |
+| --- | --- |
+| 0 | ~0.5 |
+| 1 | ~4.5 |
+| 2 | ~6.5 |
+| 3 | ~3.5 |
+| 4 | ~2.5 |
+| 5 | ~1.5 |
+| 6 | ~1.5 |
+| 7 | ~1.5 |
+| 8 | ~1.0 |
+| 9 | ~0.5 |
+| 10+ | ~4.5 |
+</details>
+
+Figure 8. Shape novelty analysis on ShapeNet [5] chair category. We show the 3 nearest neighbors in terms of Chamfer Distance (CD) for a generated shape (top). We also plot the distribution of 500 generated chair samples from our method and their closeness to training distribution. Our method can generate shapes that are similar (low CD) as well as different (high CD) from the training distribution, with shapes at the 50<sup>th</sup> percentile looking different from closest train shape.  
+![](images/5b3a33b4221fb57854918e5b77130294ccf40f3adc775ccf038ce130eb125645.jpg)
+
+<details>
+<summary>natural_image</summary>
+
+3D model of wooden furniture with various shapes and layouts, including chairs, tables, and blocks (no text or symbols)
+</details>
+
+Figure 9. Given a partial mesh, our method can infer multiple possible shape completions.
+
+Fig. 8 displays the most similar shapes from the train set corresponding to a sample generated by our model. We conduct a detailed analysis of the shape similarity distribution between the retrieved and generated shapes on the
+
+Chair category in Fig. 8. The CD distribution reveals that our method not only covers shapes in the training set, indicated by low CD values, but also successfully generates novel and realistic-looking shapes, indicated by high CD values. In the supplemental, we present further analysis of the novelty of all meshes generated by our method, which are featured in the figures of this paper.
+
+Shape Completion. Our model can infer multiple possible completions for a given partial shape, leveraging its probabilistic nature to generate diverse shape hypotheses. Fig. 9 illustrates examples of chair and table completions.
+
+## 4.2.1 Ablations
+
+In Tab. 3, we show a set of ablations on the task of unconditional mesh generation on ShapeNet Chair category. Further ablations are detailed in the supplementary.
+
+![](images/c106cef48f10754a10c06872decaa8bd01f67062fb929d7f25e9990aa5bda13f.jpg)  
+w/o Encoder Features  
+w/o Pretraining
+
+w/o Learned Tokens  
+![](images/ad9fafe54b97a2db08791ed1d9d6d5fc1f9740c532fa025b564f6f99b7850f35.jpg)
+
+<details>
+<summary>natural_image</summary>
+
+3D illustration of a wooden chair with vertical supports and a curved top (no text or symbols)
+</details>
+
+w/o Sequence Compression
+
+![](images/7cd31a0f47e47c84d92e08dca904b6c960a3e46e34d19fe04d035df0379c8406.jpg)
+
+<details>
+<summary>natural_image</summary>
+
+3D illustration of a wooden chair with geometric panel design (no text or symbols)
+</details>
+
+w/o per Vertex Quantization
+
+![](images/a1fcd1221add5906336612abb60dd62afe146092c590f7e919b6ddaee9d492a5.jpg)
+
+<details>
+<summary>natural_image</summary>
+
+3D illustration of a wooden chair with yellow cushion and side legs (no text or symbols)
+</details>
+
+Ours (Complete)  
+Figure 10. Ablation over our method’s components. Naive tokenization (w/o Learned Tokens) and naive per face quantization (w/o per-vertex quantization) markedly diminishes shape quality. Longer sequences without sequence compression (w/o Sequence Compression) lead to the model forgetting the context and repeating shape elements in the output.
+
+Do learned geometric embeddings help? Using our geometric embeddings in vocabulary learning significantly improves over naive coordinate tokenization (w/o Learned Tokens), as shown in Tab. 3 and Fig. 3.
+
+Does sequence length compression help? As evidenced by Tab. 3 and Fig. 3, a model with a shorter sequence length performs better than without (w/o Sequence Compression), as shorter sequence lengths fit transformer context windows better. Visually, with longer sequences, shapes exhibit repeating structures due to limited context.
+
+What is the effect of aggregation and quantization across vertex indices instead of faces? As discussed in Section 3, an alternative to having embeddings aggregated and quantized across vertex indices, is to simply have the same number of embeddings directly per face (w/o per Vertex Quantization). In Tab. 3, we observe that this makes sequences much harder to learn with the transformer.
+
+Do features from graph convolutional encoder help in mesh generation? An alternative to using embeddings from the graph encoder and the codebook is to only use the codebook indices of these tokens as input to the transformer, and let the transformer learn the discrete token embeddings (w/o Encoder Features). While the transformer is able to still learn meaningful embeddings, these are still not as effective as using graph encoder features.
+
+What is the effect of large-scale shape pretraining? Tab. 3 shows that training only on shapes from individual categories (w/o Pretraining) leads to overfitting and subobtimal performance, in contrast to pre-training our GPT transformer on all ShapeNet train shapes.
+
+Limitations. MeshGPT significantly advances direct mesh generation but faces several limitations. Its autoregressive nature leads to slower sampling performance, with mesh generation times taking 30 to 90 seconds. Despite our learned tokenization approach reducing sequence lengths, which suffices for single object generation, it may not be as effective for scene-scale generation, suggesting an area for future enhancement. Moreover, our current computational resources limit us to using a GPT2-medium transformer, which is smaller than more sophisticated models like Llama2 [58]. Given that larger language models benefit from increased data and computational power, expanding these resources could significantly boost MeshGPT’s performance and capabilities.
+
+## 5. Conclusion
+
+We have introduced MeshGPT, a novel shape generation approach that outputs meshes directly as triangles. We learn a vocabulary of geometric embeddings over a distribution of meshes, over which a transformer is trained to predict meshes autoregressively as a sequence of triangles. In contrast to existing mesh generation approaches, our method generates clean, coherent meshes which are compact and follow the triangulation patterns in real data more closely. We believe that MeshGPT will not only elevate the current landscape of mesh generation but also inspire new research in the area, offering a unique alternative to the more commonly explored representations for 3D content creation.
+
+## Acknowledgements
+
+This work was funded by AUDI AG. Matthias Nießner was supported by the ERC Starting Grant Scan2CAD (804724). Angela Dai was supported by the Bavarian State Ministry of Science and the Arts coordinated by the Bavarian Research Institute for Digital Transformation (BIDT). We would like to thank Ziya Erkoc¸, Quyet-Chien Nguyen, Haoxuan Li and Artem Sevastopolsky for the helpful discussions.
+
+## References
+
+[1] Panos Achlioptas, Olga Diamanti, Ioannis Mitliagkas, and Leonidas Guibas. Learning representations and generative models for 3d point clouds. In International conference on machine learning, pages 40–49. PMLR, 2018. 2, 5  
+[2] Henry Blumberg. Hausdorff’s grundzuge der mengenlehre.¨ 1920. 12  
+[3] Andrew Brock, Theodore Lim, James M Ritchie, and Nick Weston. Generative and discriminative voxel modeling with convolutional neural networks. arXiv preprint arXiv:1608.04236, 2016. 1, 2  
+[4] Ruojin Cai, Guandao Yang, Hadar Averbuch-Elor, Zekun Hao, Serge Belongie, Noah Snavely, and Bharath Hariharan. Learning gradient fields for shape generation. In Computer Vision–ECCV 2020: 16th European Conference, Glasgow, UK, August 23–28, 2020, Proceedings, Part III 16, pages 364–381. Springer, 2020. 2  
+[5] Angel X. Chang, Thomas Funkhouser, Leonidas Guibas, Pat Hanrahan, Qixing Huang, Zimo Li, Silvio Savarese, Manolis Savva, Shuran Song, Hao Su, Jianxiong Xiao, Li Yi, and Fisher Yu. ShapeNet: An Information-Rich 3D Model Repository. Technical Report arXiv:1512.03012 [cs.GR], Stanford University — Princeton University — Toyota Technological Institute at Chicago, 2015. 2, 5, 6, 7, 12, 14, 15, 16  
+[6] Zhiqin Chen and Hao Zhang. Learning implicit fields for generative shape modeling. In Proceedings of the IEEE/CVF Conference on Computer Vision and Pattern Recognition, pages 5939–5948, 2019. 2  
+[7] Zhiqin Chen, Andrea Tagliasacchi, and Hao Zhang. Bsp-net: Generating compact meshes via binary space partitioning. In Proceedings of the IEEE/CVF Conference on Computer Vision and Pattern Recognition, pages 45–54, 2020. 2, 5, 7, 14  
+[8] Yen-Chi Cheng, Hsin-Ying Lee, Sergey Tulyakov, Alexander G Schwing, and Liang-Yan Gui. Sdfusion: Multimodal 3d shape completion, reconstruction, and generation. In Proceedings of the IEEE/CVF Conference on Computer Vision and Pattern Recognition, pages 4456–4465, 2023. 2  
+[9] Christopher B Choy, Danfei Xu, JunYoung Gwak, Kevin Chen, and Silvio Savarese. 3d-r2n2: A unified approach for single and multi-view 3d object reconstruction. In Computer Vision–ECCV 2016: 14th European Conference, Amsterdam, The Netherlands, October 11-14, 2016, Proceedings, Part VIII 14, pages 628–644. Springer, 2016. 2  
+[10] Blender Online Community. Blender - a 3D modelling and rendering package. Blender Foundation, Stichting Blender Foundation, Amsterdam, 2018. 12  
+[11] Angela Dai and Matthias Nießner. Scan2mesh: From unstructured range scans to 3d meshes. In Proceedings of the IEEE/CVF Conference on Computer Vision and Pattern Recognition, pages 5574–5583, 2019. 2  
+[12] Akio Doi and Akio Koide. An efficient method of triangulating equi-valued surfaces by using tetrahedral cells. IEICE TRANSACTIONS on Information and Systems, 74(1):214– 224, 1991. 2  
+[13] Ziya Erkoc¸, Fangchang Ma, Qi Shan, Matthias Nießner, and Angela Dai. Hyperdiffusion: Generating implicit neural fields with weight-space diffusion. arXiv preprint arXiv:2303.17015, 2023. 2, 7, 15  
+[14] Jun Gao, Tianchang Shen, Zian Wang, Wenzheng Chen, Kangxue Yin, Daiqing Li, Or Litany, Zan Gojcic, and Sanja Fidler. Get3d: A generative model of high quality 3d textured shapes learned from images. Advances In Neural Information Processing Systems, 35:31841–31854, 2022. 1, 2, 5, 7, 14  
+[15] Michael Garland and Paul S Heckbert. Surface simplification using quadric error metrics. In Proceedings of the 24th annual conference on Computer graphics and interactive techniques, pages 209–216, 1997. 5, 6  
+[16] Shunwang Gong, Lei Chen, Michael Bronstein, and Stefanos Zafeiriou. Spiralnet++: A fast and highly efficient mesh convolution operator. In Proceedings of the IEEE/CVF international conference on computer vision workshops, pages 0–0, 2019. 2  
+[17] Ian Goodfellow, Jean Pouget-Abadie, Mehdi Mirza, Bing Xu, David Warde-Farley, Sherjil Ozair, Aaron Courville, and Yoshua Bengio. Generative adversarial networks. Communications ofthe ACM, 63(11):139–144, 2020. 2  
+[18] Thibault Groueix, Matthew Fisher, Vladimir G Kim, Bryan C Russell, and Mathieu Aubry. A papier-mach ˆ e ap-´ proach to learning 3d surface generation. In Proceedings of the IEEE conference on computer vision and pattern recognition, pages 216–224, 2018. 2, 5, 7, 14  
+[19] Anchit Gupta, Wenhan Xiong, Yixin Nie, Ian Jones, and Barlas Oguz. 3dgen: Triplane latent diffusion for textured mesh˘ generation. arXiv preprint arXiv:2303.05371, 2023. 1  
+[20] Will Hamilton, Zhitao Ying, and Jure Leskovec. Inductive representation learning on large graphs. Advances in neural information processing systems, 30, 2017. 3, 12, 15  
+[21] Rana Hanocka, Amir Hertz, Noa Fish, Raja Giryes, Shachar Fleishman, and Daniel Cohen-Or. Meshcnn: a network with an edge. ACM Transactions on Graphics (ToG), 38(4):1–12, 2019. 2  
+[22] Kaiming He, Xiangyu Zhang, Shaoqing Ren, and Jian Sun. Deep residual learning for image recognition. In Proceedings of the IEEE conference on computer vision and pattern recognition, pages 770–778, 2016. 2, 3, 4, 12, 15  
+[23] Shi-Min Hu, Zheng-Ning Liu, Meng-Hao Guo, Jun-Xiong Cai, Jiahui Huang, Tai-Jiang Mu, and Ralph R Martin. Subdivision-based mesh convolution networks. ACM Transactions on Graphics (TOG), 41(3):1–16, 2022. 2  
+[24] Ka-Hei Hui, Ruihui Li, Jingyu Hu, and Chi-Wing Fu. Neura wavelet-domain diffusion for 3d shape generation. In SIG-GRAPH Asia 2022 Conference Papers, pages 1–9, 2022. 7  
+[25] Ajay Jain, Ben Mildenhall, Jonathan T Barron, Pieter Abbeel, and Ben Poole. Zero-shot text-guided object generation with dream fields. In Proceedings ofthe IEEE/CVF Conference on Computer Vision and Pattern Recognition, pages 867–876, 2022. 2  
+[26] Danilo Jimenez Rezende, SM Eslami, Shakir Mohamed, Peter Battaglia, Max Jaderberg, and Nicolas Heess. Unsupervised learning of 3d structure from images. Advances in neural information processing systems, 29, 2016. 2  
+[27] Biing-Hwang Juang and A Gray. Multiple stage vector quantization for speech coding. In ICASSP’82. IEEE International Conference on Acoustics, Speech, and Signal Processing, pages 597–600. IEEE, 1982. 3  
+[28] Diederik P Kingma and Jimmy Ba. Adam: A method for stochastic optimization. arXiv preprint arXiv:1412.6980, 2014. 5  
+[29] Doyup Lee, Chiheon Kim, Saehoon Kim, Minsu Cho, and Wook-Shin Han. Autoregressive image generation using residual quantization. In Proceedings ofthe IEEE/CVF Conference on Computer Vision and Pattern Recognition, pages 11523–11532, 2022. 5, 12  
+[30] Chun-Liang Li, Manzil Zaheer, Yang Zhang, Barnabas Poczos, and Ruslan Salakhutdinov. Point cloud gan. arXiv preprint arXiv:1810.05795, 2018. 2  
+[31] Muheng Li, Yueqi Duan, Jie Zhou, and Jiwen Lu. Diffusionsdf: Text-to-shape via voxelized diffusion. In Proceedings of the IEEE/CVF Conference on Computer Vision and Pattern Recognition, pages 12642–12651, 2023. 1  
+[32] Yiyi Liao, Simon Donne, and Andreas Geiger. Deep marching cubes: Learning explicit surface representations. In Proceedings of the IEEE Conference on Computer Vision and Pattern Recognition, pages 2916–2925, 2018. 2  
+[33] Isaak Lim, Alexander Dielen, Marcel Campen, and Leif Kobbelt. A simple approach to intrinsic correspondence learning on unstructured 3d meshes. In Proceedings of the European Conference on Computer Vision (ECCV) Workshops, pages 0–0, 2018. 2  
+[34] Chen-Hsuan Lin, Jun Gao, Luming Tang, Towaki Takikawa, Xiaohui Zeng, Xun Huang, Karsten Kreis, Sanja Fidler, Ming-Yu Liu, and Tsung-Yi Lin. Magic3d: High-resolution text-to-3d content creation. In Proceedings of the IEEE/CVF Conference on Computer Vision and Pattern Recognition, pages 300–309, 2023. 2  
+[35] Zhen Liu, Yao Feng, Michael J Black, Derek Nowrouzezahrai, Liam Paull, and Weiyang Liu. Meshdiffusion: Score-based generative 3d mesh modeling. arXiv preprint arXiv:2303.08133, 2023. 1  
+[36] William E Lorensen and Harvey E Cline. Marching cubes: A high resolution 3d surface construction algorithm. In Seminal graphics: pioneering efforts that shaped thefield, pages 347–353. 1998. 1, 2  
+[37] Shitong Luo and Wei Hu. Diffusion probabilistic models for 3d point cloud generation. In Proceedings of the IEEE/CVF Conference on Computer Vision and Pattern Recognition, pages 2837–2845, 2021. 1, 5  
+[38] Julieta Martinez, Holger H Hoos, and James J Little. Stacked quantizers for compositional vector compression. arXiv preprint arXiv:1411.2173, 2014. 3, 12  
+[39] Lars Mescheder, Michael Oechsle, Michael Niemeyer, Sebastian Nowozin, and Andreas Geiger. Occupancy networks: Learning 3d reconstruction in function space. In Proceedings of the IEEE/CVF conference on computer vision and pattern recognition, pages 4460–4470, 2019. 2  
+[40] Francesco Milano, Antonio Loquercio, Antoni Rosinol, Davide Scaramuzza, and Luca Carlone. Primal-dual mesh convolutional neural networks. Advances in Neural Information Processing Systems, 33:952–963, 2020. 2  
+[41] Norman Muller, Yawar Siddiqui, Lorenzo Porzi,¨ Samuel Rota Bulo, Peter Kontschieder, and Matthias Nießner. Diffrf: Rendering-guided 3d radiance field diffusion. In Proceedings of the IEEE/CVF Conference on Computer Vision and Pattern Recognition, pages 4328–4338, 2023. 1, 2  
+[42] Liangliang Nan and Peter Wonka. Polyfit: Polygonal surface reconstruction from point clouds. In Proceedings ofthe IEEE International Conference on Computer Vision, pages 2353– 2361, 2017. 2  
+[43] Charlie Nash, Yaroslav Ganin, SM Ali Eslami, and Peter Battaglia. Polygen: An autoregressive generative model of 3d meshes. In International conference on machine learning, pages 7220–7229. PMLR, 2020. 2, 3, 5, 7, 14  
+[44] Alex Nichol, Heewoo Jun, Prafulla Dhariwal, Pamela Mishkin, and Mark Chen. Point-e: A system for generating 3d point clouds from complex prompts. arXiv preprint arXiv:2212.08751, 2022. 2  
+[45] Jeong Joon Park, Peter Florence, Julian Straub, Richard Newcombe, and Steven Lovegrove. Deepsdf: Learning continuous signed distance functions for shape representation. In Proceedings ofthe IEEE/CVF conference on computer vision and pattern recognition, pages 165–174, 2019. 2  
+[46] Adam Paszke, Sam Gross, Francisco Massa, Adam Lerer, James Bradbury, Gregory Chanan, Trevor Killeen, Zeming Lin, Natalia Gimelshein, Luca Antiga, Alban Desmaison, Andreas Kopf, Edward Yang, Zachary DeVito, Martin Raison, Alykhan Tejani, Sasank Chilamkurthy, Benoit Steiner, Lu Fang, Junjie Bai, and Soumith Chintala. Pytorch: An imperative style, high-performance deep learning library. In Advances in Neural Information Processing Systems 32, pages 8024–8035. Curran Associates, Inc., 2019. 5  
+[47] Songyou Peng, Chiyu Jiang, Yiyi Liao, Michael Niemeyer, Marc Pollefeys, and Andreas Geiger. Shape as points: A differentiable poisson solver. Advances in Neural Information Processing Systems, 34:13032–13044, 2021. 2  
+[48] Ben Poole, Ajay Jain, Jonathan T Barron, and Ben Mildenhall. Dreamfusion: Text-to-3d using 2d diffusion. arXiv preprint arXiv:2209.14988, 2022. 2  
+[49] Edoardo Remelli, Artem Lukoianov, Stephan Richter, Benoit Guillard, Timur Bagautdinov, Pierre Baque, and Pascal Fua. Meshsdf: Differentiable iso-surface extraction. Advances in Neural Information Processing Systems, 33:22468–22478, 2020. 2  
+[50] Katja Schwarz, Axel Sauer, Michael Niemeyer, Yiyi Liao, and Andreas Geiger. Voxgraf: Fast 3d-aware image synthe-  
+sis with sparse voxel grids. Advances in Neural Information Processing Systems, 35:33999–34011, 2022. 2  
+[51] Nicholas Sharp and Maks Ovsjanikov. Pointtrinet: Learned triangulation of 3d point sets. In Computer Vision–ECCV 2020: 16th European Conference, Glasgow, UK, August 23–28, 2020, Proceedings, Part XXIII 16, pages 762–778. Springer, 2020. 2  
+[52] Nicholas Sharp, Souhaib Attaiki, Keenan Crane, and Maks Ovsjanikov. Diffusionnet: Discretization agnostic learning on surfaces. ACM Transactions on Graphics (TOG), 41(3): 1–16, 2022. 2  
+[53] Tianchang Shen, Jun Gao, Kangxue Yin, Ming-Yu Liu, and Sanja Fidler. Deep marching tetrahedra: a hybrid representation for high-resolution 3d shape synthesis. Advances in Neural Information Processing Systems, 34:6087–6101, 2021. 2  
+[54] Dong Wook Shu, Sung Woo Park, and Junseok Kwon. 3d point cloud generative adversarial network based on tree structured graph convolutions. In Proceedings of the IEEE/CVF international conference on computer vision, pages 3859–3868, 2019. 2  
+[55] J Ryan Shue, Eric Ryan Chan, Ryan Po, Zachary Ankner, Jiajun Wu, and Gordon Wetzstein. 3d neural field generation using triplane diffusion. In Proceedings of the IEEE/CVF Conference on Computer Vision and Pattern Recognition, pages 20875–20886, 2023. 2  
+[56] Dmitriy Smirnov and Justin Solomon. Hodgenet: Learning spectral geometry on triangle meshes. ACM Transactions on Graphics (TOG), 40(4):1–11, 2021. 2  
+[57] Maxim Tatarchenko, Alexey Dosovitskiy, and Thomas Brox. Octree generating networks: Efficient convolutional architectures for high-resolution 3d outputs. In Proceedings of the IEEE international conference on computer vision, pages 2088–2096, 2017. 2  
+[58] Hugo Touvron, Louis Martin, Kevin Stone, Peter Albert, Amjad Almahairi, Yasmine Babaei, Nikolay Bashlykov, Soumya Batra, Prajjwal Bhargava, Shruti Bhosale, et al. Llama 2: Open foundation and fine-tuned chat models. arXiv preprint arXiv:2307.09288, 2023. 8  
+[59] Diego Valsesia, Giulia Fracastoro, and Enrico Magli. Learning localized generative models for 3d point clouds via graph convolution. In International conference on learning representations, 2018. 2  
+[60] Petar Velickoviˇ c, Guillem Cucurull, Arantxa Casanova,´ Adriana Romero, Pietro Lio, and Yoshua Bengio. Graph attention networks. arXiv preprint arXiv:1710.10903, 2017. 16  
+[61] Yue Wang, Yongbin Sun, Ziwei Liu, Sanjay E Sarma, Michael M Bronstein, and Justin M Solomon. Dynamic graph cnn for learning on point clouds. ACM Transactions on Graphics (tog), 38(5):1–12, 2019. 16  
+[62] Jiajun Wu, Chengkai Zhang, Tianfan Xue, Bill Freeman, and Josh Tenenbaum. Learning a probabilistic latent space of object shapes via 3d generative-adversarial modeling. Advances in neural information processing systems, 29, 2016. 1, 2  
+[63] Jiale Xu, Xintao Wang, Weihao Cheng, Yan-Pei Cao, Ying Shan, Xiaohu Qie, and Shenghua Gao. Dream3d: Zero-shot  
+text-to-3d synthesis using 3d shape prior and text-to-image diffusion models. In Proceedings of the IEEE/CVF Conference on Computer Vision and Pattern Recognition, pages 20908–20918, 2023. 2  
+[64] Guandao Yang, Xun Huang, Zekun Hao, Ming-Yu Liu, Serge Belongie, and Bharath Hariharan. Pointflow: 3d point cloud generation with continuous normalizing flows. In Proceedings of the IEEE/CVF international conference on computer vision, pages 4541–4550, 2019. 2  
+[65] Yaoqing Yang, Chen Feng, Yiru Shen, and Dong Tian. Foldingnet: Point cloud auto-encoder via deep grid deformation. In Proceedings of the IEEE conference on computer vision and pattern recognition, pages 206–215, 2018. 2  
+[66] Xumin Yu, Lulu Tang, Yongming Rao, Tiejun Huang, Jie Zhou, and Jiwen Lu. Point-bert: Pre-training 3d point cloud transformers with masked point modeling. In Proceedings of the IEEE/CVF Conference on Computer Vision and Pattern Recognition, pages 19313–19322, 2022. 15  
+[67] Xiaohui Zeng, Arash Vahdat, Francis Williams, Zan Gojcic, Or Litany, Sanja Fidler, and Karsten Kreis. Lion: Latent point diffusion models for 3d shape generation. In Advances in Neural Information Processing Systems, 2022. 1, 2, 5, 15  
+[68] Linqi Zhou, Yilun Du, and Jiajun Wu. 3d shape generation and completion through point-voxel diffusion. In Proceedings of the IEEE/CVF International Conference on Computer Vision, pages 5826–5835, 2021. 1, 2, 5
+
+## Appendix
+
+In this supplementary document, we discuss additional details about our method MeshGPT. We provide implementation details of our method, loss functions, and the baselines in Section B. Additional details about the user study are provided in Section C. We also provide further qualitative and quantitative results (Section E), including a shape novelty analysis (Section D) for shapes from the main paper. We further encourage the readers to check out the supplemental video for a summary of the method and an overview of results.
+
+## A. Data
+
+Selection. We use the ShapeNetV2 [5] dataset for all our experiments. We first apply planar decimation to each shape using Blender [10], with the angle tolerance parameter α set within [1, 60]. The impact of this decimation is assessed by calculating the Hausdorff distance [2] between the decimated and original shapes. We then choose, for each original shape, the decimated version with the Hausdorff distance closest to, but below, a pre-set threshold $\delta _ { \mathrm { h a u s d o r f f } } .$ Shapes with more than 800 faces are excluded, resulting in a final count of 28980 shapes across all categories. The Chair, Table, Bench, and Lamp categories are further divided into a 9:1 train-test split. All shapes from rest of the categories are used for pretraining phase, while only the training subset from specific categories is used for pretraining and finetuning. All shapes are normalized to be centered at the origin and scaled to ensure the longest side is of unit length.
+
+Augmentation. During the training of both the encoderdecoder and the transformer, multiple augmentation techniques are applied to all train shapes. Scaling augmentation, ranging from 0.75 to 1.25, is independently applied across each axis. Post-scaling, meshes are resized to keep the longest side at unit length. Additionally, jitter-shift augmentation in the range of [−0.1, 0.1] is used, adjusted to maintain the mesh within the unit bounding box around the origin. We also implement varying levels of planar decimation for training shapes, provided the distortion remains below $\delta _ { \mathrm { h a u s d o r f f } } .$
+
+## B. Method Details
+
+## B.1. Architecture
+
+The architecture of our encoder-decoder network is elaborated in Fig. 14. The encoder comprises a series of SAGE-Conv [20] graph convolution layers, processing the mesh in the form of a face graph. For each graph node, input features include the positionally encoded 9 coordinates of the face triangle, its area, the angles between its edges, and the normal of the face. The decoder is essentially a 1D
+
+ResNet-34 [22] network, applied to the face features interpreted as a 1D sequence. It outputs logits corresponding to the 9 discrete coordinates of each face triangle, which are discretized within a $1 2 8 ^ { 3 }$ space. The codebook C has a size of 16384. The architecture of the transformer is simply a GPT-2 medium architecture, i.e. 24 multi-headed self attention layers, 16 heads, 768 as feature width, with context length of 4608.
+
+## B.2. Residual Vector Quantization
+
+Fundamentals. For quantization, we employ residual vector quantization (RQ) [29, 38]. RQ discretizes a vector z with a stack of D ordered codes. Starting with the $0 ^ { \mathrm { t h } }$ residual $\mathbf { r } ^ { 0 } = \mathbf { z } ,$ , RQ recursively computes $t ^ { d }$ as the code of the residual $\mathbf { r } ^ { d - 1 }$ , and the next residual $\mathbf { r } ^ { d }$ as
+
+$$
+t ^ {d} = \mathcal {Q} \left(\mathbf {r} ^ {d - 1}; \mathcal {C}\right) \tag {7}
+$$
+
+$$
+\mathbf {r} ^ {d} = \mathbf {r} ^ {d - 1} - \mathbf {e} (t ^ {d}) \tag {8}
+$$
+
+where $\mathcal { Q } ( \mathbf { z } ; \mathcal { C } )$ denotes vector quantization of z with codebook ${ \mathcal { C } } ,$ , and $\mathbf { e } ( t ^ { d } )$ is the embedding in the codebook C. Further, we define
+
+$$
+\hat {\mathbf {z}} ^ {(d)} = \sum_ {1} ^ {d} \mathbf {e} (t ^ {d}) \tag {9}
+$$
+
+as the partial sum of up to d code embeddings, and $\hat { \mathbf { z } } = \hat { \mathbf { z } } ^ { D }$ is the quantized vector of z. The recursive quantization of RQ thus approximates the vector z in a coarse-to-fine manner [29]. The commitment loss can now be defined between vector z and its quantization zˆ as
+
+$$
+\mathcal {L} _ {\text {commit}} (\mathbf {z}, \hat {\mathbf {z}}) = \sum_ {d = 1} ^ {D} \| \mathbf {z} - \mathrm{sg} [ \hat {\mathbf {z}} ^ {(d)} ] \| _ {2} ^ {2} \tag {10}
+$$
+
+where sg denotes the stop gradient operation.
+
+Per Vertex Residual Vector Quantization. Instead of directly applying RQ, for a face feature $\mathbf { z _ { i } }$ extracted by the graph encoder, we first split this 576 dimension face feature $\mathbf { z _ { i } }$ into 3 features, $( \mathbf { z } _ { i } ^ { 1 } , \mathbf { z } _ { i } ^ { 2 } , \mathbf { z } _ { i } ^ { 3 } )$ ), each of 192 dimensions representing the features of the face triangle’s 3 vertices. The features the fall on vertices that are shared across faces are averaged. On these per vertex index feature $\mathbf { z } _ { i } ^ { j }$ , RQ quantizes them into a stack of $\textstyle { \frac { D } { 3 } }$ features,
+
+$$
+\mathrm{RQ} (\mathbf {z _ {i}}; \mathcal {C}, D) = (\mathrm{RQ} (\mathbf {z _ {i} ^ {1}}; \mathcal {C}, \frac {D}{3}), \dots , \mathrm{RQ} (\mathbf {z _ {i} ^ {3}}; \mathcal {C}, \frac {D}{3})) \tag {11}
+$$
+
+for codebook C, with
+
+$$
+\mathrm{RQ} (\mathbf {z} _ {\mathbf {i}} ^ {\mathbf {j}}; \mathcal {C}, \frac {D}{3}) = (t _ {i} ^ {2 j - \frac {D}{3} + 1}, t _ {i} ^ {2 j - \frac {D}{3} + 2}, \dots , t _ {i} ^ {2 j}), \tag {12}
+$$
+
+where $t _ { i } ^ { d }$ is the index to the embedding $\mathbf { e } ( t _ { i } ^ { d } )$ in the codebook C. Taken together for each vertex, these form a stack of D features,
+
+$$
+\mathrm{RQ} (\mathbf {z _ {i}}; \mathcal {C}, D) = (t _ {i} ^ {1}, t _ {i} ^ {2}, \dots , t _ {i} ^ {D}) = t _ {i}. \tag {13}
+$$
+
+![](images/22c1035334c0e2d06f3f6dff66da36e08b29b61356c3f3ee05ec77a5c69fdd7e.jpg)
+
+<details>
+<summary>natural_image</summary>
+
+Collection of 3D architectural and furniture models including wooden chairs, tables, benches, and decorative objects (no text or symbols)
+</details>
+
+Figure 11. Additional novel shapes on Chairs, Tables, Benches and Lamps generated by our method.
+
+Thus, the residual quantization for the features extracted for all the N faces of the mesh $\mathbf { Z } = ( z _ { 1 } , z _ { 2 } , \ldots , z _ { N } )$ is given as
+
+$$
+\mathrm{RQ} (\mathbf {Z}; \mathcal {C}, D) = \mathrm{RQ} (\mathbf {z _ {1}} \dots \mathbf {z _ {N}}; \mathcal {C}, D) \tag {14}
+$$
+
+$$
+\mathrm{RQ} (\mathbf {z _ {1}} \dots \mathbf {z _ {N}}; \mathcal {C}, D) = (t _ {0}, t _ {1}, \dots , t _ {N}). \tag {15}
+$$
+
+Fig. 16 gives an intuition on why ‘per vertex’ tokenization is better than ‘per face’ tokenization, with ablations in the main paper confirming it.
+
+## B.3. Loss Functions
+
+Vocabulary Learning. Let $\mathcal { P } _ { n i j k }$ be the predicted probability distribution over the discrete coordinates, where n is the face index, i is the vertex index inside the face, $j$ is the coordinate’s axis index $( x , y \ \mathrm { o r } \ z )$ , and k goes over the discretized positions $\in \{ 1 , 2 , 3 , \ldots , 1 2 8 \}$ . If $V _ { n i j }$ is the target discretized position, then the reconstruction loss for the encoder-decoder network is given as
+
+$$
+\mathcal {L} _ {\text {recon}} = \sum_ {n = 1} ^ {N} \sum_ {i = 1} ^ {3} \sum_ {j = 1} ^ {3} \sum_ {k = 1} ^ {1 2 8} \mathrm{w} _ {n i j k} \log \mathcal {P} _ {n i j k} \tag {16}
+$$
+
+with
+
+$$
+\mathrm{w} _ {n i j k} = \text {smooth} \left(\text {one - hot} _ {1 2 8} \left(V _ {n i j}\right)\right) \tag {17}
+$$
+
+is a smoothening kernel applied across the one-hot probability distribution over the targets, encouraging physically close coordinates to be penalized less. The loss over the encoder-decoder network is the sum of ${ \mathcal { L } } _ { \mathrm { r e c o n } }$ and $\mathcal { L } _ { \mathrm { c o m m i t } }$ previously described.
+
+Transformer. Given a target sequence $\begin{array} { r l } { \mathbf T } & { { } = } \end{array}$ $( t _ { 0 } , t _ { 1 } , \ldots , t _ { N } )$ with $\begin{array} { c c l } { t _ { i } } & { = } & { ( t _ { i } ^ { 1 } , \bar { t } _ { i } ^ { 2 } , \dots , \bar { t } _ { i } ^ { D } ) } \end{array}$ , and $s _ { i } ^ { j } \mathrm { i s }$ the corresponding predicted sequence element, then the transformer is trained with the loss
+
+![](images/af8b3cd584542eb6776b8e675298e42cc5c1a00283f7ad4d41092a1e2cc3a20a.jpg)
+
+<details>
+<summary>natural_image</summary>
+
+Grid of 3D-rendered wooden chairs with varying colors and line textures, no text or symbols present.
+</details>
+
+Generated Shape  
+Most similar shapes retrieved from training set
+
+![](images/d00aabe098c8a3f3b7dac3186467ea197ed472f32e2fee65cd05d4e034e6f1e2.jpg)
+
+<details>
+<summary>natural_image</summary>
+
+Collection of 3D-rendered wooden table and chair models in various colors, showing different shapes and sizes (no text or symbols)
+</details>
+
+Generated Shape  
+Most similar shapes retrieved from training set  
+Figure 12. Shape novelty analysis on ShapeNet [5] chair and table category for shapes generated by our method shown in main paper. We show the 3 nearest neighbors in terms of Chamfer Distance (CD) for a generated shape. Shapes are scaled to a unit length along all axes to account for augmented generations before computing CD.
+
+$$
+\mathcal {L} _ {\mathrm{recon}} = \sum_ {i = 1} ^ {N} \sum_ {j = 1} ^ {D} \sum_ {k = 1} ^ {| \mathcal {C} |} \log p (s _ {i} ^ {k} = t _ {i} ^ {j}). \tag {18}
+$$
+
+## B.4. Baselines
+
+We utilize the official implementations for BSPNet [7], AtlasNet [18], and GET3D [14]. For Polygen [43], we reimplement it following the details in their paper. To align its architecture with our method, we employ the same GPT2- medium architecture for the vertex model in Polygen. Additionally, mirroring our approach, Polygen undergoes pretraining on all categories and is finetuned for each evaluated category, applying the same train-time augmentations as used in our method.
+
+## C. User Study Details
+
+We develop a Django-based web application for the user study. In Fig. 15, we show the interface for the questionnaire. We randomly select 16 pairs of meshes from each baseline and our method across the Chair and Table categories, half of which are used for a question on preference based on shape quality, and the other half for preference based on triangulation quality. After the samples are prepared, we ask the users to pick the sample which they prefer more based on the question. To avoid biases in this user study, we shuffle the pairs so that there is no positional hint to our method. We also show a collection of ground-truth meshes to the user for them to get an idea of the real distribution. In the end, we gather 784 responses from 49 participants to calculate the preferences.
+
+![](images/95d2fd7dc948e6e373c37d2368438952d9cd7875e959f9b4d76310b4db266b77.jpg)
+
+<details>
+<summary>text_image</summary>
+
+Generated Shape
+Most similar shapes retrieved from training set
+</details>
+
+![](images/7e8ea87daf63578d77b643fe27855345f3b330fc8382177835e2da7c30cd4d4c.jpg)
+
+<details>
+<summary>text_image</summary>
+
+Generated Shape
+Most similar shapes retrieved from training set
+</details>
+
+Figure 13. Shape novelty analysis on ShapeNet [5] bench and lamp category for shapes generated by our method shown in main paper. We show the 3 nearest neighbors in terms of Chamfer Distance (CD) for a generated shape. Shapes are scaled to a unit length along all axes to account for augmented generations before computing CD.
+
+![](images/4ec5ee7755bd6f8b5c1ddbe9d84366f8031e24b91ec1d239bef0eaaa83da18f7.jpg)
+
+<details>
+<summary>flowchart</summary>
+
+```mermaid
+graph LR
+  InputMesh["Input Mesh"] -->|"F| x196"| GraphConvEncoder["Graph Conv Encoder"]
+  GraphConvEncoder -->|"F| x576"| ResidualQuantizationModule["Residual Face Quantization Module"]
+  SequenceOfFaces["Sequence Of Faces"] -->|"F| x576"| ResNet34Decoder["ResNet34 Decoder"]
+  ResNet34Decoder --> ReconstructedMesh["Reconstructed Mesh"]
+```
+</details>
+
+Figure 14. Our encoder-decoder network features an encoder with SAGEConv [20] layers processing mesh faces as a graph. Each node inputs positionally encoded face triangle coordinates, area, edge angles, and normal. The decoder, a 1D ResNet-34 [22], interprets face features as a sequence, outputting logits for the discretized face triangle coordinates in a 128<sup>3</sup> space.
+
+## D. Shape Novelty Analysis
+
+Fig. 12 and 13 displays the top-3 most similar shapes from the train set corresponding to all samples used in the main paper that were generated by our model. These nearest neighbor shapes are identified based on Chamfer Distance (CD). To ensure a fair distance computation, accounting for potential discrepancies due to scale or shift in the augmented generations, we normalize all generated and train shapes to be centered within [0, 1]<sup>3</sup> and scaled to the extremes of this cube.
+
+## E. Additional Results
+
+Metrics. Following recent works for unconditional shape generation [13, 66, 67] for calculating the shape metrics we define
+
+$$
+\begin{array}{l} \mathrm{MMD} (S _ {g}, S _ {r}) = \frac {1}{| S _ {r} |} \sum_ {Y \in S _ {r}} \min _ {X \in S _ {g}} D (X, Y), \\ \operatorname{COV} (S _ {g}, S _ {r}) = \frac {| \{\operatorname{argmin} _ {Y \in S _ {r}} D (X , Y) | X \in S _ {g} \} |}{| S _ {r} |}, \\ 1 \text {-NNA} (S _ {g}, S _ {r}) = \frac {\sum_ {X \in S _ {g}} \mathbb {1} _ {X} + \sum_ {Y \in S _ {r}} \mathbb {1} _ {Y}}{| S _ {g} | + | S _ {r} |}, \\ \mathbb {1} _ {X} = \mathbb {1} [ N _ {X} \in S _ {g} ], \\ \mathbb {1} _ {Y} = \mathbb {1} [ N _ {Y} \in S _ {r} ], \\ \end{array}
+$$
+
+where in the 1-NNA metric N is a point cloud that is closest to X in both generated and reference dataset, i.e.,
+
+$$
+N _ {X} = \underset {K \in S _ {r} \cup S _ {g}} {\operatorname{argmin}} D (X, K)
+$$
+
+![](images/9c8f17f2ed164e56329aa2345718e115db7f4d94e1cb5a94b39d1e155c6a929e.jpg)
+
+<details>
+<summary>text_image</summary>
+
+I filter your name
+were are some artist designed mesh of the category chair:
+Please answer the following questions keeping these in mind.
+• which of the objects is a better quality mesh for this category?
+• which of the objects better matches the quality of artist meshes in this category!
+</details>
+
+Figure 15. User study interface. We show users a set of random ground-truth shapes for a category and then ask users for shape quality and triangulation preference among meshed generated by two methods.
+
+<table><tr><td>Variant</td><td>Triangle Accuracy (%) ↑</td><td>Cross-Entropy ↓</td></tr><tr><td>w/o Positional Encoding</td><td>79.33</td><td>0.2484</td></tr><tr><td>w/o Output Discretization</td><td>22.03</td><td>0.5705</td></tr><tr><td>w/o Residual Quantization</td><td>1.29</td><td>4.6679</td></tr><tr><td>w/o per Vertex Quantization</td><td>98.64</td><td>0.1413</td></tr><tr><td>w/ PointNet Encoder</td><td>88.73</td><td>0.1896</td></tr><tr><td>w/ GAT [60] Encoder</td><td>86.14</td><td>0.2015</td></tr><tr><td>w/ EdgeConv [61] Encoder</td><td>91.23</td><td>0.1702</td></tr><tr><td>w/ ResNet19 Decoder</td><td>96.29</td><td>0.1492</td></tr><tr><td>w/ PointNet Decoder</td><td>95.47</td><td>0.1528</td></tr><tr><td>MeshGPT</td><td>98.49</td><td>0.1473</td></tr></table>
+
+Table 4. Ablations of our design choices for the encoder-decoder network on the Chair category of the ShapeNet [5] dataset.
+
+We use a Chamfer Distance (CD) distance measure $D ( X , Y )$ for computing these metrics in 3D. To evaluate these point-based measures, we sample 2048 points randomly from all baseline outputs; and use 6000, 1200, 1000, 8000 generated shapes from chair, bench, lamp and table categories.
+
+Qualitative Results. Fig. 11 shows more unconditional generations from our model across different ShapeNet categories.
+
+Encoder-Decoder Ablations. In Tab. 4, we show a set of ablations on the design choice for our encoder-decoder network used for learning the triangle embeddings. We measure the performance in terms of triangle accuracy, which measures average accuracy with which all 9 coordinates of faces are correctly predicted, and the cross-entropy loss on the test set.
+
+![](images/93ed53b8c4f1a77bc0a632004090c5a0533351b6ab70863f6b98e63b4c7c521a.jpg)
+
+<details>
+<summary>text_image</summary>
+
+Sequence of Faces = (F₁, F₂) = ((V₁, V₂, V₃), (V₂, V₄, V₃))
+If 6 tokens are assigned per face:
+Sequence: (t₁¹, t₁², t₁³, t₁⁴, t₁⁵, t₁⁶, t₂¹, t₂², t₂³, t₂⁴, t₂⁵, t₂⁶)
+If 2 tokens are assigned per vertex:
+Sequence: (t₁¹, t₁², t₁³, t₁⁴, t₁⁵, t₁⁶, t₂¹, t₂², t₂³, t₂⁴, t₂⁵, t₂⁶)
+Repetition of tokens
+</details>
+
+Figure 16. The effectiveness of per-vertex quantization over perface quantization can be understood through an example where two faces share an edge as shown above. With per-face tokenization assigning 6 tokens per face, the sequence yields 12 unique tokens. In contrast, per-vertex tokenization leads to repeated tokens in the sequence due to shared vertices between faces. This repetition makes the sequence easier for the transformer to learn compared to a wholly unique sequence per face, especially when both sequences are of equal length.
+
+We evaluate the effect of various choices – how much does the positional encoding at input help, effect of using continuous predictions instead of discrete as outputs, using vector quantization (1 token per face) instead of residual quantization (D tokens per face), encoder architecture as a point encoder, or different graph convolution operators, and decoder architecture as either ResNet19 or Point-Net decoder. Note that even though for encoder-decoder reconstruction, ‘w/o per Vertex Quantization’ performs best, this variant works significantly worse than with per Vertex Quantization, as shown in the main paper. Fig. 16 describes an intuition of why the embeddings from this variant are more transformer friendly.

papers/markdown/2311.15475_MeshGPT_Generating_Triangle_Meshes_with_Decoder-Only_Transformers/hybrid_auto/2311.15475_MeshGPT_Generating_Triangle_Meshes_with_Decoder-Only_Transformers_layout.pdf

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:f5511d31c643b31e539fabd1dc82d8cd36a4409d7f25b5110d43e7fc55fbe5f1
+size 11616909