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

@@ -260,6 +260,76 @@ workflows:
           name: linux_conda_py38_cu121_pyt210
           python_version: '3.8'
           pytorch_version: 2.1.0
+      - binary_linux_conda:
+          conda_docker_image: pytorch/conda-builder:cuda118
+          context: DOCKERHUB_TOKEN
+          cu_version: cu118
+          name: linux_conda_py38_cu118_pyt211
+          python_version: '3.8'
+          pytorch_version: 2.1.1
+      - binary_linux_conda:
+          conda_docker_image: pytorch/conda-builder:cuda121
+          context: DOCKERHUB_TOKEN
+          cu_version: cu121
+          name: linux_conda_py38_cu121_pyt211
+          python_version: '3.8'
+          pytorch_version: 2.1.1
+      - binary_linux_conda:
+          conda_docker_image: pytorch/conda-builder:cuda118
+          context: DOCKERHUB_TOKEN
+          cu_version: cu118
+          name: linux_conda_py38_cu118_pyt212
+          python_version: '3.8'
+          pytorch_version: 2.1.2
+      - binary_linux_conda:
+          conda_docker_image: pytorch/conda-builder:cuda121
+          context: DOCKERHUB_TOKEN
+          cu_version: cu121
+          name: linux_conda_py38_cu121_pyt212
+          python_version: '3.8'
+          pytorch_version: 2.1.2
+      - binary_linux_conda:
+          conda_docker_image: pytorch/conda-builder:cuda118
+          context: DOCKERHUB_TOKEN
+          cu_version: cu118
+          name: linux_conda_py38_cu118_pyt220
+          python_version: '3.8'
+          pytorch_version: 2.2.0
+      - binary_linux_conda:
+          conda_docker_image: pytorch/conda-builder:cuda121
+          context: DOCKERHUB_TOKEN
+          cu_version: cu121
+          name: linux_conda_py38_cu121_pyt220
+          python_version: '3.8'
+          pytorch_version: 2.2.0
+      - binary_linux_conda:
+          conda_docker_image: pytorch/conda-builder:cuda118
+          context: DOCKERHUB_TOKEN
+          cu_version: cu118
+          name: linux_conda_py38_cu118_pyt222
+          python_version: '3.8'
+          pytorch_version: 2.2.2
+      - binary_linux_conda:
+          conda_docker_image: pytorch/conda-builder:cuda121
+          context: DOCKERHUB_TOKEN
+          cu_version: cu121
+          name: linux_conda_py38_cu121_pyt222
+          python_version: '3.8'
+          pytorch_version: 2.2.2
+      - binary_linux_conda:
+          conda_docker_image: pytorch/conda-builder:cuda118
+          context: DOCKERHUB_TOKEN
+          cu_version: cu118
+          name: linux_conda_py38_cu118_pyt231
+          python_version: '3.8'
+          pytorch_version: 2.3.1
+      - binary_linux_conda:
+          conda_docker_image: pytorch/conda-builder:cuda121
+          context: DOCKERHUB_TOKEN
+          cu_version: cu121
+          name: linux_conda_py38_cu121_pyt231
+          python_version: '3.8'
+          pytorch_version: 2.3.1
       - binary_linux_conda:
           conda_docker_image: pytorch/conda-builder:cuda113
           context: DOCKERHUB_TOKEN
@@ -358,6 +428,76 @@ workflows:
           name: linux_conda_py39_cu121_pyt210
           python_version: '3.9'
           pytorch_version: 2.1.0
+      - binary_linux_conda:
+          conda_docker_image: pytorch/conda-builder:cuda118
+          context: DOCKERHUB_TOKEN
+          cu_version: cu118
+          name: linux_conda_py39_cu118_pyt211
+          python_version: '3.9'
+          pytorch_version: 2.1.1
+      - binary_linux_conda:
+          conda_docker_image: pytorch/conda-builder:cuda121
+          context: DOCKERHUB_TOKEN
+          cu_version: cu121
+          name: linux_conda_py39_cu121_pyt211
+          python_version: '3.9'
+          pytorch_version: 2.1.1
+      - binary_linux_conda:
+          conda_docker_image: pytorch/conda-builder:cuda118
+          context: DOCKERHUB_TOKEN
+          cu_version: cu118
+          name: linux_conda_py39_cu118_pyt212
+          python_version: '3.9'
+          pytorch_version: 2.1.2
+      - binary_linux_conda:
+          conda_docker_image: pytorch/conda-builder:cuda121
+          context: DOCKERHUB_TOKEN
+          cu_version: cu121
+          name: linux_conda_py39_cu121_pyt212
+          python_version: '3.9'
+          pytorch_version: 2.1.2
+      - binary_linux_conda:
+          conda_docker_image: pytorch/conda-builder:cuda118
+          context: DOCKERHUB_TOKEN
+          cu_version: cu118
+          name: linux_conda_py39_cu118_pyt220
+          python_version: '3.9'
+          pytorch_version: 2.2.0
+      - binary_linux_conda:
+          conda_docker_image: pytorch/conda-builder:cuda121
+          context: DOCKERHUB_TOKEN
+          cu_version: cu121
+          name: linux_conda_py39_cu121_pyt220
+          python_version: '3.9'
+          pytorch_version: 2.2.0
+      - binary_linux_conda:
+          conda_docker_image: pytorch/conda-builder:cuda118
+          context: DOCKERHUB_TOKEN
+          cu_version: cu118
+          name: linux_conda_py39_cu118_pyt222
+          python_version: '3.9'
+          pytorch_version: 2.2.2
+      - binary_linux_conda:
+          conda_docker_image: pytorch/conda-builder:cuda121
+          context: DOCKERHUB_TOKEN
+          cu_version: cu121
+          name: linux_conda_py39_cu121_pyt222
+          python_version: '3.9'
+          pytorch_version: 2.2.2
+      - binary_linux_conda:
+          conda_docker_image: pytorch/conda-builder:cuda118
+          context: DOCKERHUB_TOKEN
+          cu_version: cu118
+          name: linux_conda_py39_cu118_pyt231
+          python_version: '3.9'
+          pytorch_version: 2.3.1
+      - binary_linux_conda:
+          conda_docker_image: pytorch/conda-builder:cuda121
+          context: DOCKERHUB_TOKEN
+          cu_version: cu121
+          name: linux_conda_py39_cu121_pyt231
+          python_version: '3.9'
+          pytorch_version: 2.3.1
       - binary_linux_conda:
           conda_docker_image: pytorch/conda-builder:cuda113
           context: DOCKERHUB_TOKEN
@@ -456,6 +596,76 @@ workflows:
           name: linux_conda_py310_cu121_pyt210
           python_version: '3.10'
           pytorch_version: 2.1.0
+      - binary_linux_conda:
+          conda_docker_image: pytorch/conda-builder:cuda118
+          context: DOCKERHUB_TOKEN
+          cu_version: cu118
+          name: linux_conda_py310_cu118_pyt211
+          python_version: '3.10'
+          pytorch_version: 2.1.1
+      - binary_linux_conda:
+          conda_docker_image: pytorch/conda-builder:cuda121
+          context: DOCKERHUB_TOKEN
+          cu_version: cu121
+          name: linux_conda_py310_cu121_pyt211
+          python_version: '3.10'
+          pytorch_version: 2.1.1
+      - binary_linux_conda:
+          conda_docker_image: pytorch/conda-builder:cuda118
+          context: DOCKERHUB_TOKEN
+          cu_version: cu118
+          name: linux_conda_py310_cu118_pyt212
+          python_version: '3.10'
+          pytorch_version: 2.1.2
+      - binary_linux_conda:
+          conda_docker_image: pytorch/conda-builder:cuda121
+          context: DOCKERHUB_TOKEN
+          cu_version: cu121
+          name: linux_conda_py310_cu121_pyt212
+          python_version: '3.10'
+          pytorch_version: 2.1.2
+      - binary_linux_conda:
+          conda_docker_image: pytorch/conda-builder:cuda118
+          context: DOCKERHUB_TOKEN
+          cu_version: cu118
+          name: linux_conda_py310_cu118_pyt220
+          python_version: '3.10'
+          pytorch_version: 2.2.0
+      - binary_linux_conda:
+          conda_docker_image: pytorch/conda-builder:cuda121
+          context: DOCKERHUB_TOKEN
+          cu_version: cu121
+          name: linux_conda_py310_cu121_pyt220
+          python_version: '3.10'
+          pytorch_version: 2.2.0
+      - binary_linux_conda:
+          conda_docker_image: pytorch/conda-builder:cuda118
+          context: DOCKERHUB_TOKEN
+          cu_version: cu118
+          name: linux_conda_py310_cu118_pyt222
+          python_version: '3.10'
+          pytorch_version: 2.2.2
+      - binary_linux_conda:
+          conda_docker_image: pytorch/conda-builder:cuda121
+          context: DOCKERHUB_TOKEN
+          cu_version: cu121
+          name: linux_conda_py310_cu121_pyt222
+          python_version: '3.10'
+          pytorch_version: 2.2.2
+      - binary_linux_conda:
+          conda_docker_image: pytorch/conda-builder:cuda118
+          context: DOCKERHUB_TOKEN
+          cu_version: cu118
+          name: linux_conda_py310_cu118_pyt231
+          python_version: '3.10'
+          pytorch_version: 2.3.1
+      - binary_linux_conda:
+          conda_docker_image: pytorch/conda-builder:cuda121
+          context: DOCKERHUB_TOKEN
+          cu_version: cu121
+          name: linux_conda_py310_cu121_pyt231
+          python_version: '3.10'
+          pytorch_version: 2.3.1
       - binary_linux_conda:
           conda_docker_image: pytorch/conda-builder:cuda118
           context: DOCKERHUB_TOKEN
@@ -470,6 +680,118 @@ workflows:
           name: linux_conda_py311_cu121_pyt210
           python_version: '3.11'
           pytorch_version: 2.1.0
