[DONOTMERGE] one-off builds for pytorch 1.13.1

do not merge

.circleci/config.in.yml

@@ -64,7 +64,7 @@ jobs:
       CUDA_VERSION: "11.3"
     resource_class: gpu.nvidia.small.multi
     machine:
-      image: linux-cuda-11:default
+      image: ubuntu-2004:202101-01
     steps:
       - checkout
       - <<: *setupcuda
@@ -116,7 +116,7 @@ jobs:
       # so we aren't running the tests.
       - run:
           name: build
-          no_output_timeout: 40m
+          no_output_timeout: 20m
           command: MAX_JOBS=15 TEST_FLAG=--no-test python3 packaging/build_conda.py
       - store_artifacts:
           path: /opt/conda/conda-bld/linux-64
@@ -128,7 +128,7 @@ jobs:
   binary_linux_conda_cuda:
     <<: *binary_common
     machine:
-      image: linux-cuda-11:default
+      image: ubuntu-1604-cuda-10.2:202012-01
     resource_class: gpu.nvidia.small.multi
     steps:
     - checkout
@@ -145,7 +145,7 @@ jobs:
           docker pull $TESTRUN_DOCKER_IMAGE
     - run:
         name: Build and run tests
-        no_output_timeout: 40m
+        no_output_timeout: 20m
         command: |
           set -e
 
@@ -156,6 +156,24 @@ jobs:
 
           docker run --gpus all  --ipc=host -v $(pwd):/remote -w /remote ${VARS_TO_PASS} ${TESTRUN_DOCKER_IMAGE} python3 ./packaging/build_conda.py
 
+  binary_macos_wheel:
+    <<: *binary_common
+    macos:
+      xcode: "13.4.1"
+    steps:
+      - checkout
+      - run:
+          # Cannot easily deduplicate this as source'ing activate
+          # will set environment variables which we need to propagate
+          # to build_wheel.sh
+          command: |
+            curl -o conda.sh https://repo.anaconda.com/miniconda/Miniconda3-latest-MacOSX-x86_64.sh
+            sh conda.sh -b
+            source $HOME/miniconda3/bin/activate
+            packaging/build_wheel.sh
+      - store_artifacts:
+          path: dist
+
 workflows:
   version: 2
   build_and_test:
@@ -164,8 +182,23 @@ workflows:
       #     context: DOCKERHUB_TOKEN
       {{workflows()}}
       - binary_linux_conda_cuda:
-          name: testrun_conda_cuda_py310_cu117_pyt201
+          name: testrun_conda_cuda_py38_cu102_pyt190
           context: DOCKERHUB_TOKEN
-          python_version: "3.10"
+          python_version: "3.8"
-          pytorch_version: '2.0.1'
+          pytorch_version: '1.9.0'
-          cu_version: "cu117"
+          cu_version: "cu102"
+      - binary_macos_wheel:
+          cu_version: cpu
+          name: macos_wheel_py3.8_cpu
+          python_version: '3.8'
+          pytorch_version: '1.13.0'
+      - binary_macos_wheel:
+          cu_version: cpu
+          name: macos_wheel_py3.9_cpu
+          python_version: '3.9'
+          pytorch_version: '1.13.0'
+      - binary_macos_wheel:
+          cu_version: cpu
+          name: macos_wheel_py3.10_cpu
+          python_version: '3.10'
+          pytorch_version: '1.13.0'

.circleci/config.yml

@@ -64,7 +64,7 @@ jobs:
       CUDA_VERSION: "11.3"
     resource_class: gpu.nvidia.small.multi
     machine:
-      image: linux-cuda-11:default
+      image: ubuntu-2004:202101-01
     steps:
       - checkout
       - <<: *setupcuda
@@ -116,7 +116,7 @@ jobs:
       # so we aren't running the tests.
       - run:
           name: build
-          no_output_timeout: 40m
+          no_output_timeout: 20m
           command: MAX_JOBS=15 TEST_FLAG=--no-test python3 packaging/build_conda.py
       - store_artifacts:
           path: /opt/conda/conda-bld/linux-64
@@ -128,7 +128,7 @@ jobs:
   binary_linux_conda_cuda:
     <<: *binary_common
     machine:
-      image: linux-cuda-11:default
+      image: ubuntu-1604-cuda-10.2:202012-01
     resource_class: gpu.nvidia.small.multi
     steps:
     - checkout
@@ -145,7 +145,7 @@ jobs:
           docker pull $TESTRUN_DOCKER_IMAGE
     - run:
         name: Build and run tests
-        no_output_timeout: 40m
+        no_output_timeout: 20m
         command: |
           set -e
 
@@ -156,533 +156,67 @@ jobs:
 
           docker run --gpus all  --ipc=host -v $(pwd):/remote -w /remote ${VARS_TO_PASS} ${TESTRUN_DOCKER_IMAGE} python3 ./packaging/build_conda.py
 
+  binary_macos_wheel:
+    <<: *binary_common
+    macos:
+      xcode: "13.4.1"
+    steps:
+      - checkout
+      - run:
+          # Cannot easily deduplicate this as source'ing activate
+          # will set environment variables which we need to propagate
+          # to build_wheel.sh
+          command: |
+            curl -o conda.sh https://repo.anaconda.com/miniconda/Miniconda3-latest-MacOSX-x86_64.sh
+            sh conda.sh -b
+            source $HOME/miniconda3/bin/activate
+            packaging/build_wheel.sh
+      - store_artifacts:
+          path: dist
+
 workflows:
   version: 2
   build_and_test:
     jobs:
-      # - main:
-      #     context: DOCKERHUB_TOKEN
       - binary_linux_conda:
-          conda_docker_image: pytorch/conda-builder:cuda118
+          conda_docker_image: pytorch/conda-builder:cuda116
           context: DOCKERHUB_TOKEN
-          cu_version: cu118
+          cu_version: cu116
-          name: linux_conda_py38_cu118_pyt210
+          name: linux_conda_py38_cu116_pyt1131
           python_version: '3.8'
-          pytorch_version: 2.1.0
+          pytorch_version: 1.13.1
       - binary_linux_conda:
-          conda_docker_image: pytorch/conda-builder:cuda121
+          conda_docker_image: pytorch/conda-builder:cuda117
           context: DOCKERHUB_TOKEN
-          cu_version: cu121
+          cu_version: cu117
-          name: linux_conda_py38_cu121_pyt210
+          name: linux_conda_py38_cu117_pyt1131
           python_version: '3.8'
-          pytorch_version: 2.1.0
+          pytorch_version: 1.13.1
       - binary_linux_conda:
-          conda_docker_image: pytorch/conda-builder:cuda118
+          conda_docker_image: pytorch/conda-builder:cuda116
           context: DOCKERHUB_TOKEN
-          cu_version: cu118
+          cu_version: cu116
-          name: linux_conda_py38_cu118_pyt211
+          name: linux_conda_py39_cu116_pyt1131
-          python_version: '3.8'
-          pytorch_version: 2.1.1
-      - binary_linux_conda:
-          conda_docker_image: pytorch/conda-builder:cuda121
-          context: DOCKERHUB_TOKEN
-          cu_version: cu121
-          name: linux_conda_py38_cu121_pyt211
-          python_version: '3.8'
-          pytorch_version: 2.1.1
-      - binary_linux_conda:
-          conda_docker_image: pytorch/conda-builder:cuda118
-          context: DOCKERHUB_TOKEN
-          cu_version: cu118
-          name: linux_conda_py38_cu118_pyt212
-          python_version: '3.8'
-          pytorch_version: 2.1.2
-      - binary_linux_conda:
-          conda_docker_image: pytorch/conda-builder:cuda121
-          context: DOCKERHUB_TOKEN
-          cu_version: cu121
-          name: linux_conda_py38_cu121_pyt212
-          python_version: '3.8'
-          pytorch_version: 2.1.2
-      - binary_linux_conda:
-          conda_docker_image: pytorch/conda-builder:cuda118
-          context: DOCKERHUB_TOKEN
-          cu_version: cu118
-          name: linux_conda_py38_cu118_pyt220
-          python_version: '3.8'
-          pytorch_version: 2.2.0
-      - binary_linux_conda:
-          conda_docker_image: pytorch/conda-builder:cuda121
-          context: DOCKERHUB_TOKEN
-          cu_version: cu121
-          name: linux_conda_py38_cu121_pyt220
-          python_version: '3.8'
-          pytorch_version: 2.2.0
-      - binary_linux_conda:
-          conda_docker_image: pytorch/conda-builder:cuda118
-          context: DOCKERHUB_TOKEN
-          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:cuda121
-          context: DOCKERHUB_TOKEN
-          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_py38_cu118_pyt231
-          python_version: '3.8'
-          pytorch_version: 2.3.1
-      - binary_linux_conda:
-          conda_docker_image: pytorch/conda-builder:cuda121
-          context: DOCKERHUB_TOKEN
-          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_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
-          cu_version: cu118
-          name: linux_conda_py39_cu118_pyt210
           python_version: '3.9'
-          pytorch_version: 2.1.0
+          pytorch_version: 1.13.1
       - binary_linux_conda:
-          conda_docker_image: pytorch/conda-builder:cuda121
+          conda_docker_image: pytorch/conda-builder:cuda117
           context: DOCKERHUB_TOKEN
-          cu_version: cu121
+          cu_version: cu117
-          name: linux_conda_py39_cu121_pyt210
+          name: linux_conda_py39_cu117_pyt1131
           python_version: '3.9'
-          pytorch_version: 2.1.0
+          pytorch_version: 1.13.1
       - binary_linux_conda:
-          conda_docker_image: pytorch/conda-builder:cuda118
+          conda_docker_image: pytorch/conda-builder:cuda116
           context: DOCKERHUB_TOKEN
-          cu_version: cu118
+          cu_version: cu116
-          name: linux_conda_py39_cu118_pyt211
+          name: linux_conda_py310_cu116_pyt1131
-          python_version: '3.9'
-          pytorch_version: 2.1.1
-      - binary_linux_conda:
-          conda_docker_image: pytorch/conda-builder:cuda121
-          context: DOCKERHUB_TOKEN
-          cu_version: cu121
-          name: linux_conda_py39_cu121_pyt211
-          python_version: '3.9'
-          pytorch_version: 2.1.1
-      - binary_linux_conda:
-          conda_docker_image: pytorch/conda-builder:cuda118
-          context: DOCKERHUB_TOKEN
-          cu_version: cu118
-          name: linux_conda_py39_cu118_pyt212
-          python_version: '3.9'
-          pytorch_version: 2.1.2
-      - binary_linux_conda:
-          conda_docker_image: pytorch/conda-builder:cuda121
-          context: DOCKERHUB_TOKEN
-          cu_version: cu121
-          name: linux_conda_py39_cu121_pyt212
-          python_version: '3.9'
-          pytorch_version: 2.1.2
-      - binary_linux_conda:
-          conda_docker_image: pytorch/conda-builder:cuda118
-          context: DOCKERHUB_TOKEN
-          cu_version: cu118
-          name: linux_conda_py39_cu118_pyt220
-          python_version: '3.9'
-          pytorch_version: 2.2.0
-      - binary_linux_conda:
-          conda_docker_image: pytorch/conda-builder:cuda121
-          context: DOCKERHUB_TOKEN
-          cu_version: cu121
-          name: linux_conda_py39_cu121_pyt220
-          python_version: '3.9'
-          pytorch_version: 2.2.0
-      - binary_linux_conda:
-          conda_docker_image: pytorch/conda-builder:cuda118
-          context: DOCKERHUB_TOKEN
-          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:cuda121
-          context: DOCKERHUB_TOKEN
-          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_py39_cu118_pyt231
-          python_version: '3.9'
-          pytorch_version: 2.3.1
-      - binary_linux_conda:
-          conda_docker_image: pytorch/conda-builder:cuda121
-          context: DOCKERHUB_TOKEN
-          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_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
-          cu_version: cu118
-          name: linux_conda_py310_cu118_pyt210
           python_version: '3.10'
-          pytorch_version: 2.1.0
+          pytorch_version: 1.13.1
       - binary_linux_conda:
-          conda_docker_image: pytorch/conda-builder:cuda121
+          conda_docker_image: pytorch/conda-builder:cuda117
           context: DOCKERHUB_TOKEN
-          cu_version: cu121
+          cu_version: cu117
-          name: linux_conda_py310_cu121_pyt210
+          name: linux_conda_py310_cu117_pyt1131
           python_version: '3.10'
-          pytorch_version: 2.1.0
+          pytorch_version: 1.13.1
-      - binary_linux_conda:
-          conda_docker_image: pytorch/conda-builder:cuda118
-          context: DOCKERHUB_TOKEN
-          cu_version: cu118
-          name: linux_conda_py310_cu118_pyt211
-          python_version: '3.10'
-          pytorch_version: 2.1.1
-      - binary_linux_conda:
-          conda_docker_image: pytorch/conda-builder:cuda121
-          context: DOCKERHUB_TOKEN
-          cu_version: cu121
-          name: linux_conda_py310_cu121_pyt211
-          python_version: '3.10'
-          pytorch_version: 2.1.1
-      - binary_linux_conda:
-          conda_docker_image: pytorch/conda-builder:cuda118
-          context: DOCKERHUB_TOKEN
-          cu_version: cu118
-          name: linux_conda_py310_cu118_pyt212
-          python_version: '3.10'
-          pytorch_version: 2.1.2
-      - binary_linux_conda:
-          conda_docker_image: pytorch/conda-builder:cuda121
-          context: DOCKERHUB_TOKEN
-          cu_version: cu121
-          name: linux_conda_py310_cu121_pyt212
-          python_version: '3.10'
-          pytorch_version: 2.1.2
-      - binary_linux_conda:
-          conda_docker_image: pytorch/conda-builder:cuda118
-          context: DOCKERHUB_TOKEN
-          cu_version: cu118
-          name: linux_conda_py310_cu118_pyt220
-          python_version: '3.10'
-          pytorch_version: 2.2.0
-      - binary_linux_conda:
-          conda_docker_image: pytorch/conda-builder:cuda121
-          context: DOCKERHUB_TOKEN
-          cu_version: cu121
-          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
-          cu_version: cu118
-          name: linux_conda_py311_cu118_pyt210
-          python_version: '3.11'
-          pytorch_version: 2.1.0
-      - binary_linux_conda:
-          conda_docker_image: pytorch/conda-builder:cuda121
-          context: DOCKERHUB_TOKEN
-          cu_version: cu121
-          name: linux_conda_py311_cu121_pyt210
-          python_version: '3.11'
-          pytorch_version: 2.1.0
-      - binary_linux_conda:
-          conda_docker_image: pytorch/conda-builder:cuda118
-          context: DOCKERHUB_TOKEN
-          cu_version: cu118
-          name: linux_conda_py311_cu118_pyt211
-          python_version: '3.11'
-          pytorch_version: 2.1.1
-      - binary_linux_conda:
-          conda_docker_image: pytorch/conda-builder:cuda121
-          context: DOCKERHUB_TOKEN
-          cu_version: cu121
-          name: linux_conda_py311_cu121_pyt211
-          python_version: '3.11'
-          pytorch_version: 2.1.1
-      - binary_linux_conda:
-          conda_docker_image: pytorch/conda-builder:cuda118
-          context: DOCKERHUB_TOKEN
-          cu_version: cu118
-          name: linux_conda_py311_cu118_pyt212
-          python_version: '3.11'
-          pytorch_version: 2.1.2
-      - binary_linux_conda:
-          conda_docker_image: pytorch/conda-builder:cuda121
-          context: DOCKERHUB_TOKEN
-          cu_version: cu121
-          name: linux_conda_py311_cu121_pyt212
-          python_version: '3.11'
-          pytorch_version: 2.1.2
-      - binary_linux_conda:
-          conda_docker_image: pytorch/conda-builder:cuda118
-          context: DOCKERHUB_TOKEN
-          cu_version: cu118
-          name: linux_conda_py311_cu118_pyt220
-          python_version: '3.11'
-          pytorch_version: 2.2.0
-      - binary_linux_conda:
-          conda_docker_image: pytorch/conda-builder:cuda121
-          context: DOCKERHUB_TOKEN
-          cu_version: cu121
-          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
-          cu_version: cu118
-          name: linux_conda_py312_cu118_pyt220
-          python_version: '3.12'
-          pytorch_version: 2.2.0
-      - binary_linux_conda:
-          conda_docker_image: pytorch/conda-builder:cuda121
-          context: DOCKERHUB_TOKEN
-          cu_version: cu121
-          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
-          python_version: "3.10"
-          pytorch_version: '2.0.1'
-          cu_version: "cu117"

.circleci/regenerate.py

@@ -18,51 +18,55 @@ from packaging import version
 
 # The CUDA versions which have pytorch conda packages available for linux for each
 # version of pytorch.
+# Pytorch 1.4 also supports cuda 10.0 but we no longer build for cuda 10.0 at all.
 CONDA_CUDA_VERSIONS = {
-    "2.1.0": ["cu118", "cu121"],
+    "1.9.0": ["cu102", "cu111"],
-    "2.1.1": ["cu118", "cu121"],
+    "1.9.1": ["cu102", "cu111"],
-    "2.1.2": ["cu118", "cu121"],
+    "1.10.0": ["cu102", "cu111", "cu113"],
-    "2.2.0": ["cu118", "cu121"],
+    "1.10.1": ["cu102", "cu111", "cu113"],
-    "2.2.2": ["cu118", "cu121"],
+    "1.10.2": ["cu102", "cu111", "cu113"],
-    "2.3.1": ["cu118", "cu121"],
+    "1.11.0": ["cu102", "cu111", "cu113", "cu115"],
-    "2.4.0": ["cu118", "cu121"],
+    "1.12.0": ["cu102", "cu113", "cu116"],
-    "2.4.1": ["cu118", "cu121"],
+    "1.12.1": ["cu102", "cu113", "cu116"],
+    "1.13.0": ["cu116", "cu117"],
 }
 
 
 def conda_docker_image_for_cuda(cuda_version):
-    if len(cuda_version) != 5:
+    if cuda_version in ("cu101", "cu102", "cu111"):
-        raise ValueError("Unknown cuda version")
+        return None
-    return "pytorch/conda-builder:cuda" + cuda_version[2:]
+    if cuda_version == "cu113":
+        return "pytorch/conda-builder:cuda113"
+    if cuda_version == "cu115":
+        return "pytorch/conda-builder:cuda115"
+    if cuda_version == "cu116":
+        return "pytorch/conda-builder:cuda116"
+    if cuda_version == "cu117":
+        return "pytorch/conda-builder:cuda117"
+    raise ValueError("Unknown cuda version")
 
 
 def pytorch_versions_for_python(python_version):
-    if python_version in ["3.8", "3.9"]:
+    if python_version in ["3.7", "3.8"]:
         return list(CONDA_CUDA_VERSIONS)
+    if python_version == "3.9":
+        return [
+            i
+            for i in CONDA_CUDA_VERSIONS
+            if version.Version(i) > version.Version("1.7.0")
+        ]
     if python_version == "3.10":
         return [
             i
             for i in CONDA_CUDA_VERSIONS
             if version.Version(i) >= version.Version("1.11.0")
         ]
-    if python_version == "3.11":
-        return [
-            i
-            for i in CONDA_CUDA_VERSIONS
-            if version.Version(i) >= version.Version("2.1.0")
-        ]
-    if python_version == "3.12":
-        return [
-            i
-            for i in CONDA_CUDA_VERSIONS
-            if version.Version(i) >= version.Version("2.2.0")
-        ]
 
 
 def workflows(prefix="", filter_branch=None, upload=False, indentation=6):
     w = []
     for btype in ["conda"]:
