update version to 0.7.8

Summary: as title Reviewed By: das-intensity Differential Revision: D62588556 fbshipit-source-id: 55bae19dd1df796e83179cd29d805fcd871b6d23
remove pytorch2.0 builds
2025-12-22 07:10:34 +08:00 · 2024-09-13 02:31:49 -07:00 · 2024-09-13 02:07:25 -07:00 · 2024-09-13 02:00:49 -07:00 · 2024-09-11 15:09:43 -07:00 · 2024-08-15 16:18:22 -07:00
252 changed files with 1988 additions and 697 deletions
--- a/.circleci/config.yml
+++ b/.circleci/config.yml
@@ -162,90 +162,6 @@ workflows:
    jobs:
      # - main:
      #     context: DOCKERHUB_TOKEN
-      - binary_linux_conda:
-          conda_docker_image: pytorch/conda-builder:cuda113
-          context: DOCKERHUB_TOKEN
-          cu_version: cu113
-          name: linux_conda_py38_cu113_pyt1120
-          python_version: '3.8'
-          pytorch_version: 1.12.0
-      - binary_linux_conda:
-          conda_docker_image: pytorch/conda-builder:cuda116
-          context: DOCKERHUB_TOKEN
-          cu_version: cu116
-          name: linux_conda_py38_cu116_pyt1120
-          python_version: '3.8'
-          pytorch_version: 1.12.0
-      - binary_linux_conda:
-          conda_docker_image: pytorch/conda-builder:cuda113
-          context: DOCKERHUB_TOKEN
-          cu_version: cu113
-          name: linux_conda_py38_cu113_pyt1121
-          python_version: '3.8'
-          pytorch_version: 1.12.1
-      - binary_linux_conda:
-          conda_docker_image: pytorch/conda-builder:cuda116
-          context: DOCKERHUB_TOKEN
-          cu_version: cu116
-          name: linux_conda_py38_cu116_pyt1121
-          python_version: '3.8'
-          pytorch_version: 1.12.1
-      - binary_linux_conda:
-          conda_docker_image: pytorch/conda-builder:cuda116
-          context: DOCKERHUB_TOKEN
-          cu_version: cu116
-          name: linux_conda_py38_cu116_pyt1130
-          python_version: '3.8'
-          pytorch_version: 1.13.0
-      - binary_linux_conda:
-          conda_docker_image: pytorch/conda-builder:cuda117
-          context: DOCKERHUB_TOKEN
-          cu_version: cu117
-          name: linux_conda_py38_cu117_pyt1130
-          python_version: '3.8'
-          pytorch_version: 1.13.0
-      - binary_linux_conda:
-          conda_docker_image: pytorch/conda-builder:cuda116
-          context: DOCKERHUB_TOKEN
-          cu_version: cu116
-          name: linux_conda_py38_cu116_pyt1131
-          python_version: '3.8'
-          pytorch_version: 1.13.1
-      - binary_linux_conda:
-          conda_docker_image: pytorch/conda-builder:cuda117
-          context: DOCKERHUB_TOKEN
-          cu_version: cu117
-          name: linux_conda_py38_cu117_pyt1131
-          python_version: '3.8'
-          pytorch_version: 1.13.1
-      - binary_linux_conda:
-          conda_docker_image: pytorch/conda-builder:cuda117
-          context: DOCKERHUB_TOKEN
-          cu_version: cu117
-          name: linux_conda_py38_cu117_pyt200
-          python_version: '3.8'
-          pytorch_version: 2.0.0
-      - binary_linux_conda:
-          conda_docker_image: pytorch/conda-builder:cuda118
-          context: DOCKERHUB_TOKEN
-          cu_version: cu118
-          name: linux_conda_py38_cu118_pyt200
-          python_version: '3.8'
-          pytorch_version: 2.0.0
-      - binary_linux_conda:
-          conda_docker_image: pytorch/conda-builder:cuda117
-          context: DOCKERHUB_TOKEN
-          cu_version: cu117
-          name: linux_conda_py38_cu117_pyt201
-          python_version: '3.8'
-          pytorch_version: 2.0.1
-      - binary_linux_conda:
-          conda_docker_image: pytorch/conda-builder:cuda118
-          context: DOCKERHUB_TOKEN
-          cu_version: cu118
-          name: linux_conda_py38_cu118_pyt201
-          python_version: '3.8'
-          pytorch_version: 2.0.1
      - binary_linux_conda:
          conda_docker_image: pytorch/conda-builder:cuda118
          context: DOCKERHUB_TOKEN
@@ -303,89 +219,61 @@ workflows:
          python_version: '3.8'
          pytorch_version: 2.2.0
      - binary_linux_conda:
-          conda_docker_image: pytorch/conda-builder:cuda113
+          conda_docker_image: pytorch/conda-builder:cuda118
          context: DOCKERHUB_TOKEN
-          cu_version: cu113
-          name: linux_conda_py39_cu113_pyt1120
-          python_version: '3.9'
-          pytorch_version: 1.12.0
+          cu_version: cu118
+          name: linux_conda_py38_cu118_pyt222
+          python_version: '3.8'
+          pytorch_version: 2.2.2
      - binary_linux_conda:
-          conda_docker_image: pytorch/conda-builder:cuda116
+          conda_docker_image: pytorch/conda-builder:cuda121
          context: DOCKERHUB_TOKEN
-          cu_version: cu116
-          name: linux_conda_py39_cu116_pyt1120
-          python_version: '3.9'
-          pytorch_version: 1.12.0
-      - binary_linux_conda:
-          conda_docker_image: pytorch/conda-builder:cuda113
-          context: DOCKERHUB_TOKEN
-          cu_version: cu113
-          name: linux_conda_py39_cu113_pyt1121
-          python_version: '3.9'
-          pytorch_version: 1.12.1
-      - binary_linux_conda:
-          conda_docker_image: pytorch/conda-builder:cuda116
-          context: DOCKERHUB_TOKEN
-          cu_version: cu116
-          name: linux_conda_py39_cu116_pyt1121
-          python_version: '3.9'
-          pytorch_version: 1.12.1
-      - binary_linux_conda:
-          conda_docker_image: pytorch/conda-builder:cuda116
-          context: DOCKERHUB_TOKEN
-          cu_version: cu116
-          name: linux_conda_py39_cu116_pyt1130
-          python_version: '3.9'
-          pytorch_version: 1.13.0
-      - binary_linux_conda:
-          conda_docker_image: pytorch/conda-builder:cuda117
-          context: DOCKERHUB_TOKEN
-          cu_version: cu117
-          name: linux_conda_py39_cu117_pyt1130
-          python_version: '3.9'
-          pytorch_version: 1.13.0
-      - binary_linux_conda:
-          conda_docker_image: pytorch/conda-builder:cuda116
-          context: DOCKERHUB_TOKEN
-          cu_version: cu116
-          name: linux_conda_py39_cu116_pyt1131
-          python_version: '3.9'
-          pytorch_version: 1.13.1
-      - binary_linux_conda:
-          conda_docker_image: pytorch/conda-builder:cuda117
-          context: DOCKERHUB_TOKEN
-          cu_version: cu117
-          name: linux_conda_py39_cu117_pyt1131
-          python_version: '3.9'
-          pytorch_version: 1.13.1
-      - binary_linux_conda:
-          conda_docker_image: pytorch/conda-builder:cuda117
-          context: DOCKERHUB_TOKEN
-          cu_version: cu117
-          name: linux_conda_py39_cu117_pyt200
-          python_version: '3.9'
-          pytorch_version: 2.0.0
+          cu_version: cu121
+          name: linux_conda_py38_cu121_pyt222
+          python_version: '3.8'
+          pytorch_version: 2.2.2
      - binary_linux_conda:
          conda_docker_image: pytorch/conda-builder:cuda118
          context: DOCKERHUB_TOKEN
          cu_version: cu118
-          name: linux_conda_py39_cu118_pyt200
-          python_version: '3.9'
-          pytorch_version: 2.0.0
+          name: linux_conda_py38_cu118_pyt231
+          python_version: '3.8'
+          pytorch_version: 2.3.1
      - binary_linux_conda:
-          conda_docker_image: pytorch/conda-builder:cuda117
+          conda_docker_image: pytorch/conda-builder:cuda121
          context: DOCKERHUB_TOKEN
-          cu_version: cu117
-          name: linux_conda_py39_cu117_pyt201
-          python_version: '3.9'
-          pytorch_version: 2.0.1
+          cu_version: cu121
+          name: linux_conda_py38_cu121_pyt231
+          python_version: '3.8'
+          pytorch_version: 2.3.1
      - binary_linux_conda:
          conda_docker_image: pytorch/conda-builder:cuda118
          context: DOCKERHUB_TOKEN
          cu_version: cu118
-          name: linux_conda_py39_cu118_pyt201
-          python_version: '3.9'
-          pytorch_version: 2.0.1
+          name: linux_conda_py38_cu118_pyt240
+          python_version: '3.8'
+          pytorch_version: 2.4.0
+      - binary_linux_conda:
+          conda_docker_image: pytorch/conda-builder:cuda121
+          context: DOCKERHUB_TOKEN
+          cu_version: cu121
+          name: linux_conda_py38_cu121_pyt240
+          python_version: '3.8'
+          pytorch_version: 2.4.0
+      - binary_linux_conda:
+          conda_docker_image: pytorch/conda-builder:cuda118
+          context: DOCKERHUB_TOKEN
+          cu_version: cu118
+          name: linux_conda_py38_cu118_pyt241
+          python_version: '3.8'
+          pytorch_version: 2.4.1
+      - binary_linux_conda:
+          conda_docker_image: pytorch/conda-builder:cuda121
+          context: DOCKERHUB_TOKEN
+          cu_version: cu121
+          name: linux_conda_py38_cu121_pyt241
+          python_version: '3.8'
+          pytorch_version: 2.4.1
      - binary_linux_conda:
          conda_docker_image: pytorch/conda-builder:cuda118
          context: DOCKERHUB_TOKEN
@@ -443,89 +331,61 @@ workflows:
          python_version: '3.9'
          pytorch_version: 2.2.0
      - binary_linux_conda:
-          conda_docker_image: pytorch/conda-builder:cuda113
+          conda_docker_image: pytorch/conda-builder:cuda118
          context: DOCKERHUB_TOKEN
-          cu_version: cu113
-          name: linux_conda_py310_cu113_pyt1120
-          python_version: '3.10'
-          pytorch_version: 1.12.0
+          cu_version: cu118
+          name: linux_conda_py39_cu118_pyt222
+          python_version: '3.9'
+          pytorch_version: 2.2.2
      - binary_linux_conda:
-          conda_docker_image: pytorch/conda-builder:cuda116
+          conda_docker_image: pytorch/conda-builder:cuda121
          context: DOCKERHUB_TOKEN
-          cu_version: cu116
-          name: linux_conda_py310_cu116_pyt1120
-          python_version: '3.10'
-          pytorch_version: 1.12.0
-      - binary_linux_conda:
-          conda_docker_image: pytorch/conda-builder:cuda113
-          context: DOCKERHUB_TOKEN
-          cu_version: cu113
-          name: linux_conda_py310_cu113_pyt1121
-          python_version: '3.10'
-          pytorch_version: 1.12.1
-      - binary_linux_conda:
-          conda_docker_image: pytorch/conda-builder:cuda116
-          context: DOCKERHUB_TOKEN
-          cu_version: cu116
-          name: linux_conda_py310_cu116_pyt1121
-          python_version: '3.10'
-          pytorch_version: 1.12.1
-      - binary_linux_conda:
-          conda_docker_image: pytorch/conda-builder:cuda116
-          context: DOCKERHUB_TOKEN
-          cu_version: cu116
-          name: linux_conda_py310_cu116_pyt1130
-          python_version: '3.10'
-          pytorch_version: 1.13.0
-      - binary_linux_conda:
-          conda_docker_image: pytorch/conda-builder:cuda117
-          context: DOCKERHUB_TOKEN
-          cu_version: cu117
-          name: linux_conda_py310_cu117_pyt1130
-          python_version: '3.10'
-          pytorch_version: 1.13.0
-      - binary_linux_conda:
-          conda_docker_image: pytorch/conda-builder:cuda116
-          context: DOCKERHUB_TOKEN
-          cu_version: cu116
-          name: linux_conda_py310_cu116_pyt1131
-          python_version: '3.10'
-          pytorch_version: 1.13.1
-      - binary_linux_conda:
-          conda_docker_image: pytorch/conda-builder:cuda117
-          context: DOCKERHUB_TOKEN
-          cu_version: cu117
-          name: linux_conda_py310_cu117_pyt1131
-          python_version: '3.10'
-          pytorch_version: 1.13.1
-      - binary_linux_conda:
-          conda_docker_image: pytorch/conda-builder:cuda117
-          context: DOCKERHUB_TOKEN
-          cu_version: cu117
-          name: linux_conda_py310_cu117_pyt200
-          python_version: '3.10'
-          pytorch_version: 2.0.0
+          cu_version: cu121
+          name: linux_conda_py39_cu121_pyt222
+          python_version: '3.9'
+          pytorch_version: 2.2.2
      - binary_linux_conda:
          conda_docker_image: pytorch/conda-builder:cuda118
          context: DOCKERHUB_TOKEN
          cu_version: cu118
-          name: linux_conda_py310_cu118_pyt200
-          python_version: '3.10'
-          pytorch_version: 2.0.0
+          name: linux_conda_py39_cu118_pyt231
+          python_version: '3.9'
+          pytorch_version: 2.3.1
      - binary_linux_conda:
-          conda_docker_image: pytorch/conda-builder:cuda117
+          conda_docker_image: pytorch/conda-builder:cuda121
          context: DOCKERHUB_TOKEN
-          cu_version: cu117
-          name: linux_conda_py310_cu117_pyt201
-          python_version: '3.10'
-          pytorch_version: 2.0.1
+          cu_version: cu121
+          name: linux_conda_py39_cu121_pyt231
+          python_version: '3.9'
+          pytorch_version: 2.3.1
      - binary_linux_conda:
          conda_docker_image: pytorch/conda-builder:cuda118
          context: DOCKERHUB_TOKEN
          cu_version: cu118
-          name: linux_conda_py310_cu118_pyt201
-          python_version: '3.10'
-          pytorch_version: 2.0.1
+          name: linux_conda_py39_cu118_pyt240
+          python_version: '3.9'
+          pytorch_version: 2.4.0
+      - binary_linux_conda:
+          conda_docker_image: pytorch/conda-builder:cuda121
+          context: DOCKERHUB_TOKEN
+          cu_version: cu121
+          name: linux_conda_py39_cu121_pyt240
+          python_version: '3.9'
+          pytorch_version: 2.4.0
+      - binary_linux_conda:
+          conda_docker_image: pytorch/conda-builder:cuda118
+          context: DOCKERHUB_TOKEN
+          cu_version: cu118
+          name: linux_conda_py39_cu118_pyt241
+          python_version: '3.9'
+          pytorch_version: 2.4.1
+      - binary_linux_conda:
+          conda_docker_image: pytorch/conda-builder:cuda121
+          context: DOCKERHUB_TOKEN
+          cu_version: cu121
+          name: linux_conda_py39_cu121_pyt241
+          python_version: '3.9'
+          pytorch_version: 2.4.1
      - binary_linux_conda:
          conda_docker_image: pytorch/conda-builder:cuda118
          context: DOCKERHUB_TOKEN
@@ -582,6 +442,62 @@ workflows:
          name: linux_conda_py310_cu121_pyt220
          python_version: '3.10'
          pytorch_version: 2.2.0
+      - binary_linux_conda:
+          conda_docker_image: pytorch/conda-builder:cuda118
+          context: DOCKERHUB_TOKEN
+          cu_version: cu118
+          name: linux_conda_py310_cu118_pyt222
+          python_version: '3.10'
+          pytorch_version: 2.2.2
+      - binary_linux_conda:
+          conda_docker_image: pytorch/conda-builder:cuda121
+          context: DOCKERHUB_TOKEN
+          cu_version: cu121
+          name: linux_conda_py310_cu121_pyt222
+          python_version: '3.10'
+          pytorch_version: 2.2.2
+      - binary_linux_conda:
+          conda_docker_image: pytorch/conda-builder:cuda118
+          context: DOCKERHUB_TOKEN
+          cu_version: cu118
+          name: linux_conda_py310_cu118_pyt231
+          python_version: '3.10'
+          pytorch_version: 2.3.1
+      - binary_linux_conda:
+          conda_docker_image: pytorch/conda-builder:cuda121
+          context: DOCKERHUB_TOKEN
+          cu_version: cu121
+          name: linux_conda_py310_cu121_pyt231
+          python_version: '3.10'
+          pytorch_version: 2.3.1
+      - binary_linux_conda:
+          conda_docker_image: pytorch/conda-builder:cuda118
+          context: DOCKERHUB_TOKEN
+          cu_version: cu118
+          name: linux_conda_py310_cu118_pyt240
+          python_version: '3.10'
+          pytorch_version: 2.4.0
+      - binary_linux_conda:
+          conda_docker_image: pytorch/conda-builder:cuda121
+          context: DOCKERHUB_TOKEN
+          cu_version: cu121
+          name: linux_conda_py310_cu121_pyt240
+          python_version: '3.10'
+          pytorch_version: 2.4.0
+      - binary_linux_conda:
+          conda_docker_image: pytorch/conda-builder:cuda118
+          context: DOCKERHUB_TOKEN
+          cu_version: cu118
+          name: linux_conda_py310_cu118_pyt241
+          python_version: '3.10'
+          pytorch_version: 2.4.1
+      - binary_linux_conda:
+          conda_docker_image: pytorch/conda-builder:cuda121
+          context: DOCKERHUB_TOKEN
+          cu_version: cu121
+          name: linux_conda_py310_cu121_pyt241
+          python_version: '3.10'
+          pytorch_version: 2.4.1
      - binary_linux_conda:
          conda_docker_image: pytorch/conda-builder:cuda118
          context: DOCKERHUB_TOKEN