+      - binary_linux_conda:
+          conda_docker_image: pytorch/conda-builder:cuda118
+          context: DOCKERHUB_TOKEN
+          cu_version: cu118
+          name: linux_conda_py311_cu118_pyt211
+          python_version: '3.11'
+          pytorch_version: 2.1.1
+      - binary_linux_conda:
+          conda_docker_image: pytorch/conda-builder:cuda121
+          context: DOCKERHUB_TOKEN
+          cu_version: cu121
+          name: linux_conda_py311_cu121_pyt211
+          python_version: '3.11'
+          pytorch_version: 2.1.1
+      - binary_linux_conda:
+          conda_docker_image: pytorch/conda-builder:cuda118
+          context: DOCKERHUB_TOKEN
+          cu_version: cu118
+          name: linux_conda_py311_cu118_pyt212
+          python_version: '3.11'
+          pytorch_version: 2.1.2
+      - binary_linux_conda:
+          conda_docker_image: pytorch/conda-builder:cuda121
+          context: DOCKERHUB_TOKEN
+          cu_version: cu121
+          name: linux_conda_py311_cu121_pyt212
+          python_version: '3.11'
+          pytorch_version: 2.1.2
+      - binary_linux_conda:
+          conda_docker_image: pytorch/conda-builder:cuda118
+          context: DOCKERHUB_TOKEN
+          cu_version: cu118
+          name: linux_conda_py311_cu118_pyt220
+          python_version: '3.11'
+          pytorch_version: 2.2.0
+      - binary_linux_conda:
+          conda_docker_image: pytorch/conda-builder:cuda121
+          context: DOCKERHUB_TOKEN
+          cu_version: cu121
+          name: linux_conda_py311_cu121_pyt220
+          python_version: '3.11'
+          pytorch_version: 2.2.0
+      - binary_linux_conda:
+          conda_docker_image: pytorch/conda-builder:cuda118
+          context: DOCKERHUB_TOKEN
+          cu_version: cu118
+          name: linux_conda_py311_cu118_pyt222
+          python_version: '3.11'
+          pytorch_version: 2.2.2
+      - binary_linux_conda:
+          conda_docker_image: pytorch/conda-builder:cuda121
+          context: DOCKERHUB_TOKEN
+          cu_version: cu121
+          name: linux_conda_py311_cu121_pyt222
+          python_version: '3.11'
+          pytorch_version: 2.2.2
+      - binary_linux_conda:
+          conda_docker_image: pytorch/conda-builder:cuda118
+          context: DOCKERHUB_TOKEN
+          cu_version: cu118
+          name: linux_conda_py311_cu118_pyt231
+          python_version: '3.11'
+          pytorch_version: 2.3.1
+      - binary_linux_conda:
+          conda_docker_image: pytorch/conda-builder:cuda121
+          context: DOCKERHUB_TOKEN
+          cu_version: cu121
+          name: linux_conda_py311_cu121_pyt231
+          python_version: '3.11'
+          pytorch_version: 2.3.1
+      - binary_linux_conda:
+          conda_docker_image: pytorch/conda-builder:cuda118
+          context: DOCKERHUB_TOKEN
+          cu_version: cu118
+          name: linux_conda_py312_cu118_pyt220
+          python_version: '3.12'
+          pytorch_version: 2.2.0
+      - binary_linux_conda:
+          conda_docker_image: pytorch/conda-builder:cuda121
+          context: DOCKERHUB_TOKEN
+          cu_version: cu121
+          name: linux_conda_py312_cu121_pyt220
+          python_version: '3.12'
+          pytorch_version: 2.2.0
+      - binary_linux_conda:
+          conda_docker_image: pytorch/conda-builder:cuda118
+          context: DOCKERHUB_TOKEN
+          cu_version: cu118
+          name: linux_conda_py312_cu118_pyt222
+          python_version: '3.12'
+          pytorch_version: 2.2.2
+      - binary_linux_conda:
+          conda_docker_image: pytorch/conda-builder:cuda121
+          context: DOCKERHUB_TOKEN
+          cu_version: cu121
+          name: linux_conda_py312_cu121_pyt222
+          python_version: '3.12'
+          pytorch_version: 2.2.2
+      - binary_linux_conda:
+          conda_docker_image: pytorch/conda-builder:cuda118
+          context: DOCKERHUB_TOKEN
+          cu_version: cu118
+          name: linux_conda_py312_cu118_pyt231
+          python_version: '3.12'
+          pytorch_version: 2.3.1
+      - binary_linux_conda:
+          conda_docker_image: pytorch/conda-builder:cuda121
+          context: DOCKERHUB_TOKEN
+          cu_version: cu121
+          name: linux_conda_py312_cu121_pyt231
+          python_version: '3.12'
+          pytorch_version: 2.3.1
       - binary_linux_conda_cuda:
           name: testrun_conda_cuda_py310_cu117_pyt201
           context: DOCKERHUB_TOKEN

.circleci/regenerate.py

@@ -26,12 +26,15 @@ CONDA_CUDA_VERSIONS = {
     "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"],
 }
 
 
 def conda_docker_image_for_cuda(cuda_version):
-    if cuda_version in ("cu101", "cu102", "cu111"):
-        return None
     if len(cuda_version) != 5:
         raise ValueError("Unknown cuda version")
     return "pytorch/conda-builder:cuda" + cuda_version[2:]
@@ -52,12 +55,18 @@ def pytorch_versions_for_python(python_version):
             for i in CONDA_CUDA_VERSIONS
             if version.Version(i) >= version.Version("2.1.0")
         ]
+    if python_version == "3.12":
+        return [
+            i
+            for i in CONDA_CUDA_VERSIONS
+            if version.Version(i) >= version.Version("2.2.0")
+        ]
 
 
 def workflows(prefix="", filter_branch=None, upload=False, indentation=6):
     w = []
     for btype in ["conda"]:
-        for python_version in ["3.8", "3.9", "3.10", "3.11"]:
+        for python_version in ["3.8", "3.9", "3.10", "3.11", "3.12"]:
             for pytorch_version in pytorch_versions_for_python(python_version):
                 for cu_version in CONDA_CUDA_VERSIONS[pytorch_version]:
                     w += workflow_pair(

.flake8

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

INSTALL.md

@@ -9,7 +9,7 @@ The core library is written in PyTorch. Several components have underlying imple
 
 - Linux or macOS or Windows
 - Python 3.8, 3.9 or 3.10
-- PyTorch 1.12.0, 1.12.1, 1.13.0, 2.0.0, 2.0.1 or 2.1.0.
+- 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)

README.md