-        for python_version in ["3.8", "3.9", "3.10", "3.11", "3.12"]:
+        for python_version in ["3.8", "3.9", "3.10"]:
             for pytorch_version in pytorch_versions_for_python(python_version):
                 for cu_version in CONDA_CUDA_VERSIONS[pytorch_version]:
                     w += workflow_pair(
@@ -88,6 +92,7 @@ def workflow_pair(
     upload=False,
     filter_branch,
 ):
+
     w = []
     py = python_version.replace(".", "")
     pyt = pytorch_version.replace(".", "")
@@ -126,6 +131,7 @@ def generate_base_workflow(
     btype,
     filter_branch=None,
 ):
+
     d = {
         "name": base_workflow_name,
         "python_version": python_version,

.flake8

@@ -1,8 +1,5 @@
 [flake8]
-# B028 No explicit stacklevel argument found.
+ignore = E203, E266, E501, W503, E221
-# B907 'foo' is manually surrounded by quotes, consider using the `!r` conversion flag.
-# B905 `zip()` without an explicit `strict=` parameter.
-ignore = E203, E266, E501, W503, E221, B028, B905, B907
 max-line-length = 88
 max-complexity = 18
 select = B,C,E,F,W,T4,B9

.github/workflows/build.yml

@@ -1,23 +0,0 @@
-name: facebookresearch/pytorch3d/build_and_test
-on:
-  pull_request:
-    branches:
-      - main
-  push:
-    branches:
-      - main
-jobs:
-  binary_linux_conda_cuda:
-    runs-on: 4-core-ubuntu-gpu-t4
-    env:
-      PYTHON_VERSION: "3.12"
-      BUILD_VERSION: "${{ github.run_number }}"
-      PYTORCH_VERSION: "2.4.1"
-      CU_VERSION: "cu121"
-      JUST_TESTRUN: 1
-    steps:
-    - uses: actions/checkout@v4
-    - name: Build and run tests
-      run: |-
-        conda create --name env --yes --quiet conda-build
-        conda run --no-capture-output --name env python3 ./packaging/build_conda.py --use-conda-cuda

INSTALL.md

@@ -8,20 +8,21 @@
 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
+- Python 3.8, 3.9 or 3.10
-- 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.
+- PyTorch 1.9.0, 1.9.1, 1.10.0, 1.10.1, 1.10.2, 1.11.0, 1.12.0, 1.12.1 or 1.13.0.
 - 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.
+- If CUDA is to be used and you are building from source, the CUB library must be available. We recommend version 1.10.0.
 
 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 pytorch pytorch=1.9.1 torchvision cudatoolkit=11.6
-conda install -c iopath iopath
+conda install -c fvcore -c iopath -c conda-forge fvcore 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
@@ -48,7 +49,6 @@ For developing on top of PyTorch3D or contributing, you will need to run the lin
 - tdqm
 - jupyter
 - imageio
-- fvcore
 - plotly
 - opencv-python
 
@@ -59,7 +59,6 @@ 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
 ```
 
@@ -78,8 +77,13 @@ Or, to install a nightly (non-official, alpha) build:
 # Anaconda Cloud
 conda install pytorch3d -c pytorch3d-nightly
 ```
+### 2. Install from PyPI, on Mac only.
+This works with pytorch 1.13.0 only. The build is CPU only.
+```
+pip install pytorch3d
+```
 
-### 2. Install wheels for Linux
+### 3. Install wheels for Linux
 We have prebuilt wheels with CUDA for Linux for PyTorch 1.11.0, for each of the supported CUDA versions,
 for Python 3.8 and 3.9. This is for ease of use on Google Colab.
 These are installed in a special way.
@@ -98,7 +102,6 @@ version_str="".join([
     torch.version.cuda.replace(".",""),
     f"_pyt{pyt_version_str}"
 ])
-!pip install iopath
 !pip install --no-index --no-cache-dir pytorch3d -f https://dl.fbaipublicfiles.com/pytorch3d/packaging/wheels/{version_str}/download.html
 ```
 

README.md

@@ -12,7 +12,7 @@ Key features include:
 - Data structure for storing and manipulating triangle meshes
 - Efficient operations on triangle meshes (projective transformations, graph convolution, sampling, loss functions)
 - A differentiable mesh renderer
-- Implicitron, see [its README](projects/implicitron_trainer), a framework for new-view synthesis via implicit representations. ([blog post](https://ai.facebook.com/blog/implicitron-a-new-modular-extensible-framework-for-neural-implicit-representations-in-pytorch3d/))
+- Implicitron, see [its README](projects/implicitron_trainer), a framework for new-view synthesis via implicit representations.
 
 PyTorch3D is designed to integrate smoothly with deep learning methods for predicting and manipulating 3D data.
 For this reason, all operators in PyTorch3D:
@@ -24,8 +24,6 @@ For this reason, all operators in PyTorch3D:
 
 Within FAIR, PyTorch3D has been used to power research projects such as [Mesh R-CNN](https://arxiv.org/abs/1906.02739).
 
-See our [blog post](https://ai.facebook.com/blog/-introducing-pytorch3d-an-open-source-library-for-3d-deep-learning/) to see more demos and learn about PyTorch3D.
-
 ## Installation
 
 For detailed instructions refer to [INSTALL.md](INSTALL.md).
@@ -146,14 +144,6 @@ If you are using the pulsar backend for sphere-rendering (the `PulsarPointRender
 
 Please see below for a timeline of the codebase updates in reverse chronological order. We are sharing updates on the releases as well as research projects which are built with PyTorch3D. The changelogs for the releases are available under [`Releases`](https://github.com/facebookresearch/pytorch3d/releases),  and the builds can be installed using `conda` as per the instructions in [INSTALL.md](INSTALL.md).
 
-**[Oct 31st 2023]:**   PyTorch3D [v0.7.5](https://github.com/facebookresearch/pytorch3d/releases/tag/v0.7.5) released.
-
-**[May 10th 2023]:**   PyTorch3D [v0.7.4](https://github.com/facebookresearch/pytorch3d/releases/tag/v0.7.4) released.
-
-**[Apr 5th 2023]:**   PyTorch3D [v0.7.3](https://github.com/facebookresearch/pytorch3d/releases/tag/v0.7.3) released.
-
-**[Dec 19th 2022]:**   PyTorch3D [v0.7.2](https://github.com/facebookresearch/pytorch3d/releases/tag/v0.7.2) released.
-
 **[Oct 23rd 2022]:**   PyTorch3D [v0.7.1](https://github.com/facebookresearch/pytorch3d/releases/tag/v0.7.1) released.
 
 **[Aug 10th 2022]:**   PyTorch3D [v0.7.0](https://github.com/facebookresearch/pytorch3d/releases/tag/v0.7.0) released with Implicitron and MeshRasterizerOpenGL.

dev/linter.sh

@@ -10,7 +10,7 @@
 DIR="$( cd "$( dirname "${BASH_SOURCE[0]}" )" >/dev/null 2>&1 && pwd )"
 DIR=$(dirname "${DIR}")
 
-if [[ -f "${DIR}/BUCK" ]]
+if [[ -f "${DIR}/TARGETS" ]]
 then
   pyfmt "${DIR}"
 else
@@ -36,5 +36,5 @@ then
 
   echo "Running pyre..."
   echo "To restart/kill pyre server, run 'pyre restart' or 'pyre kill' in fbcode/"
-  ( cd ~/fbsource/fbcode; arc pyre check //vision/fair/pytorch3d/... )
+  ( cd ~/fbsource/fbcode; pyre -l vision/fair/pytorch3d/ )
 fi

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 iopath iopath
+conda install -y -c fvcore -c iopath -c conda-forge fvcore 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

docs/.readthedocs.yaml

@@ -1,27 +0,0 @@
-# Copyright (c) Meta Platforms, Inc. and affiliates.
-# All rights reserved.
-#
-# This source code is licensed under the BSD-style license found in the
-# LICENSE file in the root directory of this source tree.
-
-# Read the Docs configuration file
-# See https://docs.readthedocs.io/en/stable/config-file/v2.html for details
-
-# Required
-version: 2
-
-# Set the version of Python and other tools you might need
-build:
-  os: ubuntu-22.04
-  tools:
-    python: "3.11"
-
-# Build documentation in the docs/ directory with Sphinx
-sphinx:
-  configuration: docs/conf.py
-
-# We recommend specifying your dependencies to enable reproducible builds:
-# https://docs.readthedocs.io/en/stable/guides/reproducible-builds.html
-python:
-  install:
-  - requirements: docs/requirements.txt

docs/README.md

@@ -3,7 +3,7 @@
 ### Install dependencies
 
 ```
-pip install -U recommonmark sphinx sphinx_rtd_theme sphinx_markdown_tables
+pip install -U recommonmark mock sphinx sphinx_rtd_theme sphinx_markdown_tables
 ```
 
 ### Add symlink to the root README.md

docs/conf.py

@@ -19,8 +19,8 @@
 #
 import os
 import sys
-import unittest.mock as mock
 
+import mock
 from recommonmark.parser import CommonMarkParser
 from recommonmark.states import DummyStateMachine
 from sphinx.builders.html import StandaloneHTMLBuilder

docs/examples/pulsar_basic.py

@@ -10,7 +10,6 @@ This example demonstrates the most trivial, direct interface of the pulsar
 sphere renderer. It renders and saves an image with 10 random spheres.
 Output: basic.png.
 """
-
 import logging
 import math
 from os import path

docs/examples/pulsar_basic_unified.py

@@ -11,7 +11,6 @@ interface for sphere renderering. It renders and saves an image with
 10 random spheres.
 Output: basic-pt3d.png.
 """
-
 import logging
 from os import path
 

docs/examples/pulsar_cam.py

@@ -14,7 +14,6 @@ distorted. Gradient-based optimization is used to converge towards the
 original camera parameters.
 Output: cam.gif.
 """
-
 import logging
 import math
 from os import path

docs/examples/pulsar_cam_unified.py

@@ -14,7 +14,6 @@ distorted. Gradient-based optimization is used to converge towards the
 original camera parameters.
 Output: cam-pt3d.gif
 """
-
 import logging
 from os import path
 

docs/examples/pulsar_multiview.py

@@ -18,7 +18,6 @@ This example is not available yet through the 'unified' interface,
 because opacity support has not landed in PyTorch3D for general data
 structures yet.
 """
-
 import logging
 import math
 from os import path

docs/examples/pulsar_optimization.py

@@ -13,7 +13,6 @@ The scene is initialized with random spheres. Gradient-based
 optimization is used to converge towards a faithful
 scene representation.
 """
-
 import logging
 import math
 

docs/examples/pulsar_optimization_unified.py

@@ -13,7 +13,6 @@ The scene is initialized with random spheres. Gradient-based
 optimization is used to converge towards a faithful
 scene representation.
 """
-
 import logging
 import math
 

docs/notes/cameras.md

@@ -85,7 +85,7 @@ cameras_ndc = PerspectiveCameras(focal_length=fcl_ndc, principal_point=prp_ndc)
 # Screen space camera
 image_size = ((128, 256),)    # (h, w)
 fcl_screen = (76.8,)          # fcl_ndc * min(image_size) / 2
-prp_screen = ((115.2, 32), )  # w / 2 - px_ndc * min(image_size) / 2, h / 2 - py_ndc * min(image_size) / 2
+prp_screen = ((115.2, 48), )  # w / 2 - px_ndc * min(image_size) / 2, h / 2 - py_ndc * min(image_size) / 2
 cameras_screen = PerspectiveCameras(focal_length=fcl_screen, principal_point=prp_screen, in_ndc=False, image_size=image_size)
 ```
 

docs/notes/io.md

@@ -7,20 +7,20 @@ sidebar_label: File IO
 There is a flexible interface for loading and saving point clouds and meshes from different formats.
 
 The main usage is via the `pytorch3d.io.IO` object, and its methods
-`load_mesh`, `save_mesh`, `load_pointcloud` and `save_pointcloud`.
+`load_mesh`, `save_mesh`, `load_point_cloud` and `save_point_cloud`.
 
 For example, to load a mesh you might do
 ```
 from pytorch3d.io import IO
 
 device=torch.device("cuda:0")
-mesh = IO().load_mesh("mymesh.obj", device=device)
+mesh = IO().load_mesh("mymesh.ply", device=device)
 ```
 
 and to save a pointcloud you might do
 ```
 pcl = Pointclouds(...)
-IO().save_pointcloud(pcl, "output_pointcloud.ply")
+IO().save_point_cloud(pcl, "output_pointcloud.obj")
 ```
 
 For meshes, this supports OBJ, PLY and OFF files.
@@ -31,4 +31,4 @@ In addition, there is experimental support for loading meshes from
 [glTF 2 assets](https://github.com/KhronosGroup/glTF/tree/master/specification/2.0)
 stored either in a GLB container file or a glTF JSON file with embedded binary data.
 This must be enabled explicitly, as described in
-`pytorch3d/io/experimental_gltf_io.py`.
+`pytorch3d/io/experimental_gltf_io.ply`.

docs/requirements.txt

@@ -1,10 +1,12 @@
 docutils>=0.14
 Sphinx>=1.7
-recommonmark
+recommonmark==0.4.0
 sphinx_rtd_theme
 sphinx_markdown_tables
+mock
 numpy
 iopath
-https://download.pytorch.org/whl/cpu/torchvision-0.15.2%2Bcpu-cp311-cp311-linux_x86_64.whl
+fvcore
-https://download.pytorch.org/whl/cpu/torch-2.0.1%2Bcpu-cp311-cp311-linux_x86_64.whl
+https://download.pytorch.org/whl/cpu/torchvision-0.8.2%2Bcpu-cp37-cp37m-linux_x86_64.whl
+https://download.pytorch.org/whl/cpu/torch-1.7.1%2Bcpu-cp37-cp37m-linux_x86_64.whl
 omegaconf

docs/tutorials/bundle_adjustment.ipynb

@@ -83,31 +83,28 @@
     "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",
-    "    pyt_version_str=torch.__version__.split(\"+\")[0].replace(\".\", \"\")\n",
+    "    if torch.__version__.startswith(\"1.13.\") and sys.platform.startswith(\"linux\"):\n",
-    "    version_str=\"\".join([\n",
+    "        # We try to install PyTorch3D via a released wheel.\n",
-    "        f\"py3{sys.version_info.minor}_cu\",\n",
+    "        pyt_version_str=torch.__version__.split(\"+\")[0].replace(\".\", \"\")\n",
-    "        torch.version.cuda.replace(\".\",\"\"),\n",
+    "        version_str=\"\".join([\n",
-    "        f\"_pyt{pyt_version_str}\"\n",
+    "            f\"py3{sys.version_info.minor}_cu\",\n",
-    "    ])\n",
+    "            torch.version.cuda.replace(\".\",\"\"),\n",
-    "    !pip install iopath\n",
+    "            f\"_pyt{pyt_version_str}\"\n",
-    "    if sys.platform.startswith(\"linux\"):\n",
+    "        ])\n",
-    "        print(\"Trying to install wheel for PyTorch3D\")\n",
+    "        !pip install fvcore iopath\n",
     "        !pip install --no-index --no-cache-dir pytorch3d -f https://dl.fbaipublicfiles.com/pytorch3d/packaging/wheels/{version_str}/download.html\n",
-    "        pip_list = !pip freeze\n",
+    "    else:\n",
-    "        need_pytorch3d = not any(i.startswith(\"pytorch3d==\") for  i in pip_list)\n",
+    "        # We try to install PyTorch3D from source.\n",
-    "    if need_pytorch3d:\n",
+    "        !curl -LO https://github.com/NVIDIA/cub/archive/1.10.0.tar.gz\n",
-    "        print(f\"failed to find/install wheel for {version_str}\")\n",
+    "        !tar xzf 1.10.0.tar.gz\n",
-    "if need_pytorch3d:\n",
+    "        os.environ[\"CUB_HOME\"] = os.getcwd() + \"/cub-1.10.0\"\n",
-    "    print(\"Installing PyTorch3D from source\")\n",
+    "        !pip install 'git+https://github.com/facebookresearch/pytorch3d.git@stable'"
-    "    !pip install ninja\n",
-    "    !pip install 'git+https://github.com/facebookresearch/pytorch3d.git@stable'"
    ]
   },
   {

docs/tutorials/camera_position_optimization_with_differentiable_rendering.ipynb

@@ -70,31 +70,28 @@
     "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",
-    "    pyt_version_str=torch.__version__.split(\"+\")[0].replace(\".\", \"\")\n",
+    "    if torch.__version__.startswith(\"1.13.\") and sys.platform.startswith(\"linux\"):\n",
-    "    version_str=\"\".join([\n",
+    "        # We try to install PyTorch3D via a released wheel.\n",
-    "        f\"py3{sys.version_info.minor}_cu\",\n",
+    "        pyt_version_str=torch.__version__.split(\"+\")[0].replace(\".\", \"\")\n",
-    "        torch.version.cuda.replace(\".\",\"\"),\n",
+    "        version_str=\"\".join([\n",
-    "        f\"_pyt{pyt_version_str}\"\n",
+    "            f\"py3{sys.version_info.minor}_cu\",\n",
-    "    ])\n",
+    "            torch.version.cuda.replace(\".\",\"\"),\n",
-    "    !pip install iopath\n",
+    "            f\"_pyt{pyt_version_str}\"\n",
-    "    if sys.platform.startswith(\"linux\"):\n",
+    "        ])\n",
-    "        print(\"Trying to install wheel for PyTorch3D\")\n",
+    "        !pip install fvcore iopath\n",
     "        !pip install --no-index --no-cache-dir pytorch3d -f https://dl.fbaipublicfiles.com/pytorch3d/packaging/wheels/{version_str}/download.html\n",
-    "        pip_list = !pip freeze\n",
+    "    else:\n",
-    "        need_pytorch3d = not any(i.startswith(\"pytorch3d==\") for  i in pip_list)\n",
+    "        # We try to install PyTorch3D from source.\n",
-    "    if need_pytorch3d:\n",
+    "        !curl -LO https://github.com/NVIDIA/cub/archive/1.10.0.tar.gz\n",
-    "        print(f\"failed to find/install wheel for {version_str}\")\n",
+    "        !tar xzf 1.10.0.tar.gz\n",
-    "if need_pytorch3d:\n",
+    "        os.environ[\"CUB_HOME\"] = os.getcwd() + \"/cub-1.10.0\"\n",
-    "    print(\"Installing PyTorch3D from source\")\n",
+    "        !pip install 'git+https://github.com/facebookresearch/pytorch3d.git@stable'"
-    "    !pip install ninja\n",
-    "    !pip install 'git+https://github.com/facebookresearch/pytorch3d.git@stable'"
    ]
   },
   {

docs/tutorials/dataloaders_ShapeNetCore_R2N2.ipynb

@@ -45,31 +45,28 @@
     "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",
-    "    pyt_version_str=torch.__version__.split(\"+\")[0].replace(\".\", \"\")\n",
+    "    if torch.__version__.startswith(\"1.13.\") and sys.platform.startswith(\"linux\"):\n",
-    "    version_str=\"\".join([\n",
+    "        # We try to install PyTorch3D via a released wheel.\n",
-    "        f\"py3{sys.version_info.minor}_cu\",\n",
+    "        pyt_version_str=torch.__version__.split(\"+\")[0].replace(\".\", \"\")\n",
-    "        torch.version.cuda.replace(\".\",\"\"),\n",
+    "        version_str=\"\".join([\n",
-    "        f\"_pyt{pyt_version_str}\"\n",
+    "            f\"py3{sys.version_info.minor}_cu\",\n",
-    "    ])\n",
+    "            torch.version.cuda.replace(\".\",\"\"),\n",
-    "    !pip install iopath\n",
+    "            f\"_pyt{pyt_version_str}\"\n",
-    "    if sys.platform.startswith(\"linux\"):\n",
+    "        ])\n",
-    "        print(\"Trying to install wheel for PyTorch3D\")\n",
+    "        !pip install fvcore iopath\n",
     "        !pip install --no-index --no-cache-dir pytorch3d -f https://dl.fbaipublicfiles.com/pytorch3d/packaging/wheels/{version_str}/download.html\n",
-    "        pip_list = !pip freeze\n",
+    "    else:\n",
-    "        need_pytorch3d = not any(i.startswith(\"pytorch3d==\") for  i in pip_list)\n",
+    "        # We try to install PyTorch3D from source.\n",
-    "    if need_pytorch3d:\n",
+    "        !curl -LO https://github.com/NVIDIA/cub/archive/1.10.0.tar.gz\n",
-    "        print(f\"failed to find/install wheel for {version_str}\")\n",
+    "        !tar xzf 1.10.0.tar.gz\n",
-    "if need_pytorch3d:\n",
+    "        os.environ[\"CUB_HOME\"] = os.getcwd() + \"/cub-1.10.0\"\n",
-    "    print(\"Installing PyTorch3D from source\")\n",
+    "        !pip install 'git+https://github.com/facebookresearch/pytorch3d.git@stable'"
-    "    !pip install ninja\n",
-    "    !pip install 'git+https://github.com/facebookresearch/pytorch3d.git@stable'"
    ]
   },
   {
@@ -411,7 +408,7 @@
    "outputs": [],
    "source": [
     "random_model_images = shapenet_dataset.render(\n",
-    "    sample_nums=[5],\n",
+    "    sample_nums=[3],\n",
     "    device=device,\n",
     "    cameras=cameras,\n",
     "    raster_settings=raster_settings,\n",

docs/tutorials/deform_source_mesh_to_target_mesh.ipynb

@@ -84,31 +84,28 @@
     "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",
-    "    pyt_version_str=torch.__version__.split(\"+\")[0].replace(\".\", \"\")\n",
+    "    if torch.__version__.startswith(\"1.13.\") and sys.platform.startswith(\"linux\"):\n",
-    "    version_str=\"\".join([\n",
+    "        # We try to install PyTorch3D via a released wheel.\n",
-    "        f\"py3{sys.version_info.minor}_cu\",\n",
+    "        pyt_version_str=torch.__version__.split(\"+\")[0].replace(\".\", \"\")\n",
-    "        torch.version.cuda.replace(\".\",\"\"),\n",
+    "        version_str=\"\".join([\n",
-    "        f\"_pyt{pyt_version_str}\"\n",
+    "            f\"py3{sys.version_info.minor}_cu\",\n",
-    "    ])\n",
+    "            torch.version.cuda.replace(\".\",\"\"),\n",
-    "    !pip install iopath\n",
+    "            f\"_pyt{pyt_version_str}\"\n",
-    "    if sys.platform.startswith(\"linux\"):\n",
+    "        ])\n",
-    "        print(\"Trying to install wheel for PyTorch3D\")\n",
+    "        !pip install fvcore iopath\n",
     "        !pip install --no-index --no-cache-dir pytorch3d -f https://dl.fbaipublicfiles.com/pytorch3d/packaging/wheels/{version_str}/download.html\n",
-    "        pip_list = !pip freeze\n",
+    "    else:\n",
-    "        need_pytorch3d = not any(i.startswith(\"pytorch3d==\") for  i in pip_list)\n",
+    "        # We try to install PyTorch3D from source.\n",
-    "    if need_pytorch3d:\n",
+    "        !curl -LO https://github.com/NVIDIA/cub/archive/1.10.0.tar.gz\n",
-    "        print(f\"failed to find/install wheel for {version_str}\")\n",
+    "        !tar xzf 1.10.0.tar.gz\n",
-    "if need_pytorch3d:\n",
+    "        os.environ[\"CUB_HOME\"] = os.getcwd() + \"/cub-1.10.0\"\n",
-    "    print(\"Installing PyTorch3D from source\")\n",
+    "        !pip install 'git+https://github.com/facebookresearch/pytorch3d.git@stable'"
-    "    !pip install ninja\n",
-    "    !pip install 'git+https://github.com/facebookresearch/pytorch3d.git@stable'"
    ]
   },
   {
@@ -195,7 +192,7 @@
    "outputs": [],
    "source": [
     "# Load the dolphin mesh.\n",
-    "trg_obj = 'dolphin.obj'"
+    "trg_obj = os.path.join('dolphin.obj')"
    ]
   },
   {
@@ -250,7 +247,7 @@
     "id": "dYWDl4VGWHRK"
    },
    "source": [
-    "## 2. Visualize the source and target meshes"
+    "###  Visualize the source and target meshes"
    ]
   },
   {
@@ -268,7 +265,7 @@
     "    points = sample_points_from_meshes(mesh, 5000)\n",
     "    x, y, z = points.clone().detach().cpu().squeeze().unbind(1)    \n",
     "    fig = plt.figure(figsize=(5, 5))\n",
-    "    ax = fig.add_subplot(111, projection='3d')\n",
+    "    ax = Axes3D(fig)\n",
     "    ax.scatter3D(x, z, -y)\n",
     "    ax.set_xlabel('x')\n",
     "    ax.set_ylabel('z')\n",
@@ -488,7 +485,7 @@
     "final_verts = final_verts * scale + center\n",
     "\n",
     "# Store the predicted mesh using save_obj\n",
-    "final_obj = 'final_model.obj'\n",
+    "final_obj = os.path.join('./', 'final_model.obj')\n",
     "save_obj(final_obj, final_verts, final_faces)"
    ]
   },

docs/tutorials/fit_simple_neural_radiance_field.ipynb

@@ -50,31 +50,28 @@
     "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",
-    "    pyt_version_str=torch.__version__.split(\"+\")[0].replace(\".\", \"\")\n",
+    "    if torch.__version__.startswith(\"1.13.\") and sys.platform.startswith(\"linux\"):\n",
-    "    version_str=\"\".join([\n",
+    "        # We try to install PyTorch3D via a released wheel.\n",
-    "        f\"py3{sys.version_info.minor}_cu\",\n",
+    "        pyt_version_str=torch.__version__.split(\"+\")[0].replace(\".\", \"\")\n",
-    "        torch.version.cuda.replace(\".\",\"\"),\n",
+    "        version_str=\"\".join([\n",
-    "        f\"_pyt{pyt_version_str}\"\n",
+    "            f\"py3{sys.version_info.minor}_cu\",\n",
-    "    ])\n",
+    "            torch.version.cuda.replace(\".\",\"\"),\n",
-    "    !pip install iopath\n",
+    "            f\"_pyt{pyt_version_str}\"\n",
-    "    if sys.platform.startswith(\"linux\"):\n",
+    "        ])\n",
-    "        print(\"Trying to install wheel for PyTorch3D\")\n",
+    "        !pip install fvcore iopath\n",
     "        !pip install --no-index --no-cache-dir pytorch3d -f https://dl.fbaipublicfiles.com/pytorch3d/packaging/wheels/{version_str}/download.html\n",
-    "        pip_list = !pip freeze\n",
+    "    else:\n",
-    "        need_pytorch3d = not any(i.startswith(\"pytorch3d==\") for  i in pip_list)\n",
+    "        # We try to install PyTorch3D from source.\n",
-    "    if need_pytorch3d:\n",
+    "        !curl -LO https://github.com/NVIDIA/cub/archive/1.10.0.tar.gz\n",
-    "        print(f\"failed to find/install wheel for {version_str}\")\n",
+    "        !tar xzf 1.10.0.tar.gz\n",
-    "if need_pytorch3d:\n",
+    "        os.environ[\"CUB_HOME\"] = os.getcwd() + \"/cub-1.10.0\"\n",
-    "    print(\"Installing PyTorch3D from source\")\n",
+    "        !pip install 'git+https://github.com/facebookresearch/pytorch3d.git@stable'"
-    "    !pip install ninja\n",
-    "    !pip install 'git+https://github.com/facebookresearch/pytorch3d.git@stable'"
    ]
   },
   {

docs/tutorials/fit_textured_mesh.ipynb

@@ -62,31 +62,28 @@
     "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",
-    "    pyt_version_str=torch.__version__.split(\"+\")[0].replace(\".\", \"\")\n",
+    "    if torch.__version__.startswith(\"1.13.\") and sys.platform.startswith(\"linux\"):\n",
-    "    version_str=\"\".join([\n",
+    "        # We try to install PyTorch3D via a released wheel.\n",
-    "        f\"py3{sys.version_info.minor}_cu\",\n",
+    "        pyt_version_str=torch.__version__.split(\"+\")[0].replace(\".\", \"\")\n",
-    "        torch.version.cuda.replace(\".\",\"\"),\n",
+    "        version_str=\"\".join([\n",
-    "        f\"_pyt{pyt_version_str}\"\n",
+    "            f\"py3{sys.version_info.minor}_cu\",\n",
-    "    ])\n",
+    "            torch.version.cuda.replace(\".\",\"\"),\n",
-    "    !pip install iopath\n",
+    "            f\"_pyt{pyt_version_str}\"\n",
-    "    if sys.platform.startswith(\"linux\"):\n",
+    "        ])\n",
-    "        print(\"Trying to install wheel for PyTorch3D\")\n",
+    "        !pip install fvcore iopath\n",
     "        !pip install --no-index --no-cache-dir pytorch3d -f https://dl.fbaipublicfiles.com/pytorch3d/packaging/wheels/{version_str}/download.html\n",
-    "        pip_list = !pip freeze\n",
+    "    else:\n",
-    "        need_pytorch3d = not any(i.startswith(\"pytorch3d==\") for  i in pip_list)\n",
+    "        # We try to install PyTorch3D from source.\n",
-    "    if need_pytorch3d:\n",
+    "        !curl -LO https://github.com/NVIDIA/cub/archive/1.10.0.tar.gz\n",
-    "        print(f\"failed to find/install wheel for {version_str}\")\n",
+    "        !tar xzf 1.10.0.tar.gz\n",
-    "if need_pytorch3d:\n",
+    "        os.environ[\"CUB_HOME\"] = os.getcwd() + \"/cub-1.10.0\"\n",
-    "    print(\"Installing PyTorch3D from source\")\n",
+    "        !pip install 'git+https://github.com/facebookresearch/pytorch3d.git@stable'"
-    "    !pip install ninja\n",
-    "    !pip install 'git+https://github.com/facebookresearch/pytorch3d.git@stable'"
    ]
   },
   {

docs/tutorials/fit_textured_volume.ipynb

@@ -41,31 +41,28 @@
     "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",
-    "    pyt_version_str=torch.__version__.split(\"+\")[0].replace(\".\", \"\")\n",
+    "    if torch.__version__.startswith(\"1.13.\") and sys.platform.startswith(\"linux\"):\n",
-    "    version_str=\"\".join([\n",
+    "        # We try to install PyTorch3D via a released wheel.\n",
-    "        f\"py3{sys.version_info.minor}_cu\",\n",
+    "        pyt_version_str=torch.__version__.split(\"+\")[0].replace(\".\", \"\")\n",
-    "        torch.version.cuda.replace(\".\",\"\"),\n",
+    "        version_str=\"\".join([\n",
-    "        f\"_pyt{pyt_version_str}\"\n",
+    "            f\"py3{sys.version_info.minor}_cu\",\n",
-    "    ])\n",
+    "            torch.version.cuda.replace(\".\",\"\"),\n",
-    "    !pip install iopath\n",
+    "            f\"_pyt{pyt_version_str}\"\n",
-    "    if sys.platform.startswith(\"linux\"):\n",
+    "        ])\n",
-    "        print(\"Trying to install wheel for PyTorch3D\")\n",
+    "        !pip install fvcore iopath\n",
     "        !pip install --no-index --no-cache-dir pytorch3d -f https://dl.fbaipublicfiles.com/pytorch3d/packaging/wheels/{version_str}/download.html\n",
-    "        pip_list = !pip freeze\n",
+    "    else:\n",
-    "        need_pytorch3d = not any(i.startswith(\"pytorch3d==\") for  i in pip_list)\n",
+    "        # We try to install PyTorch3D from source.\n",
-    "    if need_pytorch3d:\n",
+    "        !curl -LO https://github.com/NVIDIA/cub/archive/1.10.0.tar.gz\n",
-    "        print(f\"failed to find/install wheel for {version_str}\")\n",
+    "        !tar xzf 1.10.0.tar.gz\n",
-    "if need_pytorch3d:\n",
+    "        os.environ[\"CUB_HOME\"] = os.getcwd() + \"/cub-1.10.0\"\n",
-    "    print(\"Installing PyTorch3D from source\")\n",
+    "        !pip install 'git+https://github.com/facebookresearch/pytorch3d.git@stable'"
-    "    !pip install ninja\n",
-    "    !pip install 'git+https://github.com/facebookresearch/pytorch3d.git@stable'"
    ]
   },
   {

docs/tutorials/implicitron_config_system.ipynb

@@ -72,31 +72,28 @@
         "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",
-        "    pyt_version_str=torch.__version__.split(\"+\")[0].replace(\".\", \"\")\n",
+        "    if torch.__version__.startswith(\"1.13.\") and sys.platform.startswith(\"linux\"):\n",
-        "    version_str=\"\".join([\n",
+        "        # We try to install PyTorch3D via a released wheel.\n",
-        "        f\"py3{sys.version_info.minor}_cu\",\n",
+        "        pyt_version_str=torch.__version__.split(\"+\")[0].replace(\".\", \"\")\n",
-        "        torch.version.cuda.replace(\".\",\"\"),\n",
+        "        version_str=\"\".join([\n",
-        "        f\"_pyt{pyt_version_str}\"\n",
+        "            f\"py3{sys.version_info.minor}_cu\",\n",
-        "    ])\n",
+        "            torch.version.cuda.replace(\".\",\"\"),\n",
-        "    !pip install iopath\n",
+        "            f\"_pyt{pyt_version_str}\"\n",
-        "    if sys.platform.startswith(\"linux\"):\n",
+        "        ])\n",
-        "        print(\"Trying to install wheel for PyTorch3D\")\n",
+        "        !pip install fvcore iopath\n",
         "        !pip install --no-index --no-cache-dir pytorch3d -f https://dl.fbaipublicfiles.com/pytorch3d/packaging/wheels/{version_str}/download.html\n",
-        "        pip_list = !pip freeze\n",
+        "    else:\n",
-        "        need_pytorch3d = not any(i.startswith(\"pytorch3d==\") for  i in pip_list)\n",
+        "        # We try to install PyTorch3D from source.\n",
-        "    if need_pytorch3d:\n",
+        "        !curl -LO https://github.com/NVIDIA/cub/archive/1.10.0.tar.gz\n",
-        "        print(f\"failed to find/install wheel for {version_str}\")\n",
+        "        !tar xzf 1.10.0.tar.gz\n",
-        "if need_pytorch3d:\n",
+        "        os.environ[\"CUB_HOME\"] = os.getcwd() + \"/cub-1.10.0\"\n",
-        "    print(\"Installing PyTorch3D from source\")\n",
+        "        !pip install 'git+https://github.com/facebookresearch/pytorch3d.git@stable'"
-        "    !pip install ninja\n",
-        "    !pip install 'git+https://github.com/facebookresearch/pytorch3d.git@stable'"
       ]
     },
     {

docs/tutorials/implicitron_volumes.ipynb

@@ -66,31 +66,28 @@
         "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",
-        "    pyt_version_str=torch.__version__.split(\"+\")[0].replace(\".\", \"\")\n",
+        "    if torch.__version__.startswith(\"1.13.\") and sys.platform.startswith(\"linux\"):\n",
-        "    version_str=\"\".join([\n",
+        "        # We try to install PyTorch3D via a released wheel.\n",
-        "        f\"py3{sys.version_info.minor}_cu\",\n",
+        "        pyt_version_str=torch.__version__.split(\"+\")[0].replace(\".\", \"\")\n",
-        "        torch.version.cuda.replace(\".\",\"\"),\n",
+        "        version_str=\"\".join([\n",
-        "        f\"_pyt{pyt_version_str}\"\n",
+        "            f\"py3{sys.version_info.minor}_cu\",\n",
-        "    ])\n",
+        "            torch.version.cuda.replace(\".\",\"\"),\n",
-        "    !pip install iopath\n",
+        "            f\"_pyt{pyt_version_str}\"\n",
-        "    if sys.platform.startswith(\"linux\"):\n",
+        "        ])\n",
-        "        print(\"Trying to install wheel for PyTorch3D\")\n",
+        "        !pip install fvcore iopath\n",
         "        !pip install --no-index --no-cache-dir pytorch3d -f https://dl.fbaipublicfiles.com/pytorch3d/packaging/wheels/{version_str}/download.html\n",
-        "        pip_list = !pip freeze\n",
+        "    else:\n",
-        "        need_pytorch3d = not any(i.startswith(\"pytorch3d==\") for  i in pip_list)\n",
+        "        # We try to install PyTorch3D from source.\n",
-        "    if need_pytorch3d:\n",
+        "        !curl -LO https://github.com/NVIDIA/cub/archive/1.10.0.tar.gz\n",
-        "        print(f\"failed to find/install wheel for {version_str}\")\n",
+        "        !tar xzf 1.10.0.tar.gz\n",
-        "if need_pytorch3d:\n",
+        "        os.environ[\"CUB_HOME\"] = os.getcwd() + \"/cub-1.10.0\"\n",
-        "    print(\"Installing PyTorch3D from source\")\n",
+        "        !pip install 'git+https://github.com/facebookresearch/pytorch3d.git@stable'"
-        "    !pip install ninja\n",
-        "    !pip install 'git+https://github.com/facebookresearch/pytorch3d.git@stable'"
       ]
     },
     {

docs/tutorials/render_colored_points.ipynb

@@ -44,31 +44,28 @@
     "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",
-    "    pyt_version_str=torch.__version__.split(\"+\")[0].replace(\".\", \"\")\n",
+    "    if torch.__version__.startswith(\"1.13.\") and sys.platform.startswith(\"linux\"):\n",
-    "    version_str=\"\".join([\n",
+    "        # We try to install PyTorch3D via a released wheel.\n",
-    "        f\"py3{sys.version_info.minor}_cu\",\n",
+    "        pyt_version_str=torch.__version__.split(\"+\")[0].replace(\".\", \"\")\n",
-    "        torch.version.cuda.replace(\".\",\"\"),\n",
+    "        version_str=\"\".join([\n",
-    "        f\"_pyt{pyt_version_str}\"\n",
+    "            f\"py3{sys.version_info.minor}_cu\",\n",
-    "    ])\n",
+    "            torch.version.cuda.replace(\".\",\"\"),\n",
-    "    !pip install iopath\n",
+    "            f\"_pyt{pyt_version_str}\"\n",
-    "    if sys.platform.startswith(\"linux\"):\n",
+    "        ])\n",
-    "        print(\"Trying to install wheel for PyTorch3D\")\n",
+    "        !pip install fvcore iopath\n",
     "        !pip install --no-index --no-cache-dir pytorch3d -f https://dl.fbaipublicfiles.com/pytorch3d/packaging/wheels/{version_str}/download.html\n",
-    "        pip_list = !pip freeze\n",
+    "    else:\n",
-    "        need_pytorch3d = not any(i.startswith(\"pytorch3d==\") for  i in pip_list)\n",
+    "        # We try to install PyTorch3D from source.\n",
-    "    if need_pytorch3d:\n",
+    "        !curl -LO https://github.com/NVIDIA/cub/archive/1.10.0.tar.gz\n",
-    "        print(f\"failed to find/install wheel for {version_str}\")\n",
+    "        !tar xzf 1.10.0.tar.gz\n",
-    "if need_pytorch3d:\n",
+    "        os.environ[\"CUB_HOME\"] = os.getcwd() + \"/cub-1.10.0\"\n",
-    "    print(\"Installing PyTorch3D from source\")\n",
+    "        !pip install 'git+https://github.com/facebookresearch/pytorch3d.git@stable'"
-    "    !pip install ninja\n",
-    "    !pip install 'git+https://github.com/facebookresearch/pytorch3d.git@stable'"
    ]
   },
   {

docs/tutorials/render_densepose.ipynb

@@ -51,31 +51,28 @@
     "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",
-    "    pyt_version_str=torch.__version__.split(\"+\")[0].replace(\".\", \"\")\n",
+    "    if torch.__version__.startswith(\"1.13.\") and sys.platform.startswith(\"linux\"):\n",
-    "    version_str=\"\".join([\n",
+    "        # We try to install PyTorch3D via a released wheel.\n",
-    "        f\"py3{sys.version_info.minor}_cu\",\n",
+    "        pyt_version_str=torch.__version__.split(\"+\")[0].replace(\".\", \"\")\n",
-    "        torch.version.cuda.replace(\".\",\"\"),\n",
+    "        version_str=\"\".join([\n",
-    "        f\"_pyt{pyt_version_str}\"\n",
+    "            f\"py3{sys.version_info.minor}_cu\",\n",
-    "    ])\n",
+    "            torch.version.cuda.replace(\".\",\"\"),\n",
-    "    !pip install iopath\n",
+    "            f\"_pyt{pyt_version_str}\"\n",
-    "    if sys.platform.startswith(\"linux\"):\n",
+    "        ])\n",
-    "        print(\"Trying to install wheel for PyTorch3D\")\n",
+    "        !pip install fvcore iopath\n",
     "        !pip install --no-index --no-cache-dir pytorch3d -f https://dl.fbaipublicfiles.com/pytorch3d/packaging/wheels/{version_str}/download.html\n",
-    "        pip_list = !pip freeze\n",
+    "    else:\n",
-    "        need_pytorch3d = not any(i.startswith(\"pytorch3d==\") for  i in pip_list)\n",
+    "        # We try to install PyTorch3D from source.\n",
-    "    if need_pytorch3d:\n",
+    "        !curl -LO https://github.com/NVIDIA/cub/archive/1.10.0.tar.gz\n",
-    "        print(f\"failed to find/install wheel for {version_str}\")\n",
+    "        !tar xzf 1.10.0.tar.gz\n",
-    "if need_pytorch3d:\n",
+    "        os.environ[\"CUB_HOME\"] = os.getcwd() + \"/cub-1.10.0\"\n",
-    "    print(\"Installing PyTorch3D from source\")\n",
+    "        !pip install 'git+https://github.com/facebookresearch/pytorch3d.git@stable'"
-    "    !pip install ninja\n",
-    "    !pip install 'git+https://github.com/facebookresearch/pytorch3d.git@stable'"
    ]
   },
   {

docs/tutorials/render_textured_meshes.ipynb

@@ -67,31 +67,28 @@
     "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",
-    "    pyt_version_str=torch.__version__.split(\"+\")[0].replace(\".\", \"\")\n",
+    "    if torch.__version__.startswith(\"1.13.\") and sys.platform.startswith(\"linux\"):\n",
-    "    version_str=\"\".join([\n",
+    "        # We try to install PyTorch3D via a released wheel.\n",
-    "        f\"py3{sys.version_info.minor}_cu\",\n",
+    "        pyt_version_str=torch.__version__.split(\"+\")[0].replace(\".\", \"\")\n",
-    "        torch.version.cuda.replace(\".\",\"\"),\n",
+    "        version_str=\"\".join([\n",
-    "        f\"_pyt{pyt_version_str}\"\n",
+    "            f\"py3{sys.version_info.minor}_cu\",\n",
-    "    ])\n",
+    "            torch.version.cuda.replace(\".\",\"\"),\n",
-    "    !pip install iopath\n",
+    "            f\"_pyt{pyt_version_str}\"\n",
-    "    if sys.platform.startswith(\"linux\"):\n",
+    "        ])\n",
-    "        print(\"Trying to install wheel for PyTorch3D\")\n",
+    "        !pip install fvcore iopath\n",
     "        !pip install --no-index --no-cache-dir pytorch3d -f https://dl.fbaipublicfiles.com/pytorch3d/packaging/wheels/{version_str}/download.html\n",
-    "        pip_list = !pip freeze\n",
+    "    else:\n",
-    "        need_pytorch3d = not any(i.startswith(\"pytorch3d==\") for  i in pip_list)\n",
+    "        # We try to install PyTorch3D from source.\n",
-    "    if need_pytorch3d:\n",
+    "        !curl -LO https://github.com/NVIDIA/cub/archive/1.10.0.tar.gz\n",
-    "        print(f\"failed to find/install wheel for {version_str}\")\n",
+    "        !tar xzf 1.10.0.tar.gz\n",
-    "if need_pytorch3d:\n",
+    "        os.environ[\"CUB_HOME\"] = os.getcwd() + \"/cub-1.10.0\"\n",
-    "    print(\"Installing PyTorch3D from source\")\n",
+    "        !pip install 'git+https://github.com/facebookresearch/pytorch3d.git@stable'"
-    "    !pip install ninja\n",
-    "    !pip install 'git+https://github.com/facebookresearch/pytorch3d.git@stable'"
    ]
   },
   {

docs/tutorials/utils/camera_visualization.py

@@ -33,7 +33,7 @@ def plot_camera_scene(cameras, cameras_gt, status: str):
     a string passed inside the `status` argument.
     """
     fig = plt.figure()
-    ax = fig.add_subplot(projection="3d")
+    ax = fig.gca(projection="3d")
     ax.clear()
     ax.set_title(status)
     handle_cam = plot_cameras(ax, cameras, color="#FF7D1E")

packaging/build_conda.py

@@ -4,11 +4,10 @@
 # This source code is licensed under the BSD-style license found in the
 # LICENSE file in the root directory of this source tree.
 
-import argparse
 import os.path
 import runpy
 import subprocess
-from typing import List, Tuple
+from typing import List
 
 # required env vars:
 # CU_VERSION: E.g. cu112
@@ -24,7 +23,7 @@ pytorch_major_minor = tuple(int(i) for i in PYTORCH_VERSION.split(".")[:2])
 source_root_dir = os.environ["PWD"]
 
 
-def version_constraint(version) -> str:
+def version_constraint(version):
     """
     Given version "11.3" returns " >=11.3,<11.4"
     """
@@ -33,7 +32,7 @@ def version_constraint(version) -> str:
     return f" >={version},<{upper}"
 
 
-def get_cuda_major_minor() -> Tuple[str, str]:
+def get_cuda_major_minor():
     if CU_VERSION == "cpu":
         raise ValueError("fn only for cuda builds")
     if len(CU_VERSION) != 5 or CU_VERSION[:2] != "cu":
@@ -43,13 +42,15 @@ def get_cuda_major_minor() -> Tuple[str, str]:
     return major, minor
 
 
-def setup_cuda(use_conda_cuda: bool) -> List[str]:
+def setup_cuda():
     if CU_VERSION == "cpu":
-        return []
+        return
     major, minor = get_cuda_major_minor()
+    os.environ["CUDA_HOME"] = f"/usr/local/cuda-{major}.{minor}/"
     os.environ["FORCE_CUDA"] = "1"
 
     basic_nvcc_flags = (
+        "-gencode=arch=compute_35,code=sm_35 "
         "-gencode=arch=compute_50,code=sm_50 "
         "-gencode=arch=compute_60,code=sm_60 "
         "-gencode=arch=compute_70,code=sm_70 "
@@ -57,44 +58,23 @@ def setup_cuda(use_conda_cuda: bool) -> List[str]:
         "-gencode=arch=compute_50,code=compute_50"
     )
     if CU_VERSION == "cu102":
-        nvcc_flags = "-gencode=arch=compute_35,code=sm_35 " + basic_nvcc_flags
+        nvcc_flags = basic_nvcc_flags
-    elif CU_VERSION < ("cu118"):
+    elif CU_VERSION == "cu110":
-        nvcc_flags = (
+        nvcc_flags = "-gencode=arch=compute_80,code=sm_80 " + basic_nvcc_flags
-            "-gencode=arch=compute_35,code=sm_35 "
-            + "-gencode=arch=compute_80,code=sm_80 "
-            + "-gencode=arch=compute_86,code=sm_86 "
-            + basic_nvcc_flags
-        )
     else:
         nvcc_flags = (
             "-gencode=arch=compute_80,code=sm_80 "
             + "-gencode=arch=compute_86,code=sm_86 "
-            + "-gencode=arch=compute_90,code=sm_90 "
             + basic_nvcc_flags
         )
 
     if os.environ.get("JUST_TESTRUN", "0") != "1":
         os.environ["NVCC_FLAGS"] = nvcc_flags
-    if use_conda_cuda:
-        os.environ["CONDA_CUDA_TOOLKIT_BUILD_CONSTRAINT1"] = "- cuda-toolkit"
-        os.environ["CONDA_CUDA_TOOLKIT_BUILD_CONSTRAINT2"] = (
-            f"- cuda-version={major}.{minor}"
-        )
-        return ["-c", f"nvidia/label/cuda-{major}.{minor}.0"]
-    else:
-        os.environ["CUDA_HOME"] = f"/usr/local/cuda-{major}.{minor}/"
-        return []
 
 
 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(".", "")
 
@@ -104,7 +84,7 @@ def setup_conda_pytorch_constraint() -> List[str]:
         return ["-c", "pytorch", "-c", "nvidia"]
 
 
-def setup_conda_cudatoolkit_constraint() -> None:
+def setup_conda_cudatoolkit_constraint():
     if CU_VERSION == "cpu":
         os.environ["CONDA_CPUONLY_FEATURE"] = "- cpuonly"
         os.environ["CONDA_CUDATOOLKIT_CONSTRAINT"] = ""
@@ -125,14 +105,14 @@ def setup_conda_cudatoolkit_constraint() -> None:
     os.environ["CONDA_CUDATOOLKIT_CONSTRAINT"] = toolkit
 
 
-def do_build(start_args: List[str]) -> None:
+def do_build(start_args: List[str]):
     args = start_args.copy()
 
     test_flag = os.environ.get("TEST_FLAG")
     if test_flag is not None:
         args.append(test_flag)
 
-    args.extend(["-c", "bottler", "-c", "iopath", "-c", "conda-forge"])
+    args.extend(["-c", "bottler", "-c", "fvcore", "-c", "iopath", "-c", "conda-forge"])
     args.append("--no-anaconda-upload")
     args.extend(["--python", os.environ["PYTHON_VERSION"]])
     args.append("packaging/pytorch3d")
@@ -141,16 +121,8 @@ def do_build(start_args: List[str]) -> None:
 
 
 if __name__ == "__main__":
-    parser = argparse.ArgumentParser(description="Build the conda package.")
-    parser.add_argument(
-        "--use-conda-cuda",
-        action="store_true",
-        help="get cuda from conda ignoring local cuda",
-    )
-    our_args = parser.parse_args()
-
     args = ["conda", "build"]
-    args += setup_cuda(use_conda_cuda=our_args.use_conda_cuda)
+    setup_cuda()
 
     init_path = source_root_dir + "/pytorch3d/__init__.py"
     build_version = runpy.run_path(init_path)["__version__"]

packaging/linux_wheels/README.md

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

packaging/linux_wheels/go.sh

@@ -5,13 +5,7 @@
 # This source code is licensed under the BSD-style license found in the
 # LICENSE file in the root directory of this source tree.
 
-# Some directory to persist downloaded conda packages
+sudo docker run --rm  -v "$PWD/../../:/inside" pytorch/conda-cuda bash inside/packaging/linux_wheels/inside.sh
-conda_cache=/raid/$USER/building_conda_cache
+sudo docker run --rm  -v "$PWD/../../:/inside" -e SELECTED_CUDA=cu113 pytorch/conda-builder:cuda113 bash inside/packaging/linux_wheels/inside.sh
-
+sudo docker run --rm  -v "$PWD/../../:/inside" -e SELECTED_CUDA=cu115 pytorch/conda-builder:cuda115 bash inside/packaging/linux_wheels/inside.sh
-mkdir -p "$conda_cache"
+sudo docker run --rm  -v "$PWD/../../:/inside" -e SELECTED_CUDA=cu116 pytorch/conda-builder:cuda116 bash inside/packaging/linux_wheels/inside.sh
-
-sudo docker run --rm -v "$conda_cache:/conda_cache" -v "$PWD/../../:/inside" -e SELECTED_CUDA=cu113 pytorch/conda-builder:cuda113 bash inside/packaging/linux_wheels/inside.sh
-sudo docker run --rm -v "$conda_cache:/conda_cache" -v "$PWD/../../:/inside" -e SELECTED_CUDA=cu115 pytorch/conda-builder:cuda115 bash inside/packaging/linux_wheels/inside.sh
-sudo docker run --rm -v "$conda_cache:/conda_cache" -v "$PWD/../../:/inside" -e SELECTED_CUDA=cu116 pytorch/conda-builder:cuda116 bash inside/packaging/linux_wheels/inside.sh
-sudo docker run --rm -v "$conda_cache:/conda_cache" -v "$PWD/../../:/inside" -e SELECTED_CUDA=cu117 pytorch/conda-builder:cuda117 bash inside/packaging/linux_wheels/inside.sh
-sudo docker run --rm -v "$conda_cache:/conda_cache" -v "$PWD/../../:/inside" -e SELECTED_CUDA=cu118 pytorch/conda-builder:cuda118 bash inside/packaging/linux_wheels/inside.sh

packaging/linux_wheels/inside.sh

@@ -16,32 +16,23 @@ VERSION=$(python -c "exec(open('pytorch3d/__init__.py').read()); print(__version
 
 export BUILD_VERSION=$VERSION
 export FORCE_CUDA=1
-export MAX_JOBS=8
-export CONDA_PKGS_DIRS=/conda_cache
 
-if false
+wget --no-verbose https://github.com/NVIDIA/cub/archive/1.10.0.tar.gz
-then
+tar xzf 1.10.0.tar.gz
-    # We used to have to do this for old versions of CUDA
+CUB_HOME=$(realpath ./cub-1.10.0)
-    wget --no-verbose https://github.com/NVIDIA/cub/archive/1.10.0.tar.gz
+export CUB_HOME
-    tar xzf 1.10.0.tar.gz
+echo "CUB_HOME is now $CUB_HOME"
-    CUB_HOME=$(realpath ./cub-1.10.0)
-    export CUB_HOME
-    echo "CUB_HOME is now $CUB_HOME"
-fi
 
 # As a rule, we want to build for any combination of dependencies which is supported by
 # PyTorch3D and not older than the current Google Colab set up.
 
-PYTHON_VERSIONS="3.8 3.9 3.10"
+PYTHON_VERSIONS="3.7 3.8 3.9 3.10"
 # the keys are pytorch versions
 declare -A CONDA_CUDA_VERSIONS=(
-#    ["1.11.0"]="cu113"
+    ["1.10.1"]="cu111 cu113"
-#    ["1.12.0"]="cu113"
+    ["1.10.2"]="cu111 cu113"
-#    ["1.12.1"]="cu113"
+    ["1.10.0"]="cu111 cu113"
-#    ["1.13.0"]="cu116"
+    ["1.11.0"]="cu111 cu113 cu115"
-#    ["1.13.1"]="cu116 cu117"
-#    ["2.0.0"]="cu117 cu118"
-    ["2.0.1"]="cu117 cu118"
 )
 
 
@@ -50,43 +41,39 @@ for python_version in $PYTHON_VERSIONS
 do
     for pytorch_version in "${!CONDA_CUDA_VERSIONS[@]}"
     do
+        if [[ "3.7 3.8" != *$python_version* ]] && [[ "1.7.0" == *$pytorch_version* ]]
+        then
+            #python 3.9 and later not supported by pytorch 1.7.0 and before
+            continue
+        fi
         if [[ "3.7 3.8 3.9" != *$python_version* ]] && [[ "1.7.0 1.7.1 1.8.0 1.8.1 1.9.0 1.9.1 1.10.0 1.10.1 1.10.2" == *$pytorch_version* ]]
         then
             #python 3.10 and later not supported by pytorch 1.10.2 and before
             continue
         fi
 
-        extra_channel="-c nvidia"
+        extra_channel="-c conda-forge"
-        cudatools="pytorch-cuda"
         if [[ "1.11.0" == "$pytorch_version" ]]
         then
             extra_channel=""
-            cudatools="cudatoolkit"
-        fi
-        if [[ "1.12.0" == "$pytorch_version" ]] || [[ "1.12.1" == "$pytorch_version" ]]
-        then
-            extra_channel="-c conda-forge"
-            cudatools="cudatoolkit"
         fi
 
         for cu_version in ${CONDA_CUDA_VERSIONS[$pytorch_version]}
         do
+            if [[ "cu113 cu115 cu116" == *$cu_version* ]]
+            #       ^^^ CUDA versions listed here have to be built
+            # in their own containers.
+            then
             if [[ $SELECTED_CUDA != "$cu_version" ]]
+                then
+                    continue
+                fi
+            elif [[ $SELECTED_CUDA != "" ]]
             then
                 continue
             fi
 
             case "$cu_version" in
-                cu118)
-                    export CUDA_HOME=/usr/local/cuda-11.8/
-                    export CUDA_TAG=11.8
-                    export NVCC_FLAGS="-gencode=arch=compute_35,code=sm_35 -gencode=arch=compute_50,code=sm_50 -gencode=arch=compute_60,code=sm_60 -gencode=arch=compute_70,code=sm_70 -gencode=arch=compute_75,code=sm_75 -gencode=arch=compute_80,code=sm_80 -gencode=arch=compute_86,code=sm_86 -gencode=arch=compute_50,code=compute_50"
-                ;;
-                cu117)
-                    export CUDA_HOME=/usr/local/cuda-11.7/
-                    export CUDA_TAG=11.7
-                    export NVCC_FLAGS="-gencode=arch=compute_35,code=sm_35 -gencode=arch=compute_50,code=sm_50 -gencode=arch=compute_60,code=sm_60 -gencode=arch=compute_70,code=sm_70 -gencode=arch=compute_75,code=sm_75 -gencode=arch=compute_80,code=sm_80 -gencode=arch=compute_86,code=sm_86 -gencode=arch=compute_50,code=compute_50"
-                ;;
                 cu116)
                     export CUDA_HOME=/usr/local/cuda-11.6/
                     export CUDA_TAG=11.6
@@ -143,8 +130,8 @@ do
             conda create -y -n "$tag" "python=$python_version"
             conda activate "$tag"
             # shellcheck disable=SC2086
-            conda install -y -c pytorch $extra_channel "pytorch=$pytorch_version" "$cudatools=$CUDA_TAG"
+            conda install -y -c pytorch $extra_channel "pytorch=$pytorch_version" "cudatoolkit=$CUDA_TAG" torchvision
-            pip install iopath
+            pip install fvcore iopath
             echo "python version" "$python_version" "pytorch version" "$pytorch_version" "cuda version" "$cu_version" "tag" "$tag"
 
             rm -rf dist

packaging/pytorch3d/meta.yaml

@@ -8,16 +8,12 @@ source:
 requirements:
   build:
     - {{ compiler('c') }} # [win]
-    {{ environ.get('CONDA_CUDA_TOOLKIT_BUILD_CONSTRAINT1', '') }}
-    {{ environ.get('CONDA_CUDA_TOOLKIT_BUILD_CONSTRAINT2', '') }}
     {{ environ.get('CONDA_CUB_CONSTRAINT') }}
 
   host:
     - python
-    - mkl =2023  # [x86_64]
+    - 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') }}
 
@@ -25,7 +21,7 @@ requirements:
     - python
     - numpy >=1.11
     - torchvision >=0.5
-    - mkl =2023  # [x86_64]
+    - fvcore
     - iopath
     {{ environ.get('CONDA_PYTORCH_CONSTRAINT') }}
     {{ environ.get('CONDA_CUDATOOLKIT_CONSTRAINT') }}
@@ -51,11 +47,8 @@ test:
     - imageio
     - hydra-core
     - accelerate
-    - matplotlib
-    - tabulate
-    - pandas
-    - sqlalchemy
   commands:
+    #pytest .
     python -m unittest discover -v -s tests -t .
 
 

projects/implicitron_trainer/README.md

@@ -212,7 +212,9 @@ from pytorch3d.implicitron.tools.config import registry
 class XRayRenderer(BaseRenderer, torch.nn.Module):
     n_pts_per_ray: int = 64
 
+    # if there are other base classes, make sure to call `super().__init__()` explicitly
     def __post_init__(self):
+        super().__init__()
         # custom initialization
 
     def forward(
@@ -248,7 +250,7 @@ The main object for this trainer loop is `Experiment`. It has four top-level rep
 * `data_source`: This is a `DataSourceBase` which defaults to `ImplicitronDataSource`.
 It constructs the data sets and dataloaders.
 * `model_factory`: This is a `ModelFactoryBase` which defaults to `ImplicitronModelFactory`.
-It constructs the model, which is usually an instance of `OverfitModel` (for NeRF-style training with overfitting to one scene) or `GenericModel` (that is able to generalize to multiple scenes by NeRFormer-style conditioning on other scene views), and can load its weights from a checkpoint.
+It constructs the model, which is usually an instance of implicitron's main `GenericModel` class, and can load its weights from a checkpoint.
 * `optimizer_factory`: This is an `OptimizerFactoryBase` which defaults to `ImplicitronOptimizerFactory`.
 It constructs the optimizer and can load its weights from a checkpoint.
 * `training_loop`: This is a `TrainingLoopBase` which defaults to `ImplicitronTrainingLoop` and defines the main training loop.
@@ -292,43 +294,6 @@ model_GenericModel_args: GenericModel
         ╘== ReductionFeatureAggregator
 ```
 
-Here is the class structure of OverfitModel:
-
-```
-model_OverfitModel_args: OverfitModel
-└-- raysampler_*_args: RaySampler
-    ╘== AdaptiveRaysampler
-    ╘== NearFarRaysampler
-└-- renderer_*_args: BaseRenderer
-    ╘== MultiPassEmissionAbsorptionRenderer
-    ╘== LSTMRenderer
-    ╘== SignedDistanceFunctionRenderer
-        └-- ray_tracer_args: RayTracing
-        └-- ray_normal_coloring_network_args: RayNormalColoringNetwork
-└-- implicit_function_*_args: ImplicitFunctionBase
-    ╘== NeuralRadianceFieldImplicitFunction
-    ╘== SRNImplicitFunction
-        └-- raymarch_function_args: SRNRaymarchFunction
-        └-- pixel_generator_args: SRNPixelGenerator
-    ╘== SRNHyperNetImplicitFunction
-        └-- hypernet_args: SRNRaymarchHyperNet
-        └-- pixel_generator_args: SRNPixelGenerator
-    ╘== IdrFeatureField
-└-- coarse_implicit_function_*_args: ImplicitFunctionBase
-    ╘== NeuralRadianceFieldImplicitFunction
-    ╘== SRNImplicitFunction
-        └-- raymarch_function_args: SRNRaymarchFunction
-        └-- pixel_generator_args: SRNPixelGenerator
-    ╘== SRNHyperNetImplicitFunction
-        └-- hypernet_args: SRNRaymarchHyperNet
-        └-- pixel_generator_args: SRNPixelGenerator
-    ╘== IdrFeatureField
-```
-
-OverfitModel has been introduced to create a simple class to disantagle Nerfs which the overfit pattern
-from the GenericModel.
-
-
 Please look at the annotations of the respective classes or functions for the lists of hyperparameters.
 `tests/experiment.yaml` shows every possible option if you have no user-defined classes.
 

projects/implicitron_trainer/__init__.py

@@ -3,5 +3,3 @@
 #
 # 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

projects/implicitron_trainer/configs/overfit_base.yaml

@@ -1,79 +0,0 @@
-defaults:
-- default_config
-- _self_
-exp_dir: ./data/exps/overfit_base/
-training_loop_ImplicitronTrainingLoop_args:
-  visdom_port: 8097
-  visualize_interval: 0
-  max_epochs: 1000
-data_source_ImplicitronDataSource_args:
-  data_loader_map_provider_class_type: SequenceDataLoaderMapProvider
-  dataset_map_provider_class_type: JsonIndexDatasetMapProvider
-  data_loader_map_provider_SequenceDataLoaderMapProvider_args:
-    dataset_length_train: 1000
-    dataset_length_val: 1
-    num_workers: 8
-  dataset_map_provider_JsonIndexDatasetMapProvider_args:
-    dataset_root: ${oc.env:CO3D_DATASET_ROOT}
-    n_frames_per_sequence: -1
-    test_on_train: true
-    test_restrict_sequence_id: 0
-    dataset_JsonIndexDataset_args:
-      load_point_clouds: false
-      mask_depths: false
-      mask_images: false
-model_factory_ImplicitronModelFactory_args:
-  model_class_type: "OverfitModel"
-  model_OverfitModel_args:
-    loss_weights:
-      loss_mask_bce: 1.0
-      loss_prev_stage_mask_bce: 1.0
-      loss_autodecoder_norm: 0.01
-      loss_rgb_mse: 1.0
-      loss_prev_stage_rgb_mse: 1.0
-    output_rasterized_mc: false
-    chunk_size_grid: 102400
-    render_image_height: 400
-    render_image_width: 400
-    share_implicit_function_across_passes: false
-    implicit_function_class_type: "NeuralRadianceFieldImplicitFunction"
-    implicit_function_NeuralRadianceFieldImplicitFunction_args:
-      n_harmonic_functions_xyz: 10
-      n_harmonic_functions_dir: 4
-      n_hidden_neurons_xyz: 256
-      n_hidden_neurons_dir: 128
-      n_layers_xyz: 8
-      append_xyz:
-      - 5
-    coarse_implicit_function_class_type: "NeuralRadianceFieldImplicitFunction"
-    coarse_implicit_function_NeuralRadianceFieldImplicitFunction_args:
-      n_harmonic_functions_xyz: 10
-      n_harmonic_functions_dir: 4
-      n_hidden_neurons_xyz: 256
-      n_hidden_neurons_dir: 128
-      n_layers_xyz: 8
-      append_xyz:
-      - 5
-    raysampler_AdaptiveRaySampler_args:
-      n_rays_per_image_sampled_from_mask: 1024
-      scene_extent: 8.0
-      n_pts_per_ray_training: 64
-      n_pts_per_ray_evaluation: 64
-      stratified_point_sampling_training: true
-      stratified_point_sampling_evaluation: false
-    renderer_MultiPassEmissionAbsorptionRenderer_args:
-      n_pts_per_ray_fine_training: 64
-      n_pts_per_ray_fine_evaluation: 64
-      append_coarse_samples_to_fine: true
-      density_noise_std_train: 1.0
-optimizer_factory_ImplicitronOptimizerFactory_args:
-  breed: Adam
-  weight_decay: 0.0
-  lr_policy: MultiStepLR
-  multistep_lr_milestones: []
-  lr: 0.0005
-  gamma: 0.1
-  momentum: 0.9
-  betas:
-  - 0.9
-  - 0.999

projects/implicitron_trainer/configs/overfit_singleseq_base.yaml

@@ -1,42 +0,0 @@
-defaults:
-- overfit_base
-- _self_
-data_source_ImplicitronDataSource_args:
-  data_loader_map_provider_SequenceDataLoaderMapProvider_args:
-    batch_size: 1
-    dataset_length_train: 1000
-    dataset_length_val: 1
-    num_workers: 8
-  dataset_map_provider_JsonIndexDatasetMapProvider_args:
-    assert_single_seq: true
-    n_frames_per_sequence: -1
-    test_restrict_sequence_id: 0
-    test_on_train: false
-model_factory_ImplicitronModelFactory_args:
-  model_class_type: "OverfitModel"
-  model_OverfitModel_args:
-    render_image_height: 800
-    render_image_width: 800
-    log_vars:
-    - loss_rgb_psnr_fg
-    - loss_rgb_psnr
-    - loss_eikonal
-    - loss_prev_stage_rgb_psnr
-    - loss_mask_bce
-    - loss_prev_stage_mask_bce
-    - loss_rgb_mse
-    - loss_prev_stage_rgb_mse
-    - loss_depth_abs
-    - loss_depth_abs_fg
-    - loss_kl
-    - loss_mask_neg_iou
-    - objective
-    - epoch
-    - sec/it
-optimizer_factory_ImplicitronOptimizerFactory_args:
-  lr: 0.0005
-  multistep_lr_milestones:
-  - 200
-  - 300
-training_loop_ImplicitronTrainingLoop_args:
-  max_epochs: 400

projects/implicitron_trainer/configs/overfit_singleseq_nerf_blender.yaml

@@ -1,56 +0,0 @@
-defaults:
-- overfit_singleseq_base
-- _self_
-exp_dir: "./data/overfit_nerf_blender_repro/${oc.env:BLENDER_SINGLESEQ_CLASS}"
-data_source_ImplicitronDataSource_args:
-  data_loader_map_provider_SequenceDataLoaderMapProvider_args:
-    dataset_length_train: 100
-  dataset_map_provider_class_type: BlenderDatasetMapProvider
-  dataset_map_provider_BlenderDatasetMapProvider_args:
-    base_dir: ${oc.env:BLENDER_DATASET_ROOT}/${oc.env:BLENDER_SINGLESEQ_CLASS}
-    n_known_frames_for_test: null
-    object_name: ${oc.env:BLENDER_SINGLESEQ_CLASS}
-    path_manager_factory_class_type: PathManagerFactory
-    path_manager_factory_PathManagerFactory_args:
-      silence_logs: true
-
-model_factory_ImplicitronModelFactory_args:
-  model_class_type: "OverfitModel"
-  model_OverfitModel_args:
-    mask_images: false
-    raysampler_class_type: AdaptiveRaySampler
-    raysampler_AdaptiveRaySampler_args:
-      n_pts_per_ray_training: 64
-      n_pts_per_ray_evaluation: 64
-      n_rays_per_image_sampled_from_mask: 4096
-      stratified_point_sampling_training: true
-      stratified_point_sampling_evaluation: false
-      scene_extent: 2.0
-      scene_center:
-      - 0.0
-      - 0.0
-      - 0.0
-    renderer_MultiPassEmissionAbsorptionRenderer_args:
-      density_noise_std_train: 0.0
-      n_pts_per_ray_fine_training: 128
-      n_pts_per_ray_fine_evaluation: 128
-      raymarcher_EmissionAbsorptionRaymarcher_args:
-        blend_output: false
-    loss_weights:
-      loss_rgb_mse: 1.0
-      loss_prev_stage_rgb_mse: 1.0
-      loss_mask_bce: 0.0
-      loss_prev_stage_mask_bce: 0.0
-      loss_autodecoder_norm: 0.00
-
-optimizer_factory_ImplicitronOptimizerFactory_args:
-  exponential_lr_step_size: 3001
-  lr_policy: LinearExponential
-  linear_exponential_lr_milestone: 200
-
-training_loop_ImplicitronTrainingLoop_args:
-  max_epochs: 6000
-  metric_print_interval: 10
-  store_checkpoints_purge: 3
-  test_when_finished: true
-  validation_interval: 100

projects/implicitron_trainer/experiment.py

@@ -5,9 +5,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
+""""
-
-""" "
 This file is the entry point for launching experiments with Implicitron.
 
 Launch Training
@@ -44,22 +42,25 @@ The outputs of the experiment are saved and logged in multiple ways:
         config file.
 
 """
-
 import logging
 import os
 import warnings
+
 from dataclasses import field
 
 import hydra
+
 import torch
 from accelerate import Accelerator
 from omegaconf import DictConfig, OmegaConf
 from packaging import version
+
 from pytorch3d.implicitron.dataset.data_source import (
     DataSourceBase,
     ImplicitronDataSource,
 )
-from pytorch3d.implicitron.models.base_model import ImplicitronModelBase
+from pytorch3d.implicitron.models.generic_model import ImplicitronModelBase
+
 from pytorch3d.implicitron.models.renderer.multipass_ea import (
     MultiPassEmissionAbsorptionRenderer,
 )
@@ -96,7 +97,7 @@ except ModuleNotFoundError:
 no_accelerate = os.environ.get("PYTORCH3D_NO_ACCELERATE") is not None
 
 
-class Experiment(Configurable):
+class Experiment(Configurable):  # pyre-ignore: 13
     """
     This class is at the top level of Implicitron's config hierarchy. Its
     members are high-level components necessary for training an implicit rende-
@@ -117,16 +118,12 @@ class Experiment(Configurable):
             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"
 
@@ -210,6 +207,12 @@ class Experiment(Configurable):
                 val_loader,
             ) = accelerator.prepare(model, optimizer, train_loader, val_loader)
 
+        # pyre-fixme[16]: Optional type has no attribute `is_multisequence`.
+        if not self.training_loop.evaluator.is_multisequence:
+            all_train_cameras = self.data_source.all_train_cameras
+        else:
+            all_train_cameras = None
+
         # Enter the main training loop.
         self.training_loop.run(
             train_loader=train_loader,
@@ -220,6 +223,7 @@ class Experiment(Configurable):
             model=model,
             optimizer=optimizer,
             scheduler=scheduler,
+            all_train_cameras=all_train_cameras,
             accelerator=accelerator,
             device=device,
             exp_dir=self.exp_dir,

projects/implicitron_trainer/impl/__init__.py

@@ -3,5 +3,3 @@
 #
 # 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

projects/implicitron_trainer/impl/model_factory.py

@@ -4,13 +4,12 @@
 # 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
 
 import torch.optim
+
 from accelerate import Accelerator
 from pytorch3d.implicitron.models.base_model import ImplicitronModelBase
 from pytorch3d.implicitron.tools import model_io
@@ -25,6 +24,7 @@ logger = logging.getLogger(__name__)
 
 
 class ModelFactoryBase(ReplaceableBase):
+
     resume: bool = True  # resume from the last checkpoint
 
     def __call__(self, **kwargs) -> ImplicitronModelBase:
@@ -43,7 +43,7 @@ class ModelFactoryBase(ReplaceableBase):
 
 
 @registry.register
-class ImplicitronModelFactory(ModelFactoryBase):
+class ImplicitronModelFactory(ModelFactoryBase):  # pyre-ignore [13]
     """
     A factory class that initializes an implicit rendering model.
 
@@ -59,7 +59,6 @@ class ImplicitronModelFactory(ModelFactoryBase):
 
     """
 
-    # pyre-fixme[13]: Attribute `model` is never initialized.
     model: ImplicitronModelBase
     model_class_type: str = "GenericModel"
     resume: bool = True
@@ -114,9 +113,7 @@ class ImplicitronModelFactory(ModelFactoryBase):
                         "cuda:%d" % 0: "cuda:%d" % accelerator.local_process_index
                     }
                 model_state_dict = torch.load(
-                    model_io.get_model_path(model_path),
+                    model_io.get_model_path(model_path), map_location=map_location
-                    map_location=map_location,
-                    weights_only=True,
                 )
 
                 try:

projects/implicitron_trainer/impl/optimizer_factory.py

@@ -4,8 +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
-
 import inspect
 import logging
 import os
@@ -14,7 +12,9 @@ from dataclasses import field
 from typing import Any, Dict, List, Optional, Tuple
 
 import torch.optim
+
 from accelerate import Accelerator
+
 from pytorch3d.implicitron.models.base_model import ImplicitronModelBase
 from pytorch3d.implicitron.tools import model_io
 from pytorch3d.implicitron.tools.config import (
@@ -121,7 +121,7 @@ class ImplicitronOptimizerFactory(OptimizerFactoryBase):
         """
         # Get the parameters to optimize
         if hasattr(model, "_get_param_groups"):  # use the model function
-            # pyre-fixme[29]: `Union[Tensor, Module]` is not a function.
+            # pyre-ignore[29]
             p_groups = model._get_param_groups(self.lr, wd=self.weight_decay)
         else:
             p_groups = [
@@ -240,7 +240,7 @@ class ImplicitronOptimizerFactory(OptimizerFactoryBase):
                     map_location = {
                         "cuda:%d" % 0: "cuda:%d" % accelerator.local_process_index
                     }
-                optimizer_state = torch.load(opt_path, map_location, weights_only=True)
+                optimizer_state = torch.load(opt_path, map_location)
             else:
                 raise FileNotFoundError(f"Optimizer state {opt_path} does not exist.")
         return optimizer_state

projects/implicitron_trainer/impl/training_loop.py

@@ -4,8 +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
-
 import logging
 import os
 import time
@@ -23,6 +21,7 @@ from pytorch3d.implicitron.tools.config import (
     run_auto_creation,
 )
 from pytorch3d.implicitron.tools.stats import Stats
+from pytorch3d.renderer.cameras import CamerasBase
 from torch.utils.data import DataLoader, Dataset
 
 from .utils import seed_all_random_engines
@@ -30,13 +29,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"
 
@@ -112,8 +111,6 @@ class ImplicitronTrainingLoop(TrainingLoopBase):
     def __post_init__(self):
         run_auto_creation(self)
 
-    # pyre-fixme[14]: `run` overrides method defined in `TrainingLoopBase`
-    #  inconsistently.
     def run(
         self,
         *,
@@ -125,6 +122,7 @@ class ImplicitronTrainingLoop(TrainingLoopBase):
         optimizer: torch.optim.Optimizer,
         scheduler: Any,
         accelerator: Optional[Accelerator],
+        all_train_cameras: Optional[CamerasBase],
         device: torch.device,
         exp_dir: str,
         stats: Stats,
@@ -144,6 +142,7 @@ class ImplicitronTrainingLoop(TrainingLoopBase):
             if test_loader is not None:
                 # pyre-fixme[16]: `Optional` has no attribute `run`.
                 self.evaluator.run(
+                    all_train_cameras=all_train_cameras,
                     dataloader=test_loader,
                     device=device,
                     dump_to_json=True,
@@ -161,6 +160,7 @@ class ImplicitronTrainingLoop(TrainingLoopBase):
         for epoch in range(start_epoch, self.max_epochs):
             # automatic new_epoch and plotting of stats at every epoch start
             with stats:
+
                 # Make sure to re-seed random generators to ensure reproducibility
                 # even after restart.
                 seed_all_random_engines(seed + epoch)
@@ -200,6 +200,7 @@ class ImplicitronTrainingLoop(TrainingLoopBase):
                     and epoch % self.test_interval == 0
                 ):
                     self.evaluator.run(
+                        all_train_cameras=all_train_cameras,
                         device=device,
                         dataloader=test_loader,
                         model=model,
@@ -216,6 +217,7 @@ class ImplicitronTrainingLoop(TrainingLoopBase):
         if self.test_when_finished:
             if test_loader is not None:
                 self.evaluator.run(
+                    all_train_cameras=all_train_cameras,
                     device=device,
                     dump_to_json=True,
                     epoch=stats.epoch,
@@ -258,6 +260,7 @@ class ImplicitronTrainingLoop(TrainingLoopBase):
             list(log_vars),
             plot_file=os.path.join(exp_dir, "train_stats.pdf"),
             visdom_env=visdom_env_charts,
+            verbose=False,
             visdom_server=self.visdom_server,
             visdom_port=self.visdom_port,
         )
@@ -383,8 +386,7 @@ class ImplicitronTrainingLoop(TrainingLoopBase):
 
             # print textual status update
             if it % self.metric_print_interval == 0 or last_iter:
-                std_out = stats.get_status_string(stat_set=trainmode, max_it=n_batches)
+                stats.print(stat_set=trainmode, max_it=n_batches)
-                logger.info(std_out)
 
             # visualize results
             if (
@@ -394,7 +396,7 @@ class ImplicitronTrainingLoop(TrainingLoopBase):
             ):
                 prefix = f"e{stats.epoch}_it{stats.it[trainmode]}"
                 if hasattr(model, "visualize"):
-                    # pyre-fixme[29]: `Union[Tensor, Module]` is not a function.
+                    # pyre-ignore [29]
                     model.visualize(
                         viz,
                         visdom_env_imgs,

projects/implicitron_trainer/impl/utils.py

@@ -4,8 +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
-
 
 import random
 

projects/implicitron_trainer/tests/__init__.py

@@ -3,5 +3,3 @@
 #
 # 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

projects/implicitron_trainer/tests/experiment.yaml

@@ -103,10 +103,8 @@ data_source_ImplicitronDataSource_args:
     num_views: 40
     data_file: null
     azimuth_range: 180.0
-    distance: 2.7
     resolution: 128
     use_point_light: true
-    gpu_idx: 0
     path_manager_factory_class_type: PathManagerFactory
     path_manager_factory_PathManagerFactory_args:
       silence_logs: true
@@ -129,19 +127,6 @@ data_source_ImplicitronDataSource_args:
     dataset_length_train: 0
     dataset_length_val: 0
     dataset_length_test: 0
-  data_loader_map_provider_TrainEvalDataLoaderMapProvider_args:
-    batch_size: 1
-    num_workers: 0
-    dataset_length_train: 0
-    dataset_length_val: 0
-    dataset_length_test: 0
-    train_conditioning_type: SAME
-    val_conditioning_type: SAME
-    test_conditioning_type: KNOWN
-    images_per_seq_options: []
-    sample_consecutive_frames: false
-    consecutive_frames_max_gap: 0
-    consecutive_frames_max_gap_seconds: 0.1
 model_factory_ImplicitronModelFactory_args:
   resume: true
   model_class_type: GenericModel
@@ -216,7 +201,6 @@ model_factory_ImplicitronModelFactory_args:
       n_rays_total_training: null
       stratified_point_sampling_training: true
       stratified_point_sampling_evaluation: false
-      cast_ray_bundle_as_cone: false
       scene_extent: 8.0
       scene_center:
       - 0.0
@@ -229,7 +213,6 @@ model_factory_ImplicitronModelFactory_args:
       n_rays_total_training: null
       stratified_point_sampling_training: true
       stratified_point_sampling_evaluation: false
-      cast_ray_bundle_as_cone: false
       min_depth: 0.1
       max_depth: 8.0
     renderer_LSTMRenderer_args:
@@ -249,8 +232,6 @@ model_factory_ImplicitronModelFactory_args:
       append_coarse_samples_to_fine: true
       density_noise_std_train: 0.0
       return_weights: false
-      blurpool_weights: false
-      sample_pdf_eps: 1.0e-05
       raymarcher_CumsumRaymarcher_args:
         surface_thickness: 1
         bg_color:
@@ -363,7 +344,6 @@ model_factory_ImplicitronModelFactory_args:
       n_hidden_neurons_dir: 128
       input_xyz: true
       xyz_ray_dir_in_camera_coords: false
-      use_integrated_positional_encoding: false
       transformer_dim_down_factor: 2.0
       n_hidden_neurons_xyz: 80
       n_layers_xyz: 2
@@ -375,7 +355,6 @@ model_factory_ImplicitronModelFactory_args:
       n_hidden_neurons_dir: 128
       input_xyz: true
       xyz_ray_dir_in_camera_coords: false
-      use_integrated_positional_encoding: false
       transformer_dim_down_factor: 1.0
       n_hidden_neurons_xyz: 256
       n_layers_xyz: 8
@@ -580,631 +559,6 @@ model_factory_ImplicitronModelFactory_args:
           use_xavier_init: true
     view_metrics_ViewMetrics_args: {}
     regularization_metrics_RegularizationMetrics_args: {}
-  model_OverfitModel_args:
-    log_vars:
-    - loss_rgb_psnr_fg
-    - loss_rgb_psnr
-    - loss_rgb_mse
-    - loss_rgb_huber
-    - loss_depth_abs
-    - loss_depth_abs_fg
-    - loss_mask_neg_iou
-    - loss_mask_bce
-    - loss_mask_beta_prior
-    - loss_eikonal
-    - loss_density_tv
-    - loss_depth_neg_penalty
-    - loss_autodecoder_norm
-    - loss_prev_stage_rgb_mse
-    - loss_prev_stage_rgb_psnr_fg
-    - loss_prev_stage_rgb_psnr
-    - loss_prev_stage_mask_bce
-    - objective
-    - epoch
-    - sec/it
-    mask_images: true
-    mask_depths: true
-    render_image_width: 400
-    render_image_height: 400
-    mask_threshold: 0.5
-    output_rasterized_mc: false
-    bg_color:
-    - 0.0
-    - 0.0
-    - 0.0
-    chunk_size_grid: 4096
-    render_features_dimensions: 3
-    tqdm_trigger_threshold: 16
-    n_train_target_views: 1
-    sampling_mode_training: mask_sample
-    sampling_mode_evaluation: full_grid
-    global_encoder_class_type: null
-    raysampler_class_type: AdaptiveRaySampler
-    renderer_class_type: MultiPassEmissionAbsorptionRenderer
-    share_implicit_function_across_passes: false
-    implicit_function_class_type: NeuralRadianceFieldImplicitFunction
-    coarse_implicit_function_class_type: null
-    view_metrics_class_type: ViewMetrics
-    regularization_metrics_class_type: RegularizationMetrics
-    loss_weights:
-      loss_rgb_mse: 1.0
-      loss_prev_stage_rgb_mse: 1.0
-      loss_mask_bce: 0.0
-      loss_prev_stage_mask_bce: 0.0
-    global_encoder_HarmonicTimeEncoder_args:
-      n_harmonic_functions: 10
-      append_input: true
-      time_divisor: 1.0
-    global_encoder_SequenceAutodecoder_args:
-      autodecoder_args:
-        encoding_dim: 0
-        n_instances: 1
-        init_scale: 1.0
-        ignore_input: false
-    raysampler_AdaptiveRaySampler_args:
-      n_pts_per_ray_training: 64
-      n_pts_per_ray_evaluation: 64
-      n_rays_per_image_sampled_from_mask: 1024
-      n_rays_total_training: null
-      stratified_point_sampling_training: true
-      stratified_point_sampling_evaluation: false
-      cast_ray_bundle_as_cone: false
-      scene_extent: 8.0
-      scene_center:
-      - 0.0
-      - 0.0
-      - 0.0
-    raysampler_NearFarRaySampler_args:
-      n_pts_per_ray_training: 64
-      n_pts_per_ray_evaluation: 64
-      n_rays_per_image_sampled_from_mask: 1024
-      n_rays_total_training: null
-      stratified_point_sampling_training: true
-      stratified_point_sampling_evaluation: false
-      cast_ray_bundle_as_cone: false
-      min_depth: 0.1
-      max_depth: 8.0
-    renderer_LSTMRenderer_args:
-      num_raymarch_steps: 10
-      init_depth: 17.0
-      init_depth_noise_std: 0.0005
-      hidden_size: 16
-      n_feature_channels: 256
-      bg_color: null
-      verbose: false
-    renderer_MultiPassEmissionAbsorptionRenderer_args:
-      raymarcher_class_type: EmissionAbsorptionRaymarcher
-      n_pts_per_ray_fine_training: 64
-      n_pts_per_ray_fine_evaluation: 64
-      stratified_sampling_coarse_training: true
-      stratified_sampling_coarse_evaluation: false
-      append_coarse_samples_to_fine: true
-      density_noise_std_train: 0.0
-      return_weights: false
-      blurpool_weights: false
-      sample_pdf_eps: 1.0e-05
-      raymarcher_CumsumRaymarcher_args:
-        surface_thickness: 1
-        bg_color:
-        - 0.0
-        replicate_last_interval: false
-        background_opacity: 0.0
-        density_relu: true
-        blend_output: false
-      raymarcher_EmissionAbsorptionRaymarcher_args:
-        surface_thickness: 1
-        bg_color:
-        - 0.0
-        replicate_last_interval: false
-        background_opacity: 10000000000.0
-        density_relu: true
-        blend_output: false
-    renderer_SignedDistanceFunctionRenderer_args:
-      ray_normal_coloring_network_args:
-        feature_vector_size: 3
-        mode: idr
-        d_in: 9
-        d_out: 3
-        dims:
-        - 512
-        - 512
-        - 512
-        - 512
-        weight_norm: true
-        n_harmonic_functions_dir: 0
-        pooled_feature_dim: 0
-      bg_color:
-      - 0.0
-      soft_mask_alpha: 50.0
-      ray_tracer_args:
-        sdf_threshold: 5.0e-05
-        line_search_step: 0.5
-        line_step_iters: 1
-        sphere_tracing_iters: 10
-        n_steps: 100
-        n_secant_steps: 8
-    implicit_function_IdrFeatureField_args:
-      d_in: 3
-      d_out: 1
-      dims:
-      - 512
-      - 512
-      - 512
-      - 512
-      - 512
-      - 512
-      - 512
-      - 512
-      geometric_init: true
-      bias: 1.0
-      skip_in: []
-      weight_norm: true
-      n_harmonic_functions_xyz: 0
-      pooled_feature_dim: 0
-    implicit_function_NeRFormerImplicitFunction_args:
-      n_harmonic_functions_xyz: 10
-      n_harmonic_functions_dir: 4
-      n_hidden_neurons_dir: 128
-      input_xyz: true
-      xyz_ray_dir_in_camera_coords: false
-      use_integrated_positional_encoding: false
-      transformer_dim_down_factor: 2.0
-      n_hidden_neurons_xyz: 80
-      n_layers_xyz: 2
-      append_xyz:
-      - 1
-    implicit_function_NeuralRadianceFieldImplicitFunction_args:
-      n_harmonic_functions_xyz: 10
-      n_harmonic_functions_dir: 4
-      n_hidden_neurons_dir: 128
-      input_xyz: true
-      xyz_ray_dir_in_camera_coords: false
-      use_integrated_positional_encoding: false
-      transformer_dim_down_factor: 1.0
-      n_hidden_neurons_xyz: 256
-      n_layers_xyz: 8
-      append_xyz:
-      - 5
-    implicit_function_SRNHyperNetImplicitFunction_args:
-      latent_dim_hypernet: 0
-      hypernet_args:
-        n_harmonic_functions: 3
-        n_hidden_units: 256
-        n_layers: 2
-        n_hidden_units_hypernet: 256
-        n_layers_hypernet: 1
-        in_features: 3
-        out_features: 256
-        xyz_in_camera_coords: false
-      pixel_generator_args:
-        n_harmonic_functions: 4
-        n_hidden_units: 256
-        n_hidden_units_color: 128
-        n_layers: 2
-        in_features: 256
-        out_features: 3
-        ray_dir_in_camera_coords: false
-    implicit_function_SRNImplicitFunction_args:
-      raymarch_function_args:
-        n_harmonic_functions: 3
-        n_hidden_units: 256
-        n_layers: 2
-        in_features: 3
-        out_features: 256
-        xyz_in_camera_coords: false
-        raymarch_function: null
-      pixel_generator_args:
-        n_harmonic_functions: 4
-        n_hidden_units: 256
-        n_hidden_units_color: 128
-        n_layers: 2
-        in_features: 256
-        out_features: 3
-        ray_dir_in_camera_coords: false
-    implicit_function_VoxelGridImplicitFunction_args:
-      harmonic_embedder_xyz_density_args:
-        n_harmonic_functions: 6
-        omega_0: 1.0
-        logspace: true
-        append_input: true
-      harmonic_embedder_xyz_color_args:
-        n_harmonic_functions: 6
-        omega_0: 1.0
-        logspace: true
-        append_input: true
-      harmonic_embedder_dir_color_args:
-        n_harmonic_functions: 6
-        omega_0: 1.0
-        logspace: true
-        append_input: true
-      decoder_density_class_type: MLPDecoder
-      decoder_color_class_type: MLPDecoder
-      use_multiple_streams: true
-      xyz_ray_dir_in_camera_coords: false
-      scaffold_calculating_epochs: []
-      scaffold_resolution:
-      - 128
-      - 128
-      - 128
-      scaffold_empty_space_threshold: 0.001
-      scaffold_occupancy_chunk_size: -1
-      scaffold_max_pool_kernel_size: 3
-      scaffold_filter_points: true
-      volume_cropping_epochs: []
-      voxel_grid_density_args:
-        voxel_grid_class_type: FullResolutionVoxelGrid
-        extents:
-        - 2.0
-        - 2.0
-        - 2.0
-        translation:
-        - 0.0
-        - 0.0
-        - 0.0
-        init_std: 0.1
-        init_mean: 0.0
-        hold_voxel_grid_as_parameters: true
-        param_groups: {}
-        voxel_grid_CPFactorizedVoxelGrid_args:
-          align_corners: true
-          padding: zeros
-          mode: bilinear
-          n_features: 1
-          resolution_changes:
-            0:
-            - 128
-            - 128
-            - 128
-          n_components: 24
-          basis_matrix: true
-        voxel_grid_FullResolutionVoxelGrid_args:
-          align_corners: true
-          padding: zeros
-          mode: bilinear
-          n_features: 1
-          resolution_changes:
-            0:
-            - 128
-            - 128
-            - 128
-        voxel_grid_VMFactorizedVoxelGrid_args:
-          align_corners: true
-          padding: zeros
-          mode: bilinear
-          n_features: 1
-          resolution_changes:
-            0:
-            - 128
-            - 128
-            - 128
-          n_components: null
-          distribution_of_components: null
-          basis_matrix: true
-      voxel_grid_color_args:
-        voxel_grid_class_type: FullResolutionVoxelGrid
-        extents:
-        - 2.0
-        - 2.0
-        - 2.0
-        translation:
-        - 0.0
-        - 0.0
-        - 0.0
-        init_std: 0.1
-        init_mean: 0.0
-        hold_voxel_grid_as_parameters: true
-        param_groups: {}
-        voxel_grid_CPFactorizedVoxelGrid_args:
-          align_corners: true
-          padding: zeros
-          mode: bilinear
-          n_features: 1
-          resolution_changes:
-            0:
-            - 128
-            - 128
-            - 128
-          n_components: 24
-          basis_matrix: true
-        voxel_grid_FullResolutionVoxelGrid_args:
-          align_corners: true
-          padding: zeros
-          mode: bilinear
-          n_features: 1
-          resolution_changes:
-            0:
-            - 128
-            - 128
-            - 128
-        voxel_grid_VMFactorizedVoxelGrid_args:
-          align_corners: true
-          padding: zeros
-          mode: bilinear
-          n_features: 1
-          resolution_changes:
-            0:
-            - 128
-            - 128
-            - 128
-          n_components: null
-          distribution_of_components: null
-          basis_matrix: true
-      decoder_density_ElementwiseDecoder_args:
-        scale: 1.0
-        shift: 0.0
-        operation: IDENTITY
-      decoder_density_MLPDecoder_args:
-        param_groups: {}
-        network_args:
-          n_layers: 8
-          output_dim: 256
-          skip_dim: 39
-          hidden_dim: 256
-          input_skips:
-          - 5
-          skip_affine_trans: false
-          last_layer_bias_init: null
-          last_activation: RELU
-          use_xavier_init: true
-      decoder_color_ElementwiseDecoder_args:
-        scale: 1.0
-        shift: 0.0
-        operation: IDENTITY
-      decoder_color_MLPDecoder_args:
-        param_groups: {}
-        network_args:
-          n_layers: 8
-          output_dim: 256
-          skip_dim: 39
-          hidden_dim: 256
-          input_skips:
-          - 5
-          skip_affine_trans: false
-          last_layer_bias_init: null
-          last_activation: RELU
-          use_xavier_init: true
-    coarse_implicit_function_IdrFeatureField_args:
-      d_in: 3
-      d_out: 1
-      dims:
-      - 512
-      - 512
-      - 512
-      - 512
-      - 512
-      - 512
-      - 512
-      - 512
-      geometric_init: true
-      bias: 1.0
-      skip_in: []
-      weight_norm: true
-      n_harmonic_functions_xyz: 0
-      pooled_feature_dim: 0
-    coarse_implicit_function_NeRFormerImplicitFunction_args:
-      n_harmonic_functions_xyz: 10
-      n_harmonic_functions_dir: 4
-      n_hidden_neurons_dir: 128
-      input_xyz: true
-      xyz_ray_dir_in_camera_coords: false
-      use_integrated_positional_encoding: false
-      transformer_dim_down_factor: 2.0
-      n_hidden_neurons_xyz: 80
-      n_layers_xyz: 2
-      append_xyz:
-      - 1
-    coarse_implicit_function_NeuralRadianceFieldImplicitFunction_args:
-      n_harmonic_functions_xyz: 10
-      n_harmonic_functions_dir: 4
-      n_hidden_neurons_dir: 128
-      input_xyz: true
-      xyz_ray_dir_in_camera_coords: false
-      use_integrated_positional_encoding: false
-      transformer_dim_down_factor: 1.0
-      n_hidden_neurons_xyz: 256
-      n_layers_xyz: 8
-      append_xyz:
-      - 5
-    coarse_implicit_function_SRNHyperNetImplicitFunction_args:
-      latent_dim_hypernet: 0
-      hypernet_args:
-        n_harmonic_functions: 3
-        n_hidden_units: 256
-        n_layers: 2
-        n_hidden_units_hypernet: 256
-        n_layers_hypernet: 1
-        in_features: 3
-        out_features: 256
-        xyz_in_camera_coords: false
-      pixel_generator_args:
-        n_harmonic_functions: 4
-        n_hidden_units: 256
-        n_hidden_units_color: 128
-        n_layers: 2
-        in_features: 256
-        out_features: 3
-        ray_dir_in_camera_coords: false
-    coarse_implicit_function_SRNImplicitFunction_args:
-      raymarch_function_args:
-        n_harmonic_functions: 3
-        n_hidden_units: 256
-        n_layers: 2
-        in_features: 3
-        out_features: 256
-        xyz_in_camera_coords: false
-        raymarch_function: null
-      pixel_generator_args:
-        n_harmonic_functions: 4
-        n_hidden_units: 256
-        n_hidden_units_color: 128
-        n_layers: 2
-        in_features: 256
-        out_features: 3
-        ray_dir_in_camera_coords: false
-    coarse_implicit_function_VoxelGridImplicitFunction_args:
-      harmonic_embedder_xyz_density_args:
-        n_harmonic_functions: 6
-        omega_0: 1.0
-        logspace: true
-        append_input: true
-      harmonic_embedder_xyz_color_args:
-        n_harmonic_functions: 6
-        omega_0: 1.0
-        logspace: true
-        append_input: true
-      harmonic_embedder_dir_color_args:
-        n_harmonic_functions: 6
-        omega_0: 1.0
-        logspace: true
-        append_input: true
-      decoder_density_class_type: MLPDecoder
-      decoder_color_class_type: MLPDecoder
-      use_multiple_streams: true
-      xyz_ray_dir_in_camera_coords: false
-      scaffold_calculating_epochs: []
-      scaffold_resolution:
-      - 128
-      - 128
-      - 128
-      scaffold_empty_space_threshold: 0.001
-      scaffold_occupancy_chunk_size: -1
-      scaffold_max_pool_kernel_size: 3
-      scaffold_filter_points: true
-      volume_cropping_epochs: []
-      voxel_grid_density_args:
-        voxel_grid_class_type: FullResolutionVoxelGrid
-        extents:
-        - 2.0
-        - 2.0
-        - 2.0
-        translation:
-        - 0.0
-        - 0.0
-        - 0.0
-        init_std: 0.1
-        init_mean: 0.0
-        hold_voxel_grid_as_parameters: true
-        param_groups: {}
-        voxel_grid_CPFactorizedVoxelGrid_args:
-          align_corners: true
-          padding: zeros
-          mode: bilinear
-          n_features: 1
-          resolution_changes:
-            0:
-            - 128
-            - 128
-            - 128
-          n_components: 24
-          basis_matrix: true
-        voxel_grid_FullResolutionVoxelGrid_args:
-          align_corners: true
-          padding: zeros
-          mode: bilinear
-          n_features: 1
-          resolution_changes:
-            0:
-            - 128
-            - 128
-            - 128
-        voxel_grid_VMFactorizedVoxelGrid_args:
-          align_corners: true
-          padding: zeros
-          mode: bilinear
-          n_features: 1
-          resolution_changes:
-            0:
-            - 128
-            - 128
-            - 128
-          n_components: null
-          distribution_of_components: null
-          basis_matrix: true
-      voxel_grid_color_args:
-        voxel_grid_class_type: FullResolutionVoxelGrid
-        extents:
-        - 2.0
-        - 2.0
-        - 2.0
-        translation:
-        - 0.0
-        - 0.0
-        - 0.0
-        init_std: 0.1
-        init_mean: 0.0
-        hold_voxel_grid_as_parameters: true
-        param_groups: {}
-        voxel_grid_CPFactorizedVoxelGrid_args:
-          align_corners: true
-          padding: zeros
-          mode: bilinear
-          n_features: 1
-          resolution_changes:
-            0:
-            - 128
-            - 128
-            - 128
-          n_components: 24
-          basis_matrix: true
-        voxel_grid_FullResolutionVoxelGrid_args:
-          align_corners: true
-          padding: zeros
-          mode: bilinear
-          n_features: 1
-          resolution_changes:
-            0:
-            - 128
-            - 128
-            - 128
-        voxel_grid_VMFactorizedVoxelGrid_args:
-          align_corners: true
-          padding: zeros
-          mode: bilinear
-          n_features: 1
-          resolution_changes:
-            0:
-            - 128
-            - 128
-            - 128
-          n_components: null
-          distribution_of_components: null
-          basis_matrix: true
-      decoder_density_ElementwiseDecoder_args:
-        scale: 1.0
-        shift: 0.0
-        operation: IDENTITY
-      decoder_density_MLPDecoder_args:
-        param_groups: {}
-        network_args:
-          n_layers: 8
-          output_dim: 256
-          skip_dim: 39
-          hidden_dim: 256
-          input_skips:
-          - 5
-          skip_affine_trans: false
-          last_layer_bias_init: null
-          last_activation: RELU
-          use_xavier_init: true
-      decoder_color_ElementwiseDecoder_args:
-        scale: 1.0
-        shift: 0.0
-        operation: IDENTITY
-      decoder_color_MLPDecoder_args:
-        param_groups: {}
-        network_args:
-          n_layers: 8
-          output_dim: 256
-          skip_dim: 39
-          hidden_dim: 256
-          input_skips:
-          - 5
-          skip_affine_trans: false
-          last_layer_bias_init: null
-          last_activation: RELU
-          use_xavier_init: true
-    view_metrics_ViewMetrics_args: {}
-    regularization_metrics_RegularizationMetrics_args: {}
 optimizer_factory_ImplicitronOptimizerFactory_args:
   betas:
   - 0.9

projects/implicitron_trainer/tests/test_experiment.py

@@ -4,14 +4,13 @@
 # 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
 from pathlib import Path
 
 import torch
+
 from hydra import compose, initialize_config_dir
 from omegaconf import OmegaConf
 from projects.implicitron_trainer.impl.optimizer_factory import (
@@ -52,8 +51,12 @@ class TestExperiment(unittest.TestCase):
         cfg.data_source_ImplicitronDataSource_args.dataset_map_provider_class_type = (
             "JsonIndexDatasetMapProvider"
         )
-        dataset_args = cfg.data_source_ImplicitronDataSource_args.dataset_map_provider_JsonIndexDatasetMapProvider_args
+        dataset_args = (
-        dataloader_args = cfg.data_source_ImplicitronDataSource_args.data_loader_map_provider_SequenceDataLoaderMapProvider_args
+            cfg.data_source_ImplicitronDataSource_args.dataset_map_provider_JsonIndexDatasetMapProvider_args
+        )
+        dataloader_args = (
+            cfg.data_source_ImplicitronDataSource_args.data_loader_map_provider_SequenceDataLoaderMapProvider_args
+        )
         dataset_args.category = "skateboard"
         dataset_args.test_restrict_sequence_id = 0
         dataset_args.dataset_root = "manifold://co3d/tree/extracted"
@@ -89,8 +92,12 @@ class TestExperiment(unittest.TestCase):
         cfg.data_source_ImplicitronDataSource_args.dataset_map_provider_class_type = (
             "JsonIndexDatasetMapProvider"
         )
-        dataset_args = cfg.data_source_ImplicitronDataSource_args.dataset_map_provider_JsonIndexDatasetMapProvider_args
+        dataset_args = (
-        dataloader_args = cfg.data_source_ImplicitronDataSource_args.data_loader_map_provider_SequenceDataLoaderMapProvider_args
+            cfg.data_source_ImplicitronDataSource_args.dataset_map_provider_JsonIndexDatasetMapProvider_args
+        )
+        dataloader_args = (
+            cfg.data_source_ImplicitronDataSource_args.data_loader_map_provider_SequenceDataLoaderMapProvider_args
+        )
         dataset_args.category = "skateboard"
         dataset_args.test_restrict_sequence_id = 0
         dataset_args.dataset_root = "manifold://co3d/tree/extracted"
@@ -102,7 +109,9 @@ class TestExperiment(unittest.TestCase):
         cfg.training_loop_ImplicitronTrainingLoop_args.max_epochs = 2
         cfg.training_loop_ImplicitronTrainingLoop_args.store_checkpoints = False
         cfg.optimizer_factory_ImplicitronOptimizerFactory_args.lr_policy = "Exponential"
-        cfg.optimizer_factory_ImplicitronOptimizerFactory_args.exponential_lr_step_size = 2
+        cfg.optimizer_factory_ImplicitronOptimizerFactory_args.exponential_lr_step_size = (
+            2
+        )
 
         if DEBUG:
             experiment.dump_cfg(cfg)
@@ -123,13 +132,6 @@ class TestExperiment(unittest.TestCase):
         # Check that the default config values, defined by Experiment and its
         # members, is what we expect it to be.
         cfg = OmegaConf.structured(experiment.Experiment)
-        # the following removes the possible effect of env variables
-        ds_arg = cfg.data_source_ImplicitronDataSource_args
-        ds_arg.dataset_map_provider_JsonIndexDatasetMapProvider_args.dataset_root = ""
-        ds_arg.dataset_map_provider_JsonIndexDatasetMapProviderV2_args.dataset_root = ""
-        if "dataset_map_provider_SqlIndexDatasetMapProvider_args" in ds_arg:
-            del ds_arg.dataset_map_provider_SqlIndexDatasetMapProvider_args
-        cfg.training_loop_ImplicitronTrainingLoop_args.visdom_port = 8097
         yaml = OmegaConf.to_yaml(cfg, sort_keys=False)
         if DEBUG:
             (DATA_DIR / "experiment.yaml").write_text(yaml)
@@ -139,11 +141,7 @@ class TestExperiment(unittest.TestCase):
         # Check that all the pre-prepared configs are valid.
         config_files = []
 
-        for pattern in (
+        for pattern in ("repro_singleseq*.yaml", "repro_multiseq*.yaml"):
-            "repro_singleseq*.yaml",
-            "repro_multiseq*.yaml",
-            "overfit_singleseq*.yaml",
-        ):
             config_files.extend(
                 [
                     f

projects/implicitron_trainer/tests/test_optimizer_factory.py

@@ -4,8 +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
-
 import logging
 import os
 import unittest
@@ -81,9 +79,8 @@ class TestOptimizerFactory(unittest.TestCase):
 
     def test_param_overrides_self_param_group_assignment(self):
         pa, pb, pc = [torch.nn.Parameter(data=torch.tensor(i * 1.0)) for i in range(3)]
-        na, nb = (
+        na, nb = Node(params=[pa]), Node(
-            Node(params=[pa]),
+            params=[pb], param_groups={"self": "pb_self", "p1": "pb_param"}
-            Node(params=[pb], param_groups={"self": "pb_self", "p1": "pb_param"}),
         )
         root = Node(children=[na, nb], params=[pc], param_groups={"m1": "pb_member"})
         param_groups = self._get_param_groups(root)

projects/implicitron_trainer/tests/test_visualize.py

@@ -4,8 +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
-
 import os
 import unittest
 

projects/implicitron_trainer/tests/utils.py

@@ -4,8 +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
-
 import contextlib
 import logging
 import os

projects/implicitron_trainer/visualize_reconstruction.py

@@ -5,8 +5,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
-
 """
 Script to visualize a previously trained model. Example call:
 
@@ -41,7 +39,6 @@ def visualize_reconstruction(
     visdom_server: str = "http://127.0.0.1",
     visdom_port: int = 8097,
     visdom_env: Optional[str] = None,
-    **render_flyaround_kwargs,
 ) -> None:
     """
     Given an `exp_dir` containing a trained Implicitron model, generates videos consisting
@@ -63,8 +60,6 @@ def visualize_reconstruction(
         visdom_server: The address of the visdom server.
         visdom_port: The port of the visdom server.
         visdom_env: If set, defines a custom name for the visdom environment.
-        render_flyaround_kwargs: Keyword arguments passed to the invoked `render_flyaround`
-            function (see `pytorch3d.implicitron.models.visualization.render_flyaround`).
     """
 
     # In case an output directory is specified use it. If no output_directory
@@ -120,22 +115,20 @@ def visualize_reconstruction(
     # iterate over the sequences in the dataset
     for sequence_name in dataset.sequence_names():
         with torch.no_grad():
-            render_kwargs = {
+            render_flyaround(
-                "dataset": dataset,
+                dataset=dataset,
-                "sequence_name": sequence_name,
+                sequence_name=sequence_name,
-                "model": model,
+                model=model,
-                "output_video_path": os.path.join(output_directory, "video"),
+                output_video_path=os.path.join(output_directory, "video"),
-                "n_source_views": n_source_views,
+                n_source_views=n_source_views,
-                "visdom_show_preds": visdom_show_preds,
+                visdom_show_preds=visdom_show_preds,
-                "n_flyaround_poses": n_eval_cameras,
+                n_flyaround_poses=n_eval_cameras,
-                "visdom_server": visdom_server,
+                visdom_server=visdom_server,
-                "visdom_port": visdom_port,
+                visdom_port=visdom_port,
-                "visdom_environment": visdom_env,
+                visdom_environment=visdom_env,
-                "video_resize": video_size,
+                video_resize=video_size,
-                "device": device,
+                device=device,
-                **render_flyaround_kwargs,
+            )
-            }
-            render_flyaround(**render_kwargs)
 
 
 enable_get_default_args(visualize_reconstruction)

projects/nerf/nerf/dataset.py

@@ -84,9 +84,9 @@ def get_nerf_datasets(
 
     if autodownload and any(not os.path.isfile(p) for p in (cameras_path, image_path)):
         # Automatically download the data files if missing.
-        download_data([dataset_name], data_root=data_root)
+        download_data((dataset_name,), data_root=data_root)
 
-    train_data = torch.load(cameras_path, weights_only=True)
+    train_data = torch.load(cameras_path)
     n_cameras = train_data["cameras"]["R"].shape[0]
 
     _image_max_image_pixels = Image.MAX_IMAGE_PIXELS

projects/nerf/nerf/nerf_renderer.py

@@ -343,14 +343,12 @@ class RadianceFieldRenderer(torch.nn.Module):
             # For a full render pass concatenate the output chunks,
             # and reshape to image size.
             out = {
-                k: (
+                k: torch.cat(
-                    torch.cat(
+                    [ch_o[k] for ch_o in chunk_outputs],
-                        [ch_o[k] for ch_o in chunk_outputs],
+                    dim=1,
-                        dim=1,
+                ).view(-1, *self._image_size, 3)
-                    ).view(-1, *self._image_size, 3)
+                if chunk_outputs[0][k] is not None
-                    if chunk_outputs[0][k] is not None
+                else None
-                    else None
-                )
                 for k in ("rgb_fine", "rgb_coarse", "rgb_gt")
             }
         else:

projects/nerf/nerf/raysampler.py

@@ -330,9 +330,9 @@ class NeRFRaysampler(torch.nn.Module):
 
             if self.training:
                 # During training we randomly subsample rays.
-                sel_rays = torch.randperm(
+                sel_rays = torch.randperm(n_pixels, device=device)[
-                    n_pixels, device=full_ray_bundle.lengths.device
+                    : self._mc_raysampler._n_rays_per_image
-                )[: self._mc_raysampler._n_rays_per_image]
+                ]
             else:
                 # In case we test, we take only the requested chunk.
                 if chunksize is None:

projects/nerf/nerf/stats.py

@@ -194,6 +194,7 @@ class Stats:
         it = self.it[stat_set]
 
         for stat in self.log_vars:
+
             if stat not in self.stats[stat_set]:
                 self.stats[stat_set][stat] = AverageMeter()
 

projects/nerf/test_nerf.py

@@ -24,6 +24,7 @@ CONFIG_DIR = os.path.join(os.path.dirname(os.path.realpath(__file__)), "configs"
 
 @hydra.main(config_path=CONFIG_DIR, config_name="lego")
 def main(cfg: DictConfig):
+
     # Device on which to run.
     if torch.cuda.is_available():
         device = "cuda"
@@ -62,7 +63,7 @@ def main(cfg: DictConfig):
         raise ValueError(f"Model checkpoint {checkpoint_path} does not exist!")
 
     print(f"Loading checkpoint {checkpoint_path}.")
-    loaded_data = torch.load(checkpoint_path, weights_only=True)
+    loaded_data = torch.load(checkpoint_path)
     # Do not load the cached xy grid.
     # - this allows setting an arbitrary evaluation image size.
     state_dict = {

projects/nerf/tests/test_raysampler.py

@@ -42,6 +42,7 @@ class TestRaysampler(unittest.TestCase):
         cameras, rays = [], []
 
         for _ in range(batch_size):
+
             R = random_rotations(1)
             T = torch.randn(1, 3)
             focal_length = torch.rand(1, 2) + 0.5

projects/nerf/train_nerf.py

@@ -25,6 +25,7 @@ CONFIG_DIR = os.path.join(os.path.dirname(os.path.realpath(__file__)), "configs"
 
 @hydra.main(config_path=CONFIG_DIR, config_name="lego")
 def main(cfg: DictConfig):
+
     # Set the relevant seeds for reproducibility.
     np.random.seed(cfg.seed)
     torch.manual_seed(cfg.seed)
@@ -76,7 +77,7 @@ def main(cfg: DictConfig):
         # Resume training if requested.
         if cfg.resume and os.path.isfile(checkpoint_path):
             print(f"Resuming from checkpoint {checkpoint_path}.")
-            loaded_data = torch.load(checkpoint_path, weights_only=True)
+            loaded_data = torch.load(checkpoint_path)
             model.load_state_dict(loaded_data["model"])
             stats = pickle.loads(loaded_data["stats"])
             print(f"   => resuming from epoch {stats.epoch}.")
@@ -218,6 +219,7 @@ def main(cfg: DictConfig):
 
         # Validation
         if epoch % cfg.validation_epoch_interval == 0 and epoch > 0:
+
             # Sample a validation camera/image.
             val_batch = next(val_dataloader.__iter__())
             val_image, val_camera, camera_idx = val_batch[0].values()

pytorch3d/__init__.py

@@ -4,6 +4,4 @@
 # 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
+__version__ = "0.7.2"
-
-__version__ = "0.7.9"

pytorch3d/common/__init__.py

@@ -4,8 +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 .datatypes import Device, get_device, make_device
 
 

pytorch3d/common/compat.py

@@ -4,8 +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 typing import Sequence, Tuple, Union
 
 import torch
@@ -17,7 +15,7 @@ Some functions which depend on PyTorch or Python versions.
 
 
 def meshgrid_ij(
-    *A: Union[torch.Tensor, Sequence[torch.Tensor]],
+    *A: Union[torch.Tensor, Sequence[torch.Tensor]]
 ) -> Tuple[torch.Tensor, ...]:  # pragma: no cover
     """
     Like torch.meshgrid was before PyTorch 1.10.0, i.e. with indexing set to ij

pytorch3d/common/datatypes.py

@@ -4,8 +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
+import sys
-
 from typing import Optional, Union
 
 import torch
@@ -58,3 +57,19 @@ def get_device(x, device: Optional[Device] = None) -> torch.device:
 
     # Default device is cpu
     return torch.device("cpu")
+
+
+# Provide get_origin and get_args even in Python 3.7.
+
+if sys.version_info >= (3, 8, 0):
+    from typing import get_args, get_origin
+elif sys.version_info >= (3, 7, 0):
+
+    def get_origin(cls):  # pragma: no cover
+        return getattr(cls, "__origin__", None)
+
+    def get_args(cls):  # pragma: no cover
+        return getattr(cls, "__args__", None)
+
+else:
+    raise ImportError("This module requires Python 3.7+")

pytorch3d/common/linear_with_repeat.py

@@ -4,8 +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
-
 import math
 from typing import Tuple
 

pytorch3d/common/workaround/__init__.py

@@ -4,7 +4,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
-
 from .symeig3x3 import symeig3x3
 from .utils import _safe_det_3x3

pytorch3d/common/workaround/symeig3x3.py

@@ -4,8 +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
-
 import math
 from typing import Optional, Tuple
 
@@ -82,12 +80,10 @@ class _SymEig3x3(nn.Module):
         q = inputs_trace / 3.0
 
         # Calculate squared sum of elements outside the main diagonal / 2
-        p1 = (
+        # pyre-fixme[58]: `**` is not supported for operand types `Tensor` and `int`.
-            torch.square(inputs).sum(dim=(-1, -2)) - torch.square(inputs_diag).sum(-1)
+        p1 = ((inputs**2).sum(dim=(-1, -2)) - (inputs_diag**2).sum(-1)) / 2
-        ) / 2
+        # pyre-fixme[58]: `**` is not supported for operand types `Tensor` and `int`.
-        p2 = torch.square(inputs_diag - q[..., None]).sum(dim=-1) + 2.0 * p1.clamp(
+        p2 = ((inputs_diag - q[..., None]) ** 2).sum(dim=-1) + 2.0 * p1.clamp(self._eps)
-            self._eps
-        )
 
         p = torch.sqrt(p2 / 6.0)
         B = (inputs - q[..., None, None] * self._identity) / p[..., None, None]
@@ -106,9 +102,7 @@ class _SymEig3x3(nn.Module):
         # Soft dispatch between the degenerate case (diagonal A) and general.
         # diag_soft_cond -> 1.0 when p1 < 6 * eps and diag_soft_cond -> 0.0 otherwise.
         # We use 6 * eps to take into account the error accumulated during the p1 summation
-        diag_soft_cond = torch.exp(-torch.square(p1 / (6 * self._eps))).detach()[
+        diag_soft_cond = torch.exp(-((p1 / (6 * self._eps)) ** 2)).detach()[..., None]
-            ..., None
-        ]
 
         # Eigenvalues are the ordered elements of main diagonal in the degenerate case
         diag_eigenvals, _ = torch.sort(inputs_diag, dim=-1)
@@ -203,7 +197,8 @@ class _SymEig3x3(nn.Module):
             cross_products[..., :1, :]
         )
 
-        norms_sq = torch.square(cross_products).sum(dim=-1)
+        # pyre-fixme[58]: `**` is not supported for operand types `Tensor` and `int`.
+        norms_sq = (cross_products**2).sum(dim=-1)
         max_norms_index = norms_sq.argmax(dim=-1)
 
         # Pick only the cross-product with highest squared norm for each input

pytorch3d/common/workaround/utils.py

@@ -4,8 +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
-
 
 import torch
 

pytorch3d/csrc/ball_query/ball_query.cu

@@ -32,9 +32,7 @@ __global__ void BallQueryKernel(
     at::PackedTensorAccessor64<int64_t, 3, at::RestrictPtrTraits> idxs,
     at::PackedTensorAccessor64<scalar_t, 3, at::RestrictPtrTraits> dists,
     const int64_t K,
-    const float radius,
+    const float radius2) {
-    const float radius2,
-    const bool skip_points_outside_cube) {
   const int64_t N = p1.size(0);
   const int64_t chunks_per_cloud = (1 + (p1.size(1) - 1) / blockDim.x);
   const int64_t chunks_to_do = N * chunks_per_cloud;
@@ -53,19 +51,7 @@ __global__ void BallQueryKernel(
     // Iterate over points in p2 until desired count is reached or
     // all points have been considered
     for (int64_t j = 0, count = 0; j < lengths2[n] && count < K; ++j) {
-      if (skip_points_outside_cube) {
+      // Calculate the distance between the points
-        bool is_within_radius = true;
-        // Filter when any one coordinate is already outside the radius
-        for (int d = 0; is_within_radius && d < D; ++d) {
-          scalar_t abs_diff = fabs(p1[n][i][d] - p2[n][j][d]);
-          is_within_radius = (abs_diff <= radius);
-        }
-        if (!is_within_radius) {
-          continue;
-        }
-      }
-
-      // Else, calculate the distance between the points and compare
       scalar_t dist2 = 0.0;
       for (int d = 0; d < D; ++d) {
         scalar_t diff = p1[n][i][d] - p2[n][j][d];
@@ -91,8 +77,7 @@ std::tuple<at::Tensor, at::Tensor> BallQueryCuda(
     const at::Tensor& lengths1, // (N,)
     const at::Tensor& lengths2, // (N,)
     int K,
-    float radius,
+    float radius) {
-    bool skip_points_outside_cube) {
   // Check inputs are on the same device
   at::TensorArg p1_t{p1, "p1", 1}, p2_t{p2, "p2", 2},
       lengths1_t{lengths1, "lengths1", 3}, lengths2_t{lengths2, "lengths2", 4};
@@ -135,9 +120,7 @@ std::tuple<at::Tensor, at::Tensor> BallQueryCuda(
             idxs.packed_accessor64<int64_t, 3, at::RestrictPtrTraits>(),
             dists.packed_accessor64<float, 3, at::RestrictPtrTraits>(),
             K_64,
-            radius,
+            radius2);
-            radius2,
-            skip_points_outside_cube);
       }));
 
   AT_CUDA_CHECK(cudaGetLastError());

pytorch3d/csrc/ball_query/ball_query.h

@@ -25,9 +25,6 @@
 //      within the radius
 //    radius: the radius around each point within which the neighbors need to be
 //      located
-//    skip_points_outside_cube: If true, reduce multiplications of float values
-//      by not explicitly calculating distances to points that fall outside the
-//      D-cube with side length (2*radius) centered at each point in p1.
 //
 // Returns:
 //    p1_neighbor_idx: LongTensor of shape (N, P1, K), where
@@ -49,8 +46,7 @@ std::tuple<at::Tensor, at::Tensor> BallQueryCpu(
     const at::Tensor& lengths1,
     const at::Tensor& lengths2,
     const int K,
-    const float radius,
+    const float radius);
-    const bool skip_points_outside_cube);
 
 // CUDA implementation
 std::tuple<at::Tensor, at::Tensor> BallQueryCuda(
@@ -59,8 +55,7 @@ std::tuple<at::Tensor, at::Tensor> BallQueryCuda(
     const at::Tensor& lengths1,
     const at::Tensor& lengths2,
     const int K,
-    const float radius,
+    const float radius);
-    const bool skip_points_outside_cube);
 
 // Implementation which is exposed
 // Note: the backward pass reuses the KNearestNeighborBackward kernel
@@ -70,8 +65,7 @@ inline std::tuple<at::Tensor, at::Tensor> BallQuery(
     const at::Tensor& lengths1,
     const at::Tensor& lengths2,
     int K,
-    float radius,
+    float radius) {
-    bool skip_points_outside_cube) {
   if (p1.is_cuda() || p2.is_cuda()) {
 #ifdef WITH_CUDA
     CHECK_CUDA(p1);
@@ -82,20 +76,16 @@ inline std::tuple<at::Tensor, at::Tensor> BallQuery(
         lengths1.contiguous(),
         lengths2.contiguous(),
         K,
-        radius,
+        radius);
-        skip_points_outside_cube);
 #else
     AT_ERROR("Not compiled with GPU support.");
 #endif
   }
-  CHECK_CPU(p1);
-  CHECK_CPU(p2);
   return BallQueryCpu(
       p1.contiguous(),
       p2.contiguous(),
       lengths1.contiguous(),
       lengths2.contiguous(),
       K,
-      radius,
+      radius);
-      skip_points_outside_cube);
 }

pytorch3d/csrc/ball_query/ball_query_cpu.cpp

@@ -6,8 +6,8 @@
  * LICENSE file in the root directory of this source tree.
  */
 
-#include <math.h>
 #include <torch/extension.h>
+#include <queue>
 #include <tuple>
 
 std::tuple<at::Tensor, at::Tensor> BallQueryCpu(
@@ -16,8 +16,7 @@ std::tuple<at::Tensor, at::Tensor> BallQueryCpu(
     const at::Tensor& lengths1,
     const at::Tensor& lengths2,
     int K,
-    float radius,
+    float radius) {
-    bool skip_points_outside_cube) {
   const int N = p1.size(0);
   const int P1 = p1.size(1);
   const int D = p1.size(2);
@@ -39,16 +38,6 @@ std::tuple<at::Tensor, at::Tensor> BallQueryCpu(
     const int64_t length2 = lengths2_a[n];
     for (int64_t i = 0; i < length1; ++i) {
       for (int64_t j = 0, count = 0; j < length2 && count < K; ++j) {
-        if (skip_points_outside_cube) {
-          bool is_within_radius = true;
-          for (int d = 0; is_within_radius && d < D; ++d) {
-            float abs_diff = fabs(p1_a[n][i][d] - p2_a[n][j][d]);
-            is_within_radius = (abs_diff <= radius);
-          }
-          if (!is_within_radius) {
-            continue;
-          }
-        }
         float dist2 = 0;
         for (int d = 0; d < D; ++d) {
           float diff = p1_a[n][i][d] - p2_a[n][j][d];

pytorch3d/csrc/blending/sigmoid_alpha_blend.h

@@ -98,11 +98,6 @@ at::Tensor SigmoidAlphaBlendBackward(
     AT_ERROR("Not compiled with GPU support.");
 #endif
   }
-  CHECK_CPU(distances);
-  CHECK_CPU(pix_to_face);
-  CHECK_CPU(alphas);
-  CHECK_CPU(grad_alphas);
-
   return SigmoidAlphaBlendBackwardCpu(
       grad_alphas, alphas, distances, pix_to_face, sigma);
 }

pytorch3d/csrc/compositing/alpha_composite.cu

@@ -28,16 +28,17 @@ __global__ void alphaCompositeCudaForwardKernel(
     const at::PackedTensorAccessor64<float, 4, at::RestrictPtrTraits> alphas,
     const at::PackedTensorAccessor64<int64_t, 4, at::RestrictPtrTraits> points_idx) {
   // clang-format on
+  const int64_t batch_size = result.size(0);
   const int64_t C = features.size(0);
   const int64_t H = points_idx.size(2);
   const int64_t W = points_idx.size(3);
 
   // Get the batch and index
-  const auto batch = blockIdx.x;
+  const int batch = blockIdx.x;
 
   const int num_pixels = C * H * W;
-  const auto num_threads = gridDim.y * blockDim.x;
+  const int num_threads = gridDim.y * blockDim.x;
-  const auto tid = blockIdx.y * blockDim.x + threadIdx.x;
+  const int tid = blockIdx.y * blockDim.x + threadIdx.x;
 
   // Iterate over each feature in each pixel
   for (int pid = tid; pid < num_pixels; pid += num_threads) {
@@ -78,16 +79,17 @@ __global__ void alphaCompositeCudaBackwardKernel(
     const at::PackedTensorAccessor64<float, 4, at::RestrictPtrTraits> alphas,
     const at::PackedTensorAccessor64<int64_t, 4, at::RestrictPtrTraits> points_idx) {
   // clang-format on
+  const int64_t batch_size = points_idx.size(0);
   const int64_t C = features.size(0);
   const int64_t H = points_idx.size(2);
   const int64_t W = points_idx.size(3);
 
   // Get the batch and index
-  const auto batch = blockIdx.x;
+  const int batch = blockIdx.x;
 
   const int num_pixels = C * H * W;
-  const auto num_threads = gridDim.y * blockDim.x;
+  const int num_threads = gridDim.y * blockDim.x;
-  const auto tid = blockIdx.y * blockDim.x + threadIdx.x;
+  const int tid = blockIdx.y * blockDim.x + threadIdx.x;
 
   // Parallelize over each feature in each pixel in images of size H * W,
   // for each image in the batch of size batch_size

pytorch3d/csrc/compositing/alpha_composite.h

@@ -74,9 +74,6 @@ torch::Tensor alphaCompositeForward(
     AT_ERROR("Not compiled with GPU support");
 #endif
   } else {
-    CHECK_CPU(features);
-    CHECK_CPU(alphas);
-    CHECK_CPU(points_idx);
     return alphaCompositeCpuForward(features, alphas, points_idx);
   }
 }
@@ -104,11 +101,6 @@ std::tuple<torch::Tensor, torch::Tensor> alphaCompositeBackward(
     AT_ERROR("Not compiled with GPU support");
 #endif
   } else {
-    CHECK_CPU(grad_outputs);
-    CHECK_CPU(features);
-    CHECK_CPU(alphas);
-    CHECK_CPU(points_idx);
-
     return alphaCompositeCpuBackward(
         grad_outputs, features, alphas, points_idx);
   }

pytorch3d/csrc/compositing/norm_weighted_sum.cu

@@ -28,16 +28,17 @@ __global__ void weightedSumNormCudaForwardKernel(
     const at::PackedTensorAccessor64<float, 4, at::RestrictPtrTraits> alphas,
     const at::PackedTensorAccessor64<int64_t, 4, at::RestrictPtrTraits> points_idx) {
   // clang-format on
+  const int64_t batch_size = result.size(0);
   const int64_t C = features.size(0);
   const int64_t H = points_idx.size(2);
   const int64_t W = points_idx.size(3);
 
   // Get the batch and index
-  const auto batch = blockIdx.x;
+  const int batch = blockIdx.x;
 
   const int num_pixels = C * H * W;
-  const auto num_threads = gridDim.y * blockDim.x;
+  const int num_threads = gridDim.y * blockDim.x;
-  const auto tid = blockIdx.y * blockDim.x + threadIdx.x;
+  const int tid = blockIdx.y * blockDim.x + threadIdx.x;
 
   // Parallelize over each feature in each pixel in images of size H * W,
   // for each image in the batch of size batch_size
@@ -91,16 +92,17 @@ __global__ void weightedSumNormCudaBackwardKernel(
     const at::PackedTensorAccessor64<float, 4, at::RestrictPtrTraits> alphas,
     const at::PackedTensorAccessor64<int64_t, 4, at::RestrictPtrTraits> points_idx) {
   // clang-format on
+  const int64_t batch_size = points_idx.size(0);
   const int64_t C = features.size(0);
   const int64_t H = points_idx.size(2);
   const int64_t W = points_idx.size(3);
 
   // Get the batch and index
-  const auto batch = blockIdx.x;
+  const int batch = blockIdx.x;
 
   const int num_pixels = C * W * H;
-  const auto num_threads = gridDim.y * blockDim.x;
+  const int num_threads = gridDim.y * blockDim.x;
-  const auto tid = blockIdx.y * blockDim.x + threadIdx.x;
+  const int tid = blockIdx.y * blockDim.x + threadIdx.x;
 
   // Parallelize over each feature in each pixel in images of size H * W,
   // for each image in the batch of size batch_size

pytorch3d/csrc/compositing/norm_weighted_sum.h

@@ -73,10 +73,6 @@ torch::Tensor weightedSumNormForward(
     AT_ERROR("Not compiled with GPU support");
 #endif
   } else {
-    CHECK_CPU(features);
-    CHECK_CPU(alphas);
-    CHECK_CPU(points_idx);
-
     return weightedSumNormCpuForward(features, alphas, points_idx);
   }
 }
@@ -104,11 +100,6 @@ std::tuple<torch::Tensor, torch::Tensor> weightedSumNormBackward(
     AT_ERROR("Not compiled with GPU support");
 #endif
   } else {
-    CHECK_CPU(grad_outputs);
-    CHECK_CPU(features);
-    CHECK_CPU(alphas);
-    CHECK_CPU(points_idx);
-
     return weightedSumNormCpuBackward(
         grad_outputs, features, alphas, points_idx);
   }

pytorch3d/csrc/compositing/weighted_sum.cu

@@ -26,16 +26,17 @@ __global__ void weightedSumCudaForwardKernel(
     const at::PackedTensorAccessor64<float, 4, at::RestrictPtrTraits> alphas,
     const at::PackedTensorAccessor64<int64_t, 4, at::RestrictPtrTraits> points_idx) {
   // clang-format on
+  const int64_t batch_size = result.size(0);
   const int64_t C = features.size(0);
   const int64_t H = points_idx.size(2);
   const int64_t W = points_idx.size(3);
 
   // Get the batch and index
-  const auto batch = blockIdx.x;
+  const int batch = blockIdx.x;
 
   const int num_pixels = C * H * W;
-  const auto num_threads = gridDim.y * blockDim.x;
+  const int num_threads = gridDim.y * blockDim.x;
-  const auto tid = blockIdx.y * blockDim.x + threadIdx.x;
+  const int tid = blockIdx.y * blockDim.x + threadIdx.x;
 
   // Parallelize over each feature in each pixel in images of size H * W,
   // for each image in the batch of size batch_size
@@ -73,16 +74,17 @@ __global__ void weightedSumCudaBackwardKernel(
     const at::PackedTensorAccessor64<float, 4, at::RestrictPtrTraits> alphas,
     const at::PackedTensorAccessor64<int64_t, 4, at::RestrictPtrTraits> points_idx) {
   // clang-format on
+  const int64_t batch_size = points_idx.size(0);
   const int64_t C = features.size(0);
   const int64_t H = points_idx.size(2);
   const int64_t W = points_idx.size(3);
 
   // Get the batch and index
-  const auto batch = blockIdx.x;
+  const int batch = blockIdx.x;
 
   const int num_pixels = C * H * W;
-  const auto num_threads = gridDim.y * blockDim.x;
+  const int num_threads = gridDim.y * blockDim.x;
-  const auto tid = blockIdx.y * blockDim.x + threadIdx.x;
+  const int tid = blockIdx.y * blockDim.x + threadIdx.x;
 
   // Iterate over each pixel to compute the contribution to the
   // gradient for the features and weights

pytorch3d/csrc/compositing/weighted_sum.h

@@ -72,9 +72,6 @@ torch::Tensor weightedSumForward(
     AT_ERROR("Not compiled with GPU support");
 #endif
   } else {
-    CHECK_CPU(features);
-    CHECK_CPU(alphas);
-    CHECK_CPU(points_idx);
     return weightedSumCpuForward(features, alphas, points_idx);
   }
 }
@@ -101,11 +98,6 @@ std::tuple<torch::Tensor, torch::Tensor> weightedSumBackward(
     AT_ERROR("Not compiled with GPU support");
 #endif
   } else {
-    CHECK_CPU(grad_outputs);
-    CHECK_CPU(features);
-    CHECK_CPU(alphas);
-    CHECK_CPU(points_idx);
-
     return weightedSumCpuBackward(grad_outputs, features, alphas, points_idx);
   }
 }

pytorch3d/csrc/ext.cpp

@@ -8,6 +8,7 @@
 
 // clang-format off
 #include "./pulsar/global.h" // Include before <torch/extension.h>.
+#include <torch/extension.h>
 // clang-format on
 #include "./pulsar/pytorch/renderer.h"
 #include "./pulsar/pytorch/tensor_util.h"
@@ -98,23 +99,21 @@ PYBIND11_MODULE(TORCH_EXTENSION_NAME, m) {
   m.def("marching_cubes", &MarchingCubes);
 
   // Pulsar.
-  // Pulsar not enabled on AMD.
 #ifdef PULSAR_LOGGING_ENABLED
   c10::ShowLogInfoToStderr();
 #endif
   py::class_<
       pulsar::pytorch::Renderer,
       std::shared_ptr<pulsar::pytorch::Renderer>>(m, "PulsarRenderer")
-      .def(
+      .def(py::init<
-          py::init<
+           const uint&,
-              const uint&,
+           const uint&,
-              const uint&,
+           const uint&,
-              const uint&,
+           const bool&,
-              const bool&,
+           const bool&,
-              const bool&,
+           const float&,
-              const float&,
+           const uint&,
-              const uint&,
+           const uint&>())
-              const uint&>())
       .def(
           "__eq__",
           [](const pulsar::pytorch::Renderer& a,
@@ -149,10 +148,10 @@ PYBIND11_MODULE(TORCH_EXTENSION_NAME, m) {
           py::arg("gamma"),
           py::arg("max_depth"),
           py::arg("min_depth") /* = 0.f*/,
-          py::arg("bg_col") /* = std::nullopt not exposed properly in
+          py::arg(
-                               pytorch 1.1. */
+              "bg_col") /* = at::nullopt not exposed properly in pytorch 1.1. */
           ,
-          py::arg("opacity") /* = std::nullopt ... */,
+          py::arg("opacity") /* = at::nullopt ... */,
           py::arg("percent_allowed_difference") = 0.01f,
           py::arg("max_n_hits") = MAX_UINT,
           py::arg("mode") = 0)

pytorch3d/csrc/face_areas_normals/face_areas_normals.cu

@@ -266,8 +266,6 @@ at::Tensor FaceAreasNormalsBackwardCuda(
       grad_normals_t{grad_normals, "grad_normals", 4};
   at::CheckedFrom c = "FaceAreasNormalsBackwardCuda";
   at::checkAllSameGPU(c, {verts_t, faces_t, grad_areas_t, grad_normals_t});
-  // This is nondeterministic because atomicAdd
-  at::globalContext().alertNotDeterministic("FaceAreasNormalsBackwardCuda");
 
   // Set the device for the kernel launch based on the device of verts
   at::cuda::CUDAGuard device_guard(verts.device());

pytorch3d/csrc/face_areas_normals/face_areas_normals.h

@@ -60,8 +60,6 @@ std::tuple<at::Tensor, at::Tensor> FaceAreasNormalsForward(
     AT_ERROR("Not compiled with GPU support.");
 #endif
   }
-  CHECK_CPU(verts);
-  CHECK_CPU(faces);
   return FaceAreasNormalsForwardCpu(verts, faces);
 }
 
@@ -82,9 +80,5 @@ at::Tensor FaceAreasNormalsBackward(
     AT_ERROR("Not compiled with GPU support.");
 #endif
   }
-  CHECK_CPU(grad_areas);
-  CHECK_CPU(grad_normals);
-  CHECK_CPU(verts);
-  CHECK_CPU(faces);
   return FaceAreasNormalsBackwardCpu(grad_areas, grad_normals, verts, faces);
 }

pytorch3d/csrc/gather_scatter/gather_scatter.cu

@@ -20,14 +20,14 @@ __global__ void GatherScatterCudaKernel(
     const size_t V,
     const size_t D,
     const size_t E) {
-  const auto tid = threadIdx.x;
+  const int tid = threadIdx.x;
 
   // Reverse the vertex order if backward.
   const int v0_idx = backward ? 1 : 0;
   const int v1_idx = backward ? 0 : 1;
 
   // Edges are split evenly across the blocks.
-  for (auto e = blockIdx.x; e < E; e += gridDim.x) {
+  for (int e = blockIdx.x; e < E; e += gridDim.x) {
     // Get indices of vertices which form the edge.
     const int64_t v0 = edges[2 * e + v0_idx];
     const int64_t v1 = edges[2 * e + v1_idx];
@@ -35,7 +35,7 @@ __global__ void GatherScatterCudaKernel(
     // Split vertex features evenly across threads.
     // This implementation will be quite wasteful when D<128 since there will be
     // a lot of threads doing nothing.
-    for (auto d = tid; d < D; d += blockDim.x) {
+    for (int d = tid; d < D; d += blockDim.x) {
       const float val = input[v1 * D + d];
       float* address = output + v0 * D + d;
       atomicAdd(address, val);

pytorch3d/csrc/gather_scatter/gather_scatter.h

@@ -53,7 +53,5 @@ at::Tensor GatherScatter(
     AT_ERROR("Not compiled with GPU support.");
 #endif
   }
-  CHECK_CPU(input);
-  CHECK_CPU(edges);
   return GatherScatterCpu(input, edges, directed, backward);
 }

pytorch3d/csrc/interp_face_attrs/interp_face_attrs.cu

@@ -20,8 +20,8 @@ __global__ void InterpFaceAttrsForwardKernel(
     const size_t P,
     const size_t F,
     const size_t D) {
-  const auto tid = threadIdx.x + blockIdx.x * blockDim.x;
+  const int tid = threadIdx.x + blockIdx.x * blockDim.x;
-  const auto num_threads = blockDim.x * gridDim.x;
+  const int num_threads = blockDim.x * gridDim.x;
   for (int pd = tid; pd < P * D; pd += num_threads) {
     const int p = pd / D;
     const int d = pd % D;
@@ -93,8 +93,8 @@ __global__ void InterpFaceAttrsBackwardKernel(
     const size_t P,
     const size_t F,
     const size_t D) {
-  const auto tid = threadIdx.x + blockIdx.x * blockDim.x;
+  const int tid = threadIdx.x + blockIdx.x * blockDim.x;
-  const auto num_threads = blockDim.x * gridDim.x;
+  const int num_threads = blockDim.x * gridDim.x;
   for (int pd = tid; pd < P * D; pd += num_threads) {
     const int p = pd / D;
     const int d = pd % D;
@@ -130,9 +130,6 @@ std::tuple<at::Tensor, at::Tensor> InterpFaceAttrsBackwardCuda(
   at::checkAllSameType(
       c, {barycentric_coords_t, face_attrs_t, grad_pix_attrs_t});
 
-  // This is nondeterministic because atomicAdd
-  at::globalContext().alertNotDeterministic("InterpFaceAttrsBackwardCuda");
-
   // Set the device for the kernel launch based on the input
   at::cuda::CUDAGuard device_guard(pix_to_face.device());
   cudaStream_t stream = at::cuda::getCurrentCUDAStream();

pytorch3d/csrc/interp_face_attrs/interp_face_attrs.h

@@ -57,8 +57,6 @@ at::Tensor InterpFaceAttrsForward(
     AT_ERROR("Not compiled with GPU support.");
 #endif
   }
-  CHECK_CPU(face_attrs);
-  CHECK_CPU(barycentric_coords);
   return InterpFaceAttrsForwardCpu(pix_to_face, barycentric_coords, face_attrs);
 }
 
@@ -108,9 +106,6 @@ std::tuple<at::Tensor, at::Tensor> InterpFaceAttrsBackward(
     AT_ERROR("Not compiled with GPU support.");
 #endif
   }
-  CHECK_CPU(face_attrs);
-  CHECK_CPU(barycentric_coords);
-  CHECK_CPU(grad_pix_attrs);
   return InterpFaceAttrsBackwardCpu(
       pix_to_face, barycentric_coords, face_attrs, grad_pix_attrs);
 }

pytorch3d/csrc/iou_box3d/iou_box3d.cu

@@ -12,6 +12,8 @@
 #include <math.h>
 #include <stdio.h>
 #include <stdlib.h>
+#include <thrust/device_vector.h>
+#include <thrust/tuple.h>
 #include "iou_box3d/iou_utils.cuh"
 
 // Parallelize over N*M computations which can each be done

pytorch3d/csrc/iou_box3d/iou_box3d.h

@@ -44,7 +44,5 @@ inline std::tuple<at::Tensor, at::Tensor> IoUBox3D(
     AT_ERROR("Not compiled with GPU support.");
 #endif
   }
-  CHECK_CPU(boxes1);
-  CHECK_CPU(boxes2);
   return IoUBox3DCpu(boxes1.contiguous(), boxes2.contiguous());
 }

pytorch3d/csrc/iou_box3d/iou_box3d_cpu.cpp

@@ -7,7 +7,10 @@
  */
 
 #include <torch/extension.h>
+#include <torch/torch.h>
 #include <list>
+#include <numeric>
+#include <queue>
 #include <tuple>
 #include "iou_box3d/iou_utils.h"
 

pytorch3d/csrc/iou_box3d/iou_utils.cuh

@@ -8,6 +8,7 @@
 
 #include <float.h>
 #include <math.h>
+#include <thrust/device_vector.h>
 #include <cstdio>
 #include "utils/float_math.cuh"
 
@@ -461,8 +462,10 @@ __device__ inline std::tuple<float3, float3> ArgMaxVerts(
 __device__ inline bool IsCoplanarTriTri(
     const FaceVerts& tri1,
     const FaceVerts& tri2) {
+  const float3 tri1_ctr = FaceCenter({tri1.v0, tri1.v1, tri1.v2});
   const float3 tri1_n = FaceNormal({tri1.v0, tri1.v1, tri1.v2});
 
+  const float3 tri2_ctr = FaceCenter({tri2.v0, tri2.v1, tri2.v2});
   const float3 tri2_n = FaceNormal({tri2.v0, tri2.v1, tri2.v2});
 
   // Check if parallel
@@ -498,6 +501,7 @@ __device__ inline bool IsCoplanarTriPlane(
     const FaceVerts& tri,
     const FaceVerts& plane,
     const float3& normal) {
+  const float3 tri_ctr = FaceCenter({tri.v0, tri.v1, tri.v2});
   const float3 nt = FaceNormal({tri.v0, tri.v1, tri.v2});
 
   // check if parallel
@@ -725,7 +729,7 @@ __device__ inline int BoxIntersections(
       }
     }
     // Update the face_verts_out tris
-    num_tris = min(MAX_TRIS, offset);
+    num_tris = offset;
     for (int j = 0; j < num_tris; ++j) {
       face_verts_out[j] = tri_verts_updated[j];
     }

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(p1.size(2) == D, "Point sets must have the same last dimension");
+  TORCH_CHECK(p2.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());
@@ -495,7 +495,7 @@ __global__ void KNearestNeighborBackwardKernel(
     if ((p1_idx < num1) && (k < num2)) {
       const float grad_dist = grad_dists[n * P1 * K + p1_idx * K + k];
       // index of point in p2 corresponding to the k-th nearest neighbor
-      const int64_t p2_idx = idxs[n * P1 * K + p1_idx * K + k];
+      const size_t p2_idx = idxs[n * P1 * K + p1_idx * K + k];
       // If the index is the pad value of -1 then ignore it
       if (p2_idx == -1) {
         continue;
@@ -534,9 +534,6 @@ std::tuple<at::Tensor, at::Tensor> KNearestNeighborBackwardCuda(
       c, {p1_t, p2_t, lengths1_t, lengths2_t, idxs_t, grad_dists_t});
   at::checkAllSameType(c, {p1_t, p2_t, grad_dists_t});
 
-  // This is nondeterministic because atomicAdd
-  at::globalContext().alertNotDeterministic("KNearestNeighborBackwardCuda");
-
   // Set the device for the kernel launch based on the device of the input
   at::cuda::CUDAGuard device_guard(p1.device());
   cudaStream_t stream = at::cuda::getCurrentCUDAStream();

pytorch3d/csrc/knn/knn.h

@@ -74,8 +74,6 @@ std::tuple<at::Tensor, at::Tensor> KNearestNeighborIdx(
     AT_ERROR("Not compiled with GPU support.");
 #endif
   }
-  CHECK_CPU(p1);
-  CHECK_CPU(p2);
   return KNearestNeighborIdxCpu(p1, p2, lengths1, lengths2, norm, K);
 }
 
@@ -142,8 +140,6 @@ std::tuple<at::Tensor, at::Tensor> KNearestNeighborBackward(
     AT_ERROR("Not compiled with GPU support.");
 #endif
   }
-  CHECK_CPU(p1);
-  CHECK_CPU(p2);
   return KNearestNeighborBackwardCpu(
       p1, p2, lengths1, lengths2, idxs, norm, grad_dists);
 }

pytorch3d/csrc/marching_cubes/marching_cubes.cu

@@ -9,6 +9,8 @@
 #include <ATen/ATen.h>
 #include <ATen/cuda/CUDAContext.h>
 #include <c10/cuda/CUDAGuard.h>
+#include <thrust/device_vector.h>
+#include <thrust/scan.h>
 #include <cstdio>
 #include "marching_cubes/tables.h"
 
@@ -38,6 +40,20 @@ through" each cube in the grid.
 // EPS: Used to indicate if two float values are close
 __constant__ const float EPSILON = 1e-5;
 
+// Thrust wrapper for exclusive scan
+//
+// Args:
+//    output: pointer to on-device output array
+//    input: pointer to on-device input array, where scan is performed
+//    numElements: number of elements for the input array
+//
+void ThrustScanWrapper(int* output, int* input, int numElements) {
+  thrust::exclusive_scan(
+      thrust::device_ptr<int>(input),
+      thrust::device_ptr<int>(input + numElements),
+      thrust::device_ptr<int>(output));
+}
+
 // Linearly interpolate the position where an isosurface cuts an edge
 // between two vertices, based on their scalar values
 //
@@ -223,7 +239,7 @@ __global__ void CompactVoxelsKernel(
         compactedVoxelArray,
     const at::PackedTensorAccessor32<int, 1, at::RestrictPtrTraits>
         voxelOccupied,
-    const at::PackedTensorAccessor32<int64_t, 1, at::RestrictPtrTraits>
+    const at::PackedTensorAccessor32<int, 1, at::RestrictPtrTraits>
         voxelOccupiedScan,
     uint numVoxels) {
   uint id = blockIdx.x * blockDim.x + threadIdx.x;
@@ -255,8 +271,7 @@ __global__ void GenerateFacesKernel(
     at::PackedTensorAccessor<int64_t, 1, at::RestrictPtrTraits> ids,
     at::PackedTensorAccessor32<int, 1, at::RestrictPtrTraits>
         compactedVoxelArray,
-    at::PackedTensorAccessor32<int64_t, 1, at::RestrictPtrTraits>
+    at::PackedTensorAccessor32<int, 1, at::RestrictPtrTraits> numVertsScanned,
-        numVertsScanned,
     const uint activeVoxels,
     const at::PackedTensorAccessor32<float, 3, at::RestrictPtrTraits> vol,
     const at::PackedTensorAccessor32<int, 2, at::RestrictPtrTraits> faceTable,
@@ -382,44 +397,6 @@ __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
@@ -478,9 +455,6 @@ std::tuple<at::Tensor, at::Tensor, at::Tensor> MarchingCubesCuda(
     grid.x = 65535;
   }
 
-  using at::indexing::None;
-  using at::indexing::Slice;
-
   auto d_voxelVerts =
       at::zeros({numVoxels}, at::TensorOptions().dtype(at::kInt))
           .to(vol.device());
@@ -503,9 +477,18 @@ 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.
-  int64_t activeVoxels = 0;
   auto d_voxelOccupiedScan =
-      ExclusiveScanAndTotal(d_voxelOccupied, &activeVoxels);
+      at::zeros({numVoxels}, at::TensorOptions().dtype(at::kInt))
+          .to(vol.device());
+  ThrustScanWrapper(
+      d_voxelOccupiedScan.data_ptr<int>(),
+      d_voxelOccupied.data_ptr<int>(),
+      numVoxels);
+
+  // number of active voxels
+  int lastElement = d_voxelVerts[numVoxels - 1].cpu().item<int>();
+  int lastScan = d_voxelOccupiedScan[numVoxels - 1].cpu().item<int>();
+  int activeVoxels = lastElement + lastScan;
 
   const int device_id = vol.device().index();
   auto opt = at::TensorOptions().dtype(at::kInt).device(at::kCUDA, device_id);
@@ -520,21 +503,28 @@ std::tuple<at::Tensor, at::Tensor, at::Tensor> MarchingCubesCuda(
     return std::make_tuple(verts, faces, ids);
   }
 
-  // Execute "CompactVoxelsKernel" kernel to compress voxels for acceleration.
+  // Execute "CompactVoxelsKernel" kernel to compress voxels for accleration.
   // 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<int, 1, at::RestrictPtrTraits>(),
-          .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
-  int64_t totalVerts = 0;
+  auto d_voxelVertsScan = at::zeros({numVoxels}, opt);
-  auto d_voxelVertsScan = ExclusiveScanAndTotal(d_voxelVerts, &totalVerts);
+  ThrustScanWrapper(
+      d_voxelVertsScan.data_ptr<int>(),
+      d_voxelVerts.data_ptr<int>(),
+      numVoxels);
+
+  // total number of vertices
+  lastElement = d_voxelVerts[numVoxels - 1].cpu().item<int>();
+  lastScan = d_voxelVertsScan[numVoxels - 1].cpu().item<int>();
+  int totalVerts = lastElement + lastScan;
 
   // Execute "GenerateFacesKernel" kernel
   // This runs only on the occupied voxels.
@@ -554,7 +544,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<int, 1, at::RestrictPtrTraits>(),
       activeVoxels,
       vol.packed_accessor32<float, 3, at::RestrictPtrTraits>(),
       faceTable.packed_accessor32<int, 2, at::RestrictPtrTraits>(),

pytorch3d/csrc/marching_cubes/marching_cubes.h

@@ -58,6 +58,5 @@ inline std::tuple<at::Tensor, at::Tensor, at::Tensor> MarchingCubes(
     AT_ERROR("Not compiled with GPU support.");
 #endif
   }
-  CHECK_CPU(vol);
   return MarchingCubesCpu(vol.contiguous(), isolevel);
 }

pytorch3d/csrc/marching_cubes/marching_cubes_cpu.cpp

@@ -71,8 +71,8 @@ std::tuple<at::Tensor, at::Tensor, at::Tensor> MarchingCubesCpu(
           if ((j + 1) % 3 == 0 && ps[0] != ps[1] && ps[1] != ps[2] &&
               ps[2] != ps[0]) {
             for (int k = 0; k < 3; k++) {
-              int64_t v = tri.at(k);
+              int v = tri[k];
-              edge_id_to_v[v] = ps.at(k);
+              edge_id_to_v[tri.at(k)] = ps.at(k);
               if (!uniq_edge_id.count(v)) {
                 uniq_edge_id[v] = verts.size();
                 verts.push_back(edge_id_to_v[v]);

pytorch3d/csrc/packed_to_padded_tensor/packed_to_padded_tensor.h

@@ -88,8 +88,6 @@ at::Tensor PackedToPadded(
     AT_ERROR("Not compiled with GPU support.");
 #endif
   }
-  CHECK_CPU(inputs_packed);
-  CHECK_CPU(first_idxs);
   return PackedToPaddedCpu(inputs_packed, first_idxs, max_size);
 }
 
@@ -107,7 +105,5 @@ at::Tensor PaddedToPacked(
     AT_ERROR("Not compiled with GPU support.");
 #endif
   }
-  CHECK_CPU(inputs_padded);
-  CHECK_CPU(first_idxs);
   return PaddedToPackedCpu(inputs_padded, first_idxs, num_inputs);
 }