@@ -638,6 +554,62 @@ workflows:
          name: linux_conda_py311_cu121_pyt220
          python_version: '3.11'
          pytorch_version: 2.2.0
+      - binary_linux_conda:
+          conda_docker_image: pytorch/conda-builder:cuda118
+          context: DOCKERHUB_TOKEN
+          cu_version: cu118
+          name: linux_conda_py311_cu118_pyt222
+          python_version: '3.11'
+          pytorch_version: 2.2.2
+      - binary_linux_conda:
+          conda_docker_image: pytorch/conda-builder:cuda121
+          context: DOCKERHUB_TOKEN
+          cu_version: cu121
+          name: linux_conda_py311_cu121_pyt222
+          python_version: '3.11'
+          pytorch_version: 2.2.2
+      - binary_linux_conda:
+          conda_docker_image: pytorch/conda-builder:cuda118
+          context: DOCKERHUB_TOKEN
+          cu_version: cu118
+          name: linux_conda_py311_cu118_pyt231
+          python_version: '3.11'
+          pytorch_version: 2.3.1
+      - binary_linux_conda:
+          conda_docker_image: pytorch/conda-builder:cuda121
+          context: DOCKERHUB_TOKEN
+          cu_version: cu121
+          name: linux_conda_py311_cu121_pyt231
+          python_version: '3.11'
+          pytorch_version: 2.3.1
+      - binary_linux_conda:
+          conda_docker_image: pytorch/conda-builder:cuda118
+          context: DOCKERHUB_TOKEN
+          cu_version: cu118
+          name: linux_conda_py311_cu118_pyt240
+          python_version: '3.11'
+          pytorch_version: 2.4.0
+      - binary_linux_conda:
+          conda_docker_image: pytorch/conda-builder:cuda121
+          context: DOCKERHUB_TOKEN
+          cu_version: cu121
+          name: linux_conda_py311_cu121_pyt240
+          python_version: '3.11'
+          pytorch_version: 2.4.0
+      - binary_linux_conda:
+          conda_docker_image: pytorch/conda-builder:cuda118
+          context: DOCKERHUB_TOKEN
+          cu_version: cu118
+          name: linux_conda_py311_cu118_pyt241
+          python_version: '3.11'
+          pytorch_version: 2.4.1
+      - binary_linux_conda:
+          conda_docker_image: pytorch/conda-builder:cuda121
+          context: DOCKERHUB_TOKEN
+          cu_version: cu121
+          name: linux_conda_py311_cu121_pyt241
+          python_version: '3.11'
+          pytorch_version: 2.4.1
      - binary_linux_conda:
          conda_docker_image: pytorch/conda-builder:cuda118
          context: DOCKERHUB_TOKEN
@@ -652,6 +624,62 @@ workflows:
          name: linux_conda_py312_cu121_pyt220
          python_version: '3.12'
          pytorch_version: 2.2.0
+      - binary_linux_conda:
+          conda_docker_image: pytorch/conda-builder:cuda118
+          context: DOCKERHUB_TOKEN
+          cu_version: cu118
+          name: linux_conda_py312_cu118_pyt222
+          python_version: '3.12'
+          pytorch_version: 2.2.2
+      - binary_linux_conda:
+          conda_docker_image: pytorch/conda-builder:cuda121
+          context: DOCKERHUB_TOKEN
+          cu_version: cu121
+          name: linux_conda_py312_cu121_pyt222
+          python_version: '3.12'
+          pytorch_version: 2.2.2
+      - binary_linux_conda:
+          conda_docker_image: pytorch/conda-builder:cuda118
+          context: DOCKERHUB_TOKEN
+          cu_version: cu118
+          name: linux_conda_py312_cu118_pyt231
+          python_version: '3.12'
+          pytorch_version: 2.3.1
+      - binary_linux_conda:
+          conda_docker_image: pytorch/conda-builder:cuda121
+          context: DOCKERHUB_TOKEN
+          cu_version: cu121
+          name: linux_conda_py312_cu121_pyt231
+          python_version: '3.12'
+          pytorch_version: 2.3.1
+      - binary_linux_conda:
+          conda_docker_image: pytorch/conda-builder:cuda118
+          context: DOCKERHUB_TOKEN
+          cu_version: cu118
+          name: linux_conda_py312_cu118_pyt240
+          python_version: '3.12'
+          pytorch_version: 2.4.0
+      - binary_linux_conda:
+          conda_docker_image: pytorch/conda-builder:cuda121
+          context: DOCKERHUB_TOKEN
+          cu_version: cu121
+          name: linux_conda_py312_cu121_pyt240
+          python_version: '3.12'
+          pytorch_version: 2.4.0
+      - binary_linux_conda:
+          conda_docker_image: pytorch/conda-builder:cuda118
+          context: DOCKERHUB_TOKEN
+          cu_version: cu118
+          name: linux_conda_py312_cu118_pyt241
+          python_version: '3.12'
+          pytorch_version: 2.4.1
+      - binary_linux_conda:
+          conda_docker_image: pytorch/conda-builder:cuda121
+          context: DOCKERHUB_TOKEN
+          cu_version: cu121
+          name: linux_conda_py312_cu121_pyt241
+          python_version: '3.12'
+          pytorch_version: 2.4.1
      - binary_linux_conda_cuda:
          name: testrun_conda_cuda_py310_cu117_pyt201
          context: DOCKERHUB_TOKEN
--- a/.circleci/regenerate.py
+++ b/.circleci/regenerate.py
@@ -19,16 +19,14 @@ from packaging import version
 # The CUDA versions which have pytorch conda packages available for linux for each
 # version of pytorch.
 CONDA_CUDA_VERSIONS = {
-    "1.12.0": ["cu113", "cu116"],
-    "1.12.1": ["cu113", "cu116"],
-    "1.13.0": ["cu116", "cu117"],
-    "1.13.1": ["cu116", "cu117"],
-    "2.0.0": ["cu117", "cu118"],
-    "2.0.1": ["cu117", "cu118"],
    "2.1.0": ["cu118", "cu121"],
    "2.1.1": ["cu118", "cu121"],
    "2.1.2": ["cu118", "cu121"],
    "2.2.0": ["cu118", "cu121"],
+    "2.2.2": ["cu118", "cu121"],
+    "2.3.1": ["cu118", "cu121"],
+    "2.4.0": ["cu118", "cu121"],
+    "2.4.1": ["cu118", "cu121"],
 }


--- a/INSTALL.md
+++ b/INSTALL.md
@@ -8,11 +8,10 @@
 The core library is written in PyTorch. Several components have underlying implementation in CUDA for improved performance. A subset of these components have CPU implementations in C++/PyTorch. It is advised to use PyTorch3D with GPU support in order to use all the features.

 - Linux or macOS or Windows
- Python 3.8, 3.9 or 3.10
- PyTorch 1.12.0, 1.12.1, 1.13.0, 2.0.0, 2.0.1, 2.1.0, 2.1.1, 2.1.2 or 2.2.0.
+- Python
+- PyTorch 2.1.0, 2.1.1, 2.1.2, 2.2.0, 2.2.1, 2.2.2, 2.3.0, 2.3.1, 2.4.0 or 2.4.1.
 - torchvision that matches the PyTorch installation. You can install them together as explained at pytorch.org to make sure of this.
 - gcc & g++ ≥ 4.9