@@ -146,6 +146,12 @@ If you are using the pulsar backend for sphere-rendering (the `PulsarPointRender
 
 Please see below for a timeline of the codebase updates in reverse chronological order. We are sharing updates on the releases as well as research projects which are built with PyTorch3D. The changelogs for the releases are available under [`Releases`](https://github.com/facebookresearch/pytorch3d/releases),  and the builds can be installed using `conda` as per the instructions in [INSTALL.md](INSTALL.md).
 
+**[Oct 31st 2023]:**   PyTorch3D [v0.7.5](https://github.com/facebookresearch/pytorch3d/releases/tag/v0.7.5) released.
+
+**[May 10th 2023]:**   PyTorch3D [v0.7.4](https://github.com/facebookresearch/pytorch3d/releases/tag/v0.7.4) released.
+
+**[Apr 5th 2023]:**   PyTorch3D [v0.7.3](https://github.com/facebookresearch/pytorch3d/releases/tag/v0.7.3) released.
+
 **[Dec 19th 2022]:**   PyTorch3D [v0.7.2](https://github.com/facebookresearch/pytorch3d/releases/tag/v0.7.2) released.
 
 **[Oct 23rd 2022]:**   PyTorch3D [v0.7.1](https://github.com/facebookresearch/pytorch3d/releases/tag/v0.7.1) released.

docs/tutorials/bundle_adjustment.ipynb

@@ -83,25 +83,31 @@
     "import os\n",
     "import sys\n",
     "import torch\n",
+    "import subprocess\n",
     "need_pytorch3d=False\n",
     "try:\n",
     "    import pytorch3d\n",
     "except ModuleNotFoundError:\n",
     "    need_pytorch3d=True\n",
     "if need_pytorch3d:\n",
-    "    if torch.__version__.startswith(\"2.1.\") and sys.platform.startswith(\"linux\"):\n",
-    "        # We try to install PyTorch3D via a released wheel.\n",
-    "        pyt_version_str=torch.__version__.split(\"+\")[0].replace(\".\", \"\")\n",
-    "        version_str=\"\".join([\n",
-    "            f\"py3{sys.version_info.minor}_cu\",\n",
-    "            torch.version.cuda.replace(\".\",\"\"),\n",
-    "            f\"_pyt{pyt_version_str}\"\n",
-    "        ])\n",
-    "        !pip install fvcore iopath\n",
+    "    pyt_version_str=torch.__version__.split(\"+\")[0].replace(\".\", \"\")\n",
+    "    version_str=\"\".join([\n",
+    "        f\"py3{sys.version_info.minor}_cu\",\n",
+    "        torch.version.cuda.replace(\".\",\"\"),\n",
+    "        f\"_pyt{pyt_version_str}\"\n",
+    "    ])\n",
+    "    !pip install 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",
-    "    else:\n",
-    "        # We try to install PyTorch3D from source.\n",
-    "        !pip install 'git+https://github.com/facebookresearch/pytorch3d.git@stable'"
+    "        pip_list = !pip freeze\n",
+    "        need_pytorch3d = not any(i.startswith(\"pytorch3d==\") for  i in pip_list)\n",
+    "    if need_pytorch3d:\n",
+    "        print(f\"failed to find/install wheel for {version_str}\")\n",
+    "if need_pytorch3d:\n",
+    "    print(\"Installing PyTorch3D from source\")\n",
+    "    !pip install ninja\n",
+    "    !pip install 'git+https://github.com/facebookresearch/pytorch3d.git@stable'"
    ]
   },
   {

docs/tutorials/camera_position_optimization_with_differentiable_rendering.ipynb

@@ -70,25 +70,31 @@
     "import os\n",
     "import sys\n",
     "import torch\n",
+    "import subprocess\n",
     "need_pytorch3d=False\n",
     "try:\n",
     "    import pytorch3d\n",
     "except ModuleNotFoundError:\n",
     "    need_pytorch3d=True\n",
     "if need_pytorch3d:\n",
-    "    if torch.__version__.startswith(\"2.1.\") and sys.platform.startswith(\"linux\"):\n",
-    "        # We try to install PyTorch3D via a released wheel.\n",
-    "        pyt_version_str=torch.__version__.split(\"+\")[0].replace(\".\", \"\")\n",
-    "        version_str=\"\".join([\n",
-    "            f\"py3{sys.version_info.minor}_cu\",\n",
-    "            torch.version.cuda.replace(\".\",\"\"),\n",
-    "            f\"_pyt{pyt_version_str}\"\n",
-    "        ])\n",
-    "        !pip install fvcore iopath\n",
+    "    pyt_version_str=torch.__version__.split(\"+\")[0].replace(\".\", \"\")\n",
+    "    version_str=\"\".join([\n",
+    "        f\"py3{sys.version_info.minor}_cu\",\n",
+    "        torch.version.cuda.replace(\".\",\"\"),\n",
+    "        f\"_pyt{pyt_version_str}\"\n",
+    "    ])\n",
+    "    !pip install 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",
-    "    else:\n",
-    "        # We try to install PyTorch3D from source.\n",
-    "        !pip install 'git+https://github.com/facebookresearch/pytorch3d.git@stable'"
+    "        pip_list = !pip freeze\n",
+    "        need_pytorch3d = not any(i.startswith(\"pytorch3d==\") for  i in pip_list)\n",
+    "    if need_pytorch3d:\n",
+    "        print(f\"failed to find/install wheel for {version_str}\")\n",
+    "if need_pytorch3d:\n",
+    "    print(\"Installing PyTorch3D from source\")\n",
+    "    !pip install ninja\n",
+    "    !pip install 'git+https://github.com/facebookresearch/pytorch3d.git@stable'"
    ]
   },
   {

docs/tutorials/dataloaders_ShapeNetCore_R2N2.ipynb

@@ -45,25 +45,31 @@
     "import os\n",
     "import sys\n",
     "import torch\n",
+    "import subprocess\n",
     "need_pytorch3d=False\n",
     "try:\n",
     "    import pytorch3d\n",
     "except ModuleNotFoundError:\n",
     "    need_pytorch3d=True\n",
     "if need_pytorch3d:\n",
-    "    if torch.__version__.startswith(\"2.1.\") and sys.platform.startswith(\"linux\"):\n",
-    "        # We try to install PyTorch3D via a released wheel.\n",
-    "        pyt_version_str=torch.__version__.split(\"+\")[0].replace(\".\", \"\")\n",
-    "        version_str=\"\".join([\n",
-    "            f\"py3{sys.version_info.minor}_cu\",\n",
-    "            torch.version.cuda.replace(\".\",\"\"),\n",
-    "            f\"_pyt{pyt_version_str}\"\n",
-    "        ])\n",
-    "        !pip install fvcore iopath\n",
+    "    pyt_version_str=torch.__version__.split(\"+\")[0].replace(\".\", \"\")\n",
+    "    version_str=\"\".join([\n",
+    "        f\"py3{sys.version_info.minor}_cu\",\n",
+    "        torch.version.cuda.replace(\".\",\"\"),\n",
+    "        f\"_pyt{pyt_version_str}\"\n",
+    "    ])\n",
+    "    !pip install 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",
-    "    else:\n",
-    "        # We try to install PyTorch3D from source.\n",
-    "        !pip install 'git+https://github.com/facebookresearch/pytorch3d.git@stable'"
+    "        pip_list = !pip freeze\n",
+    "        need_pytorch3d = not any(i.startswith(\"pytorch3d==\") for  i in pip_list)\n",
+    "    if need_pytorch3d:\n",
+    "        print(f\"failed to find/install wheel for {version_str}\")\n",
+    "if need_pytorch3d:\n",
+    "    print(\"Installing PyTorch3D from source\")\n",
+    "    !pip install ninja\n",
+    "    !pip install 'git+https://github.com/facebookresearch/pytorch3d.git@stable'"
    ]
   },
   {
@@ -405,7 +411,7 @@
    "outputs": [],
    "source": [
     "random_model_images = shapenet_dataset.render(\n",
-    "    sample_nums=[3],\n",
+    "    sample_nums=[5],\n",
     "    device=device,\n",
     "    cameras=cameras,\n",
     "    raster_settings=raster_settings,\n",

docs/tutorials/deform_source_mesh_to_target_mesh.ipynb

@@ -84,25 +84,31 @@
     "import os\n",
     "import sys\n",
     "import torch\n",
+    "import subprocess\n",
     "need_pytorch3d=False\n",
     "try:\n",
     "    import pytorch3d\n",
     "except ModuleNotFoundError:\n",
     "    need_pytorch3d=True\n",
     "if need_pytorch3d:\n",
-    "    if torch.__version__.startswith(\"2.1.\") and sys.platform.startswith(\"linux\"):\n",
-    "        # We try to install PyTorch3D via a released wheel.\n",
-    "        pyt_version_str=torch.__version__.split(\"+\")[0].replace(\".\", \"\")\n",
-    "        version_str=\"\".join([\n",
-    "            f\"py3{sys.version_info.minor}_cu\",\n",
-    "            torch.version.cuda.replace(\".\",\"\"),\n",
-    "            f\"_pyt{pyt_version_str}\"\n",
-    "        ])\n",
-    "        !pip install fvcore iopath\n",
+    "    pyt_version_str=torch.__version__.split(\"+\")[0].replace(\".\", \"\")\n",
+    "    version_str=\"\".join([\n",
+    "        f\"py3{sys.version_info.minor}_cu\",\n",
+    "        torch.version.cuda.replace(\".\",\"\"),\n",
+    "        f\"_pyt{pyt_version_str}\"\n",
+    "    ])\n",
+    "    !pip install 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",
-    "    else:\n",
-    "        # We try to install PyTorch3D from source.\n",
-    "        !pip install 'git+https://github.com/facebookresearch/pytorch3d.git@stable'"
+    "        pip_list = !pip freeze\n",
+    "        need_pytorch3d = not any(i.startswith(\"pytorch3d==\") for  i in pip_list)\n",
+    "    if need_pytorch3d:\n",
+    "        print(f\"failed to find/install wheel for {version_str}\")\n",
+    "if need_pytorch3d:\n",
+    "    print(\"Installing PyTorch3D from source\")\n",
+    "    !pip install ninja\n",
+    "    !pip install 'git+https://github.com/facebookresearch/pytorch3d.git@stable'"
    ]
   },
   {

docs/tutorials/fit_simple_neural_radiance_field.ipynb

@@ -50,25 +50,31 @@
     "import os\n",
     "import sys\n",
     "import torch\n",
+    "import subprocess\n",
     "need_pytorch3d=False\n",
     "try:\n",
     "    import pytorch3d\n",
     "except ModuleNotFoundError:\n",
     "    need_pytorch3d=True\n",
     "if need_pytorch3d:\n",
-    "    if torch.__version__.startswith(\"2.1.\") and sys.platform.startswith(\"linux\"):\n",
-    "        # We try to install PyTorch3D via a released wheel.\n",
-    "        pyt_version_str=torch.__version__.split(\"+\")[0].replace(\".\", \"\")\n",
-    "        version_str=\"\".join([\n",
-    "            f\"py3{sys.version_info.minor}_cu\",\n",
-    "            torch.version.cuda.replace(\".\",\"\"),\n",
-    "            f\"_pyt{pyt_version_str}\"\n",
-    "        ])\n",
-    "        !pip install fvcore iopath\n",
+    "    pyt_version_str=torch.__version__.split(\"+\")[0].replace(\".\", \"\")\n",
+    "    version_str=\"\".join([\n",
+    "        f\"py3{sys.version_info.minor}_cu\",\n",
+    "        torch.version.cuda.replace(\".\",\"\"),\n",
+    "        f\"_pyt{pyt_version_str}\"\n",
+    "    ])\n",
+    "    !pip install 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",
-    "    else:\n",
-    "        # We try to install PyTorch3D from source.\n",
-    "        !pip install 'git+https://github.com/facebookresearch/pytorch3d.git@stable'"
+    "        pip_list = !pip freeze\n",
+    "        need_pytorch3d = not any(i.startswith(\"pytorch3d==\") for  i in pip_list)\n",
+    "    if need_pytorch3d:\n",
+    "        print(f\"failed to find/install wheel for {version_str}\")\n",
+    "if need_pytorch3d:\n",
+    "    print(\"Installing PyTorch3D from source\")\n",
+    "    !pip install ninja\n",
+    "    !pip install 'git+https://github.com/facebookresearch/pytorch3d.git@stable'"
    ]
   },
   {

docs/tutorials/fit_textured_mesh.ipynb

@@ -62,25 +62,31 @@
     "import os\n",
     "import sys\n",
     "import torch\n",
+    "import subprocess\n",
     "need_pytorch3d=False\n",
     "try:\n",
     "    import pytorch3d\n",
     "except ModuleNotFoundError:\n",
     "    need_pytorch3d=True\n",
     "if need_pytorch3d:\n",
-    "    if torch.__version__.startswith(\"2.1.\") and sys.platform.startswith(\"linux\"):\n",
-    "        # We try to install PyTorch3D via a released wheel.\n",
-    "        pyt_version_str=torch.__version__.split(\"+\")[0].replace(\".\", \"\")\n",
-    "        version_str=\"\".join([\n",
-    "            f\"py3{sys.version_info.minor}_cu\",\n",
-    "            torch.version.cuda.replace(\".\",\"\"),\n",
-    "            f\"_pyt{pyt_version_str}\"\n",
-    "        ])\n",
-    "        !pip install fvcore iopath\n",
+    "    pyt_version_str=torch.__version__.split(\"+\")[0].replace(\".\", \"\")\n",
+    "    version_str=\"\".join([\n",
+    "        f\"py3{sys.version_info.minor}_cu\",\n",
+    "        torch.version.cuda.replace(\".\",\"\"),\n",
+    "        f\"_pyt{pyt_version_str}\"\n",
+    "    ])\n",
+    "    !pip install 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",
-    "    else:\n",
-    "        # We try to install PyTorch3D from source.\n",
-    "        !pip install 'git+https://github.com/facebookresearch/pytorch3d.git@stable'"
+    "        pip_list = !pip freeze\n",
+    "        need_pytorch3d = not any(i.startswith(\"pytorch3d==\") for  i in pip_list)\n",
+    "    if need_pytorch3d:\n",
+    "        print(f\"failed to find/install wheel for {version_str}\")\n",
+    "if need_pytorch3d:\n",
+    "    print(\"Installing PyTorch3D from source\")\n",
+    "    !pip install ninja\n",
+    "    !pip install 'git+https://github.com/facebookresearch/pytorch3d.git@stable'"
    ]
   },
   {

docs/tutorials/fit_textured_volume.ipynb

@@ -41,25 +41,31 @@
     "import os\n",
     "import sys\n",
     "import torch\n",
+    "import subprocess\n",
     "need_pytorch3d=False\n",
     "try:\n",
     "    import pytorch3d\n",
     "except ModuleNotFoundError:\n",
     "    need_pytorch3d=True\n",
     "if need_pytorch3d:\n",
-    "    if torch.__version__.startswith(\"2.1.\") and sys.platform.startswith(\"linux\"):\n",
-    "        # We try to install PyTorch3D via a released wheel.\n",
-    "        pyt_version_str=torch.__version__.split(\"+\")[0].replace(\".\", \"\")\n",
-    "        version_str=\"\".join([\n",
-    "            f\"py3{sys.version_info.minor}_cu\",\n",
-    "            torch.version.cuda.replace(\".\",\"\"),\n",
-    "            f\"_pyt{pyt_version_str}\"\n",
-    "        ])\n",
-    "        !pip install fvcore iopath\n",
+    "    pyt_version_str=torch.__version__.split(\"+\")[0].replace(\".\", \"\")\n",
+    "    version_str=\"\".join([\n",
+    "        f\"py3{sys.version_info.minor}_cu\",\n",
+    "        torch.version.cuda.replace(\".\",\"\"),\n",
+    "        f\"_pyt{pyt_version_str}\"\n",
+    "    ])\n",
+    "    !pip install 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",
-    "    else:\n",
-    "        # We try to install PyTorch3D from source.\n",
-    "        !pip install 'git+https://github.com/facebookresearch/pytorch3d.git@stable'"
+    "        pip_list = !pip freeze\n",
+    "        need_pytorch3d = not any(i.startswith(\"pytorch3d==\") for  i in pip_list)\n",
+    "    if need_pytorch3d:\n",
+    "        print(f\"failed to find/install wheel for {version_str}\")\n",
+    "if need_pytorch3d:\n",
+    "    print(\"Installing PyTorch3D from source\")\n",
+    "    !pip install ninja\n",
+    "    !pip install 'git+https://github.com/facebookresearch/pytorch3d.git@stable'"
    ]
   },
   {

docs/tutorials/implicitron_config_system.ipynb

@@ -72,25 +72,31 @@
         "import os\n",
         "import sys\n",
         "import torch\n",
+        "import subprocess\n",
         "need_pytorch3d=False\n",
         "try:\n",
         "    import pytorch3d\n",
         "except ModuleNotFoundError:\n",
         "    need_pytorch3d=True\n",
         "if need_pytorch3d:\n",
-        "    if torch.__version__.startswith(\"2.1.\") and sys.platform.startswith(\"linux\"):\n",
-        "        # We try to install PyTorch3D via a released wheel.\n",
-        "        pyt_version_str=torch.__version__.split(\"+\")[0].replace(\".\", \"\")\n",
-        "        version_str=\"\".join([\n",
-        "            f\"py3{sys.version_info.minor}_cu\",\n",
-        "            torch.version.cuda.replace(\".\",\"\"),\n",
-        "            f\"_pyt{pyt_version_str}\"\n",
-        "        ])\n",
-        "        !pip install fvcore iopath\n",
+        "    pyt_version_str=torch.__version__.split(\"+\")[0].replace(\".\", \"\")\n",
+        "    version_str=\"\".join([\n",
+        "        f\"py3{sys.version_info.minor}_cu\",\n",
+        "        torch.version.cuda.replace(\".\",\"\"),\n",
+        "        f\"_pyt{pyt_version_str}\"\n",
+        "    ])\n",
+        "    !pip install 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",
-        "    else:\n",
-        "        # We try to install PyTorch3D from source.\n",
-        "        !pip install 'git+https://github.com/facebookresearch/pytorch3d.git@stable'"
+        "        pip_list = !pip freeze\n",
+        "        need_pytorch3d = not any(i.startswith(\"pytorch3d==\") for  i in pip_list)\n",
+        "    if need_pytorch3d:\n",
+        "        print(f\"failed to find/install wheel for {version_str}\")\n",
+        "if need_pytorch3d:\n",
+        "    print(\"Installing PyTorch3D from source\")\n",
+        "    !pip install ninja\n",
+        "    !pip install 'git+https://github.com/facebookresearch/pytorch3d.git@stable'"
       ]
     },
     {

docs/tutorials/implicitron_volumes.ipynb

@@ -66,25 +66,31 @@
         "import os\n",
         "import sys\n",
         "import torch\n",
+        "import subprocess\n",
         "need_pytorch3d=False\n",
         "try:\n",
         "    import pytorch3d\n",
         "except ModuleNotFoundError:\n",
         "    need_pytorch3d=True\n",
         "if need_pytorch3d:\n",
-        "    if torch.__version__.startswith(\"2.1.\") and sys.platform.startswith(\"linux\"):\n",
-        "        # We try to install PyTorch3D via a released wheel.\n",
-        "        pyt_version_str=torch.__version__.split(\"+\")[0].replace(\".\", \"\")\n",
-        "        version_str=\"\".join([\n",
-        "            f\"py3{sys.version_info.minor}_cu\",\n",
-        "            torch.version.cuda.replace(\".\",\"\"),\n",
-        "            f\"_pyt{pyt_version_str}\"\n",
-        "        ])\n",
-        "        !pip install fvcore iopath\n",
+        "    pyt_version_str=torch.__version__.split(\"+\")[0].replace(\".\", \"\")\n",
+        "    version_str=\"\".join([\n",
+        "        f\"py3{sys.version_info.minor}_cu\",\n",
+        "        torch.version.cuda.replace(\".\",\"\"),\n",
+        "        f\"_pyt{pyt_version_str}\"\n",
+        "    ])\n",
+        "    !pip install 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",
-        "    else:\n",
-        "        # We try to install PyTorch3D from source.\n",
-        "        !pip install 'git+https://github.com/facebookresearch/pytorch3d.git@stable'"
+        "        pip_list = !pip freeze\n",
+        "        need_pytorch3d = not any(i.startswith(\"pytorch3d==\") for  i in pip_list)\n",
+        "    if need_pytorch3d:\n",
+        "        print(f\"failed to find/install wheel for {version_str}\")\n",
+        "if need_pytorch3d:\n",
+        "    print(\"Installing PyTorch3D from source\")\n",
+        "    !pip install ninja\n",
+        "    !pip install 'git+https://github.com/facebookresearch/pytorch3d.git@stable'"
       ]
     },
     {

docs/tutorials/render_colored_points.ipynb

@@ -44,25 +44,31 @@
     "import os\n",
     "import sys\n",
     "import torch\n",
+    "import subprocess\n",
     "need_pytorch3d=False\n",
     "try:\n",
     "    import pytorch3d\n",
     "except ModuleNotFoundError:\n",
     "    need_pytorch3d=True\n",
     "if need_pytorch3d:\n",
-    "    if torch.__version__.startswith(\"2.1.\") and sys.platform.startswith(\"linux\"):\n",
-    "        # We try to install PyTorch3D via a released wheel.\n",
-    "        pyt_version_str=torch.__version__.split(\"+\")[0].replace(\".\", \"\")\n",
-    "        version_str=\"\".join([\n",
-    "            f\"py3{sys.version_info.minor}_cu\",\n",
-    "            torch.version.cuda.replace(\".\",\"\"),\n",
-    "            f\"_pyt{pyt_version_str}\"\n",
-    "        ])\n",
-    "        !pip install fvcore iopath\n",
+    "    pyt_version_str=torch.__version__.split(\"+\")[0].replace(\".\", \"\")\n",
+    "    version_str=\"\".join([\n",
+    "        f\"py3{sys.version_info.minor}_cu\",\n",
+    "        torch.version.cuda.replace(\".\",\"\"),\n",
+    "        f\"_pyt{pyt_version_str}\"\n",
+    "    ])\n",
+    "    !pip install 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",
-    "    else:\n",
-    "        # We try to install PyTorch3D from source.\n",
-    "        !pip install 'git+https://github.com/facebookresearch/pytorch3d.git@stable'"
+    "        pip_list = !pip freeze\n",
+    "        need_pytorch3d = not any(i.startswith(\"pytorch3d==\") for  i in pip_list)\n",
+    "    if need_pytorch3d:\n",
+    "        print(f\"failed to find/install wheel for {version_str}\")\n",
+    "if need_pytorch3d:\n",
+    "    print(\"Installing PyTorch3D from source\")\n",
+    "    !pip install ninja\n",
+    "    !pip install 'git+https://github.com/facebookresearch/pytorch3d.git@stable'"
    ]
   },
   {

docs/tutorials/render_densepose.ipynb

@@ -51,25 +51,31 @@
     "import os\n",
     "import sys\n",
     "import torch\n",
+    "import subprocess\n",
     "need_pytorch3d=False\n",
     "try:\n",
     "    import pytorch3d\n",
     "except ModuleNotFoundError:\n",
     "    need_pytorch3d=True\n",
     "if need_pytorch3d:\n",
-    "    if torch.__version__.startswith(\"2.1.\") and sys.platform.startswith(\"linux\"):\n",
-    "        # We try to install PyTorch3D via a released wheel.\n",
-    "        pyt_version_str=torch.__version__.split(\"+\")[0].replace(\".\", \"\")\n",
-    "        version_str=\"\".join([\n",
-    "            f\"py3{sys.version_info.minor}_cu\",\n",
-    "            torch.version.cuda.replace(\".\",\"\"),\n",
-    "            f\"_pyt{pyt_version_str}\"\n",
-    "        ])\n",
-    "        !pip install fvcore iopath\n",
+    "    pyt_version_str=torch.__version__.split(\"+\")[0].replace(\".\", \"\")\n",
+    "    version_str=\"\".join([\n",
+    "        f\"py3{sys.version_info.minor}_cu\",\n",
+    "        torch.version.cuda.replace(\".\",\"\"),\n",
+    "        f\"_pyt{pyt_version_str}\"\n",
+    "    ])\n",
+    "    !pip install 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",
-    "    else:\n",
-    "        # We try to install PyTorch3D from source.\n",
-    "        !pip install 'git+https://github.com/facebookresearch/pytorch3d.git@stable'"
+    "        pip_list = !pip freeze\n",
+    "        need_pytorch3d = not any(i.startswith(\"pytorch3d==\") for  i in pip_list)\n",
+    "    if need_pytorch3d:\n",
+    "        print(f\"failed to find/install wheel for {version_str}\")\n",
+    "if need_pytorch3d:\n",
+    "    print(\"Installing PyTorch3D from source\")\n",
+    "    !pip install ninja\n",
+    "    !pip install 'git+https://github.com/facebookresearch/pytorch3d.git@stable'"
    ]
   },
   {

docs/tutorials/render_textured_meshes.ipynb

@@ -67,25 +67,31 @@
     "import os\n",
     "import sys\n",
     "import torch\n",
+    "import subprocess\n",
     "need_pytorch3d=False\n",
     "try:\n",
     "    import pytorch3d\n",
     "except ModuleNotFoundError:\n",
     "    need_pytorch3d=True\n",
     "if need_pytorch3d:\n",
-    "    if torch.__version__.startswith(\"2.1.\") and sys.platform.startswith(\"linux\"):\n",
-    "        # We try to install PyTorch3D via a released wheel.\n",
-    "        pyt_version_str=torch.__version__.split(\"+\")[0].replace(\".\", \"\")\n",
-    "        version_str=\"\".join([\n",
-    "            f\"py3{sys.version_info.minor}_cu\",\n",
-    "            torch.version.cuda.replace(\".\",\"\"),\n",
-    "            f\"_pyt{pyt_version_str}\"\n",
-    "        ])\n",
-    "        !pip install fvcore iopath\n",
+    "    pyt_version_str=torch.__version__.split(\"+\")[0].replace(\".\", \"\")\n",
+    "    version_str=\"\".join([\n",
+    "        f\"py3{sys.version_info.minor}_cu\",\n",
+    "        torch.version.cuda.replace(\".\",\"\"),\n",
+    "        f\"_pyt{pyt_version_str}\"\n",
+    "    ])\n",
+    "    !pip install 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",
-    "    else:\n",
-    "        # We try to install PyTorch3D from source.\n",
-    "        !pip install 'git+https://github.com/facebookresearch/pytorch3d.git@stable'"
+    "        pip_list = !pip freeze\n",
+    "        need_pytorch3d = not any(i.startswith(\"pytorch3d==\") for  i in pip_list)\n",
+    "    if need_pytorch3d:\n",
+    "        print(f\"failed to find/install wheel for {version_str}\")\n",
+    "if need_pytorch3d:\n",
+    "    print(\"Installing PyTorch3D from source\")\n",
+    "    !pip install ninja\n",
+    "    !pip install 'git+https://github.com/facebookresearch/pytorch3d.git@stable'"
    ]
   },
   {

packaging/build_conda.py

@@ -80,6 +80,12 @@ def setup_cuda():
 def setup_conda_pytorch_constraint() -> List[str]:
     pytorch_constraint = f"- pytorch=={PYTORCH_VERSION}"
     os.environ["CONDA_PYTORCH_CONSTRAINT"] = pytorch_constraint
+    if pytorch_major_minor < (2, 2):
+        os.environ["CONDA_PYTORCH_MKL_CONSTRAINT"] = "- mkl!=2024.1.0"
+        os.environ["SETUPTOOLS_CONSTRAINT"] = "- setuptools<70"
+    else:
+        os.environ["CONDA_PYTORCH_MKL_CONSTRAINT"] = ""
+        os.environ["SETUPTOOLS_CONSTRAINT"] = "- setuptools"
     os.environ["CONDA_PYTORCH_BUILD_CONSTRAINT"] = pytorch_constraint
     os.environ["PYTORCH_VERSION_NODOT"] = PYTORCH_VERSION.replace(".", "")
 

packaging/pytorch3d/meta.yaml

@@ -12,8 +12,9 @@ requirements:
 
   host:
     - python
-    - setuptools
+    {{ environ.get('SETUPTOOLS_CONSTRAINT') }}
     {{ environ.get('CONDA_PYTORCH_BUILD_CONSTRAINT') }}
+    {{ environ.get('CONDA_PYTORCH_MKL_CONSTRAINT') }}
     {{ environ.get('CONDA_CUDATOOLKIT_CONSTRAINT') }}
     {{ environ.get('CONDA_CPUONLY_FEATURE') }}
 

projects/implicitron_trainer/__init__.py

@@ -3,3 +3,5 @@
 #
 # This source code is licensed under the BSD-style license found in the
 # LICENSE file in the root directory of this source tree.
+
+# pyre-unsafe

projects/implicitron_trainer/experiment.py

@@ -5,6 +5,8 @@
 # This source code is licensed under the BSD-style license found in the
 # LICENSE file in the root directory of this source tree.
 
+# pyre-unsafe
+
 """"
 This file is the entry point for launching experiments with Implicitron.
 

projects/implicitron_trainer/impl/__init__.py

@@ -3,3 +3,5 @@
 #
 # This source code is licensed under the BSD-style license found in the
 # LICENSE file in the root directory of this source tree.
+
+# pyre-unsafe

projects/implicitron_trainer/impl/model_factory.py

@@ -4,6 +4,8 @@
 # This source code is licensed under the BSD-style license found in the
 # LICENSE file in the root directory of this source tree.
 
+# pyre-unsafe
+
 import logging
 import os
 from typing import Optional

projects/implicitron_trainer/impl/optimizer_factory.py

@@ -4,6 +4,8 @@
 # This source code is licensed under the BSD-style license found in the
 # LICENSE file in the root directory of this source tree.
 
+# pyre-unsafe
+
 import inspect
 import logging
 import os
@@ -121,7 +123,6 @@ class ImplicitronOptimizerFactory(OptimizerFactoryBase):
         """
         # Get the parameters to optimize
         if hasattr(model, "_get_param_groups"):  # use the model function
-            # pyre-ignore[29]
             p_groups = model._get_param_groups(self.lr, wd=self.weight_decay)
         else:
             p_groups = [

projects/implicitron_trainer/impl/training_loop.py

@@ -4,6 +4,8 @@
 # This source code is licensed under the BSD-style license found in the
 # LICENSE file in the root directory of this source tree.
 
+# pyre-unsafe
+
 import logging
 import os
 import time
@@ -110,6 +112,8 @@ class ImplicitronTrainingLoop(TrainingLoopBase):
     def __post_init__(self):
         run_auto_creation(self)
 
+    # pyre-fixme[14]: `run` overrides method defined in `TrainingLoopBase`
+    #  inconsistently.
     def run(
         self,
         *,
@@ -391,7 +395,6 @@ class ImplicitronTrainingLoop(TrainingLoopBase):
             ):
                 prefix = f"e{stats.epoch}_it{stats.it[trainmode]}"
                 if hasattr(model, "visualize"):
-                    # pyre-ignore [29]
                     model.visualize(
                         viz,
                         visdom_env_imgs,

projects/implicitron_trainer/impl/utils.py

@@ -4,6 +4,8 @@
 # This source code is licensed under the BSD-style license found in the
 # LICENSE file in the root directory of this source tree.
 
+# pyre-unsafe
+
 
 import random
 

projects/implicitron_trainer/tests/__init__.py

@@ -3,3 +3,5 @@
 #
 # This source code is licensed under the BSD-style license found in the
 # LICENSE file in the root directory of this source tree.
+
+# pyre-unsafe

projects/implicitron_trainer/tests/test_experiment.py

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

projects/implicitron_trainer/tests/test_optimizer_factory.py

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

projects/implicitron_trainer/tests/test_visualize.py

@@ -4,6 +4,8 @@
 # This source code is licensed under the BSD-style license found in the
 # LICENSE file in the root directory of this source tree.
 
+# pyre-unsafe
+
 import os
 import unittest
 

projects/implicitron_trainer/tests/utils.py

@@ -4,6 +4,8 @@
 # This source code is licensed under the BSD-style license found in the
 # LICENSE file in the root directory of this source tree.
 
+# pyre-unsafe
+
 import contextlib
 import logging
 import os

projects/implicitron_trainer/visualize_reconstruction.py

@@ -5,6 +5,8 @@
 # This source code is licensed under the BSD-style license found in the
 # LICENSE file in the root directory of this source tree.
 
+# pyre-unsafe
+
 """
 Script to visualize a previously trained model. Example call:
 

projects/nerf/nerf/nerf_renderer.py

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

pytorch3d/__init__.py

@@ -4,4 +4,6 @@
 # This source code is licensed under the BSD-style license found in the
 # LICENSE file in the root directory of this source tree.
 
-__version__ = "0.7.5"
+# pyre-unsafe
+
+__version__ = "0.7.6"

pytorch3d/common/__init__.py

@@ -4,6 +4,8 @@
 # This source code is licensed under the BSD-style license found in the
 # LICENSE file in the root directory of this source tree.
 
+# pyre-unsafe
+
 from .datatypes import Device, get_device, make_device
 
 

pytorch3d/common/compat.py

@@ -4,6 +4,8 @@
 # This source code is licensed under the BSD-style license found in the
 # LICENSE file in the root directory of this source tree.
 
+# pyre-unsafe
+
 from typing import Sequence, Tuple, Union
 
 import torch

pytorch3d/common/datatypes.py

@@ -4,6 +4,8 @@
 # This source code is licensed under the BSD-style license found in the
 # LICENSE file in the root directory of this source tree.
 
+# pyre-unsafe
+
 from typing import Optional, Union
 
 import torch

pytorch3d/common/linear_with_repeat.py

@@ -4,6 +4,8 @@
 # This source code is licensed under the BSD-style license found in the
 # LICENSE file in the root directory of this source tree.
 
+# pyre-unsafe
+
 import math
 from typing import Tuple
 

pytorch3d/common/workaround/__init__.py

@@ -4,5 +4,7 @@
 # This source code is licensed under the BSD-style license found in the
 # LICENSE file in the root directory of this source tree.
 
+# pyre-unsafe
+
 from .symeig3x3 import symeig3x3
 from .utils import _safe_det_3x3

pytorch3d/common/workaround/symeig3x3.py

@@ -4,6 +4,8 @@
 # This source code is licensed under the BSD-style license found in the
 # LICENSE file in the root directory of this source tree.
 
+# pyre-unsafe
+
 import math
 from typing import Optional, Tuple
 

pytorch3d/common/workaround/utils.py

@@ -4,6 +4,8 @@
 # This source code is licensed under the BSD-style license found in the
 # LICENSE file in the root directory of this source tree.
 
+# pyre-unsafe
+
 
 import torch
 

pytorch3d/csrc/knn/knn.cu

@@ -338,7 +338,7 @@ std::tuple<at::Tensor, at::Tensor> KNearestNeighborIdxCuda(
 
   TORCH_CHECK((norm == 1) || (norm == 2), "Norm must be 1 or 2.");
 
-  TORCH_CHECK(p2.size(2) == D, "Point sets must have the same last dimension");
+  TORCH_CHECK(p1.size(2) == D, "Point sets must have the same last dimension");
   auto long_dtype = lengths1.options().dtype(at::kLong);
   auto idxs = at::zeros({N, P1, K}, long_dtype);
   auto dists = at::zeros({N, P1, K}, p1.options());
@@ -495,7 +495,7 @@ __global__ void KNearestNeighborBackwardKernel(
     if ((p1_idx < num1) && (k < num2)) {
       const float grad_dist = grad_dists[n * P1 * K + p1_idx * K + k];
       // index of point in p2 corresponding to the k-th nearest neighbor
-      const size_t p2_idx = idxs[n * P1 * K + p1_idx * K + k];
+      const int64_t p2_idx = idxs[n * P1 * K + p1_idx * K + k];
       // If the index is the pad value of -1 then ignore it
       if (p2_idx == -1) {
         continue;

pytorch3d/csrc/marching_cubes/marching_cubes.cu

@@ -223,7 +223,7 @@ __global__ void CompactVoxelsKernel(
         compactedVoxelArray,
     const at::PackedTensorAccessor32<int, 1, at::RestrictPtrTraits>
         voxelOccupied,
-    const at::PackedTensorAccessor32<int, 1, at::RestrictPtrTraits>
+    const at::PackedTensorAccessor32<int64_t, 1, at::RestrictPtrTraits>
         voxelOccupiedScan,
     uint numVoxels) {
   uint id = blockIdx.x * blockDim.x + threadIdx.x;
@@ -255,7 +255,8 @@ __global__ void GenerateFacesKernel(
     at::PackedTensorAccessor<int64_t, 1, at::RestrictPtrTraits> ids,
     at::PackedTensorAccessor32<int, 1, at::RestrictPtrTraits>
         compactedVoxelArray,
-    at::PackedTensorAccessor32<int, 1, at::RestrictPtrTraits> numVertsScanned,
+    at::PackedTensorAccessor32<int64_t, 1, at::RestrictPtrTraits>
+        numVertsScanned,
     const uint activeVoxels,
     const at::PackedTensorAccessor32<float, 3, at::RestrictPtrTraits> vol,
     const at::PackedTensorAccessor32<int, 2, at::RestrictPtrTraits> faceTable,
@@ -381,6 +382,44 @@ __global__ void GenerateFacesKernel(
   } // end for grid-strided kernel
 }
 
+// ATen/Torch does not have an exclusive-scan operator. Additionally, in the
+// code below we need to get the "total number of items to work on" after
+// a scan, which with an inclusive-scan would simply be the value of the last
+// element in the tensor.
+//
+// This utility function hits two birds with one stone, by running
+// an inclusive-scan into a right-shifted view of a tensor that's
+// allocated to be one element bigger than the input tensor.
+//
+// Note; return tensor is `int64_t` per element, even if the input
+// tensor is only 32-bit. Also, the return tensor is one element bigger
+// than the input one.
+//
+// Secondary optional argument is an output argument that gets the
+// value of the last element of the return tensor (because you almost
+// always need this CPU-side right after this function anyway).
+static at::Tensor ExclusiveScanAndTotal(
+    const at::Tensor& inTensor,
+    int64_t* optTotal = nullptr) {
+  const auto inSize = inTensor.sizes()[0];
+  auto retTensor = at::zeros({inSize + 1}, at::kLong).to(inTensor.device());
+
+  using at::indexing::None;
+  using at::indexing::Slice;
+  auto rightShiftedView = retTensor.index({Slice(1, None)});
+
+  // Do an (inclusive-scan) cumulative sum in to the view that's
+  // shifted one element to the right...
+  at::cumsum_out(rightShiftedView, inTensor, 0, at::kLong);
+
+  if (optTotal) {
+    *optTotal = retTensor[inSize].cpu().item<int64_t>();
+  }
+
+  // ...so that the not-shifted tensor holds the exclusive-scan
+  return retTensor;
+}
+
 // Entrance for marching cubes cuda extension. Marching Cubes is an algorithm to
 // create triangle meshes from an implicit function (one of the form f(x, y, z)
 // = 0). It works by iteratively checking a grid of cubes superimposed over a
@@ -443,20 +482,18 @@ std::tuple<at::Tensor, at::Tensor, at::Tensor> MarchingCubesCuda(
   using at::indexing::Slice;
 
   auto d_voxelVerts =
-      at::zeros({numVoxels + 1}, at::TensorOptions().dtype(at::kInt))
+      at::zeros({numVoxels}, at::TensorOptions().dtype(at::kInt))
           .to(vol.device());
-  auto d_voxelVerts_ = d_voxelVerts.index({Slice(1, None)});
   auto d_voxelOccupied =
-      at::zeros({numVoxels + 1}, at::TensorOptions().dtype(at::kInt))
+      at::zeros({numVoxels}, at::TensorOptions().dtype(at::kInt))
           .to(vol.device());
-  auto d_voxelOccupied_ = d_voxelOccupied.index({Slice(1, None)});
 
   // Execute "ClassifyVoxelKernel" kernel to precompute
   // two arrays - d_voxelOccupied and d_voxelVertices to global memory,
   // which stores the occupancy state and number of voxel vertices per voxel.
   ClassifyVoxelKernel<<<grid, threads, 0, stream>>>(
-      d_voxelVerts_.packed_accessor32<int, 1, at::RestrictPtrTraits>(),
-      d_voxelOccupied_.packed_accessor32<int, 1, at::RestrictPtrTraits>(),
+      d_voxelVerts.packed_accessor32<int, 1, at::RestrictPtrTraits>(),
+      d_voxelOccupied.packed_accessor32<int, 1, at::RestrictPtrTraits>(),
       vol.packed_accessor32<float, 3, at::RestrictPtrTraits>(),
       isolevel);
   AT_CUDA_CHECK(cudaGetLastError());
@@ -466,12 +503,9 @@ std::tuple<at::Tensor, at::Tensor, at::Tensor> MarchingCubesCuda(
   // count for voxels in the grid and compute the number of active voxels.
   // If the number of active voxels is 0, return zero tensor for verts and
   // faces.
-
-  auto d_voxelOccupiedScan = at::cumsum(d_voxelOccupied, 0);
-  auto d_voxelOccupiedScan_ = d_voxelOccupiedScan.index({Slice(1, None)});
-
-  // number of active voxels
-  int activeVoxels = d_voxelOccupiedScan[numVoxels].cpu().item<int>();
+  int64_t activeVoxels = 0;
+  auto d_voxelOccupiedScan =
+      ExclusiveScanAndTotal(d_voxelOccupied, &activeVoxels);
 
   const int device_id = vol.device().index();
   auto opt = at::TensorOptions().dtype(at::kInt).device(at::kCUDA, device_id);
@@ -486,23 +520,21 @@ std::tuple<at::Tensor, at::Tensor, at::Tensor> MarchingCubesCuda(
     return std::make_tuple(verts, faces, ids);
   }
 
-  // Execute "CompactVoxelsKernel" kernel to compress voxels for accleration.
+  // Execute "CompactVoxelsKernel" kernel to compress voxels for acceleration.
   // This allows us to run triangle generation on only the occupied voxels.
   auto d_compVoxelArray = at::zeros({activeVoxels}, opt);
   CompactVoxelsKernel<<<grid, threads, 0, stream>>>(
       d_compVoxelArray.packed_accessor32<int, 1, at::RestrictPtrTraits>(),
       d_voxelOccupied.packed_accessor32<int, 1, at::RestrictPtrTraits>(),
-      d_voxelOccupiedScan_.packed_accessor32<int, 1, at::RestrictPtrTraits>(),
+      d_voxelOccupiedScan
+          .packed_accessor32<int64_t, 1, at::RestrictPtrTraits>(),
       numVoxels);
   AT_CUDA_CHECK(cudaGetLastError());
   cudaDeviceSynchronize();
 
   // Scan d_voxelVerts array to generate offsets of vertices for each voxel
-  auto d_voxelVertsScan = at::cumsum(d_voxelVerts, 0);
-  auto d_voxelVertsScan_ = d_voxelVertsScan.index({Slice(1, None)});
-
-  // total number of vertices
-  int totalVerts = d_voxelVertsScan[numVoxels].cpu().item<int>();
+  int64_t totalVerts = 0;
+  auto d_voxelVertsScan = ExclusiveScanAndTotal(d_voxelVerts, &totalVerts);
 
   // Execute "GenerateFacesKernel" kernel
   // This runs only on the occupied voxels.
@@ -522,7 +554,7 @@ std::tuple<at::Tensor, at::Tensor, at::Tensor> MarchingCubesCuda(
       faces.packed_accessor<int64_t, 2, at::RestrictPtrTraits>(),
       ids.packed_accessor<int64_t, 1, at::RestrictPtrTraits>(),
       d_compVoxelArray.packed_accessor32<int, 1, at::RestrictPtrTraits>(),
-      d_voxelVertsScan_.packed_accessor32<int, 1, at::RestrictPtrTraits>(),
+      d_voxelVertsScan.packed_accessor32<int64_t, 1, at::RestrictPtrTraits>(),
       activeVoxels,
       vol.packed_accessor32<float, 3, at::RestrictPtrTraits>(),
       faceTable.packed_accessor32<int, 2, at::RestrictPtrTraits>(),

pytorch3d/csrc/marching_cubes/marching_cubes_cpu.cpp

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

pytorch3d/csrc/pulsar/global.h

@@ -30,11 +30,18 @@
 #define GLOBAL __global__
 #define RESTRICT __restrict__
 #define DEBUGBREAK()
+#ifdef __NVCC_DIAG_PRAGMA_SUPPORT__
+#pragma nv_diag_suppress 1866
+#pragma nv_diag_suppress 2941
+#pragma nv_diag_suppress 2951
+#pragma nv_diag_suppress 2967
+#else
 #pragma diag_suppress = attribute_not_allowed
 #pragma diag_suppress = 1866
 #pragma diag_suppress = 2941
 #pragma diag_suppress = 2951
 #pragma diag_suppress = 2967
+#endif
 #else // __CUDACC__
 #define INLINE inline
 #define HOST
@@ -49,6 +56,7 @@
 #pragma clang diagnostic pop
 #ifdef WITH_CUDA
 #include <ATen/cuda/CUDAContext.h>
+#include <vector_functions.h>
 #else
 #ifndef cudaStream_t
 typedef void* cudaStream_t;
@@ -65,8 +73,6 @@ struct float2 {
 struct float3 {
   float x, y, z;
 };
-#endif
-namespace py = pybind11;
 inline float3 make_float3(const float& x, const float& y, const float& z) {
   float3 res;
   res.x = x;
@@ -74,6 +80,8 @@ inline float3 make_float3(const float& x, const float& y, const float& z) {
   res.z = z;
   return res;
 }
+#endif
+namespace py = pybind11;
 
 inline bool operator==(const float3& a, const float3& b) {
   return a.x == b.x && a.y == b.y && a.z == b.z;

pytorch3d/csrc/pulsar/host/commands.h

@@ -357,11 +357,11 @@ void MAX_WS(
 //
 //
 #define END_PARALLEL() \
-  end_parallel:;       \
+  end_parallel :;      \
   }
 #define END_PARALLEL_NORET() }
 #define END_PARALLEL_2D() \
-  end_parallel:;          \
+  end_parallel :;         \
   }                       \
   }
 #define END_PARALLEL_2D_NORET() \

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

@@ -93,7 +93,7 @@ HOST void construct(
   MALLOC(self->di_sorted_d, DrawInfo, max_num_balls);
   MALLOC(self->region_flags_d, char, max_num_balls);
   MALLOC(self->num_selected_d, size_t, 1);
-  MALLOC(self->forw_info_d, float, width* height*(3 + 2 * n_track));
+  MALLOC(self->forw_info_d, float, width* height * (3 + 2 * n_track));
   MALLOC(self->min_max_pixels_d, IntersectInfo, 1);
   MALLOC(self->grad_pos_d, float3, max_num_balls);
   MALLOC(self->grad_col_d, float, max_num_balls* n_channels);

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

@@ -99,7 +99,7 @@ GLOBAL void render(
   /** Whether loading of balls is completed. */
   SHARED bool loading_done;
   /** The number of balls loaded overall (just for statistics). */
-  SHARED int n_balls_loaded;
+  [[maybe_unused]] SHARED int n_balls_loaded;
   /** The area this thread block covers. */
   SHARED IntersectInfo block_area;
   if (thread_block.thread_rank() == 0) {

pytorch3d/csrc/rasterize_coarse/rasterize_coarse.cu

@@ -244,8 +244,7 @@ at::Tensor RasterizeCoarseCuda(
   if (num_bins_y >= kMaxItemsPerBin || num_bins_x >= kMaxItemsPerBin) {
     std::stringstream ss;
     ss << "In RasterizeCoarseCuda got num_bins_y: " << num_bins_y
-       << ", num_bins_x: " << num_bins_x << ", "
-       << "; that's too many!";
+       << ", num_bins_x: " << num_bins_x << ", " << "; that's too many!";
     AT_ERROR(ss.str());
   }
   auto opts = elems_per_batch.options().dtype(at::kInt);

pytorch3d/datasets/__init__.py

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

pytorch3d/datasets/r2n2/__init__.py

@@ -4,6 +4,8 @@
 # This source code is licensed under the BSD-style license found in the
 # LICENSE file in the root directory of this source tree.
 
+# pyre-unsafe
+
 from .r2n2 import R2N2
 from .utils import BlenderCamera, collate_batched_R2N2, render_cubified_voxels
 

pytorch3d/datasets/r2n2/r2n2.py

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

pytorch3d/datasets/r2n2/utils.py

@@ -4,6 +4,8 @@
 # This source code is licensed under the BSD-style license found in the
 # LICENSE file in the root directory of this source tree.
 
+# pyre-unsafe
+
 import math
 from typing import Dict, List
 

pytorch3d/datasets/shapenet/__init__.py

@@ -4,6 +4,8 @@
 # This source code is licensed under the BSD-style license found in the
 # LICENSE file in the root directory of this source tree.
 
+# pyre-unsafe
+
 from .shapenet_core import ShapeNetCore
 
 

pytorch3d/datasets/shapenet/shapenet_core.py

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

pytorch3d/datasets/shapenet_base.py

@@ -4,6 +4,8 @@
 # This source code is licensed under the BSD-style license found in the
 # LICENSE file in the root directory of this source tree.
 
+# pyre-unsafe
+
 import warnings
 from typing import Dict, List, Optional, Tuple
 

pytorch3d/datasets/utils.py

@@ -4,6 +4,8 @@
 # This source code is licensed under the BSD-style license found in the
 # LICENSE file in the root directory of this source tree.
 
+# pyre-unsafe
+
 from typing import Dict, List
 
 from pytorch3d.renderer.mesh import TexturesAtlas

pytorch3d/implicitron/__init__.py

@@ -3,3 +3,5 @@
 #
 # This source code is licensed under the BSD-style license found in the
 # LICENSE file in the root directory of this source tree.
+
+# pyre-unsafe

pytorch3d/implicitron/dataset/__init__.py

@@ -3,3 +3,5 @@
 #
 # This source code is licensed under the BSD-style license found in the
 # LICENSE file in the root directory of this source tree.
+
+# pyre-unsafe

pytorch3d/implicitron/dataset/blender_dataset_map_provider.py

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

pytorch3d/implicitron/dataset/data_loader_map_provider.py

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

pytorch3d/implicitron/dataset/data_source.py

@@ -4,6 +4,8 @@
 # This source code is licensed under the BSD-style license found in the
 # LICENSE file in the root directory of this source tree.
 
+# pyre-unsafe
+
 from typing import Optional, Tuple
 
 from pytorch3d.implicitron.tools.config import (

pytorch3d/implicitron/dataset/dataset_base.py

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

pytorch3d/implicitron/dataset/dataset_map_provider.py

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

pytorch3d/implicitron/dataset/frame_data.py

@@ -4,6 +4,8 @@
 # This source code is licensed under the BSD-style license found in the
 # LICENSE file in the root directory of this source tree.
 
+# pyre-unsafe
+
 import os
 from abc import ABC, abstractmethod
 from collections import defaultdict
@@ -576,11 +578,11 @@ class GenericFrameDataBuilder(FrameDataBuilderBase[FrameDataSubtype], ABC):
             camera_quality_score=safe_as_tensor(
                 sequence_annotation.viewpoint_quality_score, torch.float
             ),
-            point_cloud_quality_score=safe_as_tensor(
-                point_cloud.quality_score, torch.float
-            )
-            if point_cloud is not None
-            else None,
+            point_cloud_quality_score=(
+                safe_as_tensor(point_cloud.quality_score, torch.float)
+                if point_cloud is not None
+                else None
+            ),
         )
 
         fg_mask_np: Optional[np.ndarray] = None

pytorch3d/implicitron/dataset/json_index_dataset.py

@@ -4,6 +4,8 @@
 # This source code is licensed under the BSD-style license found in the
 # LICENSE file in the root directory of this source tree.
 
+# pyre-unsafe
+
 import copy
 import functools
 import gzip
@@ -124,9 +126,9 @@ class JsonIndexDataset(DatasetBase, ReplaceableBase):
             dimension of the cropping bounding box, relative to box size.
     """
 
-    frame_annotations_type: ClassVar[
-        Type[types.FrameAnnotation]
-    ] = types.FrameAnnotation
+    frame_annotations_type: ClassVar[Type[types.FrameAnnotation]] = (
+        types.FrameAnnotation
+    )
 
     path_manager: Any = None
     frame_annotations_file: str = ""

pytorch3d/implicitron/dataset/json_index_dataset_map_provider.py

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

pytorch3d/implicitron/dataset/json_index_dataset_map_provider_v2.py

@@ -4,6 +4,8 @@
 # This source code is licensed under the BSD-style license found in the
 # LICENSE file in the root directory of this source tree.
 
+# pyre-unsafe
+
 
 import copy
 import json

pytorch3d/implicitron/dataset/llff_dataset_map_provider.py

@@ -4,6 +4,8 @@
 # This source code is licensed under the BSD-style license found in the
 # LICENSE file in the root directory of this source tree.
 
+# pyre-unsafe
+
 
 import numpy as np
 import torch

pytorch3d/implicitron/dataset/load_blender.py

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

pytorch3d/implicitron/dataset/load_llff.py

@@ -1,6 +1,8 @@
 # @lint-ignore-every LICENSELINT
 # Adapted from https://github.com/bmild/nerf/blob/master/load_llff.py
 # Copyright (c) 2020 bmild
+
+# pyre-unsafe
 import logging
 import os
 import warnings
@@ -34,11 +36,7 @@ def _minify(basedir, path_manager, factors=(), resolutions=()):
 
     imgdir = os.path.join(basedir, "images")
     imgs = [os.path.join(imgdir, f) for f in sorted(_ls(path_manager, imgdir))]
-    imgs = [
-        f
-        for f in imgs
-        if any([f.endswith(ex) for ex in ["JPG", "jpg", "png", "jpeg", "PNG"]])
-    ]
+    imgs = [f for f in imgs if f.endswith("JPG", "jpg", "png", "jpeg", "PNG")]
     imgdir_orig = imgdir
 
     wd = os.getcwd()

pytorch3d/implicitron/dataset/rendered_mesh_dataset_map_provider.py

@@ -4,6 +4,8 @@
 # This source code is licensed under the BSD-style license found in the
 # LICENSE file in the root directory of this source tree.
 
+# pyre-unsafe
+
 from os.path import dirname, join, realpath
 from typing import Optional, Tuple
 

pytorch3d/implicitron/dataset/scene_batch_sampler.py

@@ -4,6 +4,8 @@
 # This source code is licensed under the BSD-style license found in the
 # LICENSE file in the root directory of this source tree.
 
+# pyre-unsafe
+
 
 import warnings
 from collections import Counter

pytorch3d/implicitron/dataset/single_sequence_dataset.py

@@ -4,6 +4,8 @@
 # This source code is licensed under the BSD-style license found in the
 # LICENSE file in the root directory of this source tree.
 
+# pyre-unsafe
+
 
 # This file defines a base class for dataset map providers which
 # provide data for a single scene.

pytorch3d/implicitron/dataset/train_eval_data_loader_provider.py

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

pytorch3d/implicitron/dataset/types.py

@@ -4,6 +4,8 @@
 # This source code is licensed under the BSD-style license found in the
 # LICENSE file in the root directory of this source tree.
 
+# pyre-unsafe
+
 
 import dataclasses
 import gzip

pytorch3d/implicitron/dataset/utils.py

@@ -4,6 +4,8 @@
 # This source code is licensed under the BSD-style license found in the
 # LICENSE file in the root directory of this source tree.
 
+# pyre-unsafe
+
 
 import functools
 import warnings
@@ -200,7 +202,7 @@ def resize_image(
     mode: str = "bilinear",
 ) -> Tuple[torch.Tensor, float, torch.Tensor]:
 
-    if type(image) == np.ndarray:
+    if isinstance(image, np.ndarray):
         image = torch.from_numpy(image)
 
     if image_height is None or image_width is None:

pytorch3d/implicitron/dataset/visualize.py

@@ -4,6 +4,8 @@
 # This source code is licensed under the BSD-style license found in the
 # LICENSE file in the root directory of this source tree.
 
+# pyre-unsafe
+
 from typing import cast, Optional, Tuple
 
 import torch
@@ -88,10 +90,11 @@ def get_implicitron_sequence_pointcloud(
             frame_data.camera,
             frame_data.image_rgb,
             frame_data.depth_map,
-            (cast(torch.Tensor, frame_data.fg_probability) > 0.5).float()
-            if frame_data.fg_probability is not None
-            else None,
-            mask_points=mask_points,
+            (
+                (cast(torch.Tensor, frame_data.fg_probability) > 0.5).float()
+                if mask_points and frame_data.fg_probability is not None
+                else None
+            ),
         )
 
     return point_cloud, frame_data

pytorch3d/implicitron/eval_demo.py

@@ -4,6 +4,8 @@
 # This source code is licensed under the BSD-style license found in the
 # LICENSE file in the root directory of this source tree.
 
+# pyre-unsafe
+
 
 import dataclasses
 import os

pytorch3d/implicitron/evaluation/__init__.py

@@ -3,3 +3,5 @@
 #
 # This source code is licensed under the BSD-style license found in the
 # LICENSE file in the root directory of this source tree.
+
+# pyre-unsafe

pytorch3d/implicitron/evaluation/evaluate_new_view_synthesis.py

@@ -4,6 +4,8 @@
 # This source code is licensed under the BSD-style license found in the
 # LICENSE file in the root directory of this source tree.
 
+# pyre-unsafe
+
 
 import copy
 import warnings
@@ -282,9 +284,9 @@ def eval_batch(
             image_rgb_masked=image_rgb_masked,
             depth_render=cloned_render["depth_render"],
             depth_map=frame_data.depth_map,
-            depth_mask=frame_data.depth_mask[:1]
-            if frame_data.depth_mask is not None
-            else None,
+            depth_mask=(
+                frame_data.depth_mask[:1] if frame_data.depth_mask is not None else None
+            ),
             visdom_env=visualize_visdom_env,
         )
 

pytorch3d/implicitron/evaluation/evaluator.py

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

pytorch3d/implicitron/models/__init__.py

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

pytorch3d/implicitron/models/base_model.py

@@ -4,6 +4,8 @@
 # This source code is licensed under the BSD-style license found in the
 # LICENSE file in the root directory of this source tree.
 
+# pyre-unsafe
+
 from dataclasses import dataclass, field
 from typing import Any, Dict, List, Optional
 

pytorch3d/implicitron/models/feature_extractor/__init__.py

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

pytorch3d/implicitron/models/feature_extractor/feature_extractor.py

@@ -4,6 +4,8 @@
 # This source code is licensed under the BSD-style license found in the
 # LICENSE file in the root directory of this source tree.
 
+# pyre-unsafe
+
 from typing import Any, Dict, Optional
 
 import torch

pytorch3d/implicitron/models/feature_extractor/resnet_feature_extractor.py

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

pytorch3d/implicitron/models/generic_model.py

@@ -4,6 +4,8 @@
 # This source code is licensed under the BSD-style license found in the
 # LICENSE file in the root directory of this source tree.
 
+# pyre-unsafe
+
 
 # Note: The #noqa comments below are for unused imports of pluggable implementations
 # which are part of implicitron. They ensure that the registry is prepopulated.
@@ -395,9 +397,11 @@ class GenericModel(ImplicitronModelBase):  # pyre-ignore: 13
         n_targets = (
             1
             if evaluation_mode == EvaluationMode.EVALUATION
-            else batch_size
-            if self.n_train_target_views <= 0
-            else min(self.n_train_target_views, batch_size)
+            else (
+                batch_size
+                if self.n_train_target_views <= 0
+                else min(self.n_train_target_views, batch_size)
+            )
         )
 
         # A helper function for selecting n_target first elements from the input
@@ -422,9 +426,12 @@ class GenericModel(ImplicitronModelBase):  # pyre-ignore: 13
         ray_bundle: ImplicitronRayBundle = self.raysampler(
             target_cameras,
             evaluation_mode,
-            mask=mask_crop[:n_targets]
-            if mask_crop is not None and sampling_mode == RenderSamplingMode.MASK_SAMPLE
-            else None,
+            mask=(
+                mask_crop[:n_targets]
+                if mask_crop is not None
+                and sampling_mode == RenderSamplingMode.MASK_SAMPLE
+                else None
+            ),
         )
 
         # custom_args hold additional arguments to the implicit function.

pytorch3d/implicitron/models/global_encoder/__init__.py

@@ -3,3 +3,5 @@
 #
 # This source code is licensed under the BSD-style license found in the
 # LICENSE file in the root directory of this source tree.
+
+# pyre-unsafe

pytorch3d/implicitron/models/global_encoder/autodecoder.py

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

pytorch3d/implicitron/models/global_encoder/global_encoder.py

@@ -4,6 +4,8 @@
 # This source code is licensed under the BSD-style license found in the
 # LICENSE file in the root directory of this source tree.
 
+# pyre-unsafe
+
 from typing import List, Optional, Union
 
 import torch

pytorch3d/implicitron/models/implicit_function/__init__.py

@@ -3,3 +3,5 @@
 #
 # This source code is licensed under the BSD-style license found in the
 # LICENSE file in the root directory of this source tree.
+
+# pyre-unsafe

pytorch3d/implicitron/models/implicit_function/base.py

@@ -4,6 +4,8 @@
 # This source code is licensed under the BSD-style license found in the
 # LICENSE file in the root directory of this source tree.
 
+# pyre-unsafe
+
 from abc import ABC, abstractmethod
 from typing import Optional
 

pytorch3d/implicitron/models/implicit_function/decoding_functions.py

@@ -4,6 +4,8 @@
 # This source code is licensed under the BSD-style license found in the
 # LICENSE file in the root directory of this source tree.
 
+# pyre-unsafe
+
 """
 This file contains
     - modules which get used by ImplicitFunction objects for decoding an embedding defined in

pytorch3d/implicitron/models/implicit_function/idr_feature_field.py

@@ -2,6 +2,8 @@
 # Adapted from https://github.com/lioryariv/idr/blob/main/code/model/
 #              implicit_differentiable_renderer.py
 # Copyright (c) 2020 Lior Yariv
+
+# pyre-unsafe
 import math
 from typing import Optional, Tuple
 
@@ -102,9 +104,7 @@ class IdrFeatureField(ImplicitFunctionBase, torch.nn.Module):
                 elif self.n_harmonic_functions_xyz >= 0 and layer_idx == 0:
                     torch.nn.init.constant_(lin.bias, 0.0)
                     torch.nn.init.constant_(lin.weight[:, 3:], 0.0)
-                    torch.nn.init.normal_(
-                        lin.weight[:, :3], 0.0, 2**0.5 / out_dim**0.5
-                    )
+                    torch.nn.init.normal_(lin.weight[:, :3], 0.0, 2**0.5 / out_dim**0.5)
                 elif self.n_harmonic_functions_xyz >= 0 and layer_idx in self.skip_in:
                     torch.nn.init.constant_(lin.bias, 0.0)
                     torch.nn.init.normal_(lin.weight, 0.0, 2**0.5 / out_dim**0.5)

pytorch3d/implicitron/models/implicit_function/neural_radiance_field.py

@@ -4,6 +4,8 @@
 # This source code is licensed under the BSD-style license found in the
 # LICENSE file in the root directory of this source tree.
 
+# pyre-unsafe
+
 import logging
 from typing import Optional, Tuple
 
@@ -193,9 +195,9 @@ class NeuralRadianceFieldBase(ImplicitFunctionBase, torch.nn.Module):
         embeds = create_embeddings_for_implicit_function(
             xyz_world=rays_points_world,
             #  for 2nd param but got `Union[None, torch.Tensor, torch.nn.Module]`.
-            xyz_embedding_function=self.harmonic_embedding_xyz
-            if self.input_xyz
-            else None,
+            xyz_embedding_function=(
+                self.harmonic_embedding_xyz if self.input_xyz else None
+            ),
             global_code=global_code,
             fun_viewpool=fun_viewpool,
             xyz_in_camera_coords=self.xyz_ray_dir_in_camera_coords,

pytorch3d/implicitron/models/implicit_function/scene_representation_networks.py

@@ -1,6 +1,8 @@
 # @lint-ignore-every LICENSELINT
 # Adapted from https://github.com/vsitzmann/scene-representation-networks
 # Copyright (c) 2019 Vincent Sitzmann
+
+# pyre-unsafe
 from typing import Any, cast, Optional, Tuple
 
 import torch

pytorch3d/implicitron/models/implicit_function/utils.py

@@ -4,6 +4,8 @@
 # This source code is licensed under the BSD-style license found in the
 # LICENSE file in the root directory of this source tree.
 
+# pyre-unsafe
+
 from typing import Callable, Optional
 
 import torch

pytorch3d/implicitron/models/implicit_function/voxel_grid.py

@@ -4,6 +4,8 @@
 # This source code is licensed under the BSD-style license found in the
 # LICENSE file in the root directory of this source tree.
 
+# pyre-unsafe
+
 """
 This file contains classes that implement Voxel grids, both in their full resolution
 as in the factorized form. There are two factorized forms implemented, Tensor rank decomposition

pytorch3d/implicitron/models/implicit_function/voxel_grid_implicit_function.py

@@ -4,6 +4,8 @@
 # This source code is licensed under the BSD-style license found in the
 # LICENSE file in the root directory of this source tree.
 
+# pyre-unsafe
+
 import logging
 import math
 import warnings