MKL version fix in CI (#1820)

Summary:
Fix for "undefined symbol: iJIT_NotifyEvent" build issue,

Pull Request resolved: https://github.com/facebookresearch/pytorch3d/pull/1820

Differential Revision: D58685326

.circleci/config.yml

@@ -162,6 +162,90 @@ workflows:
     jobs:
       # - main:
       #     context: DOCKERHUB_TOKEN
+      - binary_linux_conda:
+          conda_docker_image: pytorch/conda-builder:cuda113
+          context: DOCKERHUB_TOKEN
+          cu_version: cu113
+          name: linux_conda_py38_cu113_pyt1120
+          python_version: '3.8'
+          pytorch_version: 1.12.0
+      - binary_linux_conda:
+          conda_docker_image: pytorch/conda-builder:cuda116
+          context: DOCKERHUB_TOKEN
+          cu_version: cu116
+          name: linux_conda_py38_cu116_pyt1120
+          python_version: '3.8'
+          pytorch_version: 1.12.0
+      - binary_linux_conda:
+          conda_docker_image: pytorch/conda-builder:cuda113
+          context: DOCKERHUB_TOKEN
+          cu_version: cu113
+          name: linux_conda_py38_cu113_pyt1121
+          python_version: '3.8'
+          pytorch_version: 1.12.1
+      - binary_linux_conda:
+          conda_docker_image: pytorch/conda-builder:cuda116
+          context: DOCKERHUB_TOKEN
+          cu_version: cu116
+          name: linux_conda_py38_cu116_pyt1121
+          python_version: '3.8'
+          pytorch_version: 1.12.1
+      - binary_linux_conda:
+          conda_docker_image: pytorch/conda-builder:cuda116
+          context: DOCKERHUB_TOKEN
+          cu_version: cu116
+          name: linux_conda_py38_cu116_pyt1130
+          python_version: '3.8'
+          pytorch_version: 1.13.0
+      - binary_linux_conda:
+          conda_docker_image: pytorch/conda-builder:cuda117
+          context: DOCKERHUB_TOKEN
+          cu_version: cu117
+          name: linux_conda_py38_cu117_pyt1130
+          python_version: '3.8'
+          pytorch_version: 1.13.0
+      - binary_linux_conda:
+          conda_docker_image: pytorch/conda-builder:cuda116
+          context: DOCKERHUB_TOKEN
+          cu_version: cu116
+          name: linux_conda_py38_cu116_pyt1131
+          python_version: '3.8'
+          pytorch_version: 1.13.1
+      - binary_linux_conda:
+          conda_docker_image: pytorch/conda-builder:cuda117
+          context: DOCKERHUB_TOKEN
+          cu_version: cu117
+          name: linux_conda_py38_cu117_pyt1131
+          python_version: '3.8'
+          pytorch_version: 1.13.1
+      - binary_linux_conda:
+          conda_docker_image: pytorch/conda-builder:cuda117
+          context: DOCKERHUB_TOKEN
+          cu_version: cu117
+          name: linux_conda_py38_cu117_pyt200
+          python_version: '3.8'
+          pytorch_version: 2.0.0
+      - binary_linux_conda:
+          conda_docker_image: pytorch/conda-builder:cuda118
+          context: DOCKERHUB_TOKEN
+          cu_version: cu118
+          name: linux_conda_py38_cu118_pyt200
+          python_version: '3.8'
+          pytorch_version: 2.0.0
+      - binary_linux_conda:
+          conda_docker_image: pytorch/conda-builder:cuda117
+          context: DOCKERHUB_TOKEN
+          cu_version: cu117
+          name: linux_conda_py38_cu117_pyt201
+          python_version: '3.8'
+          pytorch_version: 2.0.1
+      - binary_linux_conda:
+          conda_docker_image: pytorch/conda-builder:cuda118
+          context: DOCKERHUB_TOKEN
+          cu_version: cu118
+          name: linux_conda_py38_cu118_pyt201
+          python_version: '3.8'
+          pytorch_version: 2.0.1
       - binary_linux_conda:
           conda_docker_image: pytorch/conda-builder:cuda118
           context: DOCKERHUB_TOKEN
@@ -247,33 +331,89 @@ workflows:
           python_version: '3.8'
           pytorch_version: 2.3.1
       - binary_linux_conda:
-          conda_docker_image: pytorch/conda-builder:cuda118
+          conda_docker_image: pytorch/conda-builder:cuda113
           context: DOCKERHUB_TOKEN
-          cu_version: cu118
-          name: linux_conda_py38_cu118_pyt240
-          python_version: '3.8'
-          pytorch_version: 2.4.0
+          cu_version: cu113
+          name: linux_conda_py39_cu113_pyt1120
+          python_version: '3.9'
+          pytorch_version: 1.12.0
       - binary_linux_conda:
-          conda_docker_image: pytorch/conda-builder:cuda121
+          conda_docker_image: pytorch/conda-builder:cuda116
           context: DOCKERHUB_TOKEN
-          cu_version: cu121
-          name: linux_conda_py38_cu121_pyt240
-          python_version: '3.8'
-          pytorch_version: 2.4.0
+          cu_version: cu116
+          name: linux_conda_py39_cu116_pyt1120
+          python_version: '3.9'
+          pytorch_version: 1.12.0
+      - binary_linux_conda:
+          conda_docker_image: pytorch/conda-builder:cuda113
+          context: DOCKERHUB_TOKEN
+          cu_version: cu113
+          name: linux_conda_py39_cu113_pyt1121
+          python_version: '3.9'
+          pytorch_version: 1.12.1
+      - binary_linux_conda:
+          conda_docker_image: pytorch/conda-builder:cuda116
+          context: DOCKERHUB_TOKEN
+          cu_version: cu116
+          name: linux_conda_py39_cu116_pyt1121
+          python_version: '3.9'
+          pytorch_version: 1.12.1
+      - binary_linux_conda:
+          conda_docker_image: pytorch/conda-builder:cuda116
+          context: DOCKERHUB_TOKEN
+          cu_version: cu116
+          name: linux_conda_py39_cu116_pyt1130
+          python_version: '3.9'
+          pytorch_version: 1.13.0
+      - binary_linux_conda:
+          conda_docker_image: pytorch/conda-builder:cuda117
+          context: DOCKERHUB_TOKEN
+          cu_version: cu117
+          name: linux_conda_py39_cu117_pyt1130
+          python_version: '3.9'
+          pytorch_version: 1.13.0
+      - binary_linux_conda:
+          conda_docker_image: pytorch/conda-builder:cuda116
+          context: DOCKERHUB_TOKEN
+          cu_version: cu116
+          name: linux_conda_py39_cu116_pyt1131
+          python_version: '3.9'
+          pytorch_version: 1.13.1
+      - binary_linux_conda:
+          conda_docker_image: pytorch/conda-builder:cuda117
+          context: DOCKERHUB_TOKEN
+          cu_version: cu117
+          name: linux_conda_py39_cu117_pyt1131
+          python_version: '3.9'
+          pytorch_version: 1.13.1
+      - binary_linux_conda:
+          conda_docker_image: pytorch/conda-builder:cuda117
+          context: DOCKERHUB_TOKEN
+          cu_version: cu117
+          name: linux_conda_py39_cu117_pyt200
+          python_version: '3.9'
+          pytorch_version: 2.0.0
       - 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
+          name: linux_conda_py39_cu118_pyt200
+          python_version: '3.9'
+          pytorch_version: 2.0.0
       - binary_linux_conda:
-          conda_docker_image: pytorch/conda-builder:cuda121
+          conda_docker_image: pytorch/conda-builder:cuda117
           context: DOCKERHUB_TOKEN
-          cu_version: cu121
-          name: linux_conda_py38_cu121_pyt241
-          python_version: '3.8'
-          pytorch_version: 2.4.1
+          cu_version: cu117
+          name: linux_conda_py39_cu117_pyt201
+          python_version: '3.9'
+          pytorch_version: 2.0.1
+      - binary_linux_conda:
+          conda_docker_image: pytorch/conda-builder:cuda118
+          context: DOCKERHUB_TOKEN
+          cu_version: cu118
+          name: linux_conda_py39_cu118_pyt201
+          python_version: '3.9'
+          pytorch_version: 2.0.1
       - binary_linux_conda:
           conda_docker_image: pytorch/conda-builder:cuda118
           context: DOCKERHUB_TOKEN
@@ -359,33 +499,89 @@ workflows:
           python_version: '3.9'
           pytorch_version: 2.3.1
       - binary_linux_conda:
-          conda_docker_image: pytorch/conda-builder:cuda118
+          conda_docker_image: pytorch/conda-builder:cuda113
           context: DOCKERHUB_TOKEN
-          cu_version: cu118
-          name: linux_conda_py39_cu118_pyt240
-          python_version: '3.9'
-          pytorch_version: 2.4.0
+          cu_version: cu113
+          name: linux_conda_py310_cu113_pyt1120
+          python_version: '3.10'
+          pytorch_version: 1.12.0
       - binary_linux_conda:
-          conda_docker_image: pytorch/conda-builder:cuda121
+          conda_docker_image: pytorch/conda-builder:cuda116
           context: DOCKERHUB_TOKEN
-          cu_version: cu121
-          name: linux_conda_py39_cu121_pyt240
-          python_version: '3.9'
-          pytorch_version: 2.4.0
+          cu_version: cu116
+          name: linux_conda_py310_cu116_pyt1120
+          python_version: '3.10'
+          pytorch_version: 1.12.0
+      - binary_linux_conda:
+          conda_docker_image: pytorch/conda-builder:cuda113
+          context: DOCKERHUB_TOKEN
+          cu_version: cu113
+          name: linux_conda_py310_cu113_pyt1121
+          python_version: '3.10'
+          pytorch_version: 1.12.1
+      - binary_linux_conda:
+          conda_docker_image: pytorch/conda-builder:cuda116
+          context: DOCKERHUB_TOKEN
+          cu_version: cu116
+          name: linux_conda_py310_cu116_pyt1121
+          python_version: '3.10'
+          pytorch_version: 1.12.1
+      - binary_linux_conda:
+          conda_docker_image: pytorch/conda-builder:cuda116
+          context: DOCKERHUB_TOKEN
+          cu_version: cu116
+          name: linux_conda_py310_cu116_pyt1130
+          python_version: '3.10'
+          pytorch_version: 1.13.0
+      - binary_linux_conda:
+          conda_docker_image: pytorch/conda-builder:cuda117
+          context: DOCKERHUB_TOKEN
+          cu_version: cu117
+          name: linux_conda_py310_cu117_pyt1130
+          python_version: '3.10'
+          pytorch_version: 1.13.0
+      - binary_linux_conda:
+          conda_docker_image: pytorch/conda-builder:cuda116
+          context: DOCKERHUB_TOKEN
+          cu_version: cu116
+          name: linux_conda_py310_cu116_pyt1131
+          python_version: '3.10'
+          pytorch_version: 1.13.1
+      - binary_linux_conda:
+          conda_docker_image: pytorch/conda-builder:cuda117
+          context: DOCKERHUB_TOKEN
+          cu_version: cu117
+          name: linux_conda_py310_cu117_pyt1131
+          python_version: '3.10'
+          pytorch_version: 1.13.1
+      - binary_linux_conda:
+          conda_docker_image: pytorch/conda-builder:cuda117
+          context: DOCKERHUB_TOKEN
+          cu_version: cu117
+          name: linux_conda_py310_cu117_pyt200
+          python_version: '3.10'
+          pytorch_version: 2.0.0
       - 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
+          name: linux_conda_py310_cu118_pyt200
+          python_version: '3.10'
+          pytorch_version: 2.0.0
       - binary_linux_conda:
-          conda_docker_image: pytorch/conda-builder:cuda121
+          conda_docker_image: pytorch/conda-builder:cuda117
           context: DOCKERHUB_TOKEN
-          cu_version: cu121
-          name: linux_conda_py39_cu121_pyt241
-          python_version: '3.9'
-          pytorch_version: 2.4.1
+          cu_version: cu117
+          name: linux_conda_py310_cu117_pyt201
+          python_version: '3.10'
+          pytorch_version: 2.0.1
+      - binary_linux_conda:
+          conda_docker_image: pytorch/conda-builder:cuda118
+          context: DOCKERHUB_TOKEN
+          cu_version: cu118
+          name: linux_conda_py310_cu118_pyt201
+          python_version: '3.10'
+          pytorch_version: 2.0.1
       - binary_linux_conda:
           conda_docker_image: pytorch/conda-builder:cuda118
           context: DOCKERHUB_TOKEN
@@ -470,34 +666,6 @@ workflows:
           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
@@ -582,34 +750,6 @@ workflows:
           name: linux_conda_py311_cu121_pyt231
           python_version: '3.11'
           pytorch_version: 2.3.1
-      - binary_linux_conda:
-          conda_docker_image: pytorch/conda-builder:cuda118
-          context: DOCKERHUB_TOKEN
-          cu_version: cu118
-          name: linux_conda_py311_cu118_pyt240
-          python_version: '3.11'
-          pytorch_version: 2.4.0
-      - binary_linux_conda:
-          conda_docker_image: pytorch/conda-builder:cuda121
-          context: DOCKERHUB_TOKEN
-          cu_version: cu121
-          name: linux_conda_py311_cu121_pyt240
-          python_version: '3.11'
-          pytorch_version: 2.4.0
-      - binary_linux_conda:
-          conda_docker_image: pytorch/conda-builder:cuda118
-          context: DOCKERHUB_TOKEN
-          cu_version: cu118
-          name: linux_conda_py311_cu118_pyt241
-          python_version: '3.11'
-          pytorch_version: 2.4.1
-      - binary_linux_conda:
-          conda_docker_image: pytorch/conda-builder:cuda121
-          context: DOCKERHUB_TOKEN
-          cu_version: cu121
-          name: linux_conda_py311_cu121_pyt241
-          python_version: '3.11'
-          pytorch_version: 2.4.1
       - binary_linux_conda:
           conda_docker_image: pytorch/conda-builder:cuda118
           context: DOCKERHUB_TOKEN
@@ -652,34 +792,6 @@ workflows:
           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

.circleci/regenerate.py

@@ -19,14 +19,18 @@ from packaging import version
 # The CUDA versions which have pytorch conda packages available for linux for each
 # version of pytorch.
 CONDA_CUDA_VERSIONS = {
+    "1.12.0": ["cu113", "cu116"],
+    "1.12.1": ["cu113", "cu116"],
+    "1.13.0": ["cu116", "cu117"],
+    "1.13.1": ["cu116", "cu117"],
+    "2.0.0": ["cu117", "cu118"],
+    "2.0.1": ["cu117", "cu118"],
     "2.1.0": ["cu118", "cu121"],
     "2.1.1": ["cu118", "cu121"],
     "2.1.2": ["cu118", "cu121"],
     "2.2.0": ["cu118", "cu121"],
     "2.2.2": ["cu118", "cu121"],
     "2.3.1": ["cu118", "cu121"],
-    "2.4.0": ["cu118", "cu121"],
-    "2.4.1": ["cu118", "cu121"],
 }
 
 
@@ -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,

.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,10 +8,11 @@
 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
-- 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.
+- Python 3.8, 3.9 or 3.10
+- PyTorch 1.12.0, 1.12.1, 1.13.0, 2.0.0, 2.0.1, 2.1.0, 2.1.1, 2.1.2, 2.2.0, 2.2.1, 2.2.2, 2.3.0 or 2.3.1.
 - torchvision that matches the PyTorch installation. You can install them together as explained at pytorch.org to make sure of this.
 - gcc & g++ ≥ 4.9
+- [fvcore](https://github.com/facebookresearch/fvcore)
 - [ioPath](https://github.com/facebookresearch/iopath)
 - If CUDA is to be used, use a version which is supported by the corresponding pytorch version and at least version 9.2.
 - If CUDA older than 11.7 is to be used and you are building from source, the CUB library must be available. We recommend version 1.10.0.
@@ -21,7 +22,7 @@ The runtime dependencies can be installed by running:
 conda create -n pytorch3d python=3.9
 conda activate pytorch3d
 conda install pytorch=1.13.0 torchvision pytorch-cuda=11.6 -c pytorch -c nvidia
-conda install -c 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
 ```
 
@@ -98,7 +97,7 @@ version_str="".join([
     torch.version.cuda.replace(".",""),
     f"_pyt{pyt_version_str}"
 ])
-!pip install iopath
+!pip install fvcore iopath
 !pip install --no-index --no-cache-dir pytorch3d -f https://dl.fbaipublicfiles.com/pytorch3d/packaging/wheels/{version_str}/download.html
 ```
 

dev/linter.sh

@@ -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/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/requirements.txt

@@ -5,6 +5,7 @@ sphinx_rtd_theme
 sphinx_markdown_tables
 numpy
 iopath
+fvcore
 https://download.pytorch.org/whl/cpu/torchvision-0.15.2%2Bcpu-cp311-cp311-linux_x86_64.whl
 https://download.pytorch.org/whl/cpu/torch-2.0.1%2Bcpu-cp311-cp311-linux_x86_64.whl
 omegaconf

docs/tutorials/bundle_adjustment.ipynb

@@ -96,7 +96,7 @@
     "        torch.version.cuda.replace(\".\",\"\"),\n",
     "        f\"_pyt{pyt_version_str}\"\n",
     "    ])\n",
-    "    !pip install iopath\n",
+    "    !pip install fvcore iopath\n",
     "    if sys.platform.startswith(\"linux\"):\n",
     "        print(\"Trying to install wheel for PyTorch3D\")\n",
     "        !pip install --no-index --no-cache-dir pytorch3d -f https://dl.fbaipublicfiles.com/pytorch3d/packaging/wheels/{version_str}/download.html\n",

docs/tutorials/camera_position_optimization_with_differentiable_rendering.ipynb

@@ -83,7 +83,7 @@
     "        torch.version.cuda.replace(\".\",\"\"),\n",
     "        f\"_pyt{pyt_version_str}\"\n",
     "    ])\n",
-    "    !pip install iopath\n",
+    "    !pip install fvcore iopath\n",
     "    if sys.platform.startswith(\"linux\"):\n",
     "        print(\"Trying to install wheel for PyTorch3D\")\n",
     "        !pip install --no-index --no-cache-dir pytorch3d -f https://dl.fbaipublicfiles.com/pytorch3d/packaging/wheels/{version_str}/download.html\n",

docs/tutorials/dataloaders_ShapeNetCore_R2N2.ipynb

@@ -58,7 +58,7 @@
     "        torch.version.cuda.replace(\".\",\"\"),\n",
     "        f\"_pyt{pyt_version_str}\"\n",
     "    ])\n",
-    "    !pip install iopath\n",
+    "    !pip install fvcore iopath\n",
     "    if sys.platform.startswith(\"linux\"):\n",
     "        print(\"Trying to install wheel for PyTorch3D\")\n",
     "        !pip install --no-index --no-cache-dir pytorch3d -f https://dl.fbaipublicfiles.com/pytorch3d/packaging/wheels/{version_str}/download.html\n",

docs/tutorials/deform_source_mesh_to_target_mesh.ipynb

@@ -97,7 +97,7 @@
     "        torch.version.cuda.replace(\".\",\"\"),\n",
     "        f\"_pyt{pyt_version_str}\"\n",
     "    ])\n",
-    "    !pip install iopath\n",
+    "    !pip install fvcore iopath\n",
     "    if sys.platform.startswith(\"linux\"):\n",
     "        print(\"Trying to install wheel for PyTorch3D\")\n",
     "        !pip install --no-index --no-cache-dir pytorch3d -f https://dl.fbaipublicfiles.com/pytorch3d/packaging/wheels/{version_str}/download.html\n",

docs/tutorials/fit_simple_neural_radiance_field.ipynb

@@ -63,7 +63,7 @@
     "        torch.version.cuda.replace(\".\",\"\"),\n",
     "        f\"_pyt{pyt_version_str}\"\n",
     "    ])\n",
-    "    !pip install iopath\n",
+    "    !pip install fvcore iopath\n",
     "    if sys.platform.startswith(\"linux\"):\n",
     "        print(\"Trying to install wheel for PyTorch3D\")\n",
     "        !pip install --no-index --no-cache-dir pytorch3d -f https://dl.fbaipublicfiles.com/pytorch3d/packaging/wheels/{version_str}/download.html\n",

docs/tutorials/fit_textured_mesh.ipynb

@@ -75,7 +75,7 @@
     "        torch.version.cuda.replace(\".\",\"\"),\n",
     "        f\"_pyt{pyt_version_str}\"\n",
     "    ])\n",
-    "    !pip install iopath\n",
+    "    !pip install fvcore iopath\n",
     "    if sys.platform.startswith(\"linux\"):\n",
     "        print(\"Trying to install wheel for PyTorch3D\")\n",
     "        !pip install --no-index --no-cache-dir pytorch3d -f https://dl.fbaipublicfiles.com/pytorch3d/packaging/wheels/{version_str}/download.html\n",

docs/tutorials/fit_textured_volume.ipynb

@@ -54,7 +54,7 @@
     "        torch.version.cuda.replace(\".\",\"\"),\n",
     "        f\"_pyt{pyt_version_str}\"\n",
     "    ])\n",
-    "    !pip install iopath\n",
+    "    !pip install fvcore iopath\n",
     "    if sys.platform.startswith(\"linux\"):\n",
     "        print(\"Trying to install wheel for PyTorch3D\")\n",
     "        !pip install --no-index --no-cache-dir pytorch3d -f https://dl.fbaipublicfiles.com/pytorch3d/packaging/wheels/{version_str}/download.html\n",

docs/tutorials/implicitron_config_system.ipynb

@@ -85,7 +85,7 @@
         "        torch.version.cuda.replace(\".\",\"\"),\n",
         "        f\"_pyt{pyt_version_str}\"\n",
         "    ])\n",
-        "    !pip install iopath\n",
+        "    !pip install fvcore iopath\n",
         "    if sys.platform.startswith(\"linux\"):\n",
         "        print(\"Trying to install wheel for PyTorch3D\")\n",
         "        !pip install --no-index --no-cache-dir pytorch3d -f https://dl.fbaipublicfiles.com/pytorch3d/packaging/wheels/{version_str}/download.html\n",

docs/tutorials/implicitron_volumes.ipynb

@@ -79,7 +79,7 @@
         "        torch.version.cuda.replace(\".\",\"\"),\n",
         "        f\"_pyt{pyt_version_str}\"\n",
         "    ])\n",
-        "    !pip install iopath\n",
+        "    !pip install fvcore iopath\n",
         "    if sys.platform.startswith(\"linux\"):\n",
         "        print(\"Trying to install wheel for PyTorch3D\")\n",
         "        !pip install --no-index --no-cache-dir pytorch3d -f https://dl.fbaipublicfiles.com/pytorch3d/packaging/wheels/{version_str}/download.html\n",

docs/tutorials/render_colored_points.ipynb

@@ -57,7 +57,7 @@
     "        torch.version.cuda.replace(\".\",\"\"),\n",
     "        f\"_pyt{pyt_version_str}\"\n",
     "    ])\n",
-    "    !pip install iopath\n",
+    "    !pip install fvcore iopath\n",
     "    if sys.platform.startswith(\"linux\"):\n",
     "        print(\"Trying to install wheel for PyTorch3D\")\n",
     "        !pip install --no-index --no-cache-dir pytorch3d -f https://dl.fbaipublicfiles.com/pytorch3d/packaging/wheels/{version_str}/download.html\n",

docs/tutorials/render_densepose.ipynb

@@ -64,7 +64,7 @@
     "        torch.version.cuda.replace(\".\",\"\"),\n",
     "        f\"_pyt{pyt_version_str}\"\n",
     "    ])\n",
-    "    !pip install iopath\n",
+    "    !pip install fvcore iopath\n",
     "    if sys.platform.startswith(\"linux\"):\n",
     "        print(\"Trying to install wheel for PyTorch3D\")\n",
     "        !pip install --no-index --no-cache-dir pytorch3d -f https://dl.fbaipublicfiles.com/pytorch3d/packaging/wheels/{version_str}/download.html\n",

docs/tutorials/render_textured_meshes.ipynb

@@ -80,7 +80,7 @@
     "        torch.version.cuda.replace(\".\",\"\"),\n",
     "        f\"_pyt{pyt_version_str}\"\n",
     "    ])\n",
-    "    !pip install iopath\n",
+    "    !pip install fvcore iopath\n",
     "    if sys.platform.startswith(\"linux\"):\n",
     "        print(\"Trying to install wheel for PyTorch3D\")\n",
     "        !pip install --no-index --no-cache-dir pytorch3d -f https://dl.fbaipublicfiles.com/pytorch3d/packaging/wheels/{version_str}/download.html\n",

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,10 +42,11 @@ 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 = (
@@ -75,15 +75,6 @@ def setup_cuda(use_conda_cuda: bool) -> List[str]:
 
     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]:
@@ -104,7 +95,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 +116,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 +132,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,6 @@ version_str="".join([
     torch.version.cuda.replace(".",""),
     f"_pyt{pyt_version_str}"
 ])
-!pip install iopath
+!pip install fvcore iopath
 !pip install --no-index --no-cache-dir pytorch3d -f https://dl.fbaipublicfiles.com/pytorch3d/packaging/wheels/{version_str}/download.html
 ```

packaging/linux_wheels/inside.sh

@@ -144,7 +144,7 @@ do
             conda activate "$tag"
             # shellcheck disable=SC2086
             conda install -y -c pytorch $extra_channel "pytorch=$pytorch_version" "$cudatools=$CUDA_TAG"
-            pip install 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,13 +8,10 @@ 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]
     {{ environ.get('SETUPTOOLS_CONSTRAINT') }}
     {{ environ.get('CONDA_PYTORCH_BUILD_CONSTRAINT') }}
     {{ environ.get('CONDA_PYTORCH_MKL_CONSTRAINT') }}
@@ -25,7 +22,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 +48,8 @@ test:
     - imageio
     - hydra-core
     - accelerate
-    - matplotlib
-    - tabulate
-    - pandas
-    - sqlalchemy
   commands:
+    #pytest .
     python -m unittest discover -v -s tests -t .
 
 

projects/implicitron_trainer/experiment.py

@@ -7,7 +7,7 @@
 
 # pyre-unsafe
 
-""" "
+""""
 This file is the entry point for launching experiments with Implicitron.
 
 Launch Training
@@ -44,7 +44,6 @@ The outputs of the experiment are saved and logged in multiple ways:
         config file.
 
 """
-
 import logging
 import os
 import warnings
@@ -100,7 +99,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-
@@ -121,16 +120,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"
 

projects/implicitron_trainer/impl/model_factory.py

@@ -26,6 +26,7 @@ logger = logging.getLogger(__name__)
 
 
 class ModelFactoryBase(ReplaceableBase):
+
     resume: bool = True  # resume from the last checkpoint
 
     def __call__(self, **kwargs) -> ImplicitronModelBase:
@@ -44,7 +45,7 @@ class ModelFactoryBase(ReplaceableBase):
 
 
 @registry.register
-class ImplicitronModelFactory(ModelFactoryBase):
+class ImplicitronModelFactory(ModelFactoryBase):  # pyre-ignore [13]
     """
     A factory class that initializes an implicit rendering model.
 
@@ -60,7 +61,6 @@ class ImplicitronModelFactory(ModelFactoryBase):
 
     """
 
-    # pyre-fixme[13]: Attribute `model` is never initialized.
     model: ImplicitronModelBase
     model_class_type: str = "GenericModel"
     resume: bool = True
@@ -115,9 +115,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),
-                    map_location=map_location,
-                    weights_only=True,
+                    model_io.get_model_path(model_path), map_location=map_location
                 )
 
                 try:

projects/implicitron_trainer/impl/optimizer_factory.py

@@ -123,7 +123,6 @@ 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.
             p_groups = model._get_param_groups(self.lr, wd=self.weight_decay)
         else:
             p_groups = [
@@ -242,7 +241,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

@@ -30,13 +30,13 @@ from .utils import seed_all_random_engines
 logger = logging.getLogger(__name__)
 
 
+# pyre-fixme[13]: Attribute `evaluator` is never initialized.
 class TrainingLoopBase(ReplaceableBase):
     """
     Members:
         evaluator: An EvaluatorBase instance, used to evaluate training results.
     """
 
-    # pyre-fixme[13]: Attribute `evaluator` is never initialized.
     evaluator: Optional[EvaluatorBase]
     evaluator_class_type: Optional[str] = "ImplicitronEvaluator"
 
@@ -161,6 +161,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)
@@ -394,7 +395,6 @@ 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.
                     model.visualize(
                         viz,
                         visdom_env_imgs,

projects/implicitron_trainer/tests/test_experiment.py

@@ -53,8 +53,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
-        dataloader_args = cfg.data_source_ImplicitronDataSource_args.data_loader_map_provider_SequenceDataLoaderMapProvider_args
+        dataset_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"
@@ -90,8 +94,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
-        dataloader_args = cfg.data_source_ImplicitronDataSource_args.data_loader_map_provider_SequenceDataLoaderMapProvider_args
+        dataset_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"
@@ -103,7 +111,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)

projects/implicitron_trainer/tests/test_optimizer_factory.py

@@ -81,9 +81,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 = (
-            Node(params=[pa]),
-            Node(params=[pb], param_groups={"self": "pb_self", "p1": "pb_param"}),
+        na, nb = Node(params=[pa]), 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/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/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

@@ -6,4 +6,4 @@
 
 # pyre-unsafe
 
-__version__ = "0.7.8"
+__version__ = "0.7.6"

pytorch3d/common/compat.py

@@ -17,7 +17,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/csrc/ball_query/ball_query_cpu.cpp

@@ -7,6 +7,7 @@
  */
 
 #include <torch/extension.h>
+#include <queue>
 #include <tuple>
 
 std::tuple<at::Tensor, at::Tensor> BallQueryCpu(

pytorch3d/csrc/compositing/alpha_composite.cu

@@ -28,6 +28,7 @@ __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);
@@ -78,6 +79,7 @@ __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);

pytorch3d/csrc/compositing/norm_weighted_sum.cu

@@ -28,6 +28,7 @@ __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);
@@ -91,6 +92,7 @@ __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);

pytorch3d/csrc/compositing/weighted_sum.cu

@@ -26,6 +26,7 @@ __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);
@@ -73,6 +74,7 @@ __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);

pytorch3d/csrc/ext.cpp

@@ -99,7 +99,6 @@ PYBIND11_MODULE(TORCH_EXTENSION_NAME, m) {
   m.def("marching_cubes", &MarchingCubes);
 
   // Pulsar.
-  // Pulsar not enabled on AMD.
 #ifdef PULSAR_LOGGING_ENABLED
   c10::ShowLogInfoToStderr();
 #endif
@@ -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
-                               pytorch 1.1. */
+          py::arg(
+              "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/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

@@ -461,8 +461,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 +500,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 +728,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/points_to_volumes/points_to_volumes_cpu.cpp

@@ -8,7 +8,9 @@
 
 #include <torch/csrc/autograd/VariableTypeUtils.h>
 #include <torch/extension.h>
+#include <algorithm>
 #include <cmath>
+#include <thread>
 #include <vector>
 
 // In the x direction, the location {0, ..., grid_size_x - 1} correspond to

pytorch3d/csrc/pulsar/cuda/commands.h

@@ -59,11 +59,6 @@ getLastCudaError(const char* errorMessage, const char* file, const int line) {
 #define SHARED __shared__
 #define ACTIVEMASK() __activemask()
 #define BALLOT(mask, val) __ballot_sync((mask), val)
-
-/* TODO (ROCM-6.2): None of the WARP_* are used anywhere and ROCM-6.2 natively
- * supports __shfl_*. Disabling until the move to ROCM-6.2.
- */
-#if !defined(USE_ROCM)
 /**
  * Find the cumulative sum within a warp up to the current
  * thread lane, with each mask thread contributing base.
@@ -120,7 +115,6 @@ INLINE DEVICE float3 WARP_SUM_FLOAT3(
   ret.z = WARP_SUM(group, mask, base.z);
   return ret;
 }
-#endif //! USE_ROCM
 
 // Floating point.
 // #define FMUL(a, b) __fmul_rn((a), (b))
@@ -148,7 +142,6 @@ INLINE DEVICE float3 WARP_SUM_FLOAT3(
 #define FMA(x, y, z) __fmaf_rn((x), (y), (z))
 #define I2F(a) __int2float_rn(a)
 #define FRCP(x) __frcp_rn(x)
-#if !defined(USE_ROCM)
 __device__ static float atomicMax(float* address, float val) {
   int* address_as_i = (int*)address;
   int old = *address_as_i, assumed;
@@ -173,7 +166,6 @@ __device__ static float atomicMin(float* address, float val) {
   } while (assumed != old);
   return __int_as_float(old);
 }
-#endif //! USE_ROCM
 #define DMAX(a, b) FMAX(a, b)
 #define DMIN(a, b) FMIN(a, b)
 #define DSQRT(a) sqrt(a)

pytorch3d/csrc/pulsar/global.h

@@ -36,13 +36,11 @@
 #pragma nv_diag_suppress 2951
 #pragma nv_diag_suppress 2967
 #else
-#if !defined(USE_ROCM)
 #pragma diag_suppress = attribute_not_allowed
 #pragma diag_suppress = 1866
 #pragma diag_suppress = 2941
 #pragma diag_suppress = 2951
 #pragma diag_suppress = 2967
-#endif //! USE_ROCM
 #endif
 #else // __CUDACC__
 #define INLINE inline
@@ -58,9 +56,7 @@
 #pragma clang diagnostic pop
 #ifdef WITH_CUDA
 #include <ATen/cuda/CUDAContext.h>
-#if !defined(USE_ROCM)
 #include <vector_functions.h>
-#endif //! USE_ROCM
 #else
 #ifndef cudaStream_t
 typedef void* cudaStream_t;

pytorch3d/csrc/pulsar/include/camera.device.h

@@ -14,7 +14,7 @@
 #include "./commands.h"
 
 namespace pulsar {
-IHD CamGradInfo::CamGradInfo(int x) {
+IHD CamGradInfo::CamGradInfo() {
   cam_pos = make_float3(0.f, 0.f, 0.f);
   pixel_0_0_center = make_float3(0.f, 0.f, 0.f);
   pixel_dir_x = make_float3(0.f, 0.f, 0.f);

pytorch3d/csrc/pulsar/include/camera.h

@@ -63,7 +63,7 @@ inline bool operator==(const CamInfo& a, const CamInfo& b) {
 };
 
 struct CamGradInfo {
-  HOST DEVICE CamGradInfo(int = 0);
+  HOST DEVICE CamGradInfo();
   float3 cam_pos;
   float3 pixel_0_0_center;
   float3 pixel_dir_x;

pytorch3d/csrc/pulsar/include/commands.h

@@ -24,7 +24,7 @@
 // #pragma diag_suppress = 68
 #include <ATen/cuda/CUDAContext.h>
 // #pragma pop
-#include "../gpu/commands.h"
+#include "../cuda/commands.h"
 #else
 #pragma clang diagnostic push
 #pragma clang diagnostic ignored "-Weverything"

pytorch3d/csrc/pulsar/include/math.h

@@ -46,7 +46,6 @@ IHD float3 outer_product_sum(const float3& a) {
 }
 
 // TODO: put intrinsics here.
-#if !defined(USE_ROCM)
 IHD float3 operator+(const float3& a, const float3& b) {
   return make_float3(a.x + b.x, a.y + b.y, a.z + b.z);
 }
@@ -94,7 +93,6 @@ IHD float3 operator*(const float3& a, const float3& b) {
 IHD float3 operator*(const float& a, const float3& b) {
   return b * a;
 }
-#endif //! USE_ROCM
 
 INLINE DEVICE float length(const float3& v) {
   // TODO: benchmark what's faster.

pytorch3d/csrc/pulsar/include/renderer.render.device.h

@@ -283,15 +283,9 @@ GLOBAL void render(
           (percent_allowed_difference > 0.f &&
            max_closest_possible_intersection > depth_threshold) ||
           tracker.get_n_hits() >= max_n_hits;
-#if defined(__CUDACC__) && defined(__HIP_PLATFORM_AMD__)
-      unsigned long long warp_done = __ballot(done);
-      int warp_done_bit_cnt = __popcll(warp_done);
-#else
       uint warp_done = thread_warp.ballot(done);
-      int warp_done_bit_cnt = POPC(warp_done);
-#endif //__CUDACC__ && __HIP_PLATFORM_AMD__
       if (thread_warp.thread_rank() == 0)
-        ATOMICADD_B(&n_pixels_done, warp_done_bit_cnt);
+        ATOMICADD_B(&n_pixels_done, POPC(warp_done));
       // This sync is necessary to keep n_loaded until all threads are done with
       // painting.
       thread_block.sync();

pytorch3d/csrc/pulsar/pytorch/renderer.cpp

@@ -213,8 +213,8 @@ std::tuple<size_t, size_t, bool, torch::Tensor> Renderer::arg_check(
     const float& gamma,
     const float& max_depth,
     float& min_depth,
-    const std::optional<torch::Tensor>& bg_col,
-    const std::optional<torch::Tensor>& opacity,
+    const c10::optional<torch::Tensor>& bg_col,
+    const c10::optional<torch::Tensor>& opacity,
     const float& percent_allowed_difference,
     const uint& max_n_hits,
     const uint& mode) {
@@ -668,8 +668,8 @@ std::tuple<torch::Tensor, torch::Tensor> Renderer::forward(
     const float& gamma,
     const float& max_depth,
     float min_depth,
-    const std::optional<torch::Tensor>& bg_col,
-    const std::optional<torch::Tensor>& opacity,
+    const c10::optional<torch::Tensor>& bg_col,
+    const c10::optional<torch::Tensor>& opacity,
     const float& percent_allowed_difference,
     const uint& max_n_hits,
     const uint& mode) {
@@ -888,14 +888,14 @@ std::tuple<torch::Tensor, torch::Tensor> Renderer::forward(
 };
 
 std::tuple<
-    std::optional<torch::Tensor>,
-    std::optional<torch::Tensor>,
-    std::optional<torch::Tensor>,
-    std::optional<torch::Tensor>,
-    std::optional<torch::Tensor>,
-    std::optional<torch::Tensor>,
-    std::optional<torch::Tensor>,
-    std::optional<torch::Tensor>>
+    at::optional<torch::Tensor>,
+    at::optional<torch::Tensor>,
+    at::optional<torch::Tensor>,
+    at::optional<torch::Tensor>,
+    at::optional<torch::Tensor>,
+    at::optional<torch::Tensor>,
+    at::optional<torch::Tensor>,
+    at::optional<torch::Tensor>>
 Renderer::backward(
     const torch::Tensor& grad_im,
     const torch::Tensor& image,
@@ -912,8 +912,8 @@ Renderer::backward(
     const float& gamma,
     const float& max_depth,
     float min_depth,
-    const std::optional<torch::Tensor>& bg_col,
-    const std::optional<torch::Tensor>& opacity,
+    const c10::optional<torch::Tensor>& bg_col,
+    const c10::optional<torch::Tensor>& opacity,
     const float& percent_allowed_difference,
     const uint& max_n_hits,
     const uint& mode,
@@ -922,7 +922,7 @@ Renderer::backward(
     const bool& dif_rad,
     const bool& dif_cam,
     const bool& dif_opy,
-    const std::optional<std::pair<uint, uint>>& dbg_pos) {
+    const at::optional<std::pair<uint, uint>>& dbg_pos) {
   this->ensure_on_device(this->device_tracker.device());
   size_t batch_size;
   size_t n_points;
@@ -1045,14 +1045,14 @@ Renderer::backward(
   }
   // Prepare the return value.
   std::tuple<
-      std::optional<torch::Tensor>,
-      std::optional<torch::Tensor>,
-      std::optional<torch::Tensor>,
-      std::optional<torch::Tensor>,
-      std::optional<torch::Tensor>,
-      std::optional<torch::Tensor>,
-      std::optional<torch::Tensor>,
-      std::optional<torch::Tensor>>
+      at::optional<torch::Tensor>,
+      at::optional<torch::Tensor>,
+      at::optional<torch::Tensor>,
+      at::optional<torch::Tensor>,
+      at::optional<torch::Tensor>,
+      at::optional<torch::Tensor>,
+      at::optional<torch::Tensor>,
+      at::optional<torch::Tensor>>
       ret;
   if (mode == 1 || (!dif_pos && !dif_col && !dif_rad && !dif_cam && !dif_opy)) {
     return ret;

pytorch3d/csrc/pulsar/pytorch/renderer.h

@@ -44,21 +44,21 @@ struct Renderer {
       const float& gamma,
       const float& max_depth,
       float min_depth,
-      const std::optional<torch::Tensor>& bg_col,
-      const std::optional<torch::Tensor>& opacity,
+      const c10::optional<torch::Tensor>& bg_col,
+      const c10::optional<torch::Tensor>& opacity,
       const float& percent_allowed_difference,
       const uint& max_n_hits,
       const uint& mode);
 
   std::tuple<
-      std::optional<torch::Tensor>,
-      std::optional<torch::Tensor>,
-      std::optional<torch::Tensor>,
-      std::optional<torch::Tensor>,
-      std::optional<torch::Tensor>,
-      std::optional<torch::Tensor>,
-      std::optional<torch::Tensor>,
-      std::optional<torch::Tensor>>
+      at::optional<torch::Tensor>,
+      at::optional<torch::Tensor>,
+      at::optional<torch::Tensor>,
+      at::optional<torch::Tensor>,
+      at::optional<torch::Tensor>,
+      at::optional<torch::Tensor>,
+      at::optional<torch::Tensor>,
+      at::optional<torch::Tensor>>
   backward(
       const torch::Tensor& grad_im,
       const torch::Tensor& image,
@@ -75,8 +75,8 @@ struct Renderer {
       const float& gamma,
       const float& max_depth,
       float min_depth,
-      const std::optional<torch::Tensor>& bg_col,
-      const std::optional<torch::Tensor>& opacity,
+      const c10::optional<torch::Tensor>& bg_col,
+      const c10::optional<torch::Tensor>& opacity,
       const float& percent_allowed_difference,
       const uint& max_n_hits,
       const uint& mode,
@@ -85,7 +85,7 @@ struct Renderer {
       const bool& dif_rad,
       const bool& dif_cam,
       const bool& dif_opy,
-      const std::optional<std::pair<uint, uint>>& dbg_pos);
+      const at::optional<std::pair<uint, uint>>& dbg_pos);
 
   // Infrastructure.
   /**
@@ -115,8 +115,8 @@ struct Renderer {
       const float& gamma,
       const float& max_depth,
       float& min_depth,
-      const std::optional<torch::Tensor>& bg_col,
-      const std::optional<torch::Tensor>& opacity,
+      const c10::optional<torch::Tensor>& bg_col,
+      const c10::optional<torch::Tensor>& opacity,
       const float& percent_allowed_difference,
       const uint& max_n_hits,
       const uint& mode);

pytorch3d/csrc/pulsar/pytorch/tensor_util.cpp

@@ -8,7 +8,6 @@
 
 #ifdef WITH_CUDA
 #include <ATen/cuda/CUDAContext.h>
-#include <c10/cuda/CUDAException.h>
 #include <cuda_runtime_api.h>
 #endif
 #include <torch/extension.h>
@@ -34,13 +33,13 @@ torch::Tensor sphere_ids_from_result_info_nograd(
           .contiguous();
   if (forw_info.device().type() == c10::DeviceType::CUDA) {
 #ifdef WITH_CUDA
-    C10_CUDA_CHECK(cudaMemcpyAsync(
+    cudaMemcpyAsync(
         result.data_ptr(),
         tmp.data_ptr(),
         sizeof(uint32_t) * tmp.size(0) * tmp.size(1) * tmp.size(2) *
             tmp.size(3),
         cudaMemcpyDeviceToDevice,
-        at::cuda::getCurrentCUDAStream()));
+        at::cuda::getCurrentCUDAStream());
 #else
     throw std::runtime_error(
         "Copy on CUDA device initiated but built "

pytorch3d/csrc/pulsar/pytorch/util.cpp

@@ -7,7 +7,6 @@
  */
 
 #ifdef WITH_CUDA
-#include <c10/cuda/CUDAException.h>
 #include <cuda_runtime_api.h>
 
 namespace pulsar {
@@ -18,8 +17,7 @@ void cudaDevToDev(
     const void* src,
     const int& size,
     const cudaStream_t& stream) {
-  C10_CUDA_CHECK(
-      cudaMemcpyAsync(trg, src, size, cudaMemcpyDeviceToDevice, stream));
+  cudaMemcpyAsync(trg, src, size, cudaMemcpyDeviceToDevice, stream);
 }
 
 void cudaDevToHost(
@@ -27,8 +25,7 @@ void cudaDevToHost(
     const void* src,
     const int& size,
     const cudaStream_t& stream) {
-  C10_CUDA_CHECK(
-      cudaMemcpyAsync(trg, src, size, cudaMemcpyDeviceToHost, stream));
+  cudaMemcpyAsync(trg, src, size, cudaMemcpyDeviceToHost, stream);
 }
 
 } // namespace pytorch

pytorch3d/csrc/rasterize_meshes/rasterize_meshes.cu

@@ -144,7 +144,7 @@ __device__ void CheckPixelInsideFace(
   const bool zero_face_area =
       (face_area <= kEpsilon && face_area >= -1.0f * kEpsilon);
 
-  if (zmax < 0 || (cull_backfaces && back_face) || outside_bbox ||
+  if (zmax < 0 || cull_backfaces && back_face || outside_bbox ||
       zero_face_area) {
     return;
   }

pytorch3d/csrc/rasterize_meshes/rasterize_meshes_cpu.cpp

@@ -9,6 +9,7 @@
 #include <torch/extension.h>
 #include <algorithm>
 #include <list>
+#include <queue>
 #include <thread>
 #include <tuple>
 #include "ATen/core/TensorAccessor.h"

pytorch3d/csrc/sample_farthest_points/sample_farthest_points.cu

@@ -35,6 +35,8 @@ __global__ void FarthestPointSamplingKernel(
   __shared__ int64_t selected_store;
 
   // Get constants
+  const int64_t N = points.size(0);
+  const int64_t P = points.size(1);
   const int64_t D = points.size(2);
 
   // Get batch index and thread index

pytorch3d/csrc/utils/float_math.cuh

@@ -18,8 +18,6 @@ const auto vEpsilon = 1e-8;
 
 // Common functions and operators for float2.
 
-// Complex arithmetic is already defined for AMD.
-#if !defined(USE_ROCM)
 __device__ inline float2 operator-(const float2& a, const float2& b) {
   return make_float2(a.x - b.x, a.y - b.y);
 }
@@ -43,7 +41,6 @@ __device__ inline float2 operator*(const float2& a, const float2& b) {
 __device__ inline float2 operator*(const float a, const float2& b) {
   return make_float2(a * b.x, a * b.y);
 }
-#endif
 
 __device__ inline float FloatMin3(const float a, const float b, const float c) {
   return fminf(a, fminf(b, c));

pytorch3d/csrc/utils/geometry_utils.cuh

@@ -376,6 +376,8 @@ PointLineDistanceBackward(
   float tt = t_top / t_bot;
   tt = __saturatef(tt);
   const float2 p_proj = (1.0f - tt) * v0 + tt * v1;
+  const float2 d = p - p_proj;
+  const float dist = sqrt(dot(d, d));
 
   const float2 grad_p = -1.0f * grad_dist * 2.0f * (p_proj - p);
   const float2 grad_v0 = grad_dist * (1.0f - tt) * 2.0f * (p_proj - p);

pytorch3d/csrc/utils/warp_reduce.cuh

@@ -23,51 +23,37 @@ WarpReduceMin(scalar_t* min_dists, int64_t* min_idxs, const size_t tid) {
     min_idxs[tid] = min_idxs[tid + 32];
     min_dists[tid] = min_dists[tid + 32];
   }
-// AMD does not use explicit syncwarp and instead automatically inserts memory
-// fences during compilation.
-#if !defined(USE_ROCM)
   __syncwarp();
-#endif
   // s = 16
   if (min_dists[tid] > min_dists[tid + 16]) {
     min_idxs[tid] = min_idxs[tid + 16];
     min_dists[tid] = min_dists[tid + 16];
   }
-#if !defined(USE_ROCM)
   __syncwarp();
-#endif
   // s = 8
   if (min_dists[tid] > min_dists[tid + 8]) {
     min_idxs[tid] = min_idxs[tid + 8];
     min_dists[tid] = min_dists[tid + 8];
   }
-#if !defined(USE_ROCM)
   __syncwarp();
-#endif
   // s = 4
   if (min_dists[tid] > min_dists[tid + 4]) {
     min_idxs[tid] = min_idxs[tid + 4];
     min_dists[tid] = min_dists[tid + 4];
   }
-#if !defined(USE_ROCM)
   __syncwarp();
-#endif
   // s = 2
   if (min_dists[tid] > min_dists[tid + 2]) {
     min_idxs[tid] = min_idxs[tid + 2];
     min_dists[tid] = min_dists[tid + 2];
   }
-#if !defined(USE_ROCM)
   __syncwarp();
-#endif
   // s = 1
   if (min_dists[tid] > min_dists[tid + 1]) {
     min_idxs[tid] = min_idxs[tid + 1];
     min_dists[tid] = min_dists[tid + 1];
   }
-#if !defined(USE_ROCM)
   __syncwarp();
-#endif
 }
 
 template <typename scalar_t>
@@ -79,42 +65,30 @@ __device__ void WarpReduceMax(
     dists[tid] = dists[tid + 32];
     dists_idx[tid] = dists_idx[tid + 32];
   }
-#if !defined(USE_ROCM)
   __syncwarp();
-#endif
   if (dists[tid] < dists[tid + 16]) {
     dists[tid] = dists[tid + 16];
     dists_idx[tid] = dists_idx[tid + 16];
   }
-#if !defined(USE_ROCM)
   __syncwarp();
-#endif
   if (dists[tid] < dists[tid + 8]) {
     dists[tid] = dists[tid + 8];
     dists_idx[tid] = dists_idx[tid + 8];
   }
-#if !defined(USE_ROCM)
   __syncwarp();
-#endif
   if (dists[tid] < dists[tid + 4]) {
     dists[tid] = dists[tid + 4];
     dists_idx[tid] = dists_idx[tid + 4];
   }
-#if !defined(USE_ROCM)
   __syncwarp();
-#endif
   if (dists[tid] < dists[tid + 2]) {
     dists[tid] = dists[tid + 2];
     dists_idx[tid] = dists_idx[tid + 2];
   }
-#if !defined(USE_ROCM)
   __syncwarp();
-#endif
   if (dists[tid] < dists[tid + 1]) {
     dists[tid] = dists[tid + 1];
     dists_idx[tid] = dists_idx[tid + 1];
   }
-#if !defined(USE_ROCM)
   __syncwarp();
-#endif
 }

pytorch3d/datasets/shapenet/shapenet_core.py

@@ -83,7 +83,7 @@ class ShapeNetCore(ShapeNetBase):  # pragma: no cover
                 ):
                     synset_set.add(synset)
                 elif (synset in self.synset_inv.keys()) and (
-                    path.isdir(path.join(data_dir, self.synset_inv[synset]))
+                    (path.isdir(path.join(data_dir, self.synset_inv[synset])))
                 ):
                     synset_set.add(self.synset_inv[synset])
                 else:

pytorch3d/datasets/utils.py

@@ -36,6 +36,7 @@ def collate_batched_meshes(batch: List[Dict]):  # pragma: no cover
 
     collated_dict["mesh"] = None
     if {"verts", "faces"}.issubset(collated_dict.keys()):
+
         textures = None
         if "textures" in collated_dict:
             textures = TexturesAtlas(atlas=collated_dict["textures"])

pytorch3d/implicitron/dataset/data_source.py

@@ -41,7 +41,7 @@ class DataSourceBase(ReplaceableBase):
 
 
 @registry.register
-class ImplicitronDataSource(DataSourceBase):
+class ImplicitronDataSource(DataSourceBase):  # pyre-ignore[13]
     """
     Represents the data used in Implicitron. This is the only implementation
     of DataSourceBase provided.
@@ -52,11 +52,8 @@ class ImplicitronDataSource(DataSourceBase):
         data_loader_map_provider_class_type: identifies type for data_loader_map_provider.
     """
 
-    # pyre-fixme[13]: Attribute `dataset_map_provider` is never initialized.
     dataset_map_provider: DatasetMapProviderBase
-    # pyre-fixme[13]: Attribute `dataset_map_provider_class_type` is never initialized.
     dataset_map_provider_class_type: str
-    # pyre-fixme[13]: Attribute `data_loader_map_provider` is never initialized.
     data_loader_map_provider: DataLoaderMapProviderBase
     data_loader_map_provider_class_type: str = "SequenceDataLoaderMapProvider"
 

pytorch3d/implicitron/dataset/frame_data.py

@@ -26,7 +26,7 @@ from typing import (
 import numpy as np
 import torch
 
-from pytorch3d.implicitron.dataset import orm_types, types
+from pytorch3d.implicitron.dataset import types
 from pytorch3d.implicitron.dataset.utils import (
     adjust_camera_to_bbox_crop_,
     adjust_camera_to_image_scale_,
@@ -48,12 +48,8 @@ from pytorch3d.implicitron.dataset.utils import (
 from pytorch3d.implicitron.tools.config import registry, ReplaceableBase
 from pytorch3d.renderer.camera_utils import join_cameras_as_batch
 from pytorch3d.renderer.cameras import CamerasBase, PerspectiveCameras
-from pytorch3d.structures.meshes import join_meshes_as_batch, Meshes
 from pytorch3d.structures.pointclouds import join_pointclouds_as_batch, Pointclouds
 
-FrameAnnotationT = types.FrameAnnotation | orm_types.SqlFrameAnnotation
-SequenceAnnotationT = types.SequenceAnnotation | orm_types.SqlSequenceAnnotation
-
 
 @dataclass
 class FrameData(Mapping[str, Any]):
@@ -126,9 +122,9 @@ class FrameData(Mapping[str, Any]):
         meta: A dict for storing additional frame information.
     """
 
-    frame_number: Optional[torch.LongTensor] = None
-    sequence_name: Union[str, List[str]] = ""
-    sequence_category: Union[str, List[str]] = ""
+    frame_number: Optional[torch.LongTensor]
+    sequence_name: Union[str, List[str]]
+    sequence_category: Union[str, List[str]]
     frame_timestamp: Optional[torch.Tensor] = None
     image_size_hw: Optional[torch.LongTensor] = None
     effective_image_size_hw: Optional[torch.LongTensor] = None
@@ -159,7 +155,7 @@ class FrameData(Mapping[str, Any]):
         new_params = {}
         for field_name in iter(self):
             value = getattr(self, field_name)
-            if isinstance(value, (torch.Tensor, Pointclouds, CamerasBase, Meshes)):
+            if isinstance(value, (torch.Tensor, Pointclouds, CamerasBase)):
                 new_params[field_name] = value.to(*args, **kwargs)
             else:
                 new_params[field_name] = value
@@ -280,7 +276,6 @@ class FrameData(Mapping[str, Any]):
             image_size_hw=tuple(self.effective_image_size_hw),  # pyre-ignore
         )
         crop_bbox_xywh = bbox_xyxy_to_xywh(clamp_bbox_xyxy)
-        self.crop_bbox_xywh = crop_bbox_xywh
 
         if self.fg_probability is not None:
             self.fg_probability = crop_around_box(
@@ -421,6 +416,7 @@ class FrameData(Mapping[str, Any]):
             for f in fields(elem):
                 if not f.init:
                     continue
+
                 list_values = override_fields.get(
                     f.name, [getattr(d, f.name) for d in batch]
                 )
@@ -429,7 +425,7 @@ class FrameData(Mapping[str, Any]):
                     if all(list_value is not None for list_value in list_values)
                     else None
                 )
-            return type(elem)(**collated)
+            return cls(**collated)
 
         elif isinstance(elem, Pointclouds):
             return join_pointclouds_as_batch(batch)
@@ -437,10 +433,8 @@ class FrameData(Mapping[str, Any]):
         elif isinstance(elem, CamerasBase):
             # TODO: don't store K; enforce working in NDC space
             return join_cameras_as_batch(batch)
-        elif isinstance(elem, Meshes):
-            return join_meshes_as_batch(batch)
         else:
-            return torch.utils.data.dataloader.default_collate(batch)
+            return torch.utils.data._utils.collate.default_collate(batch)
 
 
 FrameDataSubtype = TypeVar("FrameDataSubtype", bound=FrameData)
@@ -459,8 +453,8 @@ class FrameDataBuilderBase(ReplaceableBase, Generic[FrameDataSubtype], ABC):
     @abstractmethod
     def build(
         self,
-        frame_annotation: FrameAnnotationT,
-        sequence_annotation: SequenceAnnotationT,
+        frame_annotation: types.FrameAnnotation,
+        sequence_annotation: types.SequenceAnnotation,
         *,
         load_blobs: bool = True,
         **kwargs,
@@ -546,8 +540,8 @@ class GenericFrameDataBuilder(FrameDataBuilderBase[FrameDataSubtype], ABC):
 
     def build(
         self,
-        frame_annotation: FrameAnnotationT,
-        sequence_annotation: SequenceAnnotationT,
+        frame_annotation: types.FrameAnnotation,
+        sequence_annotation: types.SequenceAnnotation,
         *,
         load_blobs: bool = True,
         **kwargs,
@@ -591,81 +585,58 @@ class GenericFrameDataBuilder(FrameDataBuilderBase[FrameDataSubtype], ABC):
             ),
         )
 
-        dataset_root = self.dataset_root
+        fg_mask_np: Optional[np.ndarray] = None
         mask_annotation = frame_annotation.mask
-        depth_annotation = frame_annotation.depth
-        image_path: str | None = None
-        mask_path: str | None = None
-        depth_path: str | None = None
-        pcl_path: str | None = None
-        if dataset_root is not None:  # set all paths even if we won’t load blobs
-            if frame_annotation.image.path is not None:
-                image_path = os.path.join(dataset_root, frame_annotation.image.path)
-                frame_data.image_path = image_path
-
-            if mask_annotation is not None and mask_annotation.path:
-                mask_path = os.path.join(dataset_root, mask_annotation.path)
-                frame_data.mask_path = mask_path
-
-            if depth_annotation is not None and depth_annotation.path is not None:
-                depth_path = os.path.join(dataset_root, depth_annotation.path)
-                frame_data.depth_path = depth_path
-
-            if point_cloud is not None:
-                pcl_path = os.path.join(dataset_root, point_cloud.path)
-                frame_data.sequence_point_cloud_path = pcl_path
-
-        fg_mask_np: np.ndarray | None = None
-        bbox_xywh: tuple[float, float, float, float] | None = None
-
         if mask_annotation is not None:
-            if load_blobs and self.load_masks and mask_path:
-                fg_mask_np = self._load_fg_probability(frame_annotation, mask_path)
+            if load_blobs and self.load_masks:
+                fg_mask_np, mask_path = self._load_fg_probability(frame_annotation)
+                frame_data.mask_path = mask_path
                 frame_data.fg_probability = safe_as_tensor(fg_mask_np, torch.float)
 
             bbox_xywh = mask_annotation.bounding_box_xywh
+            if bbox_xywh is None and fg_mask_np is not None:
+                bbox_xywh = get_bbox_from_mask(fg_mask_np, self.box_crop_mask_thr)
+
+            frame_data.bbox_xywh = safe_as_tensor(bbox_xywh, torch.float)
 
         if frame_annotation.image is not None:
             image_size_hw = safe_as_tensor(frame_annotation.image.size, torch.long)
             frame_data.image_size_hw = image_size_hw  # original image size
             # image size after crop/resize
             frame_data.effective_image_size_hw = image_size_hw
+            image_path = None
+            dataset_root = self.dataset_root
+            if frame_annotation.image.path is not None and dataset_root is not None:
+                image_path = os.path.join(dataset_root, frame_annotation.image.path)
+                frame_data.image_path = image_path
 
             if load_blobs and self.load_images:
                 if image_path is None:
                     raise ValueError("Image path is required to load images.")
 
-                no_mask = fg_mask_np is None  # didn’t read the mask file
-                image_np = load_image(
-                    self._local_path(image_path), try_read_alpha=no_mask
-                )
-                if image_np.shape[0] == 4:  # RGBA image
-                    if no_mask:
-                        fg_mask_np = image_np[3:]
-                        frame_data.fg_probability = safe_as_tensor(
-                            fg_mask_np, torch.float
-                        )
-
-                    image_np = image_np[:3]
-
+                image_np = load_image(self._local_path(image_path))
                 frame_data.image_rgb = self._postprocess_image(
                     image_np, frame_annotation.image.size, frame_data.fg_probability
                 )
 
-        if bbox_xywh is None and fg_mask_np is not None:
-            bbox_xywh = get_bbox_from_mask(fg_mask_np, self.box_crop_mask_thr)
-        frame_data.bbox_xywh = safe_as_tensor(bbox_xywh, torch.float)
-
-        if load_blobs and self.load_depths and depth_path is not None:
-            frame_data.depth_map, frame_data.depth_mask = self._load_mask_depth(
-                frame_annotation, depth_path, fg_mask_np
-            )
+        if (
+            load_blobs
+            and self.load_depths
+            and frame_annotation.depth is not None
+            and frame_annotation.depth.path is not None
+        ):
+            (
+                frame_data.depth_map,
+                frame_data.depth_path,
+                frame_data.depth_mask,
+            ) = self._load_mask_depth(frame_annotation, fg_mask_np)
 
         if load_blobs and self.load_point_clouds and point_cloud is not None:
-            assert pcl_path is not None
+            pcl_path = self._fix_point_cloud_path(point_cloud.path)
             frame_data.sequence_point_cloud = load_pointcloud(
                 self._local_path(pcl_path), max_points=self.max_points
             )
+            frame_data.sequence_point_cloud_path = pcl_path
 
         if frame_annotation.viewpoint is not None:
             frame_data.camera = self._get_pytorch3d_camera(frame_annotation)
@@ -681,14 +652,18 @@ class GenericFrameDataBuilder(FrameDataBuilderBase[FrameDataSubtype], ABC):
 
         return frame_data
 
-    def _load_fg_probability(self, entry: FrameAnnotationT, path: str) -> np.ndarray:
-        fg_probability = load_mask(self._local_path(path))
+    def _load_fg_probability(
+        self, entry: types.FrameAnnotation
+    ) -> Tuple[np.ndarray, str]:
+        assert self.dataset_root is not None and entry.mask is not None
+        full_path = os.path.join(self.dataset_root, entry.mask.path)
+        fg_probability = load_mask(self._local_path(full_path))
         if fg_probability.shape[-2:] != entry.image.size:
             raise ValueError(
                 f"bad mask size: {fg_probability.shape[-2:]} vs {entry.image.size}!"
             )
 
-        return fg_probability
+        return fg_probability, full_path
 
     def _postprocess_image(
         self,
@@ -709,14 +684,14 @@ class GenericFrameDataBuilder(FrameDataBuilderBase[FrameDataSubtype], ABC):
 
     def _load_mask_depth(
         self,
-        entry: FrameAnnotationT,
-        path: str,
+        entry: types.FrameAnnotation,
         fg_mask: Optional[np.ndarray],
-    ) -> tuple[torch.Tensor, torch.Tensor]:
+    ) -> Tuple[torch.Tensor, str, torch.Tensor]:
         entry_depth = entry.depth
         dataset_root = self.dataset_root
         assert dataset_root is not None
-        assert entry_depth is not None
+        assert entry_depth is not None and entry_depth.path is not None
+        path = os.path.join(dataset_root, entry_depth.path)
         depth_map = load_depth(self._local_path(path), entry_depth.scale_adjustment)
 
         if self.mask_depths:
@@ -730,11 +705,11 @@ class GenericFrameDataBuilder(FrameDataBuilderBase[FrameDataSubtype], ABC):
         else:
             depth_mask = (depth_map > 0.0).astype(np.float32)
 
-        return torch.tensor(depth_map), torch.tensor(depth_mask)
+        return torch.tensor(depth_map), path, torch.tensor(depth_mask)
 
     def _get_pytorch3d_camera(
         self,
-        entry: FrameAnnotationT,
+        entry: types.FrameAnnotation,
     ) -> PerspectiveCameras:
         entry_viewpoint = entry.viewpoint
         assert entry_viewpoint is not None
@@ -763,6 +738,19 @@ class GenericFrameDataBuilder(FrameDataBuilderBase[FrameDataSubtype], ABC):
             T=torch.tensor(entry_viewpoint.T, dtype=torch.float)[None],
         )
 
+    def _fix_point_cloud_path(self, path: str) -> str:
+        """
+        Fix up a point cloud path from the dataset.
+        Some files in Co3Dv2 have an accidental absolute path stored.
+        """
+        unwanted_prefix = (
+            "/large_experiments/p3/replay/datasets/co3d/co3d45k_220512/export_v23/"
+        )
+        if path.startswith(unwanted_prefix):
+            path = path[len(unwanted_prefix) :]
+        assert self.dataset_root is not None
+        return os.path.join(self.dataset_root, path)
+
     def _local_path(self, path: str) -> str:
         if self.path_manager is None:
             return path

pytorch3d/implicitron/dataset/json_index_dataset_map_provider.py

@@ -66,7 +66,7 @@ _NEED_CONTROL: Tuple[str, ...] = (
 
 
 @registry.register
-class JsonIndexDatasetMapProvider(DatasetMapProviderBase):
+class JsonIndexDatasetMapProvider(DatasetMapProviderBase):  # pyre-ignore [13]
     """
     Generates the training / validation and testing dataset objects for
     a dataset laid out on disk like Co3D, with annotations in json files.
@@ -95,7 +95,6 @@ class JsonIndexDatasetMapProvider(DatasetMapProviderBase):
         path_manager_factory_class_type: The class type of `path_manager_factory`.
     """
 
-    # pyre-fixme[13]: Attribute `category` is never initialized.
     category: str
     task_str: str = "singlesequence"
     dataset_root: str = _CO3D_DATASET_ROOT
@@ -105,10 +104,8 @@ class JsonIndexDatasetMapProvider(DatasetMapProviderBase):
     test_restrict_sequence_id: int = -1
     assert_single_seq: bool = False
     only_test_set: bool = False
-    # pyre-fixme[13]: Attribute `dataset` is never initialized.
     dataset: JsonIndexDataset
     dataset_class_type: str = "JsonIndexDataset"
-    # pyre-fixme[13]: Attribute `path_manager_factory` is never initialized.
     path_manager_factory: PathManagerFactory
     path_manager_factory_class_type: str = "PathManagerFactory"
 

pytorch3d/implicitron/dataset/json_index_dataset_map_provider_v2.py

@@ -56,7 +56,7 @@ logger = logging.getLogger(__name__)
 
 
 @registry.register
-class JsonIndexDatasetMapProviderV2(DatasetMapProviderBase):
+class JsonIndexDatasetMapProviderV2(DatasetMapProviderBase):  # pyre-ignore [13]
     """
     Generates the training, validation, and testing dataset objects for
     a dataset laid out on disk like CO3Dv2, with annotations in gzipped json files.
@@ -171,9 +171,7 @@ class JsonIndexDatasetMapProviderV2(DatasetMapProviderBase):
         path_manager_factory_class_type: The class type of `path_manager_factory`.
     """
 
-    # pyre-fixme[13]: Attribute `category` is never initialized.
     category: str
-    # pyre-fixme[13]: Attribute `subset_name` is never initialized.
     subset_name: str
     dataset_root: str = _CO3DV2_DATASET_ROOT
 
@@ -185,10 +183,8 @@ class JsonIndexDatasetMapProviderV2(DatasetMapProviderBase):
     n_known_frames_for_test: int = 0
 
     dataset_class_type: str = "JsonIndexDataset"
-    # pyre-fixme[13]: Attribute `dataset` is never initialized.
     dataset: JsonIndexDataset
 
-    # pyre-fixme[13]: Attribute `path_manager_factory` is never initialized.
     path_manager_factory: PathManagerFactory
     path_manager_factory_class_type: str = "PathManagerFactory"
 
@@ -222,6 +218,7 @@ class JsonIndexDatasetMapProviderV2(DatasetMapProviderBase):
         self.dataset_map = dataset_map
 
     def _load_category(self, category: str) -> DatasetMap:
+
         frame_file = os.path.join(self.dataset_root, category, "frame_annotations.jgz")
         sequence_file = os.path.join(
             self.dataset_root, category, "sequence_annotations.jgz"

pytorch3d/implicitron/dataset/load_llff.py

@@ -75,6 +75,7 @@ def _minify(basedir, path_manager, factors=(), resolutions=()):
 def _load_data(
     basedir, factor=None, width=None, height=None, load_imgs=True, path_manager=None
 ):
+
     poses_arr = np.load(
         _local_path(path_manager, os.path.join(basedir, "poses_bounds.npy"))
     )
@@ -163,6 +164,7 @@ def ptstocam(pts, c2w):
 
 
 def poses_avg(poses):
+
     hwf = poses[0, :3, -1:]
 
     center = poses[:, :3, 3].mean(0)
@@ -190,6 +192,7 @@ def render_path_spiral(c2w, up, rads, focal, zdelta, zrate, rots, N):
 
 
 def recenter_poses(poses):
+
     poses_ = poses + 0
     bottom = np.reshape([0, 0, 0, 1.0], [1, 4])
     c2w = poses_avg(poses)
@@ -253,6 +256,7 @@ def spherify_poses(poses, bds):
     new_poses = []
 
     for th in np.linspace(0.0, 2.0 * np.pi, 120):
+
         camorigin = np.array([radcircle * np.cos(th), radcircle * np.sin(th), zh])
         up = np.array([0, 0, -1.0])
 
@@ -307,6 +311,7 @@ def load_llff_data(
     path_zflat=False,
     path_manager=None,
 ):
+
     poses, bds, imgs = _load_data(
         basedir, factor=factor, path_manager=path_manager
     )  # factor=8 downsamples original imgs by 8x

pytorch3d/implicitron/dataset/orm_types.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
-
 # This functionality requires SQLAlchemy 2.0 or later.
 
 import math

pytorch3d/implicitron/dataset/rendered_mesh_dataset_map_provider.py

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

pytorch3d/implicitron/dataset/single_sequence_dataset.py

@@ -83,6 +83,7 @@ class SingleSceneDataset(DatasetBase, Configurable):
         return self.eval_batches
 
 
+# pyre-fixme[13]: Uninitialized attribute
 class SingleSceneDatasetMapProviderBase(DatasetMapProviderBase):
     """
     Base for provider of data for one scene from LLFF or blender datasets.
@@ -99,11 +100,8 @@ class SingleSceneDatasetMapProviderBase(DatasetMapProviderBase):
             testing frame.
     """
 
-    # pyre-fixme[13]: Attribute `base_dir` is never initialized.
     base_dir: str
-    # pyre-fixme[13]: Attribute `object_name` is never initialized.
     object_name: str
-    # pyre-fixme[13]: Attribute `path_manager_factory` is never initialized.
     path_manager_factory: PathManagerFactory
     path_manager_factory_class_type: str = "PathManagerFactory"
     n_known_frames_for_test: Optional[int] = None

pytorch3d/implicitron/dataset/sql_dataset.py

@@ -4,15 +4,11 @@
 # 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 hashlib
 import json
 import logging
 import os
-
-import urllib
-from dataclasses import dataclass, Field, field
+from dataclasses import dataclass
 from typing import (
     Any,
     ClassVar,
@@ -33,18 +29,17 @@ import sqlalchemy as sa
 import torch
 from pytorch3d.implicitron.dataset.dataset_base import DatasetBase
 
-from pytorch3d.implicitron.dataset.frame_data import (
+from pytorch3d.implicitron.dataset.frame_data import (  # noqa
     FrameData,
-    FrameDataBuilder,  # noqa
+    FrameDataBuilder,
     FrameDataBuilderBase,
 )
-
 from pytorch3d.implicitron.tools.config import (
     registry,
     ReplaceableBase,
     run_auto_creation,
 )
-from sqlalchemy.orm import scoped_session, Session, sessionmaker
+from sqlalchemy.orm import Session
 
 from .orm_types import SqlFrameAnnotation, SqlSequenceAnnotation
 
@@ -56,7 +51,7 @@ _SET_LISTS_TABLE: str = "set_lists"
 
 
 @registry.register
-class SqlIndexDataset(DatasetBase, ReplaceableBase):
+class SqlIndexDataset(DatasetBase, ReplaceableBase):  # pyre-ignore
     """
     A dataset with annotations stored as SQLite tables. This is an index-based dataset.
     The length is returned after all sequence and frame filters are applied (see param
@@ -93,7 +88,6 @@ class SqlIndexDataset(DatasetBase, ReplaceableBase):
             engine verbatim. Don’t expose it to end users of your application!
         pick_categories: Restrict the dataset to the given list of categories.
         pick_sequences: A Sequence of sequence names to restrict the dataset to.
-        pick_sequences_sql_clause: Custom SQL WHERE clause to constrain sequence annotations.
         exclude_sequences: A Sequence of the names of the sequences to exclude.
         limit_sequences_per_category_to: Limit the dataset to the first up to N
             sequences within each category (applies after all other sequence filters
@@ -108,16 +102,9 @@ class SqlIndexDataset(DatasetBase, ReplaceableBase):
             more frames than that; applied after other frame-level filters.
         seed: The seed of the random generator sampling `n_frames_per_sequence`
             random frames per sequence.
-        preload_metadata: If True, the metadata is preloaded into memory.
-        precompute_seq_to_idx: If True, precomputes the mapping from sequence name to indices.
-        scoped_session: If True, allows different parts of the code to share
-            a global session to access the database.
     """
 
     frame_annotations_type: ClassVar[Type[SqlFrameAnnotation]] = SqlFrameAnnotation
-    sequence_annotations_type: ClassVar[Type[SqlSequenceAnnotation]] = (
-        SqlSequenceAnnotation
-    )
 
     sqlite_metadata_file: str = ""
     dataset_root: Optional[str] = None
@@ -130,7 +117,6 @@ class SqlIndexDataset(DatasetBase, ReplaceableBase):
     pick_categories: Tuple[str, ...] = ()
 
     pick_sequences: Tuple[str, ...] = ()
-    pick_sequences_sql_clause: Optional[str] = None
     exclude_sequences: Tuple[str, ...] = ()
     limit_sequences_per_category_to: int = 0
     limit_sequences_to: int = 0
@@ -138,22 +124,12 @@ class SqlIndexDataset(DatasetBase, ReplaceableBase):
     n_frames_per_sequence: int = -1
     seed: int = 0
     remove_empty_masks_poll_whole_table_threshold: int = 300_000
-    preload_metadata: bool = False
-    precompute_seq_to_idx: bool = False
     # we set it manually in the constructor
-    _index: pd.DataFrame = field(init=False, metadata={"omegaconf_ignore": True})
-    _sql_engine: sa.engine.Engine = field(
-        init=False, metadata={"omegaconf_ignore": True}
-    )
-    eval_batches: Optional[List[Any]] = field(
-        init=False, metadata={"omegaconf_ignore": True}
-    )
+    # _index: pd.DataFrame = field(init=False)
 
-    frame_data_builder: FrameDataBuilderBase  # pyre-ignore[13]
+    frame_data_builder: FrameDataBuilderBase
     frame_data_builder_class_type: str = "FrameDataBuilder"
 
-    scoped_session: bool = False
-
     def __post_init__(self) -> None:
         if sa.__version__ < "2.0":
             raise ImportError("This class requires SQL Alchemy 2.0 or later")
@@ -162,28 +138,19 @@ class SqlIndexDataset(DatasetBase, ReplaceableBase):
             raise ValueError("sqlite_metadata_file must be set")
 
         if self.dataset_root:
-            frame_args = f"frame_data_builder_{self.frame_data_builder_class_type}_args"
-            getattr(self, frame_args)["dataset_root"] = self.dataset_root
-            getattr(self, frame_args)["path_manager"] = self.path_manager
+            frame_builder_type = self.frame_data_builder_class_type
+            getattr(self, f"frame_data_builder_{frame_builder_type}_args")[
+                "dataset_root"
+            ] = self.dataset_root
 
         run_auto_creation(self)
+        self.frame_data_builder.path_manager = self.path_manager
 
-        if self.path_manager is not None:
-            self.sqlite_metadata_file = self.path_manager.get_local_path(
-                self.sqlite_metadata_file
-            )
-            self.subset_lists_file = self.path_manager.get_local_path(
-                self.subset_lists_file
-            )
-
-        # NOTE: sqlite-specific args (read-only mode).
+        # pyre-ignore  # NOTE: sqlite-specific args (read-only mode).
         self._sql_engine = sa.create_engine(
-            f"sqlite:///file:{urllib.parse.quote(self.sqlite_metadata_file)}?mode=ro&uri=true"
+            f"sqlite:///file:{self.sqlite_metadata_file}?mode=ro&uri=true"
         )
 
-        if self.preload_metadata:
-            self._sql_engine = self._preload_database(self._sql_engine)
-
         sequences = self._get_filtered_sequences_if_any()
 
         if self.subsets:
@@ -199,29 +166,16 @@ class SqlIndexDataset(DatasetBase, ReplaceableBase):
         if len(index) == 0:
             raise ValueError(f"There are no frames in the subsets: {self.subsets}!")
 
-        self._index = index.set_index(["sequence_name", "frame_number"])
+        self._index = index.set_index(["sequence_name", "frame_number"])  # pyre-ignore
 
-        self.eval_batches = None
+        self.eval_batches = None  # pyre-ignore
         if self.eval_batches_file:
             self.eval_batches = self._load_filter_eval_batches()
 
         logger.info(str(self))
 
-        if self.scoped_session:
-            self._session_factory = sessionmaker(bind=self._sql_engine)  # pyre-ignore
-
-        if self.precompute_seq_to_idx:
-            # This is deprecated and will be removed in the future.
-            # After we backport https://github.com/facebookresearch/uco3d/pull/3
-            logger.warning(
-                "Using precompute_seq_to_idx is deprecated and will be removed in the future."
-            )
-            self._index["rowid"] = np.arange(len(self._index))
-            groupby = self._index.groupby("sequence_name", sort=False)["rowid"]
-            self._seq_to_indices = dict(groupby.apply(list))  # pyre-ignore
-            del self._index["rowid"]
-
     def __len__(self) -> int:
+        # pyre-ignore[16]
         return len(self._index)
 
     def __getitem__(self, frame_idx: Union[int, Tuple[str, int]]) -> FrameData:
@@ -278,18 +232,12 @@ class SqlIndexDataset(DatasetBase, ReplaceableBase):
             self.frame_annotations_type.frame_number
             == int(frame),  # cast from np.int64
         )
-        seq_stmt = sa.select(self.sequence_annotations_type).where(
-            self.sequence_annotations_type.sequence_name == seq
+        seq_stmt = sa.select(SqlSequenceAnnotation).where(
+            SqlSequenceAnnotation.sequence_name == seq
         )
-        if self.scoped_session:
-            # pyre-ignore
-            with scoped_session(self._session_factory)() as session:
-                entry = session.scalars(stmt).one()
-                seq_metadata = session.scalars(seq_stmt).one()
-        else:
-            with Session(self._sql_engine) as session:
-                entry = session.scalars(stmt).one()
-                seq_metadata = session.scalars(seq_stmt).one()
+        with Session(self._sql_engine) as session:
+            entry = session.scalars(stmt).one()
+            seq_metadata = session.scalars(seq_stmt).one()
 
         assert entry.image.path == self._index.loc[(seq, frame), "_image_path"]
 
@@ -302,6 +250,7 @@ class SqlIndexDataset(DatasetBase, ReplaceableBase):
         return frame_data
 
     def __str__(self) -> str:
+        # pyre-ignore[16]
         return f"SqlIndexDataset #frames={len(self._index)}"
 
     def sequence_names(self) -> Iterable[str]:
@@ -311,10 +260,9 @@ class SqlIndexDataset(DatasetBase, ReplaceableBase):
     # override
     def category_to_sequence_names(self) -> Dict[str, List[str]]:
         stmt = sa.select(
-            self.sequence_annotations_type.category,
-            self.sequence_annotations_type.sequence_name,
+            SqlSequenceAnnotation.category, SqlSequenceAnnotation.sequence_name
         ).where(  # we limit results to sequences that have frames after all filters
-            self.sequence_annotations_type.sequence_name.in_(self.sequence_names())
+            SqlSequenceAnnotation.sequence_name.in_(self.sequence_names())
         )
         with self._sql_engine.connect() as connection:
             cat_to_seqs = pd.read_sql(stmt, connection)
@@ -387,31 +335,17 @@ class SqlIndexDataset(DatasetBase, ReplaceableBase):
         rows = self._index.index.get_loc(seq_name)
         if isinstance(rows, slice):
             assert rows.stop is not None, "Unexpected result from pandas"
-            rows_seq = range(rows.start or 0, rows.stop, rows.step or 1)
+            rows = range(rows.start or 0, rows.stop, rows.step or 1)
         else:
-            rows_seq = list(np.where(rows)[0])
+            rows = np.where(rows)[0]
 
         index_slice, idx = self._get_frame_no_coalesced_ts_by_row_indices(
-            rows_seq, seq_name, subset_filter
+            rows, seq_name, subset_filter
         )
         index_slice["idx"] = idx
 
         yield from index_slice.itertuples(index=False)
 
-    # override
-    def sequence_indices_in_order(
-        self, seq_name: str, subset_filter: Optional[Sequence[str]] = None
-    ) -> Iterator[int]:
-        """Same as `sequence_frames_in_order` but returns the iterator over
-        only dataset indices.
-        """
-        if self.precompute_seq_to_idx and subset_filter is None:
-            # pyre-ignore
-            yield from self._seq_to_indices[seq_name]
-        else:
-            for _, _, idx in self.sequence_frames_in_order(seq_name, subset_filter):
-                yield idx
-
     # override
     def get_eval_batches(self) -> Optional[List[Any]]:
         """
@@ -445,35 +379,11 @@ class SqlIndexDataset(DatasetBase, ReplaceableBase):
             or self.limit_sequences_to > 0
             or self.limit_sequences_per_category_to > 0
             or len(self.pick_sequences) > 0
-            or self.pick_sequences_sql_clause is not None
             or len(self.exclude_sequences) > 0
             or len(self.pick_categories) > 0
             or self.n_frames_per_sequence > 0
         )
 
-    def _preload_database(
-        self, source_engine: sa.engine.base.Engine
-    ) -> sa.engine.base.Engine:
-        destination_engine = sa.create_engine("sqlite:///:memory:")
-        metadata = sa.MetaData()
-        metadata.reflect(bind=source_engine)
-        metadata.create_all(bind=destination_engine)
-
-        with source_engine.connect() as source_conn:
-            with destination_engine.connect() as destination_conn:
-                for table_obj in metadata.tables.values():
-                    # Select all rows from the source table
-                    source_rows = source_conn.execute(table_obj.select())
-
-                    # Insert rows into the destination table
-                    for row in source_rows:
-                        destination_conn.execute(table_obj.insert().values(row))
-
-                    # Commit the changes for each table
-                    destination_conn.commit()
-
-        return destination_engine
-
     def _get_filtered_sequences_if_any(self) -> Optional[pd.Series]:
         # maximum possible filter (if limit_sequences_per_category_to == 0):
         # WHERE category IN 'self.pick_categories'
@@ -486,22 +396,19 @@ class SqlIndexDataset(DatasetBase, ReplaceableBase):
             *self._get_pick_filters(),
             *self._get_exclude_filters(),
         ]
-        if self.pick_sequences_sql_clause:
-            print("Applying the custom SQL clause.")
-            where_conditions.append(sa.text(self.pick_sequences_sql_clause))
 
         def add_where(stmt):
             return stmt.where(*where_conditions) if where_conditions else stmt
 
         if self.limit_sequences_per_category_to <= 0:
-            stmt = add_where(sa.select(self.sequence_annotations_type.sequence_name))
+            stmt = add_where(sa.select(SqlSequenceAnnotation.sequence_name))
         else:
             subquery = sa.select(
-                self.sequence_annotations_type.sequence_name,
+                SqlSequenceAnnotation.sequence_name,
                 sa.func.row_number()
                 .over(
                     order_by=sa.text("ROWID"),  # NOTE: ROWID is SQLite-specific
-                    partition_by=self.sequence_annotations_type.category,
+                    partition_by=SqlSequenceAnnotation.category,
                 )
                 .label("row_number"),
             )
@@ -537,34 +444,31 @@ class SqlIndexDataset(DatasetBase, ReplaceableBase):
             return []
 
         logger.info(f"Limiting dataset to categories: {self.pick_categories}")
-        return [self.sequence_annotations_type.category.in_(self.pick_categories)]
+        return [SqlSequenceAnnotation.category.in_(self.pick_categories)]
 
     def _get_pick_filters(self) -> List[sa.ColumnElement]:
         if not self.pick_sequences:
             return []
 
         logger.info(f"Limiting dataset to sequences: {self.pick_sequences}")
-        return [self.sequence_annotations_type.sequence_name.in_(self.pick_sequences)]
+        return [SqlSequenceAnnotation.sequence_name.in_(self.pick_sequences)]
 
     def _get_exclude_filters(self) -> List[sa.ColumnOperators]:
         if not self.exclude_sequences:
             return []
 
         logger.info(f"Removing sequences from the dataset: {self.exclude_sequences}")
-        return [
-            self.sequence_annotations_type.sequence_name.notin_(self.exclude_sequences)
-        ]
+        return [SqlSequenceAnnotation.sequence_name.notin_(self.exclude_sequences)]
 
     def _load_subsets_from_json(self, subset_lists_path: str) -> pd.DataFrame:
-        subsets = self.subsets
-        assert subsets is not None
+        assert self.subsets is not None
         with open(subset_lists_path, "r") as f:
             subset_to_seq_frame = json.load(f)
 
         seq_frame_list = sum(
             (
                 [(*row, subset) for row in subset_to_seq_frame[subset]]
-                for subset in subsets
+                for subset in self.subsets
             ),
             [],
         )
@@ -618,7 +522,7 @@ class SqlIndexDataset(DatasetBase, ReplaceableBase):
                 stmt = sa.select(
                     self.frame_annotations_type.sequence_name,
                     self.frame_annotations_type.frame_number,
-                ).where(self.frame_annotations_type._mask_mass == 0)  # pyre-ignore[16]
+                ).where(self.frame_annotations_type._mask_mass == 0)
                 with Session(self._sql_engine) as session:
                     to_remove = session.execute(stmt).all()
 
@@ -682,7 +586,7 @@ class SqlIndexDataset(DatasetBase, ReplaceableBase):
         stmt = sa.select(
             self.frame_annotations_type.sequence_name,
             self.frame_annotations_type.frame_number,
-            self.frame_annotations_type._image_path,  # pyre-ignore[16]
+            self.frame_annotations_type._image_path,
             sa.null().label("subset"),
         )
         where_conditions = []
@@ -696,7 +600,7 @@ class SqlIndexDataset(DatasetBase, ReplaceableBase):
             logger.info("  excluding samples with empty masks")
             where_conditions.append(
                 sa.or_(
-                    self.frame_annotations_type._mask_mass.is_(None),  # pyre-ignore[16]
+                    self.frame_annotations_type._mask_mass.is_(None),
                     self.frame_annotations_type._mask_mass != 0,
                 )
             )
@@ -730,9 +634,7 @@ class SqlIndexDataset(DatasetBase, ReplaceableBase):
         assert self.eval_batches_file
         logger.info(f"Loading eval batches from {self.eval_batches_file}")
 
-        if (
-            self.path_manager and not self.path_manager.isfile(self.eval_batches_file)
-        ) or (not self.path_manager and not os.path.isfile(self.eval_batches_file)):
+        if not os.path.isfile(self.eval_batches_file):
             # The batch indices file does not exist.
             # Most probably the user has not specified the root folder.
             raise ValueError(
@@ -740,8 +642,7 @@ class SqlIndexDataset(DatasetBase, ReplaceableBase):
                 + "Please specify a correct dataset_root folder."
             )
 
-        eval_batches_file = self._local_path(self.eval_batches_file)
-        with open(eval_batches_file, "r") as f:
+        with open(self.eval_batches_file, "r") as f:
             eval_batches = json.load(f)
 
         # limit the dataset to sequences to allow multiple evaluations in one file
@@ -825,15 +726,9 @@ class SqlIndexDataset(DatasetBase, ReplaceableBase):
             self.frame_annotations_type.sequence_name == seq_name,
             self.frame_annotations_type.frame_number.in_(frames),
         )
-        frame_no_ts = None
 
-        if self.scoped_session:
-            stmt_text = str(stmt.compile(compile_kwargs={"literal_binds": True}))
-            with scoped_session(self._session_factory)() as session:  # pyre-ignore
-                frame_no_ts = pd.read_sql_query(stmt_text, session.connection())
-        else:
-            with self._sql_engine.connect() as connection:
-                frame_no_ts = pd.read_sql_query(stmt, connection)
+        with self._sql_engine.connect() as connection:
+            frame_no_ts = pd.read_sql_query(stmt, connection)
 
         if len(frame_no_ts) != len(index_slice):
             raise ValueError(
@@ -863,18 +758,11 @@ class SqlIndexDataset(DatasetBase, ReplaceableBase):
             prefixes=["TEMP"],  # NOTE SQLite specific!
         )
 
-    @classmethod
-    def pre_expand(cls) -> None:
-        # remove dataclass annotations that are not meant to be init params
-        # because they cause troubles for OmegaConf
-        for attr, attr_value in list(cls.__dict__.items()):  # need to copy as we mutate
-            if isinstance(attr_value, Field) and attr_value.metadata.get(
-                "omegaconf_ignore", False
-            ):
-                delattr(cls, attr)
-                del cls.__annotations__[attr]
-
 
 def _seq_name_to_seed(seq_name) -> int:
     """Generates numbers in [0, 2 ** 28)"""
     return int(hashlib.sha1(seq_name.encode("utf-8")).hexdigest()[:7], 16)
+
+
+def _safe_as_tensor(data, dtype):
+    return torch.tensor(data, dtype=dtype) if data is not None else None

pytorch3d/implicitron/dataset/sql_dataset_provider.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
@@ -45,7 +43,7 @@ logger = logging.getLogger(__name__)
 
 
 @registry.register
-class SqlIndexDatasetMapProvider(DatasetMapProviderBase):
+class SqlIndexDatasetMapProvider(DatasetMapProviderBase):  # pyre-ignore [13]
     """
     Generates the training, validation, and testing dataset objects for
     a dataset laid out on disk like SQL-CO3D, with annotations in an SQLite data base.
@@ -195,9 +193,9 @@ class SqlIndexDatasetMapProvider(DatasetMapProviderBase):
 
     # this is a mould that is never constructed, used to build self._dataset_map values
     dataset_class_type: str = "SqlIndexDataset"
-    dataset: SqlIndexDataset  # pyre-ignore [13]
+    dataset: SqlIndexDataset
 
-    path_manager_factory: PathManagerFactory  # pyre-ignore [13]
+    path_manager_factory: PathManagerFactory
     path_manager_factory_class_type: str = "PathManagerFactory"
 
     def __post_init__(self):
@@ -284,14 +282,8 @@ class SqlIndexDatasetMapProvider(DatasetMapProviderBase):
                 logger.info(f"Val dataset: {str(val_dataset)}")
 
             logger.debug("Extracting test dataset.")
-            if self.eval_batches_path is None:
-                eval_batches_file = None
-            else:
-                eval_batches_file = self._get_lists_file("eval_batches")
-
-            if "eval_batches_file" in common_dataset_kwargs:
-                common_dataset_kwargs.pop("eval_batches_file", None)
-
+            eval_batches_file = self._get_lists_file("eval_batches")
+            del common_dataset_kwargs["eval_batches_file"]
             test_dataset = dataset_type(
                 **common_dataset_kwargs,
                 subsets=self._get_subsets(self.test_subsets, True),

pytorch3d/implicitron/dataset/utils.py

@@ -87,15 +87,6 @@ def is_train_frame(
 def get_bbox_from_mask(
     mask: np.ndarray, thr: float, decrease_quant: float = 0.05
 ) -> Tuple[int, int, int, int]:
-    # these corner cases need to be handled in order to avoid an infinite loop
-    if mask.size == 0:
-        warnings.warn("Empty mask is provided for bbox extraction.", stacklevel=1)
-        return 0, 0, 1, 1
-
-    if not mask.min() >= 0.0:
-        warnings.warn("Negative values in the mask for bbox extraction.", stacklevel=1)
-        mask = mask.clip(min=0.0)
-
     # bbox in xywh
     masks_for_box = np.zeros_like(mask)
     while masks_for_box.sum() <= 1.0:
@@ -143,15 +134,7 @@ T = TypeVar("T", bound=torch.Tensor)
 def bbox_xyxy_to_xywh(xyxy: T) -> T:
     wh = xyxy[2:] - xyxy[:2]
     xywh = torch.cat([xyxy[:2], wh])
-    return xywh  # pyre-ignore[7]
-
-
-def bbox_xywh_to_xyxy(xywh: T, clamp_size: float | int | None = None) -> T:
-    wh = xywh[2:]
-    if clamp_size is not None:
-        wh = wh.clamp(min=clamp_size)
-    xyxy = torch.cat([xywh[:2], xywh[:2] + wh])
-    return xyxy  # pyre-ignore[7]
+    return xywh  # pyre-ignore
 
 
 def get_clamp_bbox(
@@ -197,6 +180,16 @@ def rescale_bbox(
     return bbox * rel_size
 
 
+def bbox_xywh_to_xyxy(
+    xywh: torch.Tensor, clamp_size: Optional[int] = None
+) -> torch.Tensor:
+    xyxy = xywh.clone()
+    if clamp_size is not None:
+        xyxy[2:] = torch.clamp(xyxy[2:], clamp_size)
+    xyxy[2:] += xyxy[:2]
+    return xyxy
+
+
 def get_1d_bounds(arr: np.ndarray) -> Tuple[int, int]:
     nz = np.flatnonzero(arr)
     return nz[0], nz[-1] + 1
@@ -208,24 +201,18 @@ def resize_image(
     image_width: Optional[int],
     mode: str = "bilinear",
 ) -> Tuple[torch.Tensor, float, torch.Tensor]:
+
     if isinstance(image, np.ndarray):
         image = torch.from_numpy(image)
 
-    if (
-        image_height is None
-        or image_width is None
-        or image.shape[-2] == 0
-        or image.shape[-1] == 0
-    ):
+    if image_height is None or image_width is None:
         # skip the resizing
         return image, 1.0, torch.ones_like(image[:1])
-
     # takes numpy array or tensor, returns pytorch tensor
     minscale = min(
         image_height / image.shape[-2],
         image_width / image.shape[-1],
     )
-
     imre = torch.nn.functional.interpolate(
         image[None],
         scale_factor=minscale,
@@ -233,7 +220,6 @@ def resize_image(
         align_corners=False if mode == "bilinear" else None,
         recompute_scale_factor=True,
     )[0]
-
     imre_ = torch.zeros(image.shape[0], image_height, image_width)
     imre_[:, 0 : imre.shape[1], 0 : imre.shape[2]] = imre
     mask = torch.zeros(1, image_height, image_width)
@@ -246,21 +232,9 @@ def transpose_normalize_image(image: np.ndarray) -> np.ndarray:
     return im.astype(np.float32) / 255.0
 
 
-def load_image(
-    path: str, try_read_alpha: bool = False, pil_format: str = "RGB"
-) -> np.ndarray:
-    """
-    Load an image from a path and return it as a numpy array.
-    If try_read_alpha is True, the image is read as RGBA and the alpha channel is
-    returned as the fourth channel.
-    Otherwise, the image is read as RGB and a three-channel image is returned.
-    """
+def load_image(path: str) -> np.ndarray:
     with Image.open(path) as pil_im:
-        # Check if the image has an alpha channel
-        if try_read_alpha and pil_im.mode == "RGBA":
-            im = np.array(pil_im)
-        else:
-            im = np.array(pil_im.convert(pil_format))
+        im = np.array(pil_im.convert("RGB"))
 
     return transpose_normalize_image(im)
 
@@ -355,7 +329,6 @@ def adjust_camera_to_bbox_crop_(
 
     focal_length_px, principal_point_px = _convert_ndc_to_pixels(
         camera.focal_length[0],
-        # pyre-fixme[29]: `Union[(self: TensorBase, indices: Union[None, slice[Any, A...
         camera.principal_point[0],
         image_size_wh,
     )
@@ -368,7 +341,6 @@ def adjust_camera_to_bbox_crop_(
     )
 
     camera.focal_length = focal_length[None]
-    # pyre-fixme[16]: `PerspectiveCameras` has no attribute `principal_point`.
     camera.principal_point = principal_point_cropped[None]
 
 
@@ -376,11 +348,9 @@ def adjust_camera_to_image_scale_(
     camera: PerspectiveCameras,
     original_size_wh: torch.Tensor,
     new_size_wh: torch.LongTensor,
-    # pyre-fixme[7]: Expected `PerspectiveCameras` but got implicit return value of `None`.
 ) -> PerspectiveCameras:
     focal_length_px, principal_point_px = _convert_ndc_to_pixels(
         camera.focal_length[0],
-        # pyre-fixme[29]: `Union[(self: TensorBase, indices: Union[None, slice[Any, A...
         camera.principal_point[0],
         original_size_wh,
     )
@@ -397,8 +367,7 @@ def adjust_camera_to_image_scale_(
         image_size_wh_output,
     )
     camera.focal_length = focal_length_scaled[None]
-    # pyre-fixme[16]: `PerspectiveCameras` has no attribute `principal_point`.
-    camera.principal_point = principal_point_scaled[None]  # pyre-ignore[16]
+    camera.principal_point = principal_point_scaled[None]  # pyre-ignore
 
 
 # NOTE this cache is per-worker; they are implemented as processes.

pytorch3d/implicitron/evaluation/evaluate_new_view_synthesis.py

@@ -299,6 +299,7 @@ def eval_batch(
     )
 
     for loss_fg_mask, name_postfix in zip((mask_crop, mask_fg), ("_masked", "_fg")):
+
         loss_mask_now = mask_crop * loss_fg_mask
 
         for rgb_metric_name, rgb_metric_fun in zip(

pytorch3d/implicitron/models/feature_extractor/resnet_feature_extractor.py

@@ -106,7 +106,7 @@ class ResNetFeatureExtractor(FeatureExtractorBase):
             self.layers = torch.nn.ModuleList()
             self.proj_layers = torch.nn.ModuleList()
             for stage in range(self.max_stage):
-                stage_name = f"layer{stage + 1}"
+                stage_name = f"layer{stage+1}"
                 feature_name = self._get_resnet_stage_feature_name(stage)
                 if (stage + 1) in self.stages:
                     if (
@@ -139,18 +139,12 @@ class ResNetFeatureExtractor(FeatureExtractorBase):
         self.stages = set(self.stages)  # convert to set for faster "in"
 
     def _get_resnet_stage_feature_name(self, stage) -> str:
-        return f"res_layer_{stage + 1}"
+        return f"res_layer_{stage+1}"
 
     def _resnet_normalize_image(self, img: torch.Tensor) -> torch.Tensor:
-        # pyre-fixme[58]: `-` is not supported for operand types `Tensor` and
-        #  `Union[Tensor, Module]`.
-        # pyre-fixme[58]: `/` is not supported for operand types `Tensor` and
-        #  `Union[Tensor, Module]`.
         return (img - self._resnet_mean) / self._resnet_std
 
     def get_feat_dims(self) -> int:
-        # pyre-fixme[29]: `Union[(self: TensorBase) -> Tensor, Tensor, Module]` is
-        #  not a function.
         return sum(self._feat_dim.values())
 
     def forward(
@@ -189,12 +183,7 @@ class ResNetFeatureExtractor(FeatureExtractorBase):
             else:
                 imgs_normed = imgs_resized
             #  is not a function.
-            # pyre-fixme[29]: `Union[Tensor, Module]` is not a function.
             feats = self.stem(imgs_normed)
-            # pyre-fixme[6]: For 1st argument expected `Iterable[_T1]` but got
-            #  `Union[Tensor, Module]`.
-            # pyre-fixme[6]: For 2nd argument expected `Iterable[_T2]` but got
-            #  `Union[Tensor, Module]`.
             for stage, (layer, proj) in enumerate(zip(self.layers, self.proj_layers)):
                 feats = layer(feats)
                 # just a sanity check below

pytorch3d/implicitron/models/generic_model.py

@@ -65,7 +65,7 @@ logger = logging.getLogger(__name__)
 
 
 @registry.register
-class GenericModel(ImplicitronModelBase):
+class GenericModel(ImplicitronModelBase):  # pyre-ignore: 13
     """
     GenericModel is a wrapper for the neural implicit
     rendering and reconstruction pipeline which consists
@@ -226,42 +226,34 @@ class GenericModel(ImplicitronModelBase):
 
     # ---- global encoder settings
     global_encoder_class_type: Optional[str] = None
-    # pyre-fixme[13]: Attribute `global_encoder` is never initialized.
     global_encoder: Optional[GlobalEncoderBase]
 
     # ---- raysampler
     raysampler_class_type: str = "AdaptiveRaySampler"
-    # pyre-fixme[13]: Attribute `raysampler` is never initialized.
     raysampler: RaySamplerBase
 
     # ---- renderer configs
     renderer_class_type: str = "MultiPassEmissionAbsorptionRenderer"
-    # pyre-fixme[13]: Attribute `renderer` is never initialized.
     renderer: BaseRenderer
 
     # ---- image feature extractor settings
     # (This is only created if view_pooler is enabled)
-    # pyre-fixme[13]: Attribute `image_feature_extractor` is never initialized.
     image_feature_extractor: Optional[FeatureExtractorBase]
     image_feature_extractor_class_type: Optional[str] = None
     # ---- view pooler settings
     view_pooler_enabled: bool = False
-    # pyre-fixme[13]: Attribute `view_pooler` is never initialized.
     view_pooler: Optional[ViewPooler]
 
     # ---- implicit function settings
     implicit_function_class_type: str = "NeuralRadianceFieldImplicitFunction"
     # This is just a model, never constructed.
     # The actual implicit functions live in self._implicit_functions
-    # pyre-fixme[13]: Attribute `implicit_function` is never initialized.
     implicit_function: ImplicitFunctionBase
 
     # ----- metrics
-    # pyre-fixme[13]: Attribute `view_metrics` is never initialized.
     view_metrics: ViewMetricsBase
     view_metrics_class_type: str = "ViewMetrics"
 
-    # pyre-fixme[13]: Attribute `regularization_metrics` is never initialized.
     regularization_metrics: RegularizationMetricsBase
     regularization_metrics_class_type: str = "RegularizationMetrics"
 
@@ -478,8 +470,6 @@ class GenericModel(ImplicitronModelBase):
             )
         custom_args["global_code"] = global_code
 
-        # pyre-fixme[29]: `Union[(self: Tensor) -> Any, Tensor, Module]` is not a
-        #  function.
         for func in self._implicit_functions:
             func.bind_args(**custom_args)
 
@@ -502,8 +492,6 @@ class GenericModel(ImplicitronModelBase):
         # Unbind the custom arguments to prevent pytorch from storing
         # large buffers of intermediate results due to points in the
         # bound arguments.
-        # pyre-fixme[29]: `Union[(self: Tensor) -> Any, Tensor, Module]` is not a
-        #  function.
         for func in self._implicit_functions:
             func.unbind_args()
 

pytorch3d/implicitron/models/global_encoder/autodecoder.py

@@ -71,7 +71,6 @@ class Autodecoder(Configurable, torch.nn.Module):
         return key_map
 
     def calculate_squared_encoding_norm(self) -> Optional[torch.Tensor]:
-        # pyre-fixme[16]: Item `Tensor` of `Tensor | Module` has no attribute `weight`.
         return (self._autodecoder_codes.weight**2).mean()
 
     def get_encoding_dim(self) -> int:
@@ -96,7 +95,6 @@ class Autodecoder(Configurable, torch.nn.Module):
                 # pyre-fixme[9]: x has type `Union[List[str], LongTensor]`; used as
                 #  `Tensor`.
                 x = torch.tensor(
-                    # pyre-fixme[29]: `Union[(self: TensorBase, indices: Union[None, ...
                     [self._key_map[elem] for elem in x],
                     dtype=torch.long,
                     device=next(self.parameters()).device,
@@ -104,7 +102,6 @@ class Autodecoder(Configurable, torch.nn.Module):
             except StopIteration:
                 raise ValueError("Not enough n_instances in the autodecoder") from None
 
-        # pyre-fixme[29]: `Union[Tensor, Module]` is not a function.
         return self._autodecoder_codes(x)
 
     def _load_key_map_hook(

pytorch3d/implicitron/models/global_encoder/global_encoder.py

@@ -59,13 +59,12 @@ class GlobalEncoderBase(ReplaceableBase):
 
 # TODO: probabilistic embeddings?
 @registry.register
-class SequenceAutodecoder(GlobalEncoderBase, torch.nn.Module):
+class SequenceAutodecoder(GlobalEncoderBase, torch.nn.Module):  # pyre-ignore: 13
     """
     A global encoder implementation which provides an autodecoder encoding
     of the frame's sequence identifier.
     """
 
-    # pyre-fixme[13]: Attribute `autodecoder` is never initialized.
     autodecoder: Autodecoder
 
     def __post_init__(self):
@@ -122,7 +121,6 @@ class HarmonicTimeEncoder(GlobalEncoderBase, torch.nn.Module):
         if frame_timestamp.shape[-1] != 1:
             raise ValueError("Frame timestamp's last dimensions should be one.")
         time = frame_timestamp / self.time_divisor
-        # pyre-fixme[29]: `Union[Tensor, Module]` is not a function.
         return self._harmonic_embedding(time)
 
     def calculate_squared_encoding_norm(self) -> Optional[torch.Tensor]:

pytorch3d/implicitron/models/implicit_function/decoding_functions.py

@@ -232,14 +232,9 @@ class MLPWithInputSkips(Configurable, torch.nn.Module):
             # if the skip tensor is None, we use `x` instead.
             z = x
         skipi = 0
-        # pyre-fixme[6]: For 1st argument expected `Iterable[_T]` but got
-        #  `Union[Tensor, Module]`.
         for li, layer in enumerate(self.mlp):
-            # pyre-fixme[58]: `in` is not supported for right operand type
-            #  `Union[Tensor, Module]`.
             if li in self._input_skips:
                 if self._skip_affine_trans:
-                    # pyre-fixme[29]: `Union[(self: TensorBase, indices: Union[None, ...
                     y = self._apply_affine_layer(self.skip_affines[skipi], y, z)
                 else:
                     y = torch.cat((y, z), dim=-1)
@@ -249,6 +244,7 @@ class MLPWithInputSkips(Configurable, torch.nn.Module):
 
 
 @registry.register
+# pyre-fixme[13]: Attribute `network` is never initialized.
 class MLPDecoder(DecoderFunctionBase):
     """
     Decoding function which uses `MLPWithIputSkips` to convert the embedding to output.
@@ -276,7 +272,6 @@ class MLPDecoder(DecoderFunctionBase):
 
     input_dim: int = 3
     param_groups: Dict[str, str] = field(default_factory=lambda: {})
-    # pyre-fixme[13]: Attribute `network` is never initialized.
     network: MLPWithInputSkips
 
     def __post_init__(self):