- [fvcore](https://github.com/facebookresearch/fvcore)
 - [ioPath](https://github.com/facebookresearch/iopath)
 - If CUDA is to be used, use a version which is supported by the corresponding pytorch version and at least version 9.2.
 - If CUDA older than 11.7 is to be used and you are building from source, the CUB library must be available. We recommend version 1.10.0.
@@ -22,7 +21,7 @@ The runtime dependencies can be installed by running:
 conda create -n pytorch3d python=3.9
 conda activate pytorch3d
 conda install pytorch=1.13.0 torchvision pytorch-cuda=11.6 -c pytorch -c nvidia
-conda install -c fvcore -c iopath -c conda-forge fvcore iopath
+conda install -c iopath iopath
 ```

 For the CUB build time dependency, which you only need if you have CUDA older than 11.7, if you are using conda, you can continue with
@@ -49,6 +48,7 @@ For developing on top of PyTorch3D or contributing, you will need to run the lin
 - tdqm
 - jupyter
 - imageio
+- fvcore
 - plotly
 - opencv-python

@@ -59,6 +59,7 @@ conda install jupyter
 pip install scikit-image matplotlib imageio plotly opencv-python

 # Tests/Linting
+conda install -c fvcore -c conda-forge fvcore
 pip install black usort flake8 flake8-bugbear flake8-comprehensions
 ```

@@ -97,7 +98,7 @@ version_str="".join([
    torch.version.cuda.replace(".",""),
    f"_pyt{pyt_version_str}"
 ])
-!pip install fvcore iopath
+!pip install iopath
 !pip install --no-index --no-cache-dir pytorch3d -f https://dl.fbaipublicfiles.com/pytorch3d/packaging/wheels/{version_str}/download.html
 ```

--- a/dev/run_tutorials.sh
+++ b/dev/run_tutorials.sh
@@ -23,7 +23,7 @@ conda init bash
 source ~/.bashrc
 conda create -y -n myenv python=3.8 matplotlib ipython ipywidgets nbconvert
 conda activate myenv
-conda install -y -c fvcore -c iopath -c conda-forge fvcore iopath
+conda install -y -c iopath iopath
 conda install -y -c pytorch pytorch=1.6.0 cudatoolkit=10.1 torchvision
 conda install -y -c pytorch3d-nightly pytorch3d
 pip install plotly scikit-image
--- a/docs/requirements.txt
+++ b/docs/requirements.txt
@@ -5,7 +5,6 @@ sphinx_rtd_theme
 sphinx_markdown_tables
 numpy
 iopath
-fvcore
 https://download.pytorch.org/whl/cpu/torchvision-0.15.2%2Bcpu-cp311-cp311-linux_x86_64.whl
 https://download.pytorch.org/whl/cpu/torch-2.0.1%2Bcpu-cp311-cp311-linux_x86_64.whl
 omegaconf
--- a/docs/tutorials/bundle_adjustment.ipynb
+++ b/docs/tutorials/bundle_adjustment.ipynb
@@ -83,25 +83,31 @@
    "import os\n",
    "import sys\n",
    "import torch\n",
+    "import subprocess\n",
    "need_pytorch3d=False\n",
    "try:\n",
    "    import pytorch3d\n",
    "except ModuleNotFoundError:\n",
    "    need_pytorch3d=True\n",
    "if need_pytorch3d:\n",
-    "    if torch.__version__.startswith(\"2.2.\") and sys.platform.startswith(\"linux\"):\n",
-    "        # We try to install PyTorch3D via a released wheel.\n",
-    "        pyt_version_str=torch.__version__.split(\"+\")[0].replace(\".\", \"\")\n",
-    "        version_str=\"\".join([\n",
-    "            f\"py3{sys.version_info.minor}_cu\",\n",
-    "            torch.version.cuda.replace(\".\",\"\"),\n",
-    "            f\"_pyt{pyt_version_str}\"\n",
-    "        ])\n",
-    "        !pip install fvcore iopath\n",
+    "    pyt_version_str=torch.__version__.split(\"+\")[0].replace(\".\", \"\")\n",
+    "    version_str=\"\".join([\n",
+    "        f\"py3{sys.version_info.minor}_cu\",\n",
+    "        torch.version.cuda.replace(\".\",\"\"),\n",
+    "        f\"_pyt{pyt_version_str}\"\n",
+    "    ])\n",
+    "    !pip install iopath\n",
+    "    if sys.platform.startswith(\"linux\"):\n",
+    "        print(\"Trying to install wheel for PyTorch3D\")\n",
    "        !pip install --no-index --no-cache-dir pytorch3d -f https://dl.fbaipublicfiles.com/pytorch3d/packaging/wheels/{version_str}/download.html\n",
-    "    else:\n",
-    "        # We try to install PyTorch3D from source.\n",
-    "        !pip install 'git+https://github.com/facebookresearch/pytorch3d.git@stable'"
+    "        pip_list = !pip freeze\n",
+    "        need_pytorch3d = not any(i.startswith(\"pytorch3d==\") for  i in pip_list)\n",
+    "    if need_pytorch3d:\n",
+    "        print(f\"failed to find/install wheel for {version_str}\")\n",
+    "if need_pytorch3d:\n",
+    "    print(\"Installing PyTorch3D from source\")\n",
+    "    !pip install ninja\n",
+    "    !pip install 'git+https://github.com/facebookresearch/pytorch3d.git@stable'"
   ]
  },
  {
--- a/docs/tutorials/camera_position_optimization_with_differentiable_rendering.ipynb
+++ b/docs/tutorials/camera_position_optimization_with_differentiable_rendering.ipynb
@@ -70,25 +70,31 @@
    "import os\n",
    "import sys\n",
    "import torch\n",
+    "import subprocess\n",
    "need_pytorch3d=False\n",
    "try:\n",
    "    import pytorch3d\n",
    "except ModuleNotFoundError:\n",
    "    need_pytorch3d=True\n",
    "if need_pytorch3d:\n",
-    "    if torch.__version__.startswith(\"2.2.\") and sys.platform.startswith(\"linux\"):\n",
-    "        # We try to install PyTorch3D via a released wheel.\n",
-    "        pyt_version_str=torch.__version__.split(\"+\")[0].replace(\".\", \"\")\n",
-    "        version_str=\"\".join([\n",
-    "            f\"py3{sys.version_info.minor}_cu\",\n",
-    "            torch.version.cuda.replace(\".\",\"\"),\n",
-    "            f\"_pyt{pyt_version_str}\"\n",
-    "        ])\n",
-    "        !pip install fvcore iopath\n",
+    "    pyt_version_str=torch.__version__.split(\"+\")[0].replace(\".\", \"\")\n",
+    "    version_str=\"\".join([\n",
+    "        f\"py3{sys.version_info.minor}_cu\",\n",
+    "        torch.version.cuda.replace(\".\",\"\"),\n",
+    "        f\"_pyt{pyt_version_str}\"\n",
+    "    ])\n",
+    "    !pip install iopath\n",
+    "    if sys.platform.startswith(\"linux\"):\n",
+    "        print(\"Trying to install wheel for PyTorch3D\")\n",
    "        !pip install --no-index --no-cache-dir pytorch3d -f https://dl.fbaipublicfiles.com/pytorch3d/packaging/wheels/{version_str}/download.html\n",
-    "    else:\n",
-    "        # We try to install PyTorch3D from source.\n",
-    "        !pip install 'git+https://github.com/facebookresearch/pytorch3d.git@stable'"
+    "        pip_list = !pip freeze\n",
+    "        need_pytorch3d = not any(i.startswith(\"pytorch3d==\") for  i in pip_list)\n",
+    "    if need_pytorch3d:\n",
+    "        print(f\"failed to find/install wheel for {version_str}\")\n",
+    "if need_pytorch3d:\n",
+    "    print(\"Installing PyTorch3D from source\")\n",
+    "    !pip install ninja\n",
+    "    !pip install 'git+https://github.com/facebookresearch/pytorch3d.git@stable'"
   ]
  },
  {
--- a/docs/tutorials/dataloaders_ShapeNetCore_R2N2.ipynb
+++ b/docs/tutorials/dataloaders_ShapeNetCore_R2N2.ipynb
@@ -45,25 +45,31 @@
    "import os\n",
    "import sys\n",
    "import torch\n",
+    "import subprocess\n",
    "need_pytorch3d=False\n",
    "try:\n",
    "    import pytorch3d\n",
    "except ModuleNotFoundError:\n",
    "    need_pytorch3d=True\n",
    "if need_pytorch3d:\n",
-    "    if torch.__version__.startswith(\"2.2.\") and sys.platform.startswith(\"linux\"):\n",
-    "        # We try to install PyTorch3D via a released wheel.\n",
-    "        pyt_version_str=torch.__version__.split(\"+\")[0].replace(\".\", \"\")\n",
-    "        version_str=\"\".join([\n",
-    "            f\"py3{sys.version_info.minor}_cu\",\n",
-    "            torch.version.cuda.replace(\".\",\"\"),\n",
-    "            f\"_pyt{pyt_version_str}\"\n",
-    "        ])\n",
-    "        !pip install fvcore iopath\n",
+    "    pyt_version_str=torch.__version__.split(\"+\")[0].replace(\".\", \"\")\n",
+    "    version_str=\"\".join([\n",
+    "        f\"py3{sys.version_info.minor}_cu\",\n",
+    "        torch.version.cuda.replace(\".\",\"\"),\n",
+    "        f\"_pyt{pyt_version_str}\"\n",
+    "    ])\n",
+    "    !pip install iopath\n",
+    "    if sys.platform.startswith(\"linux\"):\n",
+    "        print(\"Trying to install wheel for PyTorch3D\")\n",
    "        !pip install --no-index --no-cache-dir pytorch3d -f https://dl.fbaipublicfiles.com/pytorch3d/packaging/wheels/{version_str}/download.html\n",
-    "    else:\n",
-    "        # We try to install PyTorch3D from source.\n",
-    "        !pip install 'git+https://github.com/facebookresearch/pytorch3d.git@stable'"
+    "        pip_list = !pip freeze\n",
+    "        need_pytorch3d = not any(i.startswith(\"pytorch3d==\") for  i in pip_list)\n",
+    "    if need_pytorch3d:\n",
+    "        print(f\"failed to find/install wheel for {version_str}\")\n",
+    "if need_pytorch3d:\n",
+    "    print(\"Installing PyTorch3D from source\")\n",
+    "    !pip install ninja\n",
+    "    !pip install 'git+https://github.com/facebookresearch/pytorch3d.git@stable'"
   ]
  },
  {
@@ -405,7 +411,7 @@
   "outputs": [],
   "source": [
    "random_model_images = shapenet_dataset.render(\n",
-    "    sample_nums=[3],\n",
+    "    sample_nums=[5],\n",
    "    device=device,\n",
    "    cameras=cameras,\n",
    "    raster_settings=raster_settings,\n",
--- a/docs/tutorials/deform_source_mesh_to_target_mesh.ipynb
+++ b/docs/tutorials/deform_source_mesh_to_target_mesh.ipynb
@@ -84,25 +84,31 @@
    "import os\n",
    "import sys\n",
    "import torch\n",
+    "import subprocess\n",
    "need_pytorch3d=False\n",
    "try:\n",
    "    import pytorch3d\n",
    "except ModuleNotFoundError:\n",
    "    need_pytorch3d=True\n",
    "if need_pytorch3d:\n",
-    "    if torch.__version__.startswith(\"2.2.\") and sys.platform.startswith(\"linux\"):\n",
-    "        # We try to install PyTorch3D via a released wheel.\n",
-    "        pyt_version_str=torch.__version__.split(\"+\")[0].replace(\".\", \"\")\n",
-    "        version_str=\"\".join([\n",
-    "            f\"py3{sys.version_info.minor}_cu\",\n",
-    "            torch.version.cuda.replace(\".\",\"\"),\n",
-    "            f\"_pyt{pyt_version_str}\"\n",
-    "        ])\n",
-    "        !pip install fvcore iopath\n",
+    "    pyt_version_str=torch.__version__.split(\"+\")[0].replace(\".\", \"\")\n",
+    "    version_str=\"\".join([\n",
+    "        f\"py3{sys.version_info.minor}_cu\",\n",
+    "        torch.version.cuda.replace(\".\",\"\"),\n",
+    "        f\"_pyt{pyt_version_str}\"\n",
+    "    ])\n",
+    "    !pip install iopath\n",
+    "    if sys.platform.startswith(\"linux\"):\n",
+    "        print(\"Trying to install wheel for PyTorch3D\")\n",
    "        !pip install --no-index --no-cache-dir pytorch3d -f https://dl.fbaipublicfiles.com/pytorch3d/packaging/wheels/{version_str}/download.html\n",
-    "    else:\n",
-    "        # We try to install PyTorch3D from source.\n",
-    "        !pip install 'git+https://github.com/facebookresearch/pytorch3d.git@stable'"
+    "        pip_list = !pip freeze\n",
+    "        need_pytorch3d = not any(i.startswith(\"pytorch3d==\") for  i in pip_list)\n",
+    "    if need_pytorch3d:\n",
+    "        print(f\"failed to find/install wheel for {version_str}\")\n",
+    "if need_pytorch3d:\n",
+    "    print(\"Installing PyTorch3D from source\")\n",
+    "    !pip install ninja\n",
+    "    !pip install 'git+https://github.com/facebookresearch/pytorch3d.git@stable'"
   ]
  },
  {
--- a/docs/tutorials/fit_simple_neural_radiance_field.ipynb
+++ b/docs/tutorials/fit_simple_neural_radiance_field.ipynb
@@ -50,25 +50,31 @@
    "import os\n",
    "import sys\n",
    "import torch\n",
+    "import subprocess\n",
    "need_pytorch3d=False\n",
    "try:\n",
    "    import pytorch3d\n",
    "except ModuleNotFoundError:\n",
    "    need_pytorch3d=True\n",
    "if need_pytorch3d:\n",
-    "    if torch.__version__.startswith(\"2.2.\") and sys.platform.startswith(\"linux\"):\n",
-    "        # We try to install PyTorch3D via a released wheel.\n",
-    "        pyt_version_str=torch.__version__.split(\"+\")[0].replace(\".\", \"\")\n",
-    "        version_str=\"\".join([\n",
-    "            f\"py3{sys.version_info.minor}_cu\",\n",
-    "            torch.version.cuda.replace(\".\",\"\"),\n",
-    "            f\"_pyt{pyt_version_str}\"\n",
-    "        ])\n",
-    "        !pip install fvcore iopath\n",
+    "    pyt_version_str=torch.__version__.split(\"+\")[0].replace(\".\", \"\")\n",
+    "    version_str=\"\".join([\n",
+    "        f\"py3{sys.version_info.minor}_cu\",\n",
+    "        torch.version.cuda.replace(\".\",\"\"),\n",
+    "        f\"_pyt{pyt_version_str}\"\n",
+    "    ])\n",
+    "    !pip install iopath\n",
+    "    if sys.platform.startswith(\"linux\"):\n",
+    "        print(\"Trying to install wheel for PyTorch3D\")\n",
    "        !pip install --no-index --no-cache-dir pytorch3d -f https://dl.fbaipublicfiles.com/pytorch3d/packaging/wheels/{version_str}/download.html\n",
-    "    else:\n",
-    "        # We try to install PyTorch3D from source.\n",
-    "        !pip install 'git+https://github.com/facebookresearch/pytorch3d.git@stable'"
+    "        pip_list = !pip freeze\n",
+    "        need_pytorch3d = not any(i.startswith(\"pytorch3d==\") for  i in pip_list)\n",
+    "    if need_pytorch3d:\n",
+    "        print(f\"failed to find/install wheel for {version_str}\")\n",
+    "if need_pytorch3d:\n",
+    "    print(\"Installing PyTorch3D from source\")\n",
+    "    !pip install ninja\n",
+    "    !pip install 'git+https://github.com/facebookresearch/pytorch3d.git@stable'"
   ]
  },
  {
--- a/docs/tutorials/fit_textured_mesh.ipynb
+++ b/docs/tutorials/fit_textured_mesh.ipynb
@@ -62,25 +62,31 @@
    "import os\n",
    "import sys\n",
    "import torch\n",
+    "import subprocess\n",
    "need_pytorch3d=False\n",
    "try:\n",
    "    import pytorch3d\n",
    "except ModuleNotFoundError:\n",
    "    need_pytorch3d=True\n",
    "if need_pytorch3d:\n",
-    "    if torch.__version__.startswith(\"2.2.\") and sys.platform.startswith(\"linux\"):\n",
-    "        # We try to install PyTorch3D via a released wheel.\n",
-    "        pyt_version_str=torch.__version__.split(\"+\")[0].replace(\".\", \"\")\n",
-    "        version_str=\"\".join([\n",
-    "            f\"py3{sys.version_info.minor}_cu\",\n",
-    "            torch.version.cuda.replace(\".\",\"\"),\n",
-    "            f\"_pyt{pyt_version_str}\"\n",
-    "        ])\n",
-    "        !pip install fvcore iopath\n",
+    "    pyt_version_str=torch.__version__.split(\"+\")[0].replace(\".\", \"\")\n",
+    "    version_str=\"\".join([\n",
+    "        f\"py3{sys.version_info.minor}_cu\",\n",
+    "        torch.version.cuda.replace(\".\",\"\"),\n",
+    "        f\"_pyt{pyt_version_str}\"\n",
+    "    ])\n",
+    "    !pip install iopath\n",
+    "    if sys.platform.startswith(\"linux\"):\n",
+    "        print(\"Trying to install wheel for PyTorch3D\")\n",
    "        !pip install --no-index --no-cache-dir pytorch3d -f https://dl.fbaipublicfiles.com/pytorch3d/packaging/wheels/{version_str}/download.html\n",
-    "    else:\n",
-    "        # We try to install PyTorch3D from source.\n",
-    "        !pip install 'git+https://github.com/facebookresearch/pytorch3d.git@stable'"
+    "        pip_list = !pip freeze\n",
+    "        need_pytorch3d = not any(i.startswith(\"pytorch3d==\") for  i in pip_list)\n",
+    "    if need_pytorch3d:\n",
+    "        print(f\"failed to find/install wheel for {version_str}\")\n",
+    "if need_pytorch3d:\n",
+    "    print(\"Installing PyTorch3D from source\")\n",
+    "    !pip install ninja\n",
+    "    !pip install 'git+https://github.com/facebookresearch/pytorch3d.git@stable'"
   ]
  },
  {
--- a/docs/tutorials/fit_textured_volume.ipynb
+++ b/docs/tutorials/fit_textured_volume.ipynb
@@ -41,25 +41,31 @@
    "import os\n",
    "import sys\n",
    "import torch\n",
+    "import subprocess\n",
    "need_pytorch3d=False\n",
    "try:\n",
    "    import pytorch3d\n",
    "except ModuleNotFoundError:\n",
    "    need_pytorch3d=True\n",
    "if need_pytorch3d:\n",
-    "    if torch.__version__.startswith(\"2.2.\") and sys.platform.startswith(\"linux\"):\n",
-    "        # We try to install PyTorch3D via a released wheel.\n",
-    "        pyt_version_str=torch.__version__.split(\"+\")[0].replace(\".\", \"\")\n",
-    "        version_str=\"\".join([\n",
-    "            f\"py3{sys.version_info.minor}_cu\",\n",
-    "            torch.version.cuda.replace(\".\",\"\"),\n",
-    "            f\"_pyt{pyt_version_str}\"\n",
-    "        ])\n",
-    "        !pip install fvcore iopath\n",
+    "    pyt_version_str=torch.__version__.split(\"+\")[0].replace(\".\", \"\")\n",
+    "    version_str=\"\".join([\n",
+    "        f\"py3{sys.version_info.minor}_cu\",\n",
+    "        torch.version.cuda.replace(\".\",\"\"),\n",
+    "        f\"_pyt{pyt_version_str}\"\n",
+    "    ])\n",
+    "    !pip install iopath\n",
+    "    if sys.platform.startswith(\"linux\"):\n",
+    "        print(\"Trying to install wheel for PyTorch3D\")\n",
    "        !pip install --no-index --no-cache-dir pytorch3d -f https://dl.fbaipublicfiles.com/pytorch3d/packaging/wheels/{version_str}/download.html\n",
-    "    else:\n",
-    "        # We try to install PyTorch3D from source.\n",
-    "        !pip install 'git+https://github.com/facebookresearch/pytorch3d.git@stable'"
+    "        pip_list = !pip freeze\n",
+    "        need_pytorch3d = not any(i.startswith(\"pytorch3d==\") for  i in pip_list)\n",
+    "    if need_pytorch3d:\n",
+    "        print(f\"failed to find/install wheel for {version_str}\")\n",
+    "if need_pytorch3d:\n",
+    "    print(\"Installing PyTorch3D from source\")\n",
+    "    !pip install ninja\n",
+    "    !pip install 'git+https://github.com/facebookresearch/pytorch3d.git@stable'"
   ]
  },
  {
--- a/docs/tutorials/implicitron_config_system.ipynb
+++ b/docs/tutorials/implicitron_config_system.ipynb
@@ -72,25 +72,31 @@
        "import os\n",
        "import sys\n",
        "import torch\n",
+        "import subprocess\n",
        "need_pytorch3d=False\n",
        "try:\n",
        "    import pytorch3d\n",
        "except ModuleNotFoundError:\n",
        "    need_pytorch3d=True\n",
        "if need_pytorch3d:\n",
-        "    if torch.__version__.startswith(\"2.2.\") and sys.platform.startswith(\"linux\"):\n",
-        "        # We try to install PyTorch3D via a released wheel.\n",
-        "        pyt_version_str=torch.__version__.split(\"+\")[0].replace(\".\", \"\")\n",
-        "        version_str=\"\".join([\n",
-        "            f\"py3{sys.version_info.minor}_cu\",\n",
-        "            torch.version.cuda.replace(\".\",\"\"),\n",
-        "            f\"_pyt{pyt_version_str}\"\n",
-        "        ])\n",
-        "        !pip install fvcore iopath\n",
+        "    pyt_version_str=torch.__version__.split(\"+\")[0].replace(\".\", \"\")\n",
+        "    version_str=\"\".join([\n",
+        "        f\"py3{sys.version_info.minor}_cu\",\n",
+        "        torch.version.cuda.replace(\".\",\"\"),\n",
+        "        f\"_pyt{pyt_version_str}\"\n",
+        "    ])\n",
+        "    !pip install iopath\n",
+        "    if sys.platform.startswith(\"linux\"):\n",
+        "        print(\"Trying to install wheel for PyTorch3D\")\n",
        "        !pip install --no-index --no-cache-dir pytorch3d -f https://dl.fbaipublicfiles.com/pytorch3d/packaging/wheels/{version_str}/download.html\n",
-        "    else:\n",
-        "        # We try to install PyTorch3D from source.\n",
-        "        !pip install 'git+https://github.com/facebookresearch/pytorch3d.git@stable'"
+        "        pip_list = !pip freeze\n",
+        "        need_pytorch3d = not any(i.startswith(\"pytorch3d==\") for  i in pip_list)\n",
+        "    if need_pytorch3d:\n",
+        "        print(f\"failed to find/install wheel for {version_str}\")\n",
+        "if need_pytorch3d:\n",
+        "    print(\"Installing PyTorch3D from source\")\n",
+        "    !pip install ninja\n",
+        "    !pip install 'git+https://github.com/facebookresearch/pytorch3d.git@stable'"
      ]
    },
    {
--- a/docs/tutorials/implicitron_volumes.ipynb
+++ b/docs/tutorials/implicitron_volumes.ipynb
@@ -66,25 +66,31 @@
        "import os\n",
        "import sys\n",
        "import torch\n",
+        "import subprocess\n",
        "need_pytorch3d=False\n",
        "try:\n",
        "    import pytorch3d\n",
        "except ModuleNotFoundError:\n",
        "    need_pytorch3d=True\n",
        "if need_pytorch3d:\n",
-        "    if torch.__version__.startswith(\"2.2.\") and sys.platform.startswith(\"linux\"):\n",
-        "        # We try to install PyTorch3D via a released wheel.\n",
-        "        pyt_version_str=torch.__version__.split(\"+\")[0].replace(\".\", \"\")\n",
-        "        version_str=\"\".join([\n",
-        "            f\"py3{sys.version_info.minor}_cu\",\n",
-        "            torch.version.cuda.replace(\".\",\"\"),\n",
-        "            f\"_pyt{pyt_version_str}\"\n",
-        "        ])\n",
-        "        !pip install fvcore iopath\n",
+        "    pyt_version_str=torch.__version__.split(\"+\")[0].replace(\".\", \"\")\n",
+        "    version_str=\"\".join([\n",
+        "        f\"py3{sys.version_info.minor}_cu\",\n",
+        "        torch.version.cuda.replace(\".\",\"\"),\n",
+        "        f\"_pyt{pyt_version_str}\"\n",
+        "    ])\n",
+        "    !pip install iopath\n",
+        "    if sys.platform.startswith(\"linux\"):\n",
+        "        print(\"Trying to install wheel for PyTorch3D\")\n",
        "        !pip install --no-index --no-cache-dir pytorch3d -f https://dl.fbaipublicfiles.com/pytorch3d/packaging/wheels/{version_str}/download.html\n",
-        "    else:\n",
-        "        # We try to install PyTorch3D from source.\n",
-        "        !pip install 'git+https://github.com/facebookresearch/pytorch3d.git@stable'"
+        "        pip_list = !pip freeze\n",
+        "        need_pytorch3d = not any(i.startswith(\"pytorch3d==\") for  i in pip_list)\n",
+        "    if need_pytorch3d:\n",
+        "        print(f\"failed to find/install wheel for {version_str}\")\n",
+        "if need_pytorch3d:\n",
+        "    print(\"Installing PyTorch3D from source\")\n",
+        "    !pip install ninja\n",
+        "    !pip install 'git+https://github.com/facebookresearch/pytorch3d.git@stable'"
      ]
    },
    {
--- a/docs/tutorials/render_colored_points.ipynb
+++ b/docs/tutorials/render_colored_points.ipynb
@@ -44,25 +44,31 @@
    "import os\n",
    "import sys\n",
    "import torch\n",
+    "import subprocess\n",
    "need_pytorch3d=False\n",
    "try:\n",
    "    import pytorch3d\n",
    "except ModuleNotFoundError:\n",
    "    need_pytorch3d=True\n",
    "if need_pytorch3d:\n",
-    "    if torch.__version__.startswith(\"2.2.\") and sys.platform.startswith(\"linux\"):\n",
-    "        # We try to install PyTorch3D via a released wheel.\n",
-    "        pyt_version_str=torch.__version__.split(\"+\")[0].replace(\".\", \"\")\n",
-    "        version_str=\"\".join([\n",
-    "            f\"py3{sys.version_info.minor}_cu\",\n",
-    "            torch.version.cuda.replace(\".\",\"\"),\n",
-    "            f\"_pyt{pyt_version_str}\"\n",
-    "        ])\n",
-    "        !pip install fvcore iopath\n",
+    "    pyt_version_str=torch.__version__.split(\"+\")[0].replace(\".\", \"\")\n",
+    "    version_str=\"\".join([\n",
+    "        f\"py3{sys.version_info.minor}_cu\",\n",
+    "        torch.version.cuda.replace(\".\",\"\"),\n",
+    "        f\"_pyt{pyt_version_str}\"\n",
+    "    ])\n",
+    "    !pip install iopath\n",
+    "    if sys.platform.startswith(\"linux\"):\n",
+    "        print(\"Trying to install wheel for PyTorch3D\")\n",
    "        !pip install --no-index --no-cache-dir pytorch3d -f https://dl.fbaipublicfiles.com/pytorch3d/packaging/wheels/{version_str}/download.html\n",
-    "    else:\n",
-    "        # We try to install PyTorch3D from source.\n",
-    "        !pip install 'git+https://github.com/facebookresearch/pytorch3d.git@stable'"
+    "        pip_list = !pip freeze\n",
+    "        need_pytorch3d = not any(i.startswith(\"pytorch3d==\") for  i in pip_list)\n",
+    "    if need_pytorch3d:\n",
+    "        print(f\"failed to find/install wheel for {version_str}\")\n",
+    "if need_pytorch3d:\n",
+    "    print(\"Installing PyTorch3D from source\")\n",
+    "    !pip install ninja\n",
+    "    !pip install 'git+https://github.com/facebookresearch/pytorch3d.git@stable'"
   ]
  },
  {
--- a/docs/tutorials/render_densepose.ipynb
+++ b/docs/tutorials/render_densepose.ipynb
@@ -51,25 +51,31 @@
    "import os\n",
    "import sys\n",
    "import torch\n",
+    "import subprocess\n",
    "need_pytorch3d=False\n",
    "try:\n",
    "    import pytorch3d\n",
    "except ModuleNotFoundError:\n",
    "    need_pytorch3d=True\n",
    "if need_pytorch3d:\n",
-    "    if torch.__version__.startswith(\"2.2.\") and sys.platform.startswith(\"linux\"):\n",
-    "        # We try to install PyTorch3D via a released wheel.\n",
-    "        pyt_version_str=torch.__version__.split(\"+\")[0].replace(\".\", \"\")\n",
-    "        version_str=\"\".join([\n",
-    "            f\"py3{sys.version_info.minor}_cu\",\n",
-    "            torch.version.cuda.replace(\".\",\"\"),\n",
-    "            f\"_pyt{pyt_version_str}\"\n",
-    "        ])\n",
-    "        !pip install fvcore iopath\n",
+    "    pyt_version_str=torch.__version__.split(\"+\")[0].replace(\".\", \"\")\n",
+    "    version_str=\"\".join([\n",
+    "        f\"py3{sys.version_info.minor}_cu\",\n",
+    "        torch.version.cuda.replace(\".\",\"\"),\n",
+    "        f\"_pyt{pyt_version_str}\"\n",
+    "    ])\n",
+    "    !pip install iopath\n",
+    "    if sys.platform.startswith(\"linux\"):\n",
+    "        print(\"Trying to install wheel for PyTorch3D\")\n",
    "        !pip install --no-index --no-cache-dir pytorch3d -f https://dl.fbaipublicfiles.com/pytorch3d/packaging/wheels/{version_str}/download.html\n",
-    "    else:\n",
-    "        # We try to install PyTorch3D from source.\n",
-    "        !pip install 'git+https://github.com/facebookresearch/pytorch3d.git@stable'"
+    "        pip_list = !pip freeze\n",
+    "        need_pytorch3d = not any(i.startswith(\"pytorch3d==\") for  i in pip_list)\n",
+    "    if need_pytorch3d:\n",
+    "        print(f\"failed to find/install wheel for {version_str}\")\n",
+    "if need_pytorch3d:\n",
+    "    print(\"Installing PyTorch3D from source\")\n",
+    "    !pip install ninja\n",
+    "    !pip install 'git+https://github.com/facebookresearch/pytorch3d.git@stable'"
   ]
  },
  {
--- a/docs/tutorials/render_textured_meshes.ipynb
+++ b/docs/tutorials/render_textured_meshes.ipynb
@@ -67,25 +67,31 @@
    "import os\n",
    "import sys\n",
    "import torch\n",
+    "import subprocess\n",
    "need_pytorch3d=False\n",
    "try:\n",
    "    import pytorch3d\n",
    "except ModuleNotFoundError:\n",
    "    need_pytorch3d=True\n",
    "if need_pytorch3d:\n",
-    "    if torch.__version__.startswith(\"2.2.\") and sys.platform.startswith(\"linux\"):\n",
-    "        # We try to install PyTorch3D via a released wheel.\n",
-    "        pyt_version_str=torch.__version__.split(\"+\")[0].replace(\".\", \"\")\n",
-    "        version_str=\"\".join([\n",
-    "            f\"py3{sys.version_info.minor}_cu\",\n",
-    "            torch.version.cuda.replace(\".\",\"\"),\n",
-    "            f\"_pyt{pyt_version_str}\"\n",
-    "        ])\n",
-    "        !pip install fvcore iopath\n",
+    "    pyt_version_str=torch.__version__.split(\"+\")[0].replace(\".\", \"\")\n",
+    "    version_str=\"\".join([\n",
+    "        f\"py3{sys.version_info.minor}_cu\",\n",
+    "        torch.version.cuda.replace(\".\",\"\"),\n",
+    "        f\"_pyt{pyt_version_str}\"\n",
+    "    ])\n",
+    "    !pip install iopath\n",
+    "    if sys.platform.startswith(\"linux\"):\n",
+    "        print(\"Trying to install wheel for PyTorch3D\")\n",
    "        !pip install --no-index --no-cache-dir pytorch3d -f https://dl.fbaipublicfiles.com/pytorch3d/packaging/wheels/{version_str}/download.html\n",
-    "    else:\n",
-    "        # We try to install PyTorch3D from source.\n",
-    "        !pip install 'git+https://github.com/facebookresearch/pytorch3d.git@stable'"
+    "        pip_list = !pip freeze\n",
+    "        need_pytorch3d = not any(i.startswith(\"pytorch3d==\") for  i in pip_list)\n",
+    "    if need_pytorch3d:\n",
+    "        print(f\"failed to find/install wheel for {version_str}\")\n",
+    "if need_pytorch3d:\n",
+    "    print(\"Installing PyTorch3D from source\")\n",
+    "    !pip install ninja\n",
+    "    !pip install 'git+https://github.com/facebookresearch/pytorch3d.git@stable'"
   ]
  },
  {
--- a/packaging/build_conda.py
+++ b/packaging/build_conda.py
@@ -80,6 +80,12 @@ def setup_cuda():
 def setup_conda_pytorch_constraint() -> List[str]:
    pytorch_constraint = f"- pytorch=={PYTORCH_VERSION}"
    os.environ["CONDA_PYTORCH_CONSTRAINT"] = pytorch_constraint
+    if pytorch_major_minor < (2, 2):
+        os.environ["CONDA_PYTORCH_MKL_CONSTRAINT"] = "- mkl!=2024.1.0"
+        os.environ["SETUPTOOLS_CONSTRAINT"] = "- setuptools<70"
+    else:
+        os.environ["CONDA_PYTORCH_MKL_CONSTRAINT"] = ""
+        os.environ["SETUPTOOLS_CONSTRAINT"] = "- setuptools"
    os.environ["CONDA_PYTORCH_BUILD_CONSTRAINT"] = pytorch_constraint
    os.environ["PYTORCH_VERSION_NODOT"] = PYTORCH_VERSION.replace(".", "")

@@ -117,7 +123,7 @@ def do_build(start_args: List[str]):
    if test_flag is not None:
        args.append(test_flag)

-    args.extend(["-c", "bottler", "-c", "fvcore", "-c", "iopath", "-c", "conda-forge"])
+    args.extend(["-c", "bottler", "-c", "iopath", "-c", "conda-forge"])
    args.append("--no-anaconda-upload")
    args.extend(["--python", os.environ["PYTHON_VERSION"]])
    args.append("packaging/pytorch3d")
--- a/packaging/linux_wheels/README.md
+++ b/packaging/linux_wheels/README.md
@@ -26,6 +26,6 @@ version_str="".join([
    torch.version.cuda.replace(".",""),
    f"_pyt{pyt_version_str}"
 ])
-!pip install fvcore iopath
+!pip install iopath
 !pip install --no-index --no-cache-dir pytorch3d -f https://dl.fbaipublicfiles.com/pytorch3d/packaging/wheels/{version_str}/download.html
 ```
--- a/packaging/linux_wheels/inside.sh
+++ b/packaging/linux_wheels/inside.sh
@@ -144,7 +144,7 @@ do
            conda activate "$tag"
            # shellcheck disable=SC2086
            conda install -y -c pytorch $extra_channel "pytorch=$pytorch_version" "$cudatools=$CUDA_TAG"
-            pip install fvcore iopath
+            pip install iopath
            echo "python version" "$python_version" "pytorch version" "$pytorch_version" "cuda version" "$cu_version" "tag" "$tag"

            rm -rf dist
--- a/packaging/pytorch3d/meta.yaml
+++ b/packaging/pytorch3d/meta.yaml
@@ -12,8 +12,9 @@ requirements:

  host:
    - python
-    - setuptools
+    {{ environ.get('SETUPTOOLS_CONSTRAINT') }}
    {{ environ.get('CONDA_PYTORCH_BUILD_CONSTRAINT') }}
+    {{ environ.get('CONDA_PYTORCH_MKL_CONSTRAINT') }}
    {{ environ.get('CONDA_CUDATOOLKIT_CONSTRAINT') }}
    {{ environ.get('CONDA_CPUONLY_FEATURE') }}

@@ -21,7 +22,6 @@ requirements:
    - python
    - numpy >=1.11
    - torchvision >=0.5
-    - fvcore
    - iopath
    {{ environ.get('CONDA_PYTORCH_CONSTRAINT') }}
    {{ environ.get('CONDA_CUDATOOLKIT_CONSTRAINT') }}
--- a/projects/implicitron_trainer/init.py
+++ b/projects/implicitron_trainer/init.py
@@ -3,3 +3,5 @@
 #
 # This source code is licensed under the BSD-style license found in the
 # LICENSE file in the root directory of this source tree.
+
+# pyre-unsafe
--- a/projects/implicitron_trainer/experiment.py
+++ b/projects/implicitron_trainer/experiment.py
@@ -5,6 +5,8 @@
 # This source code is licensed under the BSD-style license found in the
 # LICENSE file in the root directory of this source tree.

+# pyre-unsafe
+
 """"
 This file is the entry point for launching experiments with Implicitron.

@@ -97,7 +99,7 @@ except ModuleNotFoundError:
 no_accelerate = os.environ.get("PYTORCH3D_NO_ACCELERATE") is not None


-class Experiment(Configurable):  # pyre-ignore: 13
+class Experiment(Configurable):
    """
    This class is at the top level of Implicitron's config hierarchy. Its
    members are high-level components necessary for training an implicit rende-
@@ -118,12 +120,16 @@ class Experiment(Configurable):  # pyre-ignore: 13
            will be saved here.
    """

+    # pyre-fixme[13]: Attribute `data_source` is never initialized.
    data_source: DataSourceBase
    data_source_class_type: str = "ImplicitronDataSource"
+    # pyre-fixme[13]: Attribute `model_factory` is never initialized.
    model_factory: ModelFactoryBase
    model_factory_class_type: str = "ImplicitronModelFactory"
+    # pyre-fixme[13]: Attribute `optimizer_factory` is never initialized.
    optimizer_factory: OptimizerFactoryBase
    optimizer_factory_class_type: str = "ImplicitronOptimizerFactory"
+    # pyre-fixme[13]: Attribute `training_loop` is never initialized.
    training_loop: TrainingLoopBase
    training_loop_class_type: str = "ImplicitronTrainingLoop"

--- a/projects/implicitron_trainer/impl/init.py
+++ b/projects/implicitron_trainer/impl/init.py
@@ -3,3 +3,5 @@
 #
 # This source code is licensed under the BSD-style license found in the
 # LICENSE file in the root directory of this source tree.
+
+# pyre-unsafe
--- a/projects/implicitron_trainer/impl/model_factory.py
+++ b/projects/implicitron_trainer/impl/model_factory.py
@@ -4,6 +4,8 @@
 # This source code is licensed under the BSD-style license found in the
 # LICENSE file in the root directory of this source tree.

+# pyre-unsafe
+
 import logging
 import os
 from typing import Optional
@@ -43,7 +45,7 @@ class ModelFactoryBase(ReplaceableBase):


@registry.register
-class ImplicitronModelFactory(ModelFactoryBase):  # pyre-ignore [13]
+class ImplicitronModelFactory(ModelFactoryBase):
    """
    A factory class that initializes an implicit rendering model.

@@ -59,6 +61,7 @@ class ImplicitronModelFactory(ModelFactoryBase):  # pyre-ignore [13]

    """

+    # pyre-fixme[13]: Attribute `model` is never initialized.
    model: ImplicitronModelBase
    model_class_type: str = "GenericModel"
    resume: bool = True
--- a/projects/implicitron_trainer/impl/optimizer_factory.py
+++ b/projects/implicitron_trainer/impl/optimizer_factory.py
@@ -4,6 +4,8 @@
 # This source code is licensed under the BSD-style license found in the
 # LICENSE file in the root directory of this source tree.

+# pyre-unsafe
+
 import inspect
 import logging
 import os
--- a/projects/implicitron_trainer/impl/training_loop.py
+++ b/projects/implicitron_trainer/impl/training_loop.py
@@ -4,6 +4,8 @@
 # This source code is licensed under the BSD-style license found in the
 # LICENSE file in the root directory of this source tree.

+# pyre-unsafe
+
 import logging
 import os
 import time
@@ -28,13 +30,13 @@ from .utils import seed_all_random_engines
 logger = logging.getLogger(__name__)


-# pyre-fixme[13]: Attribute `evaluator` is never initialized.
 class TrainingLoopBase(ReplaceableBase):
    """
    Members:
        evaluator: An EvaluatorBase instance, used to evaluate training results.
    """

+    # pyre-fixme[13]: Attribute `evaluator` is never initialized.
    evaluator: Optional[EvaluatorBase]
    evaluator_class_type: Optional[str] = "ImplicitronEvaluator"

--- a/projects/implicitron_trainer/impl/utils.py
+++ b/projects/implicitron_trainer/impl/utils.py
@@ -4,6 +4,8 @@
 # This source code is licensed under the BSD-style license found in the
 # LICENSE file in the root directory of this source tree.

+# pyre-unsafe
+

 import random

--- a/projects/implicitron_trainer/tests/init.py
+++ b/projects/implicitron_trainer/tests/init.py
@@ -3,3 +3,5 @@
 #
 # This source code is licensed under the BSD-style license found in the
 # LICENSE file in the root directory of this source tree.
+
+# pyre-unsafe
--- a/projects/implicitron_trainer/tests/test_experiment.py
+++ b/projects/implicitron_trainer/tests/test_experiment.py
@@ -4,6 +4,8 @@
 # This source code is licensed under the BSD-style license found in the
 # LICENSE file in the root directory of this source tree.

+# pyre-unsafe
+
 import os
 import tempfile
 import unittest
--- a/projects/implicitron_trainer/tests/test_optimizer_factory.py
+++ b/projects/implicitron_trainer/tests/test_optimizer_factory.py
@@ -4,6 +4,8 @@
 # This source code is licensed under the BSD-style license found in the
 # LICENSE file in the root directory of this source tree.

+# pyre-unsafe
+
 import logging
 import os
 import unittest
--- a/projects/implicitron_trainer/tests/test_visualize.py
+++ b/projects/implicitron_trainer/tests/test_visualize.py
@@ -4,6 +4,8 @@
 # This source code is licensed under the BSD-style license found in the
 # LICENSE file in the root directory of this source tree.

+# pyre-unsafe
+
 import os
 import unittest

--- a/projects/implicitron_trainer/tests/utils.py
+++ b/projects/implicitron_trainer/tests/utils.py
@@ -4,6 +4,8 @@
 # This source code is licensed under the BSD-style license found in the
 # LICENSE file in the root directory of this source tree.

+# pyre-unsafe
+
 import contextlib
 import logging
 import os
--- a/projects/implicitron_trainer/visualize_reconstruction.py
+++ b/projects/implicitron_trainer/visualize_reconstruction.py
@@ -5,6 +5,8 @@
 # This source code is licensed under the BSD-style license found in the
 # LICENSE file in the root directory of this source tree.

+# pyre-unsafe
+
 """
 Script to visualize a previously trained model. Example call:

--- a/projects/nerf/nerf/nerf_renderer.py
+++ b/projects/nerf/nerf/nerf_renderer.py
@@ -343,12 +343,14 @@ class RadianceFieldRenderer(torch.nn.Module):
            # For a full render pass concatenate the output chunks,
            # and reshape to image size.
            out = {
-                k: torch.cat(
-                    [ch_o[k] for ch_o in chunk_outputs],
-                    dim=1,
-                ).view(-1, *self._image_size, 3)
-                if chunk_outputs[0][k] is not None
-                else None
+                k: (
+                    torch.cat(
+                        [ch_o[k] for ch_o in chunk_outputs],
+                        dim=1,
+                    ).view(-1, *self._image_size, 3)
+                    if chunk_outputs[0][k] is not None
+                    else None
+                )
                for k in ("rgb_fine", "rgb_coarse", "rgb_gt")
            }
        else:
--- a/pytorch3d/init.py
+++ b/pytorch3d/init.py
@@ -4,4 +4,6 @@
 # This source code is licensed under the BSD-style license found in the
 # LICENSE file in the root directory of this source tree.

-__version__ = "0.7.6"
+# pyre-unsafe
+
+__version__ = "0.7.8"
--- a/pytorch3d/common/init.py
+++ b/pytorch3d/common/init.py
@@ -4,6 +4,8 @@
 # This source code is licensed under the BSD-style license found in the
 # LICENSE file in the root directory of this source tree.

+# pyre-unsafe
+
 from .datatypes import Device, get_device, make_device


--- a/pytorch3d/common/compat.py
+++ b/pytorch3d/common/compat.py
@@ -4,6 +4,8 @@
 # This source code is licensed under the BSD-style license found in the
 # LICENSE file in the root directory of this source tree.

+# pyre-unsafe
+
 from typing import Sequence, Tuple, Union

 import torch
--- a/pytorch3d/common/datatypes.py
+++ b/pytorch3d/common/datatypes.py
@@ -4,6 +4,8 @@
 # This source code is licensed under the BSD-style license found in the
 # LICENSE file in the root directory of this source tree.

+# pyre-unsafe
+
 from typing import Optional, Union

 import torch
--- a/pytorch3d/common/linear_with_repeat.py
+++ b/pytorch3d/common/linear_with_repeat.py
@@ -4,6 +4,8 @@
 # This source code is licensed under the BSD-style license found in the
 # LICENSE file in the root directory of this source tree.

+# pyre-unsafe
+
 import math
 from typing import Tuple

--- a/pytorch3d/common/workaround/init.py
+++ b/pytorch3d/common/workaround/init.py
@@ -4,5 +4,7 @@
 # This source code is licensed under the BSD-style license found in the
 # LICENSE file in the root directory of this source tree.

+# pyre-unsafe
+
 from .symeig3x3 import symeig3x3
 from .utils import _safe_det_3x3
--- a/pytorch3d/common/workaround/symeig3x3.py
+++ b/pytorch3d/common/workaround/symeig3x3.py
@@ -4,6 +4,8 @@
 # This source code is licensed under the BSD-style license found in the
 # LICENSE file in the root directory of this source tree.

+# pyre-unsafe
+
 import math
 from typing import Optional, Tuple

--- a/pytorch3d/common/workaround/utils.py
+++ b/pytorch3d/common/workaround/utils.py
@@ -4,6 +4,8 @@
 # This source code is licensed under the BSD-style license found in the
 # LICENSE file in the root directory of this source tree.

+# pyre-unsafe
+

 import torch

--- a/pytorch3d/csrc/ext.cpp
+++ b/pytorch3d/csrc/ext.cpp
@@ -7,11 +7,15 @@
 */

 // clang-format off
+#if !defined(USE_ROCM)
 #include "./pulsar/global.h" // Include before <torch/extension.h>.
+#endif
 #include <torch/extension.h>
 // clang-format on
+#if !defined(USE_ROCM)
 #include "./pulsar/pytorch/renderer.h"
 #include "./pulsar/pytorch/tensor_util.h"
+#endif
 #include "ball_query/ball_query.h"
 #include "blending/sigmoid_alpha_blend.h"
 #include "compositing/alpha_composite.h"
@@ -99,6 +103,8 @@ PYBIND11_MODULE(TORCH_EXTENSION_NAME, m) {
  m.def("marching_cubes", &MarchingCubes);

  // Pulsar.
+  // Pulsar not enabled on AMD.
+#if !defined(USE_ROCM)
 #ifdef PULSAR_LOGGING_ENABLED
  c10::ShowLogInfoToStderr();
 #endif
@@ -183,4 +189,5 @@ PYBIND11_MODULE(TORCH_EXTENSION_NAME, m) {
  m.attr("MAX_UINT") = py::int_(MAX_UINT);
  m.attr("MAX_USHORT") = py::int_(MAX_USHORT);
  m.attr("PULSAR_MAX_GRAD_SPHERES") = py::int_(MAX_GRAD_SPHERES);
+#endif
 }
--- a/pytorch3d/csrc/knn/knn.cu
+++ b/pytorch3d/csrc/knn/knn.cu
@@ -338,7 +338,7 @@ std::tuple<at::Tensor, at::Tensor> KNearestNeighborIdxCuda(

  TORCH_CHECK((norm == 1) || (norm == 2), "Norm must be 1 or 2.");

-  TORCH_CHECK(p2.size(2) == D, "Point sets must have the same last dimension");
+  TORCH_CHECK(p1.size(2) == D, "Point sets must have the same last dimension");
  auto long_dtype = lengths1.options().dtype(at::kLong);
  auto idxs = at::zeros({N, P1, K}, long_dtype);
  auto dists = at::zeros({N, P1, K}, p1.options());
--- a/pytorch3d/csrc/marching_cubes/marching_cubes.cu
+++ b/pytorch3d/csrc/marching_cubes/marching_cubes.cu
@@ -382,6 +382,44 @@ __global__ void GenerateFacesKernel(
  } // end for grid-strided kernel
 }

+// ATen/Torch does not have an exclusive-scan operator. Additionally, in the
+// code below we need to get the "total number of items to work on" after
+// a scan, which with an inclusive-scan would simply be the value of the last
+// element in the tensor.
+//
+// This utility function hits two birds with one stone, by running
+// an inclusive-scan into a right-shifted view of a tensor that's
+// allocated to be one element bigger than the input tensor.
+//
+// Note; return tensor is `int64_t` per element, even if the input
+// tensor is only 32-bit. Also, the return tensor is one element bigger
+// than the input one.
+//
+// Secondary optional argument is an output argument that gets the
+// value of the last element of the return tensor (because you almost
+// always need this CPU-side right after this function anyway).
+static at::Tensor ExclusiveScanAndTotal(
+    const at::Tensor& inTensor,
+    int64_t* optTotal = nullptr) {
+  const auto inSize = inTensor.sizes()[0];
+  auto retTensor = at::zeros({inSize + 1}, at::kLong).to(inTensor.device());
+
+  using at::indexing::None;
+  using at::indexing::Slice;
+  auto rightShiftedView = retTensor.index({Slice(1, None)});
+
+  // Do an (inclusive-scan) cumulative sum in to the view that's
+  // shifted one element to the right...
+  at::cumsum_out(rightShiftedView, inTensor, 0, at::kLong);
+
+  if (optTotal) {
+    *optTotal = retTensor[inSize].cpu().item<int64_t>();
+  }
+
+  // ...so that the not-shifted tensor holds the exclusive-scan
+  return retTensor;
+}
+
 // Entrance for marching cubes cuda extension. Marching Cubes is an algorithm to
 // create triangle meshes from an implicit function (one of the form f(x, y, z)
 // = 0). It works by iteratively checking a grid of cubes superimposed over a
@@ -444,20 +482,18 @@ std::tuple<at::Tensor, at::Tensor, at::Tensor> MarchingCubesCuda(
  using at::indexing::Slice;

  auto d_voxelVerts =
-      at::zeros({numVoxels + 1}, at::TensorOptions().dtype(at::kInt))
+      at::zeros({numVoxels}, at::TensorOptions().dtype(at::kInt))
          .to(vol.device());
-  auto d_voxelVerts_ = d_voxelVerts.index({Slice(1, None)});
  auto d_voxelOccupied =
-      at::zeros({numVoxels + 1}, at::TensorOptions().dtype(at::kInt))
+      at::zeros({numVoxels}, at::TensorOptions().dtype(at::kInt))
          .to(vol.device());
-  auto d_voxelOccupied_ = d_voxelOccupied.index({Slice(1, None)});

  // Execute "ClassifyVoxelKernel" kernel to precompute
  // two arrays - d_voxelOccupied and d_voxelVertices to global memory,
  // which stores the occupancy state and number of voxel vertices per voxel.
  ClassifyVoxelKernel<<<grid, threads, 0, stream>>>(
-      d_voxelVerts_.packed_accessor32<int, 1, at::RestrictPtrTraits>(),
-      d_voxelOccupied_.packed_accessor32<int, 1, at::RestrictPtrTraits>(),
+      d_voxelVerts.packed_accessor32<int, 1, at::RestrictPtrTraits>(),
+      d_voxelOccupied.packed_accessor32<int, 1, at::RestrictPtrTraits>(),
      vol.packed_accessor32<float, 3, at::RestrictPtrTraits>(),
      isolevel);
  AT_CUDA_CHECK(cudaGetLastError());
@@ -467,12 +503,9 @@ std::tuple<at::Tensor, at::Tensor, at::Tensor> MarchingCubesCuda(
  // count for voxels in the grid and compute the number of active voxels.
  // If the number of active voxels is 0, return zero tensor for verts and
  // faces.
-
-  auto d_voxelOccupiedScan = at::cumsum(d_voxelOccupied, 0);
-  auto d_voxelOccupiedScan_ = d_voxelOccupiedScan.index({Slice(1, None)});
-
-  // number of active voxels
-  int64_t activeVoxels = d_voxelOccupiedScan[numVoxels].cpu().item<int64_t>();
+  int64_t activeVoxels = 0;
+  auto d_voxelOccupiedScan =
+      ExclusiveScanAndTotal(d_voxelOccupied, &activeVoxels);

  const int device_id = vol.device().index();
  auto opt = at::TensorOptions().dtype(at::kInt).device(at::kCUDA, device_id);
@@ -487,24 +520,21 @@ std::tuple<at::Tensor, at::Tensor, at::Tensor> MarchingCubesCuda(
    return std::make_tuple(verts, faces, ids);
  }

-  // Execute "CompactVoxelsKernel" kernel to compress voxels for accleration.
+  // Execute "CompactVoxelsKernel" kernel to compress voxels for acceleration.
  // This allows us to run triangle generation on only the occupied voxels.
  auto d_compVoxelArray = at::zeros({activeVoxels}, opt);
  CompactVoxelsKernel<<<grid, threads, 0, stream>>>(
      d_compVoxelArray.packed_accessor32<int, 1, at::RestrictPtrTraits>(),
      d_voxelOccupied.packed_accessor32<int, 1, at::RestrictPtrTraits>(),
-      d_voxelOccupiedScan_
+      d_voxelOccupiedScan
          .packed_accessor32<int64_t, 1, at::RestrictPtrTraits>(),
      numVoxels);
  AT_CUDA_CHECK(cudaGetLastError());
  cudaDeviceSynchronize();

  // Scan d_voxelVerts array to generate offsets of vertices for each voxel
-  auto d_voxelVertsScan = at::cumsum(d_voxelVerts, 0);
-  auto d_voxelVertsScan_ = d_voxelVertsScan.index({Slice(1, None)});
-
-  // total number of vertices
-  int64_t totalVerts = d_voxelVertsScan[numVoxels].cpu().item<int64_t>();
+  int64_t totalVerts = 0;
+  auto d_voxelVertsScan = ExclusiveScanAndTotal(d_voxelVerts, &totalVerts);

  // Execute "GenerateFacesKernel" kernel
  // This runs only on the occupied voxels.
@@ -524,7 +554,7 @@ std::tuple<at::Tensor, at::Tensor, at::Tensor> MarchingCubesCuda(
      faces.packed_accessor<int64_t, 2, at::RestrictPtrTraits>(),
      ids.packed_accessor<int64_t, 1, at::RestrictPtrTraits>(),
      d_compVoxelArray.packed_accessor32<int, 1, at::RestrictPtrTraits>(),
-      d_voxelVertsScan_.packed_accessor32<int64_t, 1, at::RestrictPtrTraits>(),
+      d_voxelVertsScan.packed_accessor32<int64_t, 1, at::RestrictPtrTraits>(),
      activeVoxels,
      vol.packed_accessor32<float, 3, at::RestrictPtrTraits>(),
      faceTable.packed_accessor32<int, 2, at::RestrictPtrTraits>(),
--- a/pytorch3d/csrc/pulsar/host/commands.h
+++ b/pytorch3d/csrc/pulsar/host/commands.h
@@ -357,11 +357,11 @@ void MAX_WS(
 //
 //
 #define END_PARALLEL() \
-  end_parallel:;       \
+  end_parallel :;      \
  }
 #define END_PARALLEL_NORET() }
 #define END_PARALLEL_2D() \
-  end_parallel:;          \
+  end_parallel :;         \
  }                       \
  }
 #define END_PARALLEL_2D_NORET() \
--- a/pytorch3d/csrc/pulsar/include/renderer.construct.device.h
+++ b/pytorch3d/csrc/pulsar/include/renderer.construct.device.h
@@ -93,7 +93,7 @@ HOST void construct(
  MALLOC(self->di_sorted_d, DrawInfo, max_num_balls);
  MALLOC(self->region_flags_d, char, max_num_balls);
  MALLOC(self->num_selected_d, size_t, 1);
-  MALLOC(self->forw_info_d, float, width* height*(3 + 2 * n_track));
+  MALLOC(self->forw_info_d, float, width* height * (3 + 2 * n_track));
  MALLOC(self->min_max_pixels_d, IntersectInfo, 1);
  MALLOC(self->grad_pos_d, float3, max_num_balls);
  MALLOC(self->grad_col_d, float, max_num_balls* n_channels);
--- a/pytorch3d/csrc/pulsar/include/renderer.render.device.h
+++ b/pytorch3d/csrc/pulsar/include/renderer.render.device.h
@@ -99,7 +99,7 @@ GLOBAL void render(
  /** Whether loading of balls is completed. */
  SHARED bool loading_done;
  /** The number of balls loaded overall (just for statistics). */
-  SHARED int n_balls_loaded;
+  [[maybe_unused]] SHARED int n_balls_loaded;
  /** The area this thread block covers. */
  SHARED IntersectInfo block_area;
  if (thread_block.thread_rank() == 0) {
--- a/pytorch3d/csrc/rasterize_coarse/rasterize_coarse.cu
+++ b/pytorch3d/csrc/rasterize_coarse/rasterize_coarse.cu
@@ -244,8 +244,7 @@ at::Tensor RasterizeCoarseCuda(
  if (num_bins_y >= kMaxItemsPerBin || num_bins_x >= kMaxItemsPerBin) {
    std::stringstream ss;
    ss << "In RasterizeCoarseCuda got num_bins_y: " << num_bins_y
-       << ", num_bins_x: " << num_bins_x << ", "
-       << "; that's too many!";
+       << ", num_bins_x: " << num_bins_x << ", " << "; that's too many!";
    AT_ERROR(ss.str());
  }
  auto opts = elems_per_batch.options().dtype(at::kInt);
--- a/pytorch3d/csrc/rasterize_meshes/rasterize_meshes.cu
+++ b/pytorch3d/csrc/rasterize_meshes/rasterize_meshes.cu
@@ -144,7 +144,7 @@ __device__ void CheckPixelInsideFace(
  const bool zero_face_area =
      (face_area <= kEpsilon && face_area >= -1.0f * kEpsilon);

-  if (zmax < 0 || cull_backfaces && back_face || outside_bbox ||
+  if (zmax < 0 || (cull_backfaces && back_face) || outside_bbox ||
      zero_face_area) {
    return;
  }
--- a/pytorch3d/csrc/utils/float_math.cuh
+++ b/pytorch3d/csrc/utils/float_math.cuh
@@ -18,6 +18,8 @@ const auto vEpsilon = 1e-8;

 // Common functions and operators for float2.

+// Complex arithmetic is already defined for AMD.
+#if !defined(USE_ROCM)
 __device__ inline float2 operator-(const float2& a, const float2& b) {
  return make_float2(a.x - b.x, a.y - b.y);
 }
@@ -41,6 +43,7 @@ __device__ inline float2 operator*(const float2& a, const float2& b) {
 __device__ inline float2 operator*(const float a, const float2& b) {
  return make_float2(a * b.x, a * b.y);
 }
+#endif

 __device__ inline float FloatMin3(const float a, const float b, const float c) {
  return fminf(a, fminf(b, c));
--- a/pytorch3d/csrc/utils/warp_reduce.cuh
+++ b/pytorch3d/csrc/utils/warp_reduce.cuh
@@ -23,37 +23,51 @@ WarpReduceMin(scalar_t* min_dists, int64_t* min_idxs, const size_t tid) {
    min_idxs[tid] = min_idxs[tid + 32];
    min_dists[tid] = min_dists[tid + 32];
  }
+// AMD does not use explicit syncwarp and instead automatically inserts memory
+// fences during compilation.
+#if !defined(USE_ROCM)
  __syncwarp();
+#endif
  // s = 16
  if (min_dists[tid] > min_dists[tid + 16]) {
    min_idxs[tid] = min_idxs[tid + 16];
    min_dists[tid] = min_dists[tid + 16];
  }
+#if !defined(USE_ROCM)
  __syncwarp();
+#endif
  // s = 8
  if (min_dists[tid] > min_dists[tid + 8]) {
    min_idxs[tid] = min_idxs[tid + 8];
    min_dists[tid] = min_dists[tid + 8];
  }
+#if !defined(USE_ROCM)
  __syncwarp();
+#endif
  // s = 4
  if (min_dists[tid] > min_dists[tid + 4]) {
    min_idxs[tid] = min_idxs[tid + 4];
    min_dists[tid] = min_dists[tid + 4];
  }
+#if !defined(USE_ROCM)
  __syncwarp();
+#endif
  // s = 2
  if (min_dists[tid] > min_dists[tid + 2]) {
    min_idxs[tid] = min_idxs[tid + 2];
    min_dists[tid] = min_dists[tid + 2];
  }
+#if !defined(USE_ROCM)
  __syncwarp();
+#endif
  // s = 1
  if (min_dists[tid] > min_dists[tid + 1]) {
    min_idxs[tid] = min_idxs[tid + 1];
    min_dists[tid] = min_dists[tid + 1];
  }
+#if !defined(USE_ROCM)
  __syncwarp();
+#endif
 }

 template <typename scalar_t>
@@ -65,30 +79,42 @@ __device__ void WarpReduceMax(
    dists[tid] = dists[tid + 32];
    dists_idx[tid] = dists_idx[tid + 32];
  }
+#if !defined(USE_ROCM)
  __syncwarp();
+#endif
  if (dists[tid] < dists[tid + 16]) {
    dists[tid] = dists[tid + 16];
    dists_idx[tid] = dists_idx[tid + 16];
  }
+#if !defined(USE_ROCM)
  __syncwarp();
+#endif
  if (dists[tid] < dists[tid + 8]) {
    dists[tid] = dists[tid + 8];
    dists_idx[tid] = dists_idx[tid + 8];
  }
+#if !defined(USE_ROCM)
  __syncwarp();
+#endif
  if (dists[tid] < dists[tid + 4]) {
    dists[tid] = dists[tid + 4];
    dists_idx[tid] = dists_idx[tid + 4];
  }
+#if !defined(USE_ROCM)
  __syncwarp();
+#endif
  if (dists[tid] < dists[tid + 2]) {
    dists[tid] = dists[tid + 2];
    dists_idx[tid] = dists_idx[tid + 2];
  }
+#if !defined(USE_ROCM)
  __syncwarp();
+#endif
  if (dists[tid] < dists[tid + 1]) {
    dists[tid] = dists[tid + 1];
    dists_idx[tid] = dists_idx[tid + 1];
  }
+#if !defined(USE_ROCM)
  __syncwarp();
+#endif
 }
--- a/pytorch3d/datasets/init.py
+++ b/pytorch3d/datasets/init.py
@@ -4,6 +4,8 @@
 # This source code is licensed under the BSD-style license found in the
 # LICENSE file in the root directory of this source tree.

+# pyre-unsafe
+
 from .r2n2 import BlenderCamera, collate_batched_R2N2, R2N2, render_cubified_voxels
 from .shapenet import ShapeNetCore
 from .utils import collate_batched_meshes
--- a/pytorch3d/datasets/r2n2/init.py
+++ b/pytorch3d/datasets/r2n2/init.py
@@ -4,6 +4,8 @@
 # This source code is licensed under the BSD-style license found in the
 # LICENSE file in the root directory of this source tree.

+# pyre-unsafe
+
 from .r2n2 import R2N2
 from .utils import BlenderCamera, collate_batched_R2N2, render_cubified_voxels

--- a/pytorch3d/datasets/r2n2/r2n2.py
+++ b/pytorch3d/datasets/r2n2/r2n2.py
@@ -4,6 +4,8 @@
 # This source code is licensed under the BSD-style license found in the
 # LICENSE file in the root directory of this source tree.

+# pyre-unsafe
+
 import json
 import warnings
 from os import path
--- a/pytorch3d/datasets/r2n2/utils.py
+++ b/pytorch3d/datasets/r2n2/utils.py
@@ -4,6 +4,8 @@
 # This source code is licensed under the BSD-style license found in the
 # LICENSE file in the root directory of this source tree.

+# pyre-unsafe
+
 import math
 from typing import Dict, List

--- a/pytorch3d/datasets/shapenet/init.py
+++ b/pytorch3d/datasets/shapenet/init.py
@@ -4,6 +4,8 @@
 # This source code is licensed under the BSD-style license found in the
 # LICENSE file in the root directory of this source tree.

+# pyre-unsafe
+
 from .shapenet_core import ShapeNetCore


--- a/pytorch3d/datasets/shapenet/shapenet_core.py
+++ b/pytorch3d/datasets/shapenet/shapenet_core.py
@@ -4,6 +4,8 @@
 # This source code is licensed under the BSD-style license found in the
 # LICENSE file in the root directory of this source tree.

+# pyre-unsafe
+
 import json
 import os
 import warnings
--- a/pytorch3d/datasets/shapenet_base.py
+++ b/pytorch3d/datasets/shapenet_base.py
@@ -4,6 +4,8 @@
 # This source code is licensed under the BSD-style license found in the
 # LICENSE file in the root directory of this source tree.

+# pyre-unsafe
+
 import warnings
 from typing import Dict, List, Optional, Tuple

--- a/pytorch3d/datasets/utils.py
+++ b/pytorch3d/datasets/utils.py
@@ -4,6 +4,8 @@
 # This source code is licensed under the BSD-style license found in the
 # LICENSE file in the root directory of this source tree.

+# pyre-unsafe
+
 from typing import Dict, List

 from pytorch3d.renderer.mesh import TexturesAtlas
--- a/pytorch3d/implicitron/init.py
+++ b/pytorch3d/implicitron/init.py
@@ -3,3 +3,5 @@
 #
 # This source code is licensed under the BSD-style license found in the
 # LICENSE file in the root directory of this source tree.
+
+# pyre-unsafe
--- a/pytorch3d/implicitron/dataset/init.py
+++ b/pytorch3d/implicitron/dataset/init.py
@@ -3,3 +3,5 @@
 #
 # This source code is licensed under the BSD-style license found in the
 # LICENSE file in the root directory of this source tree.
+
+# pyre-unsafe
--- a/pytorch3d/implicitron/dataset/blender_dataset_map_provider.py
+++ b/pytorch3d/implicitron/dataset/blender_dataset_map_provider.py
@@ -4,6 +4,8 @@
 # This source code is licensed under the BSD-style license found in the
 # LICENSE file in the root directory of this source tree.

+# pyre-unsafe
+

 import torch
 from pytorch3d.implicitron.tools.config import registry
--- a/pytorch3d/implicitron/dataset/data_loader_map_provider.py
+++ b/pytorch3d/implicitron/dataset/data_loader_map_provider.py
@@ -4,6 +4,8 @@
 # This source code is licensed under the BSD-style license found in the
 # LICENSE file in the root directory of this source tree.

+# pyre-unsafe
+
 from dataclasses import dataclass
 from enum import Enum
 from typing import Iterator, List, Optional, Tuple
--- a/pytorch3d/implicitron/dataset/data_source.py
+++ b/pytorch3d/implicitron/dataset/data_source.py
@@ -4,6 +4,8 @@
 # This source code is licensed under the BSD-style license found in the
 # LICENSE file in the root directory of this source tree.

+# pyre-unsafe
+
 from typing import Optional, Tuple

 from pytorch3d.implicitron.tools.config import (
@@ -39,7 +41,7 @@ class DataSourceBase(ReplaceableBase):


@registry.register
-class ImplicitronDataSource(DataSourceBase):  # pyre-ignore[13]
+class ImplicitronDataSource(DataSourceBase):
    """
    Represents the data used in Implicitron. This is the only implementation
    of DataSourceBase provided.
@@ -50,8 +52,11 @@ class ImplicitronDataSource(DataSourceBase):  # pyre-ignore[13]
        data_loader_map_provider_class_type: identifies type for data_loader_map_provider.
    """

+    # pyre-fixme[13]: Attribute `dataset_map_provider` is never initialized.
    dataset_map_provider: DatasetMapProviderBase
+    # pyre-fixme[13]: Attribute `dataset_map_provider_class_type` is never initialized.
    dataset_map_provider_class_type: str
+    # pyre-fixme[13]: Attribute `data_loader_map_provider` is never initialized.
    data_loader_map_provider: DataLoaderMapProviderBase
    data_loader_map_provider_class_type: str = "SequenceDataLoaderMapProvider"

--- a/pytorch3d/implicitron/dataset/dataset_base.py
+++ b/pytorch3d/implicitron/dataset/dataset_base.py
@@ -4,6 +4,8 @@
 # This source code is licensed under the BSD-style license found in the
 # LICENSE file in the root directory of this source tree.

+# pyre-unsafe
+
 from collections import defaultdict
 from dataclasses import dataclass
 from typing import (
--- a/pytorch3d/implicitron/dataset/dataset_map_provider.py
+++ b/pytorch3d/implicitron/dataset/dataset_map_provider.py
@@ -4,6 +4,8 @@
 # This source code is licensed under the BSD-style license found in the
 # LICENSE file in the root directory of this source tree.

+# pyre-unsafe
+
 import logging
 import os
 from dataclasses import dataclass
--- a/pytorch3d/implicitron/dataset/frame_data.py
+++ b/pytorch3d/implicitron/dataset/frame_data.py
@@ -4,6 +4,8 @@
 # This source code is licensed under the BSD-style license found in the
 # LICENSE file in the root directory of this source tree.

+# pyre-unsafe
+
 import os
 from abc import ABC, abstractmethod
 from collections import defaultdict
@@ -274,6 +276,7 @@ class FrameData(Mapping[str, Any]):
            image_size_hw=tuple(self.effective_image_size_hw),  # pyre-ignore
        )
        crop_bbox_xywh = bbox_xyxy_to_xywh(clamp_bbox_xyxy)
+        self.crop_bbox_xywh = crop_bbox_xywh

        if self.fg_probability is not None:
            self.fg_probability = crop_around_box(
@@ -432,7 +435,7 @@ class FrameData(Mapping[str, Any]):
            # TODO: don't store K; enforce working in NDC space
            return join_cameras_as_batch(batch)
        else:
-            return torch.utils.data._utils.collate.default_collate(batch)
+            return torch.utils.data.dataloader.default_collate(batch)


 FrameDataSubtype = TypeVar("FrameDataSubtype", bound=FrameData)
@@ -576,11 +579,11 @@ class GenericFrameDataBuilder(FrameDataBuilderBase[FrameDataSubtype], ABC):
            camera_quality_score=safe_as_tensor(
                sequence_annotation.viewpoint_quality_score, torch.float
            ),
-            point_cloud_quality_score=safe_as_tensor(
-                point_cloud.quality_score, torch.float
-            )
-            if point_cloud is not None
-            else None,
+            point_cloud_quality_score=(
+                safe_as_tensor(point_cloud.quality_score, torch.float)
+                if point_cloud is not None
+                else None
+            ),
        )

        fg_mask_np: Optional[np.ndarray] = None
--- a/pytorch3d/implicitron/dataset/json_index_dataset.py
+++ b/pytorch3d/implicitron/dataset/json_index_dataset.py
@@ -4,6 +4,8 @@
 # This source code is licensed under the BSD-style license found in the
 # LICENSE file in the root directory of this source tree.

+# pyre-unsafe
+
 import copy
 import functools
 import gzip
@@ -124,9 +126,9 @@ class JsonIndexDataset(DatasetBase, ReplaceableBase):
            dimension of the cropping bounding box, relative to box size.
    """

-    frame_annotations_type: ClassVar[
-        Type[types.FrameAnnotation]
-    ] = types.FrameAnnotation
+    frame_annotations_type: ClassVar[Type[types.FrameAnnotation]] = (
+        types.FrameAnnotation
+    )

    path_manager: Any = None
    frame_annotations_file: str = ""
--- a/pytorch3d/implicitron/dataset/json_index_dataset_map_provider.py
+++ b/pytorch3d/implicitron/dataset/json_index_dataset_map_provider.py
@@ -4,6 +4,8 @@
 # This source code is licensed under the BSD-style license found in the
 # LICENSE file in the root directory of this source tree.

+# pyre-unsafe
+

 import json
 import os
@@ -64,7 +66,7 @@ _NEED_CONTROL: Tuple[str, ...] = (


@registry.register
-class JsonIndexDatasetMapProvider(DatasetMapProviderBase):  # pyre-ignore [13]
+class JsonIndexDatasetMapProvider(DatasetMapProviderBase):
    """
    Generates the training / validation and testing dataset objects for
    a dataset laid out on disk like Co3D, with annotations in json files.
@@ -93,6 +95,7 @@ class JsonIndexDatasetMapProvider(DatasetMapProviderBase):  # pyre-ignore [13]
        path_manager_factory_class_type: The class type of `path_manager_factory`.
    """

+    # pyre-fixme[13]: Attribute `category` is never initialized.
    category: str
    task_str: str = "singlesequence"
    dataset_root: str = _CO3D_DATASET_ROOT
@@ -102,8 +105,10 @@ class JsonIndexDatasetMapProvider(DatasetMapProviderBase):  # pyre-ignore [13]
    test_restrict_sequence_id: int = -1
    assert_single_seq: bool = False
    only_test_set: bool = False
+    # pyre-fixme[13]: Attribute `dataset` is never initialized.
    dataset: JsonIndexDataset
    dataset_class_type: str = "JsonIndexDataset"
+    # pyre-fixme[13]: Attribute `path_manager_factory` is never initialized.
    path_manager_factory: PathManagerFactory
    path_manager_factory_class_type: str = "PathManagerFactory"

--- a/pytorch3d/implicitron/dataset/json_index_dataset_map_provider_v2.py
+++ b/pytorch3d/implicitron/dataset/json_index_dataset_map_provider_v2.py
@@ -4,6 +4,8 @@
 # This source code is licensed under the BSD-style license found in the
 # LICENSE file in the root directory of this source tree.

+# pyre-unsafe
+

 import copy
 import json
@@ -54,7 +56,7 @@ logger = logging.getLogger(__name__)


@registry.register
-class JsonIndexDatasetMapProviderV2(DatasetMapProviderBase):  # pyre-ignore [13]
+class JsonIndexDatasetMapProviderV2(DatasetMapProviderBase):
    """
    Generates the training, validation, and testing dataset objects for
    a dataset laid out on disk like CO3Dv2, with annotations in gzipped json files.
@@ -169,7 +171,9 @@ class JsonIndexDatasetMapProviderV2(DatasetMapProviderBase):  # pyre-ignore [13]
        path_manager_factory_class_type: The class type of `path_manager_factory`.
    """

+    # pyre-fixme[13]: Attribute `category` is never initialized.
    category: str
+    # pyre-fixme[13]: Attribute `subset_name` is never initialized.
    subset_name: str
    dataset_root: str = _CO3DV2_DATASET_ROOT

@@ -181,8 +185,10 @@ class JsonIndexDatasetMapProviderV2(DatasetMapProviderBase):  # pyre-ignore [13]
    n_known_frames_for_test: int = 0

    dataset_class_type: str = "JsonIndexDataset"
+    # pyre-fixme[13]: Attribute `dataset` is never initialized.
    dataset: JsonIndexDataset

+    # pyre-fixme[13]: Attribute `path_manager_factory` is never initialized.
    path_manager_factory: PathManagerFactory
    path_manager_factory_class_type: str = "PathManagerFactory"

--- a/pytorch3d/implicitron/dataset/llff_dataset_map_provider.py
+++ b/pytorch3d/implicitron/dataset/llff_dataset_map_provider.py
@@ -4,6 +4,8 @@
 # This source code is licensed under the BSD-style license found in the
 # LICENSE file in the root directory of this source tree.

+# pyre-unsafe
+

 import numpy as np
 import torch
--- a/pytorch3d/implicitron/dataset/load_blender.py
+++ b/pytorch3d/implicitron/dataset/load_blender.py
@@ -1,6 +1,8 @@
 # @lint-ignore-every LICENSELINT
 # Adapted from https://github.com/bmild/nerf/blob/master/load_blender.py
 # Copyright (c) 2020 bmild
+
+# pyre-unsafe
 import json
 import os

--- a/pytorch3d/implicitron/dataset/load_llff.py
+++ b/pytorch3d/implicitron/dataset/load_llff.py
@@ -1,6 +1,8 @@
 # @lint-ignore-every LICENSELINT
 # Adapted from https://github.com/bmild/nerf/blob/master/load_llff.py
 # Copyright (c) 2020 bmild
+
+# pyre-unsafe
 import logging
 import os
 import warnings
--- a/pytorch3d/implicitron/dataset/rendered_mesh_dataset_map_provider.py
+++ b/pytorch3d/implicitron/dataset/rendered_mesh_dataset_map_provider.py
@@ -4,6 +4,8 @@
 # This source code is licensed under the BSD-style license found in the
 # LICENSE file in the root directory of this source tree.

+# pyre-unsafe
+
 from os.path import dirname, join, realpath
 from typing import Optional, Tuple

@@ -30,7 +32,7 @@ from .utils import DATASET_TYPE_KNOWN


@registry.register
-class RenderedMeshDatasetMapProvider(DatasetMapProviderBase):  # pyre-ignore [13]
+class RenderedMeshDatasetMapProvider(DatasetMapProviderBase):
    """
    A simple single-scene dataset based on PyTorch3D renders of a mesh.
    Provides `num_views` renders of the mesh as train, with no val
@@ -74,6 +76,7 @@ class RenderedMeshDatasetMapProvider(DatasetMapProviderBase):  # pyre-ignore [13
    resolution: int = 128
    use_point_light: bool = True
    gpu_idx: Optional[int] = 0
+    # pyre-fixme[13]: Attribute `path_manager_factory` is never initialized.
    path_manager_factory: PathManagerFactory
    path_manager_factory_class_type: str = "PathManagerFactory"

--- a/pytorch3d/implicitron/dataset/scene_batch_sampler.py
+++ b/pytorch3d/implicitron/dataset/scene_batch_sampler.py
@@ -4,6 +4,8 @@
 # This source code is licensed under the BSD-style license found in the
 # LICENSE file in the root directory of this source tree.

+# pyre-unsafe
+

 import warnings
 from collections import Counter
--- a/pytorch3d/implicitron/dataset/single_sequence_dataset.py
+++ b/pytorch3d/implicitron/dataset/single_sequence_dataset.py
@@ -4,6 +4,8 @@
 # This source code is licensed under the BSD-style license found in the
 # LICENSE file in the root directory of this source tree.

+# pyre-unsafe
+

 # This file defines a base class for dataset map providers which
 # provide data for a single scene.
@@ -81,7 +83,6 @@ class SingleSceneDataset(DatasetBase, Configurable):
        return self.eval_batches


-# pyre-fixme[13]: Uninitialized attribute
 class SingleSceneDatasetMapProviderBase(DatasetMapProviderBase):
    """
    Base for provider of data for one scene from LLFF or blender datasets.
@@ -98,8 +99,11 @@ class SingleSceneDatasetMapProviderBase(DatasetMapProviderBase):
            testing frame.
    """

+    # pyre-fixme[13]: Attribute `base_dir` is never initialized.
    base_dir: str
+    # pyre-fixme[13]: Attribute `object_name` is never initialized.
    object_name: str
+    # pyre-fixme[13]: Attribute `path_manager_factory` is never initialized.
    path_manager_factory: PathManagerFactory
    path_manager_factory_class_type: str = "PathManagerFactory"
    n_known_frames_for_test: Optional[int] = None
--- a/pytorch3d/implicitron/dataset/train_eval_data_loader_provider.py
+++ b/pytorch3d/implicitron/dataset/train_eval_data_loader_provider.py
@@ -4,6 +4,8 @@
 # This source code is licensed under the BSD-style license found in the
 # LICENSE file in the root directory of this source tree.

+# pyre-unsafe
+
 import logging
 from typing import Any, Dict, Optional, Tuple

--- a/pytorch3d/implicitron/dataset/types.py
+++ b/pytorch3d/implicitron/dataset/types.py
@@ -4,6 +4,8 @@
 # This source code is licensed under the BSD-style license found in the
 # LICENSE file in the root directory of this source tree.

+# pyre-unsafe
+

 import dataclasses
 import gzip
--- a/pytorch3d/implicitron/dataset/utils.py
+++ b/pytorch3d/implicitron/dataset/utils.py
@@ -4,6 +4,8 @@
 # This source code is licensed under the BSD-style license found in the
 # LICENSE file in the root directory of this source tree.

+# pyre-unsafe
+

 import functools
 import warnings
@@ -346,6 +348,7 @@ def adjust_camera_to_image_scale_(
    camera: PerspectiveCameras,
    original_size_wh: torch.Tensor,
    new_size_wh: torch.LongTensor,
+    # pyre-fixme[7]: Expected `PerspectiveCameras` but got implicit return value of `None`.
 ) -> PerspectiveCameras:
    focal_length_px, principal_point_px = _convert_ndc_to_pixels(
        camera.focal_length[0],
@@ -365,7 +368,7 @@ def adjust_camera_to_image_scale_(
        image_size_wh_output,
    )
    camera.focal_length = focal_length_scaled[None]
-    camera.principal_point = principal_point_scaled[None]  # pyre-ignore
+    camera.principal_point = principal_point_scaled[None]


 # NOTE this cache is per-worker; they are implemented as processes.
--- a/pytorch3d/implicitron/dataset/visualize.py
+++ b/pytorch3d/implicitron/dataset/visualize.py
@@ -4,6 +4,8 @@
 # This source code is licensed under the BSD-style license found in the
 # LICENSE file in the root directory of this source tree.

+# pyre-unsafe
+
 from typing import cast, Optional, Tuple

 import torch
@@ -88,9 +90,11 @@ def get_implicitron_sequence_pointcloud(
            frame_data.camera,
            frame_data.image_rgb,
            frame_data.depth_map,
-            (cast(torch.Tensor, frame_data.fg_probability) > 0.5).float()
-            if mask_points and frame_data.fg_probability is not None
-            else None,
+            (
+                (cast(torch.Tensor, frame_data.fg_probability) > 0.5).float()
+                if mask_points and frame_data.fg_probability is not None
+                else None
+            ),
        )

    return point_cloud, frame_data
--- a/pytorch3d/implicitron/eval_demo.py
+++ b/pytorch3d/implicitron/eval_demo.py
@@ -4,6 +4,8 @@
 # This source code is licensed under the BSD-style license found in the
 # LICENSE file in the root directory of this source tree.

+# pyre-unsafe
+

 import dataclasses
 import os
--- a/pytorch3d/implicitron/evaluation/init.py
+++ b/pytorch3d/implicitron/evaluation/init.py
@@ -3,3 +3,5 @@
 #
 # This source code is licensed under the BSD-style license found in the
 # LICENSE file in the root directory of this source tree.
+
+# pyre-unsafe
--- a/pytorch3d/implicitron/evaluation/evaluate_new_view_synthesis.py
+++ b/pytorch3d/implicitron/evaluation/evaluate_new_view_synthesis.py
@@ -4,6 +4,8 @@
 # This source code is licensed under the BSD-style license found in the
 # LICENSE file in the root directory of this source tree.

+# pyre-unsafe
+

 import copy
 import warnings
@@ -282,9 +284,9 @@ def eval_batch(
            image_rgb_masked=image_rgb_masked,
            depth_render=cloned_render["depth_render"],
            depth_map=frame_data.depth_map,
-            depth_mask=frame_data.depth_mask[:1]
-            if frame_data.depth_mask is not None
-            else None,
+            depth_mask=(
+                frame_data.depth_mask[:1] if frame_data.depth_mask is not None else None
+            ),
            visdom_env=visualize_visdom_env,
        )

--- a/pytorch3d/implicitron/evaluation/evaluator.py
+++ b/pytorch3d/implicitron/evaluation/evaluator.py
@@ -4,6 +4,8 @@
 # This source code is licensed under the BSD-style license found in the
 # LICENSE file in the root directory of this source tree.

+# pyre-unsafe
+
 import copy
 import json
 import logging
--- a/pytorch3d/implicitron/models/init.py
+++ b/pytorch3d/implicitron/models/init.py
@@ -4,6 +4,8 @@
 # This source code is licensed under the BSD-style license found in the
 # LICENSE file in the root directory of this source tree.

+# pyre-unsafe
+
 # Allows to register the models
 # see: pytorch3d.implicitron.tools.config.registry:register
 from pytorch3d.implicitron.models.generic_model import GenericModel
--- a/pytorch3d/implicitron/models/base_model.py
+++ b/pytorch3d/implicitron/models/base_model.py
@@ -4,6 +4,8 @@
 # This source code is licensed under the BSD-style license found in the
 # LICENSE file in the root directory of this source tree.

+# pyre-unsafe
+
 from dataclasses import dataclass, field
 from typing import Any, Dict, List, Optional

--- a/pytorch3d/implicitron/models/feature_extractor/init.py
+++ b/pytorch3d/implicitron/models/feature_extractor/init.py
@@ -4,4 +4,6 @@
 # This source code is licensed under the BSD-style license found in the
 # LICENSE file in the root directory of this source tree.

+# pyre-unsafe
+
 from .feature_extractor import FeatureExtractorBase
--- a/pytorch3d/implicitron/models/feature_extractor/feature_extractor.py
+++ b/pytorch3d/implicitron/models/feature_extractor/feature_extractor.py
@@ -4,6 +4,8 @@
 # This source code is licensed under the BSD-style license found in the
 # LICENSE file in the root directory of this source tree.

+# pyre-unsafe
+
 from typing import Any, Dict, Optional

 import torch
--- a/pytorch3d/implicitron/models/feature_extractor/resnet_feature_extractor.py
+++ b/pytorch3d/implicitron/models/feature_extractor/resnet_feature_extractor.py
@@ -4,6 +4,8 @@
 # This source code is licensed under the BSD-style license found in the
 # LICENSE file in the root directory of this source tree.

+# pyre-unsafe
+
 import logging
 import math
 from typing import Any, Dict, Optional, Tuple
--- a/pytorch3d/implicitron/models/generic_model.py
+++ b/pytorch3d/implicitron/models/generic_model.py
@@ -4,6 +4,8 @@
 # This source code is licensed under the BSD-style license found in the
 # LICENSE file in the root directory of this source tree.

+# pyre-unsafe
+

 # Note: The #noqa comments below are for unused imports of pluggable implementations
 # which are part of implicitron. They ensure that the registry is prepopulated.
@@ -63,7 +65,7 @@ logger = logging.getLogger(__name__)


@registry.register
-class GenericModel(ImplicitronModelBase):  # pyre-ignore: 13
+class GenericModel(ImplicitronModelBase):
    """
    GenericModel is a wrapper for the neural implicit
    rendering and reconstruction pipeline which consists
@@ -224,34 +226,42 @@ class GenericModel(ImplicitronModelBase):  # pyre-ignore: 13

    # ---- global encoder settings
    global_encoder_class_type: Optional[str] = None
+    # pyre-fixme[13]: Attribute `global_encoder` is never initialized.
    global_encoder: Optional[GlobalEncoderBase]

    # ---- raysampler
    raysampler_class_type: str = "AdaptiveRaySampler"
+    # pyre-fixme[13]: Attribute `raysampler` is never initialized.
    raysampler: RaySamplerBase

    # ---- renderer configs
    renderer_class_type: str = "MultiPassEmissionAbsorptionRenderer"
+    # pyre-fixme[13]: Attribute `renderer` is never initialized.
    renderer: BaseRenderer

    # ---- image feature extractor settings
    # (This is only created if view_pooler is enabled)
+    # pyre-fixme[13]: Attribute `image_feature_extractor` is never initialized.
    image_feature_extractor: Optional[FeatureExtractorBase]
    image_feature_extractor_class_type: Optional[str] = None
    # ---- view pooler settings
    view_pooler_enabled: bool = False
+    # pyre-fixme[13]: Attribute `view_pooler` is never initialized.
    view_pooler: Optional[ViewPooler]

    # ---- implicit function settings
    implicit_function_class_type: str = "NeuralRadianceFieldImplicitFunction"
    # This is just a model, never constructed.
    # The actual implicit functions live in self._implicit_functions
+    # pyre-fixme[13]: Attribute `implicit_function` is never initialized.
    implicit_function: ImplicitFunctionBase

    # ----- metrics
+    # pyre-fixme[13]: Attribute `view_metrics` is never initialized.
    view_metrics: ViewMetricsBase
    view_metrics_class_type: str = "ViewMetrics"

+    # pyre-fixme[13]: Attribute `regularization_metrics` is never initialized.
    regularization_metrics: RegularizationMetricsBase
    regularization_metrics_class_type: str = "RegularizationMetrics"

@@ -395,9 +405,11 @@ class GenericModel(ImplicitronModelBase):  # pyre-ignore: 13
        n_targets = (
            1
            if evaluation_mode == EvaluationMode.EVALUATION
-            else batch_size
-            if self.n_train_target_views <= 0
-            else min(self.n_train_target_views, batch_size)
+            else (
+                batch_size
+                if self.n_train_target_views <= 0
+                else min(self.n_train_target_views, batch_size)
+            )
        )

        # A helper function for selecting n_target first elements from the input
@@ -422,9 +434,12 @@ class GenericModel(ImplicitronModelBase):  # pyre-ignore: 13
        ray_bundle: ImplicitronRayBundle = self.raysampler(
            target_cameras,
            evaluation_mode,
-            mask=mask_crop[:n_targets]
-            if mask_crop is not None and sampling_mode == RenderSamplingMode.MASK_SAMPLE
-            else None,
+            mask=(
+                mask_crop[:n_targets]
+                if mask_crop is not None
+                and sampling_mode == RenderSamplingMode.MASK_SAMPLE
+                else None
+            ),
        )

        # custom_args hold additional arguments to the implicit function.
--- a/pytorch3d/implicitron/models/global_encoder/init.py
+++ b/pytorch3d/implicitron/models/global_encoder/init.py
@@ -3,3 +3,5 @@
 #
 # This source code is licensed under the BSD-style license found in the
 # LICENSE file in the root directory of this source tree.
+
+# pyre-unsafe
--- a/pytorch3d/implicitron/models/global_encoder/autodecoder.py
+++ b/pytorch3d/implicitron/models/global_encoder/autodecoder.py
@@ -4,6 +4,8 @@
 # This source code is licensed under the BSD-style license found in the
 # LICENSE file in the root directory of this source tree.

+# pyre-unsafe
+
 import warnings
 from collections import defaultdict
 from typing import Dict, List, Optional, Union
--- a/pytorch3d/implicitron/models/global_encoder/global_encoder.py
+++ b/pytorch3d/implicitron/models/global_encoder/global_encoder.py
@@ -4,6 +4,8 @@
 # This source code is licensed under the BSD-style license found in the
 # LICENSE file in the root directory of this source tree.

+# pyre-unsafe
+
 from typing import List, Optional, Union

 import torch
@@ -57,12 +59,13 @@ class GlobalEncoderBase(ReplaceableBase):

 # TODO: probabilistic embeddings?
@registry.register
-class SequenceAutodecoder(GlobalEncoderBase, torch.nn.Module):  # pyre-ignore: 13
+class SequenceAutodecoder(GlobalEncoderBase, torch.nn.Module):
    """
    A global encoder implementation which provides an autodecoder encoding
    of the frame's sequence identifier.
    """

+    # pyre-fixme[13]: Attribute `autodecoder` is never initialized.
    autodecoder: Autodecoder

    def __post_init__(self):
--- a/pytorch3d/implicitron/models/implicit_function/init.py
+++ b/pytorch3d/implicitron/models/implicit_function/init.py
@@ -3,3 +3,5 @@
 #
 # This source code is licensed under the BSD-style license found in the
 # LICENSE file in the root directory of this source tree.
+
+# pyre-unsafe
--- a/pytorch3d/implicitron/models/implicit_function/base.py
+++ b/pytorch3d/implicitron/models/implicit_function/base.py
@@ -4,6 +4,8 @@
 # This source code is licensed under the BSD-style license found in the
 # LICENSE file in the root directory of this source tree.

+# pyre-unsafe
+
 from abc import ABC, abstractmethod
 from typing import Optional

--- a/pytorch3d/implicitron/models/implicit_function/decoding_functions.py
+++ b/pytorch3d/implicitron/models/implicit_function/decoding_functions.py
@@ -4,6 +4,8 @@
 # This source code is licensed under the BSD-style license found in the
 # LICENSE file in the root directory of this source tree.

+# pyre-unsafe
+
 """
 This file contains
    - modules which get used by ImplicitFunction objects for decoding an embedding defined in
@@ -242,7 +244,6 @@ class MLPWithInputSkips(Configurable, torch.nn.Module):


@registry.register
-# pyre-fixme[13]: Attribute `network` is never initialized.
 class MLPDecoder(DecoderFunctionBase):
    """
    Decoding function which uses `MLPWithIputSkips` to convert the embedding to output.
@@ -270,6 +271,7 @@ class MLPDecoder(DecoderFunctionBase):

    input_dim: int = 3
    param_groups: Dict[str, str] = field(default_factory=lambda: {})
+    # pyre-fixme[13]: Attribute `network` is never initialized.
    network: MLPWithInputSkips

    def __post_init__(self):
--- a/pytorch3d/implicitron/models/implicit_function/idr_feature_field.py
+++ b/pytorch3d/implicitron/models/implicit_function/idr_feature_field.py
@@ -2,6 +2,8 @@
 # Adapted from https://github.com/lioryariv/idr/blob/main/code/model/
 #              implicit_differentiable_renderer.py
 # Copyright (c) 2020 Lior Yariv
+
+# pyre-unsafe
 import math
 from typing import Optional, Tuple

@@ -102,9 +104,7 @@ class IdrFeatureField(ImplicitFunctionBase, torch.nn.Module):
                elif self.n_harmonic_functions_xyz >= 0 and layer_idx == 0:
                    torch.nn.init.constant_(lin.bias, 0.0)
                    torch.nn.init.constant_(lin.weight[:, 3:], 0.0)
-                    torch.nn.init.normal_(
-                        lin.weight[:, :3], 0.0, 2**0.5 / out_dim**0.5
-                    )
+                    torch.nn.init.normal_(lin.weight[:, :3], 0.0, 2**0.5 / out_dim**0.5)
                elif self.n_harmonic_functions_xyz >= 0 and layer_idx in self.skip_in:
                    torch.nn.init.constant_(lin.bias, 0.0)
                    torch.nn.init.normal_(lin.weight, 0.0, 2**0.5 / out_dim**0.5)
--- a/pytorch3d/implicitron/models/implicit_function/neural_radiance_field.py
+++ b/pytorch3d/implicitron/models/implicit_function/neural_radiance_field.py
@@ -4,6 +4,8 @@
 # This source code is licensed under the BSD-style license found in the
 # LICENSE file in the root directory of this source tree.

+# pyre-unsafe
+
 import logging
 from typing import Optional, Tuple

@@ -193,9 +195,9 @@ class NeuralRadianceFieldBase(ImplicitFunctionBase, torch.nn.Module):
        embeds = create_embeddings_for_implicit_function(
            xyz_world=rays_points_world,
            #  for 2nd param but got `Union[None, torch.Tensor, torch.nn.Module]`.
-            xyz_embedding_function=self.harmonic_embedding_xyz
-            if self.input_xyz
-            else None,
+            xyz_embedding_function=(
+                self.harmonic_embedding_xyz if self.input_xyz else None
+            ),
            global_code=global_code,
            fun_viewpool=fun_viewpool,
            xyz_in_camera_coords=self.xyz_ray_dir_in_camera_coords,
--- a/Show More
+++ b/Show More
Author	SHA1	Message	Date
Jeremy Reizenstein	75ebeeaea0	update version to 0.7.8 Summary: as title Reviewed By: das-intensity Differential Revision: D62588556 fbshipit-source-id: 55bae19dd1df796e83179cd29d805fcd871b6d23	2024-09-13 02:31:49 -07:00
Jeremy Reizenstein	ab793177c6	remove pytorch2.0 builds Summary: these are failing in ci Reviewed By: das-intensity Differential Revision: D62594666 fbshipit-source-id: 5e3a7441be2978803dc2d3e361365e0fffa7ad3b	2024-09-13 02:07:25 -07:00
Jeremy Reizenstein	9acdd67b83	fix obj material indexing bug #1368 Summary: Make the negative index actually not an error fixes https://github.com/facebookresearch/pytorch3d/issues/1368 Reviewed By: das-intensity Differential Revision: D62177991 fbshipit-source-id: e5ed433bde1f54251c4d4b6db073c029cbe87343	2024-09-13 02:00:49 -07:00
Nicholas Dahm	3f428d9981	pytorch 2.4.0 + 2.4.1 Summary: Apparently pytorch 2.4 is now supported as per [this closed issue](https://github.com/facebookresearch/pytorch3d/issues/1863). Added the `2.4.0` & `2.4.1` versions to `regenerate.py` then ran that as per the `README_fb.md` which generated `config.yml` changes. Reviewed By: bottler Differential Revision: D62517831 fbshipit-source-id: 002e276dfe2fa078136ff2f6c747d937abbadd1a	2024-09-11 15:09:43 -07:00
Josh Fromm	05cbea115a	Hipify Pytorch3D (#1851 ) Summary: X-link: https://github.com/pytorch/pytorch/pull/133343 X-link: https://github.com/fairinternal/pytorch3d/pull/45 Pull Request resolved: https://github.com/facebookresearch/pytorch3d/pull/1851 Enables pytorch3d to build on AMD. An important part of enabling this was not compiling the Pulsar backend when the target is AMD. There are simply too many kernel incompatibilites to make it work (I tried haha). Fortunately, it doesnt seem like most modern applications of pytorch3d rely on Pulsar. We should be able to unlock most of pytorch3d's goodness on AMD without it. Reviewed By: bottler, houseroad Differential Revision: D61171993 fbshipit-source-id: fd4aee378a3568b22676c5bf2b727c135ff710af	2024-08-15 16:18:22 -07:00
generatedunixname89002005307016	38afdcfc68	upgrade pyre version in `fbcode/vision` - batch 2 Reviewed By: bottler Differential Revision: D60992234 fbshipit-source-id: 899db6ed590ef966ff651c11027819e59b8401a3	2024-08-09 02:07:45 -07:00
Christine Sun	1e0b1d9c72	Remove Python versions from Install.md Summary: To avoid the installation instructions for PyTorch3D becoming out-of-date, instead of specifying certain Python versions, update to just `Python`. Reader will understand it has to be a Python version compatible with GitHub. Reviewed By: bottler Differential Revision: D60919848 fbshipit-source-id: 5e974970a0db3d3d32fae44e5dd30cbc1ce237a9	2024-08-07 13:46:31 -07:00
Rebecca Chen (Python)	44702fdb4b	Add "max" point reduction for chamfer distance Summary: * Adds a "max" option for the point_reduction input to the chamfer_distance function. * When combining the x and y directions, maxes the losses instead of summing them when point_reduction="max". * Moves batch reduction to happen after the directions are combined. * Adds test_chamfer_point_reduction_max and test_single_directional_chamfer_point_reduction_max tests. Fixes https://github.com/facebookresearch/pytorch3d/issues/1838 Reviewed By: bottler Differential Revision: D60614661 fbshipit-source-id: 7879816acfda03e945bada951b931d2c522756eb	2024-08-02 10:46:07 -07:00
Jeremy Reizenstein	7edaee71a9	allow matrix_to_quaternion onnx export Summary: Attempt to allow torch.onnx.dynamo_export(matrix_to_quaternion) to work. Differential Revision: D59812279 fbshipit-source-id: 4497e5b543bec9d5c2bdccfb779d154750a075ad	2024-07-16 11:30:20 -07:00
Roman Shapovalov	d0d0e02007	Fix: setting FrameData.crop_bbox_xywh for backwards compatibility Summary: This diff is fixing a backwards compatibility issue in PyTorch3D's dataset API. The code ensures that the `crop_bbox_xywh` attribute is set when box_crop flag is on. This is an implementation detail that people should not really use, however some people depend on this behaviour. Reviewed By: bottler Differential Revision: D59777449 fbshipit-source-id: b875e9eb909038b8629ccdade87661bb2c39d529	2024-07-16 02:21:13 -07:00
Jeremy Reizenstein	4df110b0a9	remove fvcore dependency Summary: This is not actually needed and is causing a conda-forge confusion to do with python_abi - which needs users to have `-c conda-forge` when they install pytorch3d. Reviewed By: patricklabatut Differential Revision: D59587930 fbshipit-source-id: 961ae13a62e1b2b2ce6d8781db38bd97eca69e65	2024-07-11 04:35:38 -07:00
Huy Do	51fd114d8b	Forward fix internal pyre failure from D58983461 Summary: X-link: https://github.com/pytorch/pytorch/pull/129525 Somehow, using underscore alias of some builtin types breaks pyre Reviewed By: malfet, clee2000 Differential Revision: D59029768 fbshipit-source-id: cfa2171b66475727b9545355e57a8297c1dc0bc6	2024-06-27 07:35:18 -07:00
Jeremy Reizenstein	89653419d0	version 0.7.7 Summary: New version Reviewed By: MichaelRamamonjisoa Differential Revision: D58668979 fbshipit-source-id: 195eaf83e4da51a106ef72e38dbb98c51c51724c	2024-06-25 06:59:24 -07:00
Jeremy Reizenstein	7980854d44	require pytorch 2.0+ Summary: Problems with timeouts on old builds. Reviewed By: MichaelRamamonjisoa Differential Revision: D58819435 fbshipit-source-id: e1976534a102ad3841f3b297c772e916aeea12cb	2024-06-21 08:15:17 -07:00
Jeremy Reizenstein	51d7c06ddd	MKL version fix in CI (#1820 ) Summary: Fix for "undefined symbol: iJIT_NotifyEvent" build issue, Pull Request resolved: https://github.com/facebookresearch/pytorch3d/pull/1820 Reviewed By: MichaelRamamonjisoa Differential Revision: D58685326 fbshipit-source-id: 48b54367c00851cc6fbb111ca98d69a2ace8361b	2024-06-21 08:15:17 -07:00
Sergii Dymchenko	00c36ec01c	Update deprecated PyTorch functions in fbcode/vision Reviewed By: bottler Differential Revision: D58762015 fbshipit-source-id: a0d05fe63a88d33e3f7783b5a7b2a476dd3a7449	2024-06-20 14:06:28 -07:00
vedrenne	b0462d8079	Allow indexing for classes inheriting Transform3d (#1801 ) Summary: Currently, it is not possible to access a sub-transform using an indexer for all 3d transforms inheriting the `Transforms3d` class. For instance: ```python from pytorch3d import transforms N = 10 r = transforms.random_rotations(N) T = transforms.Transform3d().rotate(R=r) R = transforms.Rotate(r) x = T[0] # ok x = R[0] # TypeError: __init__() got an unexpected keyword argument 'matrix' ``` This is because all these classes (namely `Rotate`, `Translate`, `Scale`, `RotateAxisAngle`) inherit the `__getitem__()` method from `Transform3d` which has the [following code on line 201](https://github.com/facebookresearch/pytorch3d/blob/main/pytorch3d/transforms/transform3d.py#L201): ```python return self.__class__(matrix=self.get_matrix()[index]) ``` The four classes inheriting `Transform3d` are not initialized through a matrix argument, hence they error. I propose to modify the `__getitem__()` method of the `Transform3d` class to fix this behavior. The least invasive way to do it I can think of consists of creating an empty instance of the current class, then setting the `_matrix` attribute manually. Thus, instead of ```python return self.__class__(matrix=self.get_matrix()[index]) ``` I propose to do: ```python instance = self.__class__.__new__(self.__class__) instance._matrix = self.get_matrix()[index] return instance ``` As far as I can tell, this modification occurs no modification whatsoever for the user, except for the ability to index all 3d transforms. Pull Request resolved: https://github.com/facebookresearch/pytorch3d/pull/1801 Reviewed By: MichaelRamamonjisoa Differential Revision: D58410389 Pulled By: bottler fbshipit-source-id: f371e4c63d2ae4c927a7ad48c2de8862761078de	2024-06-17 07:48:18 -07:00
Jeremy Reizenstein	b66d17a324	Undo c10=>std optional rename Summary: Undoes the pytorch3d changes in D57294278 because they break builds for for PyTorch<2.1 . Reviewed By: MichaelRamamonjisoa Differential Revision: D57379779 fbshipit-source-id: 47a12511abcec4c3f4e2f62eff5ba99deb2fab4c	2024-06-17 07:09:30 -07:00
Kyle Vedder	717493cb79	Fixed last dimension size check so that it doesn't trivially pass. (#1815 ) Summary: Currently, it checks that the `2`th dimension of `p2` is the same size as the `2`th dimension of `p2` instead of `p1`. Pull Request resolved: https://github.com/facebookresearch/pytorch3d/pull/1815 Reviewed By: MichaelRamamonjisoa Differential Revision: D58586966 Pulled By: bottler fbshipit-source-id: d4f723fa264f90fe368c10825c1acdfdc4c406dc	2024-06-17 06:00:13 -07:00
Jeremy Reizenstein	302da69461	builds for PyTorch 2.2.1 2.2.2 2.3.0 2.3.1 Summary: Build for new pytorch versions Reviewed By: MichaelRamamonjisoa Differential Revision: D58668956 fbshipit-source-id: 7fdfb377b370448d6147daded6a21b8db87586fb	2024-06-17 05:57:59 -07:00
Roman Shapovalov	4ae25bfce7	Moving ray bundle to float dtype Summary: We can now move ray bundle to float dtype (e.g. from fp16 like types). Reviewed By: bottler Differential Revision: D57493109 fbshipit-source-id: 4e18a427e968b646fe5feafbff653811cd007981	2024-05-30 10:06:38 -07:00
Richard Barnes	bd52f4a408	c10::optional -> std::optional in tensorboard/adhoc/Adhoc.h +9 Summary: `c10::optional` was switched to be `std::optional` after PyTorch moved to C++17. Let's eliminate `c10::optional`, if we can. Reviewed By: albanD Differential Revision: D57294278 fbshipit-source-id: f6f26133c43f8d92a4588f59df7d689e7909a0cd	2024-05-13 16:40:34 -07:00
generatedunixname89002005307016	17117106e4	upgrade pyre version in `fbcode/vision` - batch 2 Differential Revision: D57183103 fbshipit-source-id: 7e2f42ddc6a1fa02abc27a451987d67a00264cbb	2024-05-10 01:18:43 -07:00
Richard Barnes	aec76bb4c8	Remove unused-but-set variables in vision/fair/pytorch3d/pytorch3d/csrc/pulsar/include/renderer.render.device.h +1 Summary: This diff removes a variable that was set, but which was not used. LLVM-15 has a warning `-Wunused-but-set-variable` which we treat as an error because it's so often diagnostic of a code issue. Unused but set variables often indicate a programming mistake, but can also just be unnecessary cruft that harms readability and performance. Removing this variable will not change how your code works, but the unused variable may indicate your code isn't working the way you thought it was. I've gone through each of these by hand, but mistakes may have slipped through. If you feel the diff needs changes before landing, please commandeer and make appropriate changes: there are hundreds of these and responding to them individually is challenging. For questions/comments, contact r-barnes. - If you approve of this diff, please use the "Accept & Ship" button :-) Reviewed By: bottler Differential Revision: D56886956 fbshipit-source-id: 0c515ed98b812b1c106a59e19ec90751ce32e8c0	2024-05-02 13:58:05 -07:00
Andres Suarez	47d5dc8824	Apply clang-format 18 Summary: Previously this code conformed from clang-format 12. Reviewed By: igorsugak Differential Revision: D56065247 fbshipit-source-id: f5a985dd8f8b84f2f9e1818b3719b43c5a1b05b3	2024-04-14 11:28:32 -07:00
generatedunixname89002005307016	fe0b1bae49	upgrade pyre version in `fbcode/vision` - batch 2 Differential Revision: D55650177 fbshipit-source-id: d5faa4d805bb40fe3dea70b0601e7a1382b09f3a	2024-04-02 18:11:50 -07:00
Ruishen Lyu	ccf22911d4	Optimize list_to_packed to avoid for loop (#1737 ) Summary: For larger N and Mi value (e.g. N=154, Mi=238) I notice list_to_packed() has become a bottleneck for my application. By removing the for loop and running on GPU, i see a 10-20 x speedup. Pull Request resolved: https://github.com/facebookresearch/pytorch3d/pull/1737 Reviewed By: MichaelRamamonjisoa Differential Revision: D54187993 Pulled By: bottler fbshipit-source-id: 16399a24cb63b48c30460c7d960abef603b115d0	2024-04-02 07:50:25 -07:00
Ashim Dahal	128be02fc0	feat: adjusted sample_nums (#1768 ) Summary: adjusted sample_nums to match the number of columns in the image grid. It originally produced image grid with 5 axes but only 3 images and after this fix, the block would work as intended. Pull Request resolved: https://github.com/facebookresearch/pytorch3d/pull/1768 Reviewed By: MichaelRamamonjisoa Differential Revision: D55632872 Pulled By: bottler fbshipit-source-id: 44d633a8068076889e49d49b8a7910dba0db37a7	2024-04-02 06:02:48 -07:00
Roeia Kishk	31e3488a51	Changed tutorials' pip searching Summary: ### Generalise tutorials' pip searching: ## Required Information: This diff contains changes to several PyTorch3D tutorials. Purpose of this diff: Replace the current installation code with a more streamlined approach that tries to install the wheel first and falls back to installing from source if the wheel is not found. Why this diff is required: This diff makes it easier to cope with new PyTorch releases and reduce the need for manual intervention, as the current process involves checking the version of PyTorch in Colab and building a new wheel if it doesn't match the expected version, which generates additional work each time there is a a new PyTorch version in Colab. Changes: Before: ``` if torch.__version__.startswith("2.1.") and sys.platform.startswith("linux"): # We try to install PyTorch3D via a released wheel. pyt_version_str=torch.__version__.split("+")[0].replace(".", "") version_str="".join([ f"py3{sys.version_info.minor}_cu", torch.version.cuda.replace(".",""), f"_pyt{pyt_version_str}" ]) !pip install fvcore iopath !pip install --no-index --no-cache-dir pytorch3d -f https://dl.fbaipublicfiles.com/pytorch3d/packaging/wheels/{version_str}/download.html else: # We try to install PyTorch3D from source. !pip install 'git+https://github.com/facebookresearch/pytorch3d.git@stable' ``` After: ``` pyt_version_str=torch.__version__.split("+")[0].replace(".", "") version_str="".join([ f"py3{sys.version_info.minor}_cu", torch.version.cuda.replace(".",""), f"_pyt{pyt_version_str}" ]) !pip install fvcore iopath if sys.platform.startswith("linux"): # We try to install PyTorch3D via a released wheel. !pip install --no-index --no-cache-dir pytorch3d -f https://dl.fbaipublicfiles.com/pytorch3d/packaging/wheels/{version_str}/download.html pip_list = !pip freeze need_pytorch3d = not any(i.startswith("pytorch3d==") for i in pip_list) if need_pytorch3d: # We try to install PyTorch3D from source. !pip install 'git+https://github.com/facebookresearch/pytorch3d.git@stable' ``` Reviewed By: bottler Differential Revision: D55431832 fbshipit-source-id: a8de9162470698320241ae8401427dcb1ce17c37	2024-03-28 11:24:43 -07:00
generatedunixname89002005307016	b215776f2d	upgrade pyre version in `fbcode/vision` - batch 2 Differential Revision: D55395614 fbshipit-source-id: 71677892b5d6f219f6df25b4efb51fb0f6b1441b	2024-03-26 22:02:22 -07:00
Cijo Jose	38cf0dc1c5	TexturesUV multiple maps Summary: Implements the the TexturesUV with multiple map ids. Reviewed By: bottler Differential Revision: D53944063 fbshipit-source-id: 06c25eb6d69f72db0484f16566dd2ca32a560b82	2024-03-12 06:59:31 -07:00
Jaap Suter	7566530669	CUDA marching_cubes fix Summary: Fix an inclusive vs exclusive scan mix-up that was accidentally introduced when removing the Thrust dependency (`Thrust::exclusive_scan`) and reimplementing it using `at::cumsum` (which does an inclusive scan). This fixes two Github reported issues: * https://github.com/facebookresearch/pytorch3d/issues/1731 * https://github.com/facebookresearch/pytorch3d/issues/1751 Reviewed By: bottler Differential Revision: D54605545 fbshipit-source-id: da9e92f3f8a9a35f7b7191428d0b9a9ca03e0d4d	2024-03-07 15:38:24 -08:00
Conner Nilsen	a27755db41	Pyre Configurationless migration for] [batch:85/112] [shard:6/N] Reviewed By: inseokhwang Differential Revision: D54438157 fbshipit-source-id: a6acfe146ed29fff82123b5e458906d4b4cee6a2	2024-03-04 18:30:37 -08:00
Amethyst Reese	3da7703c5a	apply Black 2024 style in fbcode (4/16) Summary: Formats the covered files with pyfmt. paintitblack Reviewed By: aleivag Differential Revision: D54447727 fbshipit-source-id: 8844b1caa08de94d04ac4df3c768dbf8c865fd2f	2024-03-02 17:31:19 -08:00