Add files using upload-large-folder tool

project/ManiSkill3/src/maniskill2_benchmark/cfdp_experiment/cfdp/extern/pytorch3d/projects/implicitron_trainer/README.md

@@ -0,0 +1,455 @@
+# Introduction
+
+Implicitron is a PyTorch3D-based framework for new-view synthesis via modeling the neural-network based representations.
+
+# License
+
+Implicitron is distributed as part of PyTorch3D under the [BSD license](https://github.com/facebookresearch/pytorch3d/blob/main/LICENSE).
+It includes code from the [NeRF](https://github.com/bmild/nerf), [SRN](http://github.com/vsitzmann/scene-representation-networks) and [IDR](http://github.com/lioryariv/idr) repos.
+See [LICENSE-3RD-PARTY](https://github.com/facebookresearch/pytorch3d/blob/main/LICENSE-3RD-PARTY) for their licenses.
+
+
+# Installation
+
+There are three ways to set up Implicitron, depending on the flexibility level required.
+If you only want to train or evaluate models as they are implemented changing only the parameters, you can just install the package.
+Implicitron also provides a flexible API that supports user-defined plug-ins;
+if you want to re-implement some of the components without changing the high-level pipeline, you need to create a custom launcher script.
+The most flexible option, though, is cloning PyTorch3D repo and building it from sources, which allows changing the code in arbitrary ways.
+Below, we descibe all three options in more details.
+
+
+## [Option 1] Running an executable from the package
+
+This option allows you to use the code as is without changing the implementations.
+Only configuration can be changed (see [Configuration system](#configuration-system)).
+
+For this setup, install the dependencies and PyTorch3D from conda following [the guide](https://github.com/facebookresearch/pytorch3d/blob/master/INSTALL.md#1-install-with-cuda-support-from-anaconda-cloud-on-linux-only). Then, install implicitron-specific dependencies:
+
+```shell
+pip install "hydra-core>=1.1" visdom lpips matplotlib accelerate
+```
+
+Runner executable is available as `pytorch3d_implicitron_runner` shell command.
+See [Running](#running) section below for examples of training and evaluation commands.
+
+
+## [Option 2] Supporting custom implementations
+
+To plug in custom implementations, for example, of renderer or implicit-function protocols, you need to create your own runner script and import the plug-in implementations there.
+First, install PyTorch3D and Implicitron dependencies as described in the previous section.
+Then, implement the custom script; copying `pytorch3d/projects/implicitron_trainer` is a good place to start.
+See [Custom plugins](#custom-plugins) for more information on how to import implementations and enable them in the configs.
+
+
+## [Option 3] Cloning PyTorch3D repo
+
+This is the most flexible way to set up Implicitron as it allows changing the code directly.
+It allows modifying the high-level rendering pipeline or implementing yet-unsupported loss functions.
+Please follow the instructions to [install PyTorch3D from a local clone](https://github.com/facebookresearch/pytorch3d/blob/main/INSTALL.md#2-install-from-a-local-clone).
+Then, install Implicitron-specific dependencies:
+
+```shell
+pip install "hydra-core>=1.1" visdom lpips matplotlib accelerate
+```
+
+You are still encouraged to implement custom plugins as above where possible as it makes reusing the code easier.
+The executable is located in `pytorch3d/projects/implicitron_trainer`.
+
+> **_NOTE:_**  Both `pytorch3d_implicitron_runner` and `pytorch3d_implicitron_visualizer`
+executables (mentioned below) are not available when using local clone.
+Instead users should use the python scripts `experiment.py` and `visualize_reconstruction.py` (see the [Running](Running) section below).
+
+
+# Running
+
+This section assumes that you use the executable provided by the installed package
+(Option 1 / Option 2 in [#Installation](Installation) above),
+i.e. `pytorch3d_implicitron_runner` and `pytorch3d_implicitron_visualizer` are available.
+
+> **_NOTE:_**  If the executables are not available (e.g. when using a local clone - Option 3 in [#Installation](Installation)),
+users should directly use the `experiment.py` and `visualize_reconstruction.py` python scripts
+which correspond to the executables as follows:
+- `pytorch3d_implicitron_runner` corresponds to `<pytorch3d_root>/projects/implicitron_trainer/experiment.py`
+- `pytorch3d_implicitron_visualizer` corresponds to `<pytorch3d_root>/projects/implicitron_trainer/visualize_reconstruction.py`
+
+For instance, in order to directly execute training with the python script, users can call:
+```shell
+cd <pytorch3d_root>/projects/
+python -m implicitron_trainer.experiment <args>`
+```
+
+If you have a custom `experiment.py` or `visualize_reconstruction.py` script
+(as in the Option 2 [above](#Installation)), replace the executable with the path to your script.
+
+## Training
+
+To run training, pass a yaml config file, followed by a list of overridden arguments.
+For example, to train NeRF on the first skateboard sequence from CO3D dataset, you can run:
+```shell
+dataset_args=data_source_ImplicitronDataSource_args.dataset_map_provider_JsonIndexDatasetMapProvider_args
+pytorch3d_implicitron_runner --config-path ./configs/ --config-name repro_singleseq_nerf \
+    $dataset_args.dataset_root=<DATASET_ROOT> $dataset_args.category='skateboard' \
+    $dataset_args.test_restrict_sequence_id=0 test_when_finished=True exp_dir=<CHECKPOINT_DIR>
+```
+
+Here, `--config-path` points to the config path relative to `pytorch3d_implicitron_runner` location;
+`--config-name` picks the config (in this case, `repro_singleseq_nerf.yaml`);
+`test_when_finished` will launch evaluation script once training is finished.
+Replace `<DATASET_ROOT>` with the location where the dataset in Implicitron format is stored
+and `<CHECKPOINT_DIR>` with a directory where checkpoints will be dumped during training.
+Other configuration parameters can be overridden in the same way.
+See [Configuration system](#configuration-system) section for more information on this.
+
+### Visdom logging
+
+Note that the training script logs its progress to Visdom. Make sure to start a visdom server before the training commences:
+```
+python -m visdom.server
+```
+> In case a Visdom server is not started, the console will get flooded with `requests.exceptions.ConnectionError` errors signalling that a Visdom server is not available. Note that these errors <b>will NOT interrupt</b> the program and the training will still continue without issues.
+
+## Evaluation
+
+To run evaluation on the latest checkpoint after (or during) training, simply add `eval_only=True` to your training command.
+
+E.g. for executing the evaluation on the NeRF skateboard sequence, you can run:
+```shell
+dataset_args=data_source_ImplicitronDataSource_args.dataset_map_provider_JsonIndexDatasetMapProvider_args
+pytorch3d_implicitron_runner --config-path ./configs/ --config-name repro_singleseq_nerf \
+    $dataset_args.dataset_root=<CO3D_DATASET_ROOT> $dataset_args.category='skateboard' \
+    $dataset_args.test_restrict_sequence_id=0 exp_dir=<CHECKPOINT_DIR> eval_only=True
+```
+Evaluation prints the metrics to `stdout` and dumps them to a json file in `exp_dir`.
+
+## Visualisation
+
+The script produces a video of renders by a trained model assuming a pre-defined camera trajectory.
+In order for it to work, `ffmpeg` needs to be installed:
+
+```shell
+conda install ffmpeg
+```
+
+Here is an example of calling the script:
+```shell
+pytorch3d_implicitron_visualizer exp_dir=<CHECKPOINT_DIR> \
+    visdom_show_preds=True n_eval_cameras=40 render_size="[64,64]" video_size="[256,256]"
+```
+
+The argument `n_eval_cameras` sets the number of renderring viewpoints sampled on a trajectory, which defaults to a circular fly-around;
+`render_size` sets the size of a render passed to the model, which can be resized to `video_size` before writing.
+
+Rendered videos of images, masks, and depth maps will be saved to `<CHECKPOINT_DIR>/video`.
+
+
+# Configuration system
+
+We use hydra and OmegaConf to parse the configs.
+The config schema and default values are defined by the dataclasses implementing the modules.
+More specifically, if a class derives from `Configurable`, its fields can be set in config yaml files or overridden in CLI.
+For example, `GenericModel` has a field `render_image_width` with the default value 400.
+If it is specified in the yaml config file or in CLI command, the new value will be used.
+
+Configurables can form hierarchies.
+For example, `GenericModel` has a field `raysampler: RaySampler`, which is also Configurable.
+In the config, inner parameters can be propagated using `_args` postfix, e.g. to change `raysampler.n_pts_per_ray_training` (the number of sampled points per ray), the node `raysampler_args.n_pts_per_ray_training` should be specified.
+
+### Top-level configuration class: `Experiment`
+
+<b>The root of the hierarchy is defined by `Experiment` Configurable in `<pytorch3d_root>/projects/implicitron_trainer/experiment.py`.</b>
+
+It has top-level fields like `seed`, which seeds the random number generator.
+Additionally, it has non-leaf nodes like `model_factory_ImplicitronModelFactory_args.model_GenericModel_args`, which dispatches the config parameters to `GenericModel`.
+Thus, changing the model parameters may be achieved in two ways: either by editing the config file, e.g.
+```yaml
+model_factory_ImplicitronModelFactory_args:
+    model_GenericModel_args:
+        render_image_width: 800
+        raysampler_args:
+            n_pts_per_ray_training: 128
+```
+
+or, equivalently, by adding the following to `pytorch3d_implicitron_runner` arguments:
+
+```shell
+model_args=model_factory_ImplicitronModelFactory_args.model_GenericModel_args
+$model_args.render_image_width=800 $model_args.raysampler_args.n_pts_per_ray_training=128
+```
+
+See the documentation in `pytorch3d/implicitron/tools/config.py` for more details.
+
+## Replaceable implementations
+
+Sometimes changing the model parameters does not provide enough flexibility, and you want to provide a new implementation for a building block.
+The configuration system also supports it!
+Abstract classes like `BaseRenderer` derive from `ReplaceableBase` instead of `Configurable`.
+This means that other Configurables can refer to them using the base type, while the specific implementation is chosen in the config using `_class_type`-postfixed node.
+In that case, `_args` node name has to include the implementation type.
+More specifically, to change renderer settings, the config will look like this:
+```yaml
+model_factory_ImplicitronModelFactory_args:
+    model_GenericModel_args:
+        renderer_class_type: LSTMRenderer
+        renderer_LSTMRenderer_args:
+            num_raymarch_steps: 10
+            hidden_size: 16
+```
+
+See the documentation in `pytorch3d/implicitron/tools/config.py` for more details on the configuration system.
+
+## Custom plugins
+
+If you have an idea for another implementation of a replaceable component, it can be plugged in without changing the core code.
+For that, you need to set up Implicitron through option 2 or 3 above.
+Let's say you want to implement a renderer that accumulates opacities similar to an X-ray machine.
+First, create a module `x_ray_renderer.py` with a class deriving from `BaseRenderer`:
+
+```python
+from pytorch3d.implicitron.tools.config import registry
+
+@registry.register
+class XRayRenderer(BaseRenderer, torch.nn.Module):
+    n_pts_per_ray: int = 64
+
+    def __post_init__(self):
+        # custom initialization
+
+    def forward(
+        self,
+        ray_bundle,
+        implicit_functions=[],
+        evaluation_mode: EvaluationMode = EvaluationMode.EVALUATION,
+        **kwargs,
+    ) -> RendererOutput:
+        ...
+```
+
+Please note `@registry.register` decorator that registers the plug-in as an implementation of `Renderer`.
+IMPORTANT: In order for it to run, the class (or its enclosing module) has to be imported in your launch script.
+Additionally, this has to be done before parsing the root configuration class `ExperimentConfig`.
+Simply add `import .x_ray_renderer` in the beginning of `experiment.py`.
+
+After that, you should be able to change the config with:
+```yaml
+model_factory_ImplicitronModelFactory_args:
+    model_GenericModel_args:
+        renderer_class_type: XRayRenderer
+        renderer_XRayRenderer_args:
+            n_pts_per_ray: 128
+```
+
+to replace the implementation and potentially override the parameters.
+
+# Code and config structure
+
+The main object for this trainer loop is `Experiment`. It has four top-level replaceable components.
+
+* `data_source`: This is a `DataSourceBase` which defaults to `ImplicitronDataSource`.
+It constructs the data sets and dataloaders.
+* `model_factory`: This is a `ModelFactoryBase` which defaults to `ImplicitronModelFactory`.
+It constructs the model, which is usually an instance of `OverfitModel` (for NeRF-style training with overfitting to one scene) or `GenericModel` (that is able to generalize to multiple scenes by NeRFormer-style conditioning on other scene views), and can load its weights from a checkpoint.
+* `optimizer_factory`: This is an `OptimizerFactoryBase` which defaults to `ImplicitronOptimizerFactory`.
+It constructs the optimizer and can load its weights from a checkpoint.
+* `training_loop`: This is a `TrainingLoopBase` which defaults to `ImplicitronTrainingLoop` and defines the main training loop.
+
+As per above, the config structure is parsed automatically from the module hierarchy.
+In particular, for ImplicitronModelFactory with generic model, model parameters are contained in the `model_factory_ImplicitronModelFactory_args.model_GenericModel_args` node, and dataset parameters in `data_source_ImplicitronDataSource_args` node.
+
+Here is the class structure of GenericModel (single-line edges show aggregation, while double lines show available implementations):
+```
+model_GenericModel_args: GenericModel
+└-- global_encoder_*_args: GlobalEncoderBase
+    ╘== SequenceAutodecoder
+        └-- autodecoder_args: Autodecoder
+    ╘== HarmonicTimeEncoder
+└-- raysampler_*_args: RaySampler
+    ╘== AdaptiveRaysampler
+    ╘== NearFarRaysampler
+└-- renderer_*_args: BaseRenderer
+    ╘== MultiPassEmissionAbsorptionRenderer
+    ╘== LSTMRenderer
+    ╘== SignedDistanceFunctionRenderer
+        └-- ray_tracer_args: RayTracing
+        └-- ray_normal_coloring_network_args: RayNormalColoringNetwork
+└-- implicit_function_*_args: ImplicitFunctionBase
+    ╘== NeuralRadianceFieldImplicitFunction
+    ╘== SRNImplicitFunction
+        └-- raymarch_function_args: SRNRaymarchFunction
+        └-- pixel_generator_args: SRNPixelGenerator
+    ╘== SRNHyperNetImplicitFunction
+        └-- hypernet_args: SRNRaymarchHyperNet
+        └-- pixel_generator_args: SRNPixelGenerator
+    ╘== IdrFeatureField
+└-- image_feature_extractor_*_args: FeatureExtractorBase
+    ╘== ResNetFeatureExtractor
+└-- view_pooler_args: ViewPooler
+    └-- view_sampler_args: ViewSampler
+    └-- feature_aggregator_*_args: FeatureAggregatorBase
+        ╘== IdentityFeatureAggregator
+        ╘== AngleWeightedIdentityFeatureAggregator
+        ╘== AngleWeightedReductionFeatureAggregator
+        ╘== ReductionFeatureAggregator
+```
+
+Here is the class structure of OverfitModel:
+
+```
+model_OverfitModel_args: OverfitModel
+└-- raysampler_*_args: RaySampler
+    ╘== AdaptiveRaysampler
+    ╘== NearFarRaysampler
+└-- renderer_*_args: BaseRenderer
+    ╘== MultiPassEmissionAbsorptionRenderer
+    ╘== LSTMRenderer
+    ╘== SignedDistanceFunctionRenderer
+        └-- ray_tracer_args: RayTracing
+        └-- ray_normal_coloring_network_args: RayNormalColoringNetwork
+└-- implicit_function_*_args: ImplicitFunctionBase
+    ╘== NeuralRadianceFieldImplicitFunction
+    ╘== SRNImplicitFunction
+        └-- raymarch_function_args: SRNRaymarchFunction
+        └-- pixel_generator_args: SRNPixelGenerator
+    ╘== SRNHyperNetImplicitFunction
+        └-- hypernet_args: SRNRaymarchHyperNet
+        └-- pixel_generator_args: SRNPixelGenerator
+    ╘== IdrFeatureField
+└-- coarse_implicit_function_*_args: ImplicitFunctionBase
+    ╘== NeuralRadianceFieldImplicitFunction
+    ╘== SRNImplicitFunction
+        └-- raymarch_function_args: SRNRaymarchFunction
+        └-- pixel_generator_args: SRNPixelGenerator
+    ╘== SRNHyperNetImplicitFunction
+        └-- hypernet_args: SRNRaymarchHyperNet
+        └-- pixel_generator_args: SRNPixelGenerator
+    ╘== IdrFeatureField
+```
+
+OverfitModel has been introduced to create a simple class to disantagle Nerfs which the overfit pattern
+from the GenericModel.
+
+
+Please look at the annotations of the respective classes or functions for the lists of hyperparameters.
+`tests/experiment.yaml` shows every possible option if you have no user-defined classes.
+
+
+# Implementations of existing methods
+
+We provide configuration files that implement several existing works.
+
+<b>The configuration files live in `pytorch3d/projects/implicitron_trainer/configs`.</b>
+
+
+## NeRF
+
+The following config file corresponds to training of a vanilla NeRF on Blender Synthetic dataset
+(see https://arxiv.org/abs/2003.08934 for details of the method):
+
+`./configs/repro_singleseq_nerf_blender.yaml`
+
+
+### Downloading Blender-Synthetic
+Training requires the Blender Synthetic dataset.
+To download the dataset, visit the [gdrive bucket](https://drive.google.com/file/d/18JxhpWD-4ZmuFKLzKlAw-w5PpzZxXOcG/view?usp=share_link)
+and click Download.
+Then unpack the downloaded .zip file to a folder which we call `<BLENDER_DATASET_ROOT_FOLDER>`.
+
+
+### Launching NeRF training
+In order to train NeRF on the "drums" scene, execute the following command:
+```shell
+export BLENDER_DATASET_ROOT="<BLENDER_DATASET_ROOT_FOLDER>" \
+export BLENDER_SINGLESEQ_CLASS="drums" \
+pytorch3d_implicitron_runner --config-path ./configs/ --config-name repro_singleseq_nerf_blender
+```
+
+Note that the training scene is selected by setting the environment variable `BLENDER_SINGLESEQ_CLASS`
+appropriately (one of `"chair"`, `"drums"`, `"ficus"`, `"hotdog"`, `"lego"`, `"materials"`, `"mic"`, `"ship"`).
+
+By default, the training outputs will be stored to `"./data/nerf_blender_repro/$BLENDER_SINGLESEQ_CLASS/"`
+
+
+### Visualizing trained NeRF
+```shell
+pytorch3d_implicitron_visualizer exp_dir=<CHECKPOINT_DIR> \
+    visdom_show_preds=True n_eval_cameras=40 render_size="[64,64]" video_size="[256,256]"
+```
+where `<CHECKPOINT_DIR>` corresponds to the directory with the training outputs (defaults to `"./data/nerf_blender_repro/$BLENDER_SINGLESEQ_CLASS/"`).
+
+The script will output a rendered video of the learned radiance field to `"./data/nerf_blender_repro/$BLENDER_SINGLESEQ_CLASS/"` (requires `ffmpeg`).
+
+> **_NOTE:_** Recall that, if `pytorch3d_implicitron_runner`/`pytorch3d_implicitron_visualizer` are not available, replace the calls
+with `cd <pytorch3d_root>/projects/; python -m implicitron_trainer.[experiment|visualize_reconstruction]`
+
+
+## CO3D experiments
+
+Common Objects in 3D (CO3D) is a large-scale dataset of videos of rigid objects grouped into 50 common categories.
+Implicitron provides implementations and config files to reproduce the results from [the paper](https://arxiv.org/abs/2109.00512).
+Please follow [the link](https://github.com/facebookresearch/co3d#automatic-batch-download) for the instructions to download the dataset.
+In training and evaluation scripts, use the download location as `<DATASET_ROOT>`.
+It is also possible to define environment variable `CO3D_DATASET_ROOT` instead of specifying it.
+To reproduce the experiments from the paper, use the following configs.
+
+For single-sequence experiments:
+
+| Method          |   config file                       |
+|-----------------|-------------------------------------|
+| NeRF            | repro_singleseq_nerf.yaml           |
+| NeRF + WCE      | repro_singleseq_nerf_wce.yaml       |
+| NerFormer       | repro_singleseq_nerformer.yaml      |
+| IDR             | repro_singleseq_idr.yaml            |
+| SRN             | repro_singleseq_srn_noharm.yaml     |
+| SRN + γ         | repro_singleseq_srn.yaml            |
+| SRN + WCE       | repro_singleseq_srn_wce_noharm.yaml |
+| SRN + WCE + γ   | repro_singleseq_srn_wce_noharm.yaml |
+
+For multi-sequence autodecoder experiments (without generalization to new sequences):
+
+| Method          |   config file                              |
+|-----------------|--------------------------------------------|
+| NeRF + AD       | repro_multiseq_nerf_ad.yaml                |
+| SRN + AD        | repro_multiseq_srn_ad_hypernet_noharm.yaml |
+| SRN + γ + AD    | repro_multiseq_srn_ad_hypernet.yaml        |
+
+For multi-sequence experiments (with generalization to new sequences):
+
+| Method          |   config file                        |
+|-----------------|--------------------------------------|
+| NeRF + WCE      | repro_multiseq_nerf_wce.yaml         |
+| NerFormer       | repro_multiseq_nerformer.yaml        |
+| SRN + WCE       | repro_multiseq_srn_wce_noharm.yaml   |
+| SRN + WCE + γ   | repro_multiseq_srn_wce.yaml          |
+
+
+## CO3Dv2 experiments
+
+The following config files implement training on the second version of CO3D, `CO3Dv2`.
+
+In order to launch trainings, set the `CO3DV2_DATASET_ROOT` environment variable
+to the root folder of the dataset (note that the name of the env. variable differs from the CO3Dv1 version).
+
+Single-sequence experiments:
+
+| Method          |   config file                         |
+|-----------------|-------------------------------------|
+| NeRF            | repro_singleseq_v2_nerf.yaml        |
+| NerFormer       | repro_singleseq_v2_nerformer.yaml   |
+| IDR             | repro_singleseq_v2_idr.yaml         |
+| SRN             | repro_singleseq_v2_srn_noharm.yaml  |
+
+Multi-sequence autodecoder experiments (without generalization to new sequences):
+
+| Method          |   config file                                |
+|-----------------|--------------------------------------------|
+| NeRF + AD       | repro_multiseq_v2_nerf_ad.yaml             |
+| SRN + γ + AD    | repro_multiseq_v2_srn_ad_hypernet.yaml     |
+
+Multi-sequence experiments (with generalization to new sequences):
+
+| Method          |   config file                            |
+|-----------------|----------------------------------------|
+| NeRF + WCE      | repro_multiseq_v2_nerf_wce.yaml        |
+| NerFormer       | repro_multiseq_v2_nerformer.yaml       |
+| SRN + WCE       | repro_multiseq_v2_srn_wce_noharm.yaml  |
+| SRN + WCE + γ   | repro_multiseq_v2_srn_wce.yaml         |

project/ManiSkill3/src/maniskill2_benchmark/cfdp_experiment/cfdp/extern/pytorch3d/projects/implicitron_trainer/__init__.py

@@ -0,0 +1,7 @@
+# Copyright (c) Meta Platforms, Inc. and affiliates.
+# All rights reserved.
+#
+# This source code is licensed under the BSD-style license found in the
+# LICENSE file in the root directory of this source tree.
+
+# pyre-unsafe

project/ManiSkill3/src/maniskill2_benchmark/cfdp_experiment/cfdp/extern/pytorch3d/projects/implicitron_trainer/experiment.py

@@ -0,0 +1,303 @@
+#!/usr/bin/env python
+# Copyright (c) Meta Platforms, Inc. and affiliates.
+# All rights reserved.
+#
+# This source code is licensed under the BSD-style license found in the
+# LICENSE file in the root directory of this source tree.
+
+# pyre-unsafe
+
+""""
+This file is the entry point for launching experiments with Implicitron.
+
+Launch Training
+---------------
+Experiment config .yaml files are located in the
+`projects/implicitron_trainer/configs` folder. To launch an experiment,
+specify the name of the file. Specific config values can also be overridden
+from the command line, for example:
+
+```
+./experiment.py --config-name base_config.yaml override.param.one=42 override.param.two=84
+```
+
+Main functions
+---------------
+- The Experiment class defines `run` which creates the model, optimizer, and other
+  objects used in training, then starts TrainingLoop's `run` function.
+- TrainingLoop takes care of the actual training logic: forward and backward passes,
+  evaluation and testing, as well as model checkpointing, visualization, and metric
+  printing.
+
+Outputs
+--------
+The outputs of the experiment are saved and logged in multiple ways:
+  - Checkpoints:
+        Model, optimizer and stats are stored in the directory
+        named by the `exp_dir` key from the config file / CLI parameters.
+  - Stats
+        Stats are logged and plotted to the file "train_stats.pdf" in the
+        same directory. The stats are also saved as part of the checkpoint file.
+  - Visualizations
+        Predictions are plotted to a visdom server running at the
+        port specified by the `visdom_server` and `visdom_port` keys in the
+        config file.
+
+"""
+import logging
+import os
+import warnings
+
+from dataclasses import field
+
+import hydra
+
+import torch
+from accelerate import Accelerator
+from omegaconf import DictConfig, OmegaConf
+from packaging import version
+
+from pytorch3d.implicitron.dataset.data_source import (
+    DataSourceBase,
+    ImplicitronDataSource,
+)
+from pytorch3d.implicitron.models.base_model import ImplicitronModelBase
+
+from pytorch3d.implicitron.models.renderer.multipass_ea import (
+    MultiPassEmissionAbsorptionRenderer,
+)
+from pytorch3d.implicitron.models.renderer.ray_sampler import AdaptiveRaySampler
+from pytorch3d.implicitron.tools.config import (
+    Configurable,
+    expand_args_fields,
+    remove_unused_components,
+    run_auto_creation,
+)
+
+from .impl.model_factory import ModelFactoryBase
+from .impl.optimizer_factory import OptimizerFactoryBase
+from .impl.training_loop import TrainingLoopBase
+from .impl.utils import seed_all_random_engines
+
+logger = logging.getLogger(__name__)
+
+# workaround for https://github.com/facebookresearch/hydra/issues/2262
+_RUN = hydra.types.RunMode.RUN
+
+if version.parse(hydra.__version__) < version.Version("1.1"):
+    raise ValueError(
+        f"Hydra version {hydra.__version__} is too old."
+        " (Implicitron requires version 1.1 or later.)"
+    )
+
+try:
+    # only makes sense in FAIR cluster
+    import pytorch3d.implicitron.fair_cluster.slurm  # noqa: F401
+except ModuleNotFoundError:
+    pass
+
+no_accelerate = os.environ.get("PYTORCH3D_NO_ACCELERATE") is not None
+
+
+class Experiment(Configurable):
+    """
+    This class is at the top level of Implicitron's config hierarchy. Its
+    members are high-level components necessary for training an implicit rende-
+    ring network.
+
+    Members:
+        data_source: An object that produces datasets and dataloaders.
+        model_factory: An object that produces an implicit rendering model as
+            well as its corresponding Stats object.
+        optimizer_factory: An object that produces the optimizer and lr
+            scheduler.
+        training_loop: An object that runs training given the outputs produced
+            by the data_source, model_factory and optimizer_factory.
+        seed: A random seed to ensure reproducibility.
+        detect_anomaly: Whether torch.autograd should detect anomalies. Useful
+            for debugging, but might slow down the training.
+        exp_dir: Root experimentation directory. Checkpoints and training stats
+            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"
+
+    seed: int = 42
+    detect_anomaly: bool = False
+    exp_dir: str = "./data/default_experiment/"
+
+    hydra: dict = field(
+        default_factory=lambda: {
+            "run": {"dir": "."},  # Make hydra not change the working dir.
+            "output_subdir": None,  # disable storing the .hydra logs
+            "mode": _RUN,
+        }
+    )
+
+    def __post_init__(self):
+        seed_all_random_engines(
+            self.seed
+        )  # Set all random engine seeds for reproducibility
+
+        run_auto_creation(self)
+
+    def run(self) -> None:
+        # Initialize the accelerator if desired.
+        if no_accelerate:
+            accelerator = None
+            device = torch.device("cuda:0")
+        else:
+            accelerator = Accelerator(device_placement=False)
+            logger.info(accelerator.state)
+            device = accelerator.device
+
+        logger.info(f"Running experiment on device: {device}")
+        os.makedirs(self.exp_dir, exist_ok=True)
+
+        # set the debug mode
+        if self.detect_anomaly:
+            logger.info("Anomaly detection!")
+        torch.autograd.set_detect_anomaly(self.detect_anomaly)
+
+        # Initialize the datasets and dataloaders.
+        datasets, dataloaders = self.data_source.get_datasets_and_dataloaders()
+
+        # Init the model and the corresponding Stats object.
+        model = self.model_factory(
+            accelerator=accelerator,
+            exp_dir=self.exp_dir,
+        )
+
+        stats = self.training_loop.load_stats(
+            log_vars=model.log_vars,
+            exp_dir=self.exp_dir,
+            resume=self.model_factory.resume,
+            resume_epoch=self.model_factory.resume_epoch,  # pyre-ignore [16]
+        )
+        start_epoch = stats.epoch + 1
+
+        model.to(device)
+
+        # Init the optimizer and LR scheduler.
+        optimizer, scheduler = self.optimizer_factory(
+            accelerator=accelerator,
+            exp_dir=self.exp_dir,
+            last_epoch=start_epoch,
+            model=model,
+            resume=self.model_factory.resume,
+            resume_epoch=self.model_factory.resume_epoch,
+        )
+
+        # Wrap all modules in the distributed library
+        # Note: we don't pass the scheduler to prepare as it
+        # doesn't need to be stepped at each optimizer step
+        train_loader = dataloaders.train
+        val_loader = dataloaders.val
+        test_loader = dataloaders.test
+        if accelerator is not None:
+            (
+                model,
+                optimizer,
+                train_loader,
+                val_loader,
+            ) = accelerator.prepare(model, optimizer, train_loader, val_loader)
+
+        # Enter the main training loop.
+        self.training_loop.run(
+            train_loader=train_loader,
+            val_loader=val_loader,
+            test_loader=test_loader,
+            # pyre-ignore[6]
+            train_dataset=datasets.train,
+            model=model,
+            optimizer=optimizer,
+            scheduler=scheduler,
+            accelerator=accelerator,
+            device=device,
+            exp_dir=self.exp_dir,
+            stats=stats,
+            seed=self.seed,
+        )
+
+
+def _setup_envvars_for_cluster() -> bool:
+    """
+    Prepares to run on cluster if relevant.
+    Returns whether FAIR cluster in use.
+    """
+    # TODO: How much of this is needed in general?
+
+    try:
+        import submitit
+    except ImportError:
+        return False
+
+    try:
+        # Only needed when launching on cluster with slurm and submitit
+        job_env = submitit.JobEnvironment()
+    except RuntimeError:
+        return False
+
+    os.environ["LOCAL_RANK"] = str(job_env.local_rank)
+    os.environ["RANK"] = str(job_env.global_rank)
+    os.environ["WORLD_SIZE"] = str(job_env.num_tasks)
+    os.environ["MASTER_ADDR"] = "localhost"
+    os.environ["MASTER_PORT"] = "42918"
+    logger.info(
+        "Num tasks %s, global_rank %s"
+        % (str(job_env.num_tasks), str(job_env.global_rank))
+    )
+
+    return True
+
+
+def dump_cfg(cfg: DictConfig) -> None:
+    remove_unused_components(cfg)
+    # dump the exp config to the exp dir
+    os.makedirs(cfg.exp_dir, exist_ok=True)
+    try:
+        cfg_filename = os.path.join(cfg.exp_dir, "expconfig.yaml")
+        OmegaConf.save(config=cfg, f=cfg_filename)
+    except PermissionError:
+        warnings.warn("Can't dump config due to insufficient permissions!")
+
+
+expand_args_fields(Experiment)
+cs = hydra.core.config_store.ConfigStore.instance()
+cs.store(name="default_config", node=Experiment)
+
+
+@hydra.main(config_path="./configs/", config_name="default_config")
+def experiment(cfg: DictConfig) -> None:
+    # CUDA_VISIBLE_DEVICES must have been set.
+
+    if "CUDA_DEVICE_ORDER" not in os.environ:
+        os.environ["CUDA_DEVICE_ORDER"] = "PCI_BUS_ID"
+
+    if not _setup_envvars_for_cluster():
+        logger.info("Running locally")
+
+    # TODO: The following may be needed for hydra/submitit it to work
+    expand_args_fields(ImplicitronModelBase)
+    expand_args_fields(AdaptiveRaySampler)
+    expand_args_fields(MultiPassEmissionAbsorptionRenderer)
+    expand_args_fields(ImplicitronDataSource)
+
+    experiment = Experiment(**cfg)
+    dump_cfg(cfg)
+    experiment.run()
+
+
+if __name__ == "__main__":
+    experiment()

project/ManiSkill3/src/maniskill2_benchmark/cfdp_experiment/cfdp/extern/pytorch3d/projects/implicitron_trainer/impl/__init__.py

@@ -0,0 +1,7 @@
+# Copyright (c) Meta Platforms, Inc. and affiliates.
+# All rights reserved.
+#
+# This source code is licensed under the BSD-style license found in the
+# LICENSE file in the root directory of this source tree.
+
+# pyre-unsafe

project/ManiSkill3/src/maniskill2_benchmark/cfdp_experiment/cfdp/extern/pytorch3d/projects/implicitron_trainer/impl/model_factory.py

@@ -0,0 +1,136 @@
+# Copyright (c) Meta Platforms, Inc. and affiliates.
+# All rights reserved.
+#
+# This source code is licensed under the BSD-style license found in the
+# LICENSE file in the root directory of this source tree.
+
+# pyre-unsafe
+
+import logging
+import os
+from typing import Optional
+
+import torch.optim
+
+from accelerate import Accelerator
+from pytorch3d.implicitron.models.base_model import ImplicitronModelBase
+from pytorch3d.implicitron.tools import model_io
+from pytorch3d.implicitron.tools.config import (
+    registry,
+    ReplaceableBase,
+    run_auto_creation,
+)
+from pytorch3d.implicitron.tools.stats import Stats
+
+logger = logging.getLogger(__name__)
+
+
+class ModelFactoryBase(ReplaceableBase):
+
+    resume: bool = True  # resume from the last checkpoint
+
+    def __call__(self, **kwargs) -> ImplicitronModelBase:
+        """
+        Initialize the model (possibly from a previously saved state).
+
+        Returns: An instance of ImplicitronModelBase.
+        """
+        raise NotImplementedError()
+
+    def load_stats(self, **kwargs) -> Stats:
+        """
+        Initialize or load a Stats object.
+        """
+        raise NotImplementedError()
+
+
+@registry.register
+class ImplicitronModelFactory(ModelFactoryBase):
+    """
+    A factory class that initializes an implicit rendering model.
+
+    Members:
+        model: An ImplicitronModelBase object.
+        resume: If True, attempt to load the last checkpoint from `exp_dir`
+            passed to __call__. Failure to do so will return a model with ini-
+            tial weights unless `force_resume` is True.
+        resume_epoch: If `resume` is True: Resume a model at this epoch, or if
+            `resume_epoch` <= 0, then resume from the latest checkpoint.
+        force_resume: If True, throw a FileNotFoundError if `resume` is True but
+            a model checkpoint cannot be found.
+
+    """
+
+    # pyre-fixme[13]: Attribute `model` is never initialized.
+    model: ImplicitronModelBase
+    model_class_type: str = "GenericModel"
+    resume: bool = True
+    resume_epoch: int = -1
+    force_resume: bool = False
+
+    def __post_init__(self):
+        run_auto_creation(self)
+
+    def __call__(
+        self,
+        exp_dir: str,
+        accelerator: Optional[Accelerator] = None,
+    ) -> ImplicitronModelBase:
+        """
+        Returns an instance of `ImplicitronModelBase`, possibly loaded from a
+        checkpoint (if self.resume, self.resume_epoch specify so).
+
+        Args:
+            exp_dir: Root experiment directory.
+            accelerator: An Accelerator object.
+
+        Returns:
+            model: The model with optionally loaded weights from checkpoint
+
+        Raise:
+            FileNotFoundError if `force_resume` is True but checkpoint not found.
+        """
+        # Determine the network outputs that should be logged
+        if hasattr(self.model, "log_vars"):
+            log_vars = list(self.model.log_vars)
+        else:
+            log_vars = ["objective"]
+
+        if self.resume_epoch > 0:
+            # Resume from a certain epoch
+            model_path = model_io.get_checkpoint(exp_dir, self.resume_epoch)
+            if not os.path.isfile(model_path):
+                raise ValueError(f"Cannot find model from epoch {self.resume_epoch}.")
+        else:
+            # Retrieve the last checkpoint
+            model_path = model_io.find_last_checkpoint(exp_dir)
+
+        if model_path is not None:
+            logger.info(f"Found previous model {model_path}")
+            if self.force_resume or self.resume:
+                logger.info("Resuming.")
+
+                map_location = None
+                if accelerator is not None and not accelerator.is_local_main_process:
+                    map_location = {
+                        "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
+                )
+
+                try:
+                    self.model.load_state_dict(model_state_dict, strict=True)
+                except RuntimeError as e:
+                    logger.error(e)
+                    logger.info(
+                        "Cannot load state dict in strict mode! -> trying non-strict"
+                    )
+                    self.model.load_state_dict(model_state_dict, strict=False)
+                self.model.log_vars = log_vars
+            else:
+                logger.info("Not resuming -> starting from scratch.")
+        elif self.force_resume:
+            raise FileNotFoundError(f"Cannot find a checkpoint in {exp_dir}!")
+
+        return self.model

project/ManiSkill3/src/maniskill2_benchmark/cfdp_experiment/cfdp/extern/pytorch3d/projects/implicitron_trainer/impl/optimizer_factory.py

@@ -0,0 +1,339 @@
+# Copyright (c) Meta Platforms, Inc. and affiliates.
+# All rights reserved.
+#
+# This source code is licensed under the BSD-style license found in the
+# LICENSE file in the root directory of this source tree.
+
+# pyre-unsafe
+
+import inspect
+import logging
+import os
+from collections import defaultdict
+from dataclasses import field
+from typing import Any, Dict, List, Optional, Tuple
+
+import torch.optim
+
+from accelerate import Accelerator
+
+from pytorch3d.implicitron.models.base_model import ImplicitronModelBase
+from pytorch3d.implicitron.tools import model_io
+from pytorch3d.implicitron.tools.config import (
+    registry,
+    ReplaceableBase,
+    run_auto_creation,
+)
+
+logger = logging.getLogger(__name__)
+
+
+class OptimizerFactoryBase(ReplaceableBase):
+    def __call__(
+        self, model: ImplicitronModelBase, **kwargs
+    ) -> Tuple[torch.optim.Optimizer, Any]:
+        """
+        Initialize the optimizer and lr scheduler.
+
+        Args:
+            model: The model with optionally loaded weights.
+
+        Returns:
+            An optimizer module (optionally loaded from a checkpoint) and
+            a learning rate scheduler module (should be a subclass of torch.optim's
+            lr_scheduler._LRScheduler).
+        """
+        raise NotImplementedError()
+
+
+@registry.register
+class ImplicitronOptimizerFactory(OptimizerFactoryBase):
+    """
+    A factory that initializes the optimizer and lr scheduler.
+
+    Members:
+        betas: Beta parameters for the Adam optimizer.
+        breed: The type of optimizer to use. We currently support SGD, Adagrad
+            and Adam.
+        exponential_lr_step_size: With Exponential policy only,
+            lr = lr * gamma ** (epoch/step_size)
+        gamma: Multiplicative factor of learning rate decay.
+        lr: The value for the initial learning rate.
+        lr_policy: The policy to use for learning rate. We currently support
+            MultiStepLR and Exponential policies.
+        momentum: A momentum value (for SGD only).
+        multistep_lr_milestones: With MultiStepLR policy only: list of
+            increasing epoch indices at which the learning rate is modified.
+        momentum: Momentum factor for SGD optimizer.
+        weight_decay: The optimizer weight_decay (L2 penalty on model weights).
+        foreach: Whether to use new "foreach" implementation of optimizer where
+            available (e.g. requires PyTorch 1.12.0 for Adam)
+        group_learning_rates: Parameters or modules can be assigned to parameter
+            groups. This dictionary has names of those parameter groups as keys
+            and learning rates as values. All parameter group names have to be
+            defined in this dictionary. Parameters which do not have predefined
+            parameter group are put into "default" parameter group which has
+            `lr` as its learning rate.
+    """
+
+    betas: Tuple[float, ...] = (0.9, 0.999)
+    breed: str = "Adam"
+    exponential_lr_step_size: int = 250
+    gamma: float = 0.1
+    lr: float = 0.0005
+    lr_policy: str = "MultiStepLR"
+    momentum: float = 0.9
+    multistep_lr_milestones: tuple = ()
+    weight_decay: float = 0.0
+    linear_exponential_lr_milestone: int = 200
+    linear_exponential_start_gamma: float = 0.1
+    foreach: Optional[bool] = True
+    group_learning_rates: Dict[str, float] = field(default_factory=lambda: {})
+
+    def __post_init__(self):
+        run_auto_creation(self)
+
+    def __call__(
+        self,
+        last_epoch: int,
+        model: ImplicitronModelBase,
+        accelerator: Optional[Accelerator] = None,
+        exp_dir: Optional[str] = None,
+        resume: bool = True,
+        resume_epoch: int = -1,
+        **kwargs,
+    ) -> Tuple[torch.optim.Optimizer, Any]:
+        """
+        Initialize the optimizer (optionally from a checkpoint) and the lr scheduluer.
+
+        Args:
+            last_epoch: If the model was loaded from checkpoint this will be the
+                number of the last epoch that was saved.
+            model: The model with optionally loaded weights.
+            accelerator: An optional Accelerator instance.
+            exp_dir: Root experiment directory.
+            resume: If True, attempt to load optimizer checkpoint from exp_dir.
+                Failure to do so will return a newly initialized optimizer.
+            resume_epoch: If `resume` is True: Resume optimizer at this epoch. If
+                `resume_epoch` <= 0, then resume from the latest checkpoint.
+        Returns:
+            An optimizer module (optionally loaded from a checkpoint) and
+            a learning rate scheduler module (should be a subclass of torch.optim's
+            lr_scheduler._LRScheduler).
+        """
+        # Get the parameters to optimize
+        if hasattr(model, "_get_param_groups"):  # use the model function
+            p_groups = model._get_param_groups(self.lr, wd=self.weight_decay)
+        else:
+            p_groups = [
+                {"params": params, "lr": self._get_group_learning_rate(group)}
+                for group, params in self._get_param_groups(model).items()
+            ]
+
+        # Intialize the optimizer
+        optimizer_kwargs: Dict[str, Any] = {
+            "lr": self.lr,
+            "weight_decay": self.weight_decay,
+        }
+        if self.breed == "SGD":
+            optimizer_class = torch.optim.SGD
+            optimizer_kwargs["momentum"] = self.momentum
+        elif self.breed == "Adagrad":
+            optimizer_class = torch.optim.Adagrad
+        elif self.breed == "Adam":
+            optimizer_class = torch.optim.Adam
+            optimizer_kwargs["betas"] = self.betas
+        else:
+            raise ValueError(f"No such solver type {self.breed}")
+
+        if "foreach" in inspect.signature(optimizer_class.__init__).parameters:
+            optimizer_kwargs["foreach"] = self.foreach
+        optimizer = optimizer_class(p_groups, **optimizer_kwargs)
+        logger.info(f"Solver type = {self.breed}")
+
+        # Load state from checkpoint
+        optimizer_state = self._get_optimizer_state(
+            exp_dir,
+            accelerator,
+            resume_epoch=resume_epoch,
+            resume=resume,
+        )
+        if optimizer_state is not None:
+            logger.info("Setting loaded optimizer state.")
+            optimizer.load_state_dict(optimizer_state)
+
+        # Initialize the learning rate scheduler
+        if self.lr_policy.casefold() == "MultiStepLR".casefold():
+            scheduler = torch.optim.lr_scheduler.MultiStepLR(
+                optimizer,
+                milestones=self.multistep_lr_milestones,
+                gamma=self.gamma,
+            )
+        elif self.lr_policy.casefold() == "Exponential".casefold():
+            scheduler = torch.optim.lr_scheduler.LambdaLR(
+                optimizer,
+                lambda epoch: self.gamma ** (epoch / self.exponential_lr_step_size),
+                verbose=False,
+            )
+        elif self.lr_policy.casefold() == "LinearExponential".casefold():
+            # linear learning rate progression between epochs 0 to
+            # self.linear_exponential_lr_milestone, followed by exponential
+            # lr decay for the rest of the epochs
+            def _get_lr(epoch: int):
+                m = self.linear_exponential_lr_milestone
+                if epoch < m:
+                    w = (m - epoch) / m
+                    gamma = w * self.linear_exponential_start_gamma + (1 - w)
+                else:
+                    epoch_rest = epoch - m
+                    gamma = self.gamma ** (epoch_rest / self.exponential_lr_step_size)
+                return gamma
+
+            scheduler = torch.optim.lr_scheduler.LambdaLR(
+                optimizer, _get_lr, verbose=False
+            )
+        else:
+            raise ValueError("no such lr policy %s" % self.lr_policy)
+
+        # When loading from checkpoint, this will make sure that the
+        # lr is correctly set even after returning.
+        for _ in range(last_epoch):
+            scheduler.step()
+
+        optimizer.zero_grad()
+
+        return optimizer, scheduler
+
+    def _get_optimizer_state(
+        self,
+        exp_dir: Optional[str],
+        accelerator: Optional[Accelerator] = None,
+        resume: bool = True,
+        resume_epoch: int = -1,
+    ) -> Optional[Dict[str, Any]]:
+        """
+        Load an optimizer state from a checkpoint.
+
+        resume: If True, attempt to load the last checkpoint from `exp_dir`
+            passed to __call__. Failure to do so will return a newly initialized
+            optimizer.
+        resume_epoch: If `resume` is True: Resume optimizer at this epoch. If
+            `resume_epoch` <= 0, then resume from the latest checkpoint.
+        """
+        if exp_dir is None or not resume:
+            return None
+        if resume_epoch > 0:
+            save_path = model_io.get_checkpoint(exp_dir, resume_epoch)
+            if not os.path.isfile(save_path):
+                raise FileNotFoundError(
+                    f"Cannot find optimizer from epoch {resume_epoch}."
+                )
+        else:
+            save_path = model_io.find_last_checkpoint(exp_dir)
+        optimizer_state = None
+        if save_path is not None:
+            logger.info(f"Found previous optimizer state {save_path} -> resuming.")
+            opt_path = model_io.get_optimizer_path(save_path)
+
+            if os.path.isfile(opt_path):
+                map_location = None
+                if accelerator is not None and not accelerator.is_local_main_process:
+                    map_location = {
+                        "cuda:%d" % 0: "cuda:%d" % accelerator.local_process_index
+                    }
+                optimizer_state = torch.load(opt_path, map_location)
+            else:
+                raise FileNotFoundError(f"Optimizer state {opt_path} does not exist.")
+        return optimizer_state
+
+    def _get_param_groups(
+        self, module: torch.nn.Module
+    ) -> Dict[str, List[torch.nn.Parameter]]:
+        """
+        Recursively visits all the modules inside the `module` and sorts all the
+        parameters in parameter groups.
+
+        Uses `param_groups` dictionary member, where keys are names of individual
+        parameters or module members and values are the names of the parameter groups
+        for those parameters or members. "self" key is used to denote the parameter groups
+        at the module level. Possible keys, including the "self" key do not have to
+        be defined. By default all parameters have the learning rate defined in the
+        optimizer. This can be overridden by setting the parameter group in `param_groups`
+        member of a specific module. Values are a parameter group name. The keys
+        specify what parameters will be affected as follows:
+            - “self”: All the parameters of the module and its child modules
+            - name of a parameter: A parameter with that name.
+            - name of a module member: All the parameters of the module and its
+                child modules.
+                This is useful if members do not have `param_groups`, for
+                example torch.nn.Linear.
+            - <name of module member>.<something>: recursive. Same as if <something>
+                was used in param_groups of that submodule/member.
+
+        Args:
+            module: module from which to extract the parameters and their parameter
+                groups
+        Returns:
+            dictionary with parameter groups as keys and lists of parameters as values
+        """
+
+        param_groups = defaultdict(list)
+
+        def traverse(module, default_group: str, mapping: Dict[str, str]) -> None:
+            """
+            Visitor for module to assign its parameters to the relevant member of
+            param_groups.
+
+            Args:
+                module: the module being visited in a depth-first search
+                default_group: the param group to assign parameters to unless
+                                otherwise overriden.
+                mapping: known mappings of parameters to groups for this module,
+                    destructively modified by this function.
+            """
+            # If key self is defined in param_groups then chenge the default param
+            # group for all parameters and children in the module.
+            if hasattr(module, "param_groups") and "self" in module.param_groups:
+                default_group = module.param_groups["self"]
+
+            # Collect all the parameters that are directly inside the `module`,
+            # they will be in the default param group if they don't have
+            # defined group.
+            if hasattr(module, "param_groups"):
+                mapping.update(module.param_groups)
+
+            for name, param in module.named_parameters(recurse=False):
+                if param.requires_grad:
+                    group_name = mapping.get(name, default_group)
+                    logger.debug(f"Assigning {name} to param_group {group_name}")
+                    param_groups[group_name].append(param)
+
+            # If children have defined default param group then use it else pass
+            # own default.
+            for child_name, child in module.named_children():
+                mapping_to_add = {
+                    name[len(child_name) + 1 :]: group
+                    for name, group in mapping.items()
+                    if name.startswith(child_name + ".")
+                }
+                traverse(child, mapping.get(child_name, default_group), mapping_to_add)
+
+        traverse(module, "default", {})
+        return param_groups
+
+    def _get_group_learning_rate(self, group_name: str) -> float:
+        """
+        Wraps the `group_learning_rates` dictionary providing errors and returns
+        `self.lr` for "default" group_name.
+
+        Args:
+            group_name: a string representing the name of the group
+        Returns:
+            learning rate for a specific group
+        """
+        if group_name == "default":
+            return self.lr
+        lr = self.group_learning_rates.get(group_name, None)
+        if lr is None:
+            raise ValueError(f"no learning rate given for group {group_name}")
+        return lr

project/ManiSkill3/src/maniskill2_benchmark/cfdp_experiment/cfdp/extern/pytorch3d/projects/implicitron_trainer/impl/training_loop.py

@@ -0,0 +1,454 @@
+# Copyright (c) Meta Platforms, Inc. and affiliates.
+# All rights reserved.
+#
+# This source code is licensed under the BSD-style license found in the
+# LICENSE file in the root directory of this source tree.
+
+# pyre-unsafe
+
+import logging
+import os
+import time
+from typing import Any, List, Optional
+
+import torch
+from accelerate import Accelerator
+from pytorch3d.implicitron.evaluation.evaluator import EvaluatorBase
+from pytorch3d.implicitron.models.base_model import ImplicitronModelBase
+from pytorch3d.implicitron.models.generic_model import EvaluationMode
+from pytorch3d.implicitron.tools import model_io, vis_utils
+from pytorch3d.implicitron.tools.config import (
+    registry,
+    ReplaceableBase,
+    run_auto_creation,
+)
+from pytorch3d.implicitron.tools.stats import Stats
+from torch.utils.data import DataLoader, Dataset
+
+from .utils import seed_all_random_engines
+
+logger = logging.getLogger(__name__)
+
+
+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"
+
+    def run(
+        self,
+        train_loader: DataLoader,
+        val_loader: Optional[DataLoader],
+        test_loader: Optional[DataLoader],
+        train_dataset: Dataset,
+        model: ImplicitronModelBase,
+        optimizer: torch.optim.Optimizer,
+        scheduler: Any,
+        **kwargs,
+    ) -> None:
+        raise NotImplementedError()
+
+    def load_stats(
+        self,
+        log_vars: List[str],
+        exp_dir: str,
+        resume: bool = True,
+        resume_epoch: int = -1,
+        **kwargs,
+    ) -> Stats:
+        raise NotImplementedError()
+
+
+@registry.register
+class ImplicitronTrainingLoop(TrainingLoopBase):
+    """
+    Members:
+        eval_only: If True, only run evaluation using the test dataloader.
+        max_epochs: Train for this many epochs. Note that if the model was
+            loaded from a checkpoint, we will restart training at the appropriate
+            epoch and run for (max_epochs - checkpoint_epoch) epochs.
+        store_checkpoints: If True, store model and optimizer state checkpoints.
+        store_checkpoints_purge: If >= 0, remove any checkpoints older or equal
+            to this many epochs.
+        test_interval: Evaluate on a test dataloader each `test_interval` epochs.
+        test_when_finished: If True, evaluate on a test dataloader when training
+            completes.
+        validation_interval: Validate each `validation_interval` epochs.
+        clip_grad: Optionally clip the gradient norms.
+            If set to a value <=0.0, no clipping
+        metric_print_interval: The batch interval at which the stats should be
+            logged.
+        visualize_interval: The batch interval at which the visualizations
+            should be plotted
+        visdom_env: The name of the Visdom environment to use for plotting.
+        visdom_port: The Visdom port.
+        visdom_server: Address of the Visdom server.
+    """
+
+    # Parameters of the outer training loop.
+    eval_only: bool = False
+    max_epochs: int = 1000
+    store_checkpoints: bool = True
+    store_checkpoints_purge: int = 1
+    test_interval: int = -1
+    test_when_finished: bool = False
+    validation_interval: int = 1
+
+    # Gradient clipping.
+    clip_grad: float = 0.0
+
+    # Visualization/logging parameters.
+    metric_print_interval: int = 5
+    visualize_interval: int = 1000
+    visdom_env: str = ""
+    visdom_port: int = int(os.environ.get("VISDOM_PORT", 8097))
+    visdom_server: str = "http://127.0.0.1"
+
+    def __post_init__(self):
+        run_auto_creation(self)
+
+    # pyre-fixme[14]: `run` overrides method defined in `TrainingLoopBase`
+    #  inconsistently.
+    def run(
+        self,
+        *,
+        train_loader: DataLoader,
+        val_loader: Optional[DataLoader],
+        test_loader: Optional[DataLoader],
+        train_dataset: Dataset,
+        model: ImplicitronModelBase,
+        optimizer: torch.optim.Optimizer,
+        scheduler: Any,
+        accelerator: Optional[Accelerator],
+        device: torch.device,
+        exp_dir: str,
+        stats: Stats,
+        seed: int,
+        **kwargs,
+    ):
+        """
+        Entry point to run the training and validation loops
+        based on the specified config file.
+        """
+        start_epoch = stats.epoch + 1
+        assert scheduler.last_epoch == stats.epoch + 1
+        assert scheduler.last_epoch == start_epoch
+
+        # only run evaluation on the test dataloader
+        if self.eval_only:
+            if test_loader is not None:
+                # pyre-fixme[16]: `Optional` has no attribute `run`.
+                self.evaluator.run(
+                    dataloader=test_loader,
+                    device=device,
+                    dump_to_json=True,
+                    epoch=stats.epoch,
+                    exp_dir=exp_dir,
+                    model=model,
+                )
+                return
+            else:
+                raise ValueError(
+                    "Cannot evaluate and dump results to json, no test data provided."
+                )
+
+        # loop through epochs
+        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)
+
+                cur_lr = float(scheduler.get_last_lr()[-1])
+                logger.debug(f"scheduler lr = {cur_lr:1.2e}")
+
+                # train loop
+                self._training_or_validation_epoch(
+                    accelerator=accelerator,
+                    device=device,
+                    epoch=epoch,
+                    loader=train_loader,
+                    model=model,
+                    optimizer=optimizer,
+                    stats=stats,
+                    validation=False,
+                )
+
+                # val loop (optional)
+                if val_loader is not None and epoch % self.validation_interval == 0:
+                    self._training_or_validation_epoch(
+                        accelerator=accelerator,
+                        device=device,
+                        epoch=epoch,
+                        loader=val_loader,
+                        model=model,
+                        optimizer=optimizer,
+                        stats=stats,
+                        validation=True,
+                    )
+
+                # eval loop (optional)
+                if (
+                    test_loader is not None
+                    and self.test_interval > 0
+                    and epoch % self.test_interval == 0
+                ):
+                    self.evaluator.run(
+                        device=device,
+                        dataloader=test_loader,
+                        model=model,
+                    )
+
+                assert stats.epoch == epoch, "inconsistent stats!"
+                self._checkpoint(accelerator, epoch, exp_dir, model, optimizer, stats)
+
+                scheduler.step()
+                new_lr = float(scheduler.get_last_lr()[-1])
+                if new_lr != cur_lr:
+                    logger.info(f"LR change! {cur_lr} -> {new_lr}")
+
+        if self.test_when_finished:
+            if test_loader is not None:
+                self.evaluator.run(
+                    device=device,
+                    dump_to_json=True,
+                    epoch=stats.epoch,
+                    exp_dir=exp_dir,
+                    dataloader=test_loader,
+                    model=model,
+                )
+            else:
+                raise ValueError(
+                    "Cannot evaluate and dump results to json, no test data provided."
+                )
+
+    def load_stats(
+        self,
+        log_vars: List[str],
+        exp_dir: str,
+        resume: bool = True,
+        resume_epoch: int = -1,
+        **kwargs,
+    ) -> Stats:
+        """
+        Load Stats that correspond to the model's log_vars and resume_epoch.
+
+        Args:
+            log_vars: A list of variable names to log. Should be a subset of the
+                `preds` returned by the forward function of the corresponding
+                ImplicitronModelBase instance.
+            exp_dir: Root experiment directory.
+            resume: If False, do not load stats from the checkpoint speci-
+                fied by resume and resume_epoch; instead, create a fresh stats object.
+
+        stats: The stats structure (optionally loaded from checkpoint)
+        """
+        # Init the stats struct
+        visdom_env_charts = (
+            vis_utils.get_visdom_env(self.visdom_env, exp_dir) + "_charts"
+        )
+        stats = Stats(
+            # log_vars should be a list, but OmegaConf might load them as ListConfig
+            list(log_vars),
+            plot_file=os.path.join(exp_dir, "train_stats.pdf"),
+            visdom_env=visdom_env_charts,
+            visdom_server=self.visdom_server,
+            visdom_port=self.visdom_port,
+        )
+
+        model_path = None
+        if resume:
+            if resume_epoch > 0:
+                model_path = model_io.get_checkpoint(exp_dir, resume_epoch)
+                if not os.path.isfile(model_path):
+                    raise FileNotFoundError(
+                        f"Cannot find stats from epoch {resume_epoch}."
+                    )
+            else:
+                model_path = model_io.find_last_checkpoint(exp_dir)
+
+        if model_path is not None:
+            stats_path = model_io.get_stats_path(model_path)
+            stats_load = model_io.load_stats(stats_path)
+
+            # Determine if stats should be reset
+            if resume:
+                if stats_load is None:
+                    logger.warning("\n\n\n\nCORRUPT STATS -> clearing stats\n\n\n\n")
+                    last_epoch = model_io.parse_epoch_from_model_path(model_path)
+                    logger.info(f"Estimated resume epoch = {last_epoch}")
+
+                    # Reset the stats struct
+                    for _ in range(last_epoch + 1):
+                        stats.new_epoch()
+                    assert last_epoch == stats.epoch
+                else:
+                    logger.info(f"Found previous stats in {stats_path} -> resuming.")
+                    stats = stats_load
+
+                # Update stats properties incase it was reset on load
+                stats.visdom_env = visdom_env_charts
+                stats.visdom_server = self.visdom_server
+                stats.visdom_port = self.visdom_port
+                stats.plot_file = os.path.join(exp_dir, "train_stats.pdf")
+                stats.synchronize_logged_vars(log_vars)
+            else:
+                logger.info("Clearing stats")
+
+        return stats
+
+    def _training_or_validation_epoch(
+        self,
+        epoch: int,
+        loader: DataLoader,
+        model: ImplicitronModelBase,
+        optimizer: torch.optim.Optimizer,
+        stats: Stats,
+        validation: bool,
+        *,
+        accelerator: Optional[Accelerator],
+        bp_var: str = "objective",
+        device: torch.device,
+        **kwargs,
+    ) -> None:
+        """
+        This is the main loop for training and evaluation including:
+        model forward pass, loss computation, backward pass and visualization.
+
+        Args:
+            epoch: The index of the current epoch
+            loader: The dataloader to use for the loop
+            model: The model module optionally loaded from checkpoint
+            optimizer: The optimizer module optionally loaded from checkpoint
+            stats: The stats struct, also optionally loaded from checkpoint
+            validation: If true, run the loop with the model in eval mode
+                and skip the backward pass
+            accelerator: An optional Accelerator instance.
+            bp_var: The name of the key in the model output `preds` dict which
+                should be used as the loss for the backward pass.
+            device: The device on which to run the model.
+        """
+
+        if validation:
+            model.eval()
+            trainmode = "val"
+        else:
+            model.train()
+            trainmode = "train"
+
+        t_start = time.time()
+
+        # get the visdom env name
+        visdom_env_imgs = stats.visdom_env + "_images_" + trainmode
+        viz = vis_utils.get_visdom_connection(
+            server=stats.visdom_server,
+            port=stats.visdom_port,
+        )
+
+        # Iterate through the batches
+        n_batches = len(loader)
+        for it, net_input in enumerate(loader):
+            last_iter = it == n_batches - 1
+
+            # move to gpu where possible (in place)
+            net_input = net_input.to(device)
+
+            # run the forward pass
+            if not validation:
+                optimizer.zero_grad()
+                preds = model(
+                    **{**net_input, "evaluation_mode": EvaluationMode.TRAINING}
+                )
+            else:
+                with torch.no_grad():
+                    preds = model(
+                        **{**net_input, "evaluation_mode": EvaluationMode.EVALUATION}
+                    )
+
+            # make sure we dont overwrite something
+            assert all(k not in preds for k in net_input.keys())
+            # merge everything into one big dict
+            preds.update(net_input)
+
+            # update the stats logger
+            stats.update(preds, time_start=t_start, stat_set=trainmode)
+            # pyre-ignore [16]
+            assert stats.it[trainmode] == it, "inconsistent stat iteration number!"
+
+            # print textual status update
+            if it % self.metric_print_interval == 0 or last_iter:
+                std_out = stats.get_status_string(stat_set=trainmode, max_it=n_batches)
+                logger.info(std_out)
+
+            # visualize results
+            if (
+                (accelerator is None or accelerator.is_local_main_process)
+                and self.visualize_interval > 0
+                and it % self.visualize_interval == 0
+            ):
+                prefix = f"e{stats.epoch}_it{stats.it[trainmode]}"
+                if hasattr(model, "visualize"):
+                    model.visualize(
+                        viz,
+                        visdom_env_imgs,
+                        preds,
+                        prefix,
+                    )
+
+            # optimizer step
+            if not validation:
+                loss = preds[bp_var]
+                assert torch.isfinite(loss).all(), "Non-finite loss!"
+                # backprop
+                if accelerator is None:
+                    loss.backward()
+                else:
+                    accelerator.backward(loss)
+                if self.clip_grad > 0.0:
+                    # Optionally clip the gradient norms.
+                    total_norm = torch.nn.utils.clip_grad_norm(
+                        model.parameters(), self.clip_grad
+                    )
+                    if total_norm > self.clip_grad:
+                        logger.debug(
+                            f"Clipping gradient: {total_norm}"
+                            + f" with coef {self.clip_grad / float(total_norm)}."
+                        )
+
+                optimizer.step()
+
+    def _checkpoint(
+        self,
+        accelerator: Optional[Accelerator],
+        epoch: int,
+        exp_dir: str,
+        model: ImplicitronModelBase,
+        optimizer: torch.optim.Optimizer,
+        stats: Stats,
+    ):
+        """
+        Save a model and its corresponding Stats object to a file, if
+        `self.store_checkpoints` is True. In addition, if
+        `self.store_checkpoints_purge` is True, remove any checkpoints older
+        than `self.store_checkpoints_purge` epochs old.
+        """
+        if self.store_checkpoints and (
+            accelerator is None or accelerator.is_local_main_process
+        ):
+            if self.store_checkpoints_purge > 0:
+                for prev_epoch in range(epoch - self.store_checkpoints_purge):
+                    model_io.purge_epoch(exp_dir, prev_epoch)
+            outfile = model_io.get_checkpoint(exp_dir, epoch)
+            unwrapped_model = (
+                model if accelerator is None else accelerator.unwrap_model(model)
+            )
+            model_io.safe_save_model(
+                unwrapped_model, stats, outfile, optimizer=optimizer
+            )

project/ManiSkill3/src/maniskill2_benchmark/cfdp_experiment/cfdp/extern/pytorch3d/projects/implicitron_trainer/impl/utils.py

@@ -0,0 +1,19 @@
+# Copyright (c) Meta Platforms, Inc. and affiliates.
+# All rights reserved.
+#
+# This source code is licensed under the BSD-style license found in the
+# LICENSE file in the root directory of this source tree.
+
+# pyre-unsafe
+
+
+import random
+
+import numpy as np
+import torch
+
+
+def seed_all_random_engines(seed: int) -> None:
+    np.random.seed(seed)
+    torch.manual_seed(seed)
+    random.seed(seed)

project/ManiSkill3/src/maniskill2_benchmark/cfdp_experiment/cfdp/extern/pytorch3d/projects/implicitron_trainer/tests/__init__.py

@@ -0,0 +1,7 @@
+# Copyright (c) Meta Platforms, Inc. and affiliates.
+# All rights reserved.
+#
+# This source code is licensed under the BSD-style license found in the
+# LICENSE file in the root directory of this source tree.
+
+# pyre-unsafe

project/ManiSkill3/src/maniskill2_benchmark/cfdp_experiment/cfdp/extern/pytorch3d/projects/implicitron_trainer/tests/experiment.yaml

@@ -0,0 +1,1243 @@
+data_source_class_type: ImplicitronDataSource
+model_factory_class_type: ImplicitronModelFactory
+optimizer_factory_class_type: ImplicitronOptimizerFactory
+training_loop_class_type: ImplicitronTrainingLoop
+seed: 42
+detect_anomaly: false
+exp_dir: ./data/default_experiment/
+hydra:
+  run:
+    dir: .
+  output_subdir: null
+  mode: RUN
+data_source_ImplicitronDataSource_args:
+  dataset_map_provider_class_type: ???
+  data_loader_map_provider_class_type: SequenceDataLoaderMapProvider
+  dataset_map_provider_BlenderDatasetMapProvider_args:
+    base_dir: ???
+    object_name: ???
+    path_manager_factory_class_type: PathManagerFactory
+    n_known_frames_for_test: null
+    path_manager_factory_PathManagerFactory_args:
+      silence_logs: true
+  dataset_map_provider_JsonIndexDatasetMapProvider_args:
+    category: ???
+    task_str: singlesequence
+    dataset_root: ''
+    n_frames_per_sequence: -1
+    test_on_train: false
+    restrict_sequence_name: []
+    test_restrict_sequence_id: -1
+    assert_single_seq: false
+    only_test_set: false
+    dataset_class_type: JsonIndexDataset
+    path_manager_factory_class_type: PathManagerFactory
+    dataset_JsonIndexDataset_args:
+      limit_to: 0
+      limit_sequences_to: 0
+      exclude_sequence: []
+      limit_category_to: []
+      load_images: true
+      load_depths: true
+      load_depth_masks: true
+      load_masks: true
+      load_point_clouds: false
+      max_points: 0
+      mask_images: false
+      mask_depths: false
+      image_height: 800
+      image_width: 800
+      box_crop: true
+      box_crop_mask_thr: 0.4
+      box_crop_context: 0.3
+      remove_empty_masks: true
+      seed: 0
+      sort_frames: false
+    path_manager_factory_PathManagerFactory_args:
+      silence_logs: true
+  dataset_map_provider_JsonIndexDatasetMapProviderV2_args:
+    category: ???
+    subset_name: ???
+    dataset_root: ''
+    test_on_train: false
+    only_test_set: false
+    load_eval_batches: true
+    num_load_workers: 4
+    n_known_frames_for_test: 0
+    dataset_class_type: JsonIndexDataset
+    path_manager_factory_class_type: PathManagerFactory
+    dataset_JsonIndexDataset_args:
+      limit_to: 0
+      limit_sequences_to: 0
+      pick_sequence: []
+      exclude_sequence: []
+      limit_category_to: []
+      load_images: true
+      load_depths: true
+      load_depth_masks: true
+      load_masks: true
+      load_point_clouds: false
+      max_points: 0
+      mask_images: false
+      mask_depths: false
+      image_height: 800
+      image_width: 800
+      box_crop: true
+      box_crop_mask_thr: 0.4
+      box_crop_context: 0.3
+      remove_empty_masks: true
+      n_frames_per_sequence: -1
+      seed: 0
+      sort_frames: false
+    path_manager_factory_PathManagerFactory_args:
+      silence_logs: true
+  dataset_map_provider_LlffDatasetMapProvider_args:
+    base_dir: ???
+    object_name: ???
+    path_manager_factory_class_type: PathManagerFactory
+    n_known_frames_for_test: null
+    path_manager_factory_PathManagerFactory_args:
+      silence_logs: true
+    downscale_factor: 4
+  dataset_map_provider_RenderedMeshDatasetMapProvider_args:
+    num_views: 40
+    data_file: null
+    azimuth_range: 180.0
+    distance: 2.7
+    resolution: 128
+    use_point_light: true
+    gpu_idx: 0
+    path_manager_factory_class_type: PathManagerFactory
+    path_manager_factory_PathManagerFactory_args:
+      silence_logs: true
+  data_loader_map_provider_SequenceDataLoaderMapProvider_args:
+    batch_size: 1
+    num_workers: 0
+    dataset_length_train: 0
+    dataset_length_val: 0
+    dataset_length_test: 0
+    train_conditioning_type: SAME
+    val_conditioning_type: SAME
+    test_conditioning_type: KNOWN
+    images_per_seq_options: []
+    sample_consecutive_frames: false
+    consecutive_frames_max_gap: 0
+    consecutive_frames_max_gap_seconds: 0.1
+  data_loader_map_provider_SimpleDataLoaderMapProvider_args:
+    batch_size: 1
+    num_workers: 0
+    dataset_length_train: 0
+    dataset_length_val: 0
+    dataset_length_test: 0
+  data_loader_map_provider_TrainEvalDataLoaderMapProvider_args:
+    batch_size: 1
+    num_workers: 0
+    dataset_length_train: 0
+    dataset_length_val: 0
+    dataset_length_test: 0
+    train_conditioning_type: SAME
+    val_conditioning_type: SAME
+    test_conditioning_type: KNOWN
+    images_per_seq_options: []
+    sample_consecutive_frames: false
+    consecutive_frames_max_gap: 0
+    consecutive_frames_max_gap_seconds: 0.1
+model_factory_ImplicitronModelFactory_args:
+  resume: true
+  model_class_type: GenericModel
+  resume_epoch: -1
+  force_resume: false
+  model_GenericModel_args:
+    log_vars:
+    - loss_rgb_psnr_fg
+    - loss_rgb_psnr
+    - loss_rgb_mse
+    - loss_rgb_huber
+    - loss_depth_abs
+    - loss_depth_abs_fg
+    - loss_mask_neg_iou
+    - loss_mask_bce
+    - loss_mask_beta_prior
+    - loss_eikonal
+    - loss_density_tv
+    - loss_depth_neg_penalty
+    - loss_autodecoder_norm
+    - loss_prev_stage_rgb_mse
+    - loss_prev_stage_rgb_psnr_fg
+    - loss_prev_stage_rgb_psnr
+    - loss_prev_stage_mask_bce
+    - objective
+    - epoch
+    - sec/it
+    mask_images: true
+    mask_depths: true
+    render_image_width: 400
+    render_image_height: 400
+    mask_threshold: 0.5
+    output_rasterized_mc: false
+    bg_color:
+    - 0.0
+    - 0.0
+    - 0.0
+    num_passes: 1
+    chunk_size_grid: 4096
+    render_features_dimensions: 3
+    tqdm_trigger_threshold: 16
+    n_train_target_views: 1
+    sampling_mode_training: mask_sample
+    sampling_mode_evaluation: full_grid
+    global_encoder_class_type: null
+    raysampler_class_type: AdaptiveRaySampler
+    renderer_class_type: MultiPassEmissionAbsorptionRenderer
+    image_feature_extractor_class_type: null
+    view_pooler_enabled: false
+    implicit_function_class_type: NeuralRadianceFieldImplicitFunction
+    view_metrics_class_type: ViewMetrics
+    regularization_metrics_class_type: RegularizationMetrics
+    loss_weights:
+      loss_rgb_mse: 1.0
+      loss_prev_stage_rgb_mse: 1.0
+      loss_mask_bce: 0.0
+      loss_prev_stage_mask_bce: 0.0
+    global_encoder_HarmonicTimeEncoder_args:
+      n_harmonic_functions: 10
+      append_input: true
+      time_divisor: 1.0
+    global_encoder_SequenceAutodecoder_args:
+      autodecoder_args:
+        encoding_dim: 0
+        n_instances: 1
+        init_scale: 1.0
+        ignore_input: false
+    raysampler_AdaptiveRaySampler_args:
+      n_pts_per_ray_training: 64
+      n_pts_per_ray_evaluation: 64
+      n_rays_per_image_sampled_from_mask: 1024
+      n_rays_total_training: null
+      stratified_point_sampling_training: true
+      stratified_point_sampling_evaluation: false
+      cast_ray_bundle_as_cone: false
+      scene_extent: 8.0
+      scene_center:
+      - 0.0
+      - 0.0
+      - 0.0
+    raysampler_NearFarRaySampler_args:
+      n_pts_per_ray_training: 64
+      n_pts_per_ray_evaluation: 64
+      n_rays_per_image_sampled_from_mask: 1024
+      n_rays_total_training: null
+      stratified_point_sampling_training: true
+      stratified_point_sampling_evaluation: false
+      cast_ray_bundle_as_cone: false
+      min_depth: 0.1
+      max_depth: 8.0
+    renderer_LSTMRenderer_args:
+      num_raymarch_steps: 10
+      init_depth: 17.0
+      init_depth_noise_std: 0.0005
+      hidden_size: 16
+      n_feature_channels: 256
+      bg_color: null
+      verbose: false
+    renderer_MultiPassEmissionAbsorptionRenderer_args:
+      raymarcher_class_type: EmissionAbsorptionRaymarcher
+      n_pts_per_ray_fine_training: 64
+      n_pts_per_ray_fine_evaluation: 64
+      stratified_sampling_coarse_training: true
+      stratified_sampling_coarse_evaluation: false
+      append_coarse_samples_to_fine: true
+      density_noise_std_train: 0.0
+      return_weights: false
+      blurpool_weights: false
+      sample_pdf_eps: 1.0e-05
+      raymarcher_CumsumRaymarcher_args:
+        surface_thickness: 1
+        bg_color:
+        - 0.0
+        replicate_last_interval: false
+        background_opacity: 0.0
+        density_relu: true
+        blend_output: false
+      raymarcher_EmissionAbsorptionRaymarcher_args:
+        surface_thickness: 1
+        bg_color:
+        - 0.0
+        replicate_last_interval: false
+        background_opacity: 10000000000.0
+        density_relu: true
+        blend_output: false
+    renderer_SignedDistanceFunctionRenderer_args:
+      ray_normal_coloring_network_args:
+        feature_vector_size: 3
+        mode: idr
+        d_in: 9
+        d_out: 3
+        dims:
+        - 512
+        - 512
+        - 512
+        - 512
+        weight_norm: true
+        n_harmonic_functions_dir: 0
+        pooled_feature_dim: 0
+      bg_color:
+      - 0.0
+      soft_mask_alpha: 50.0
+      ray_tracer_args:
+        sdf_threshold: 5.0e-05
+        line_search_step: 0.5
+        line_step_iters: 1
+        sphere_tracing_iters: 10
+        n_steps: 100
+        n_secant_steps: 8
+    image_feature_extractor_ResNetFeatureExtractor_args:
+      name: resnet34
+      pretrained: true
+      stages:
+      - 1
+      - 2
+      - 3
+      - 4
+      normalize_image: true
+      image_rescale: 0.16
+      first_max_pool: true
+      proj_dim: 32
+      l2_norm: true
+      add_masks: true
+      add_images: true
+      global_average_pool: false
+      feature_rescale: 1.0
+    view_pooler_args:
+      feature_aggregator_class_type: AngleWeightedReductionFeatureAggregator
+      view_sampler_args:
+        masked_sampling: false
+        sampling_mode: bilinear
+      feature_aggregator_AngleWeightedIdentityFeatureAggregator_args:
+        exclude_target_view: true
+        exclude_target_view_mask_features: true
+        concatenate_output: true
+        weight_by_ray_angle_gamma: 1.0
+        min_ray_angle_weight: 0.1
+      feature_aggregator_AngleWeightedReductionFeatureAggregator_args:
+        exclude_target_view: true
+        exclude_target_view_mask_features: true
+        concatenate_output: true
+        reduction_functions:
+        - AVG
+        - STD
+        weight_by_ray_angle_gamma: 1.0
+        min_ray_angle_weight: 0.1
+      feature_aggregator_IdentityFeatureAggregator_args:
+        exclude_target_view: true
+        exclude_target_view_mask_features: true
+        concatenate_output: true
+      feature_aggregator_ReductionFeatureAggregator_args:
+        exclude_target_view: true
+        exclude_target_view_mask_features: true
+        concatenate_output: true
+        reduction_functions:
+        - AVG
+        - STD
+    implicit_function_IdrFeatureField_args:
+      d_in: 3
+      d_out: 1
+      dims:
+      - 512
+      - 512
+      - 512
+      - 512
+      - 512
+      - 512
+      - 512
+      - 512
+      geometric_init: true
+      bias: 1.0
+      skip_in: []
+      weight_norm: true
+      n_harmonic_functions_xyz: 0
+      pooled_feature_dim: 0
+    implicit_function_NeRFormerImplicitFunction_args:
+      n_harmonic_functions_xyz: 10
+      n_harmonic_functions_dir: 4
+      n_hidden_neurons_dir: 128
+      input_xyz: true
+      xyz_ray_dir_in_camera_coords: false
+      use_integrated_positional_encoding: false
+      transformer_dim_down_factor: 2.0
+      n_hidden_neurons_xyz: 80
+      n_layers_xyz: 2
+      append_xyz:
+      - 1
+    implicit_function_NeuralRadianceFieldImplicitFunction_args:
+      n_harmonic_functions_xyz: 10
+      n_harmonic_functions_dir: 4
+      n_hidden_neurons_dir: 128
+      input_xyz: true
+      xyz_ray_dir_in_camera_coords: false
+      use_integrated_positional_encoding: false
+      transformer_dim_down_factor: 1.0
+      n_hidden_neurons_xyz: 256
+      n_layers_xyz: 8
+      append_xyz:
+      - 5
+    implicit_function_SRNHyperNetImplicitFunction_args:
+      hypernet_args:
+        n_harmonic_functions: 3
+        n_hidden_units: 256
+        n_layers: 2
+        n_hidden_units_hypernet: 256
+        n_layers_hypernet: 1
+        in_features: 3
+        out_features: 256
+        xyz_in_camera_coords: false
+      pixel_generator_args:
+        n_harmonic_functions: 4
+        n_hidden_units: 256
+        n_hidden_units_color: 128
+        n_layers: 2
+        in_features: 256
+        out_features: 3
+        ray_dir_in_camera_coords: false
+    implicit_function_SRNImplicitFunction_args:
+      raymarch_function_args:
+        n_harmonic_functions: 3
+        n_hidden_units: 256
+        n_layers: 2
+        in_features: 3
+        out_features: 256
+        xyz_in_camera_coords: false
+        raymarch_function: null
+      pixel_generator_args:
+        n_harmonic_functions: 4
+        n_hidden_units: 256
+        n_hidden_units_color: 128
+        n_layers: 2
+        in_features: 256
+        out_features: 3
+        ray_dir_in_camera_coords: false
+    implicit_function_VoxelGridImplicitFunction_args:
+      harmonic_embedder_xyz_density_args:
+        n_harmonic_functions: 6
+        omega_0: 1.0
+        logspace: true
+        append_input: true
+      harmonic_embedder_xyz_color_args:
+        n_harmonic_functions: 6
+        omega_0: 1.0
+        logspace: true
+        append_input: true
+      harmonic_embedder_dir_color_args:
+        n_harmonic_functions: 6
+        omega_0: 1.0
+        logspace: true
+        append_input: true
+      decoder_density_class_type: MLPDecoder
+      decoder_color_class_type: MLPDecoder
+      use_multiple_streams: true
+      xyz_ray_dir_in_camera_coords: false
+      scaffold_calculating_epochs: []
+      scaffold_resolution:
+      - 128
+      - 128
+      - 128
+      scaffold_empty_space_threshold: 0.001
+      scaffold_occupancy_chunk_size: -1
+      scaffold_max_pool_kernel_size: 3
+      scaffold_filter_points: true
+      volume_cropping_epochs: []
+      voxel_grid_density_args:
+        voxel_grid_class_type: FullResolutionVoxelGrid
+        extents:
+        - 2.0
+        - 2.0
+        - 2.0
+        translation:
+        - 0.0
+        - 0.0
+        - 0.0
+        init_std: 0.1
+        init_mean: 0.0
+        hold_voxel_grid_as_parameters: true
+        param_groups: {}
+        voxel_grid_CPFactorizedVoxelGrid_args:
+          align_corners: true
+          padding: zeros
+          mode: bilinear
+          n_features: 1
+          resolution_changes:
+            0:
+            - 128
+            - 128
+            - 128
+          n_components: 24
+          basis_matrix: true
+        voxel_grid_FullResolutionVoxelGrid_args:
+          align_corners: true
+          padding: zeros
+          mode: bilinear
+          n_features: 1
+          resolution_changes:
+            0:
+            - 128
+            - 128
+            - 128
+        voxel_grid_VMFactorizedVoxelGrid_args:
+          align_corners: true
+          padding: zeros
+          mode: bilinear
+          n_features: 1
+          resolution_changes:
+            0:
+            - 128
+            - 128
+            - 128
+          n_components: null
+          distribution_of_components: null
+          basis_matrix: true
+      voxel_grid_color_args:
+        voxel_grid_class_type: FullResolutionVoxelGrid
+        extents:
+        - 2.0
+        - 2.0
+        - 2.0
+        translation:
+        - 0.0
+        - 0.0
+        - 0.0
+        init_std: 0.1
+        init_mean: 0.0
+        hold_voxel_grid_as_parameters: true
+        param_groups: {}
+        voxel_grid_CPFactorizedVoxelGrid_args:
+          align_corners: true
+          padding: zeros
+          mode: bilinear
+          n_features: 1
+          resolution_changes:
+            0:
+            - 128
+            - 128
+            - 128
+          n_components: 24
+          basis_matrix: true
+        voxel_grid_FullResolutionVoxelGrid_args:
+          align_corners: true
+          padding: zeros
+          mode: bilinear
+          n_features: 1
+          resolution_changes:
+            0:
+            - 128
+            - 128
+            - 128
+        voxel_grid_VMFactorizedVoxelGrid_args:
+          align_corners: true
+          padding: zeros
+          mode: bilinear
+          n_features: 1
+          resolution_changes:
+            0:
+            - 128
+            - 128
+            - 128
+          n_components: null
+          distribution_of_components: null
+          basis_matrix: true
+      decoder_density_ElementwiseDecoder_args:
+        scale: 1.0
+        shift: 0.0
+        operation: IDENTITY
+      decoder_density_MLPDecoder_args:
+        param_groups: {}
+        network_args:
+          n_layers: 8
+          output_dim: 256
+          skip_dim: 39
+          hidden_dim: 256
+          input_skips:
+          - 5
+          skip_affine_trans: false
+          last_layer_bias_init: null
+          last_activation: RELU
+          use_xavier_init: true
+      decoder_color_ElementwiseDecoder_args:
+        scale: 1.0
+        shift: 0.0
+        operation: IDENTITY
+      decoder_color_MLPDecoder_args:
+        param_groups: {}
+        network_args:
+          n_layers: 8
+          output_dim: 256
+          skip_dim: 39
+          hidden_dim: 256
+          input_skips:
+          - 5
+          skip_affine_trans: false
+          last_layer_bias_init: null
+          last_activation: RELU
+          use_xavier_init: true
+    view_metrics_ViewMetrics_args: {}
+    regularization_metrics_RegularizationMetrics_args: {}
+  model_OverfitModel_args:
+    log_vars:
+    - loss_rgb_psnr_fg
+    - loss_rgb_psnr
+    - loss_rgb_mse
+    - loss_rgb_huber
+    - loss_depth_abs
+    - loss_depth_abs_fg
+    - loss_mask_neg_iou
+    - loss_mask_bce
+    - loss_mask_beta_prior
+    - loss_eikonal
+    - loss_density_tv
+    - loss_depth_neg_penalty
+    - loss_autodecoder_norm
+    - loss_prev_stage_rgb_mse
+    - loss_prev_stage_rgb_psnr_fg
+    - loss_prev_stage_rgb_psnr
+    - loss_prev_stage_mask_bce
+    - objective
+    - epoch
+    - sec/it
+    mask_images: true
+    mask_depths: true
+    render_image_width: 400
+    render_image_height: 400
+    mask_threshold: 0.5
+    output_rasterized_mc: false
+    bg_color:
+    - 0.0
+    - 0.0
+    - 0.0
+    chunk_size_grid: 4096
+    render_features_dimensions: 3
+    tqdm_trigger_threshold: 16
+    n_train_target_views: 1
+    sampling_mode_training: mask_sample
+    sampling_mode_evaluation: full_grid
+    global_encoder_class_type: null
+    raysampler_class_type: AdaptiveRaySampler
+    renderer_class_type: MultiPassEmissionAbsorptionRenderer
+    share_implicit_function_across_passes: false
+    implicit_function_class_type: NeuralRadianceFieldImplicitFunction
+    coarse_implicit_function_class_type: null
+    view_metrics_class_type: ViewMetrics
+    regularization_metrics_class_type: RegularizationMetrics
+    loss_weights:
+      loss_rgb_mse: 1.0
+      loss_prev_stage_rgb_mse: 1.0
+      loss_mask_bce: 0.0
+      loss_prev_stage_mask_bce: 0.0
+    global_encoder_HarmonicTimeEncoder_args:
+      n_harmonic_functions: 10
+      append_input: true
+      time_divisor: 1.0
+    global_encoder_SequenceAutodecoder_args:
+      autodecoder_args:
+        encoding_dim: 0
+        n_instances: 1
+        init_scale: 1.0
+        ignore_input: false
+    raysampler_AdaptiveRaySampler_args:
+      n_pts_per_ray_training: 64
+      n_pts_per_ray_evaluation: 64
+      n_rays_per_image_sampled_from_mask: 1024
+      n_rays_total_training: null
+      stratified_point_sampling_training: true
+      stratified_point_sampling_evaluation: false
+      cast_ray_bundle_as_cone: false
+      scene_extent: 8.0
+      scene_center:
+      - 0.0
+      - 0.0
+      - 0.0
+    raysampler_NearFarRaySampler_args:
+      n_pts_per_ray_training: 64
+      n_pts_per_ray_evaluation: 64
+      n_rays_per_image_sampled_from_mask: 1024
+      n_rays_total_training: null
+      stratified_point_sampling_training: true
+      stratified_point_sampling_evaluation: false
+      cast_ray_bundle_as_cone: false
+      min_depth: 0.1
+      max_depth: 8.0
+    renderer_LSTMRenderer_args:
+      num_raymarch_steps: 10
+      init_depth: 17.0
+      init_depth_noise_std: 0.0005
+      hidden_size: 16
+      n_feature_channels: 256
+      bg_color: null
+      verbose: false
+    renderer_MultiPassEmissionAbsorptionRenderer_args:
+      raymarcher_class_type: EmissionAbsorptionRaymarcher
+      n_pts_per_ray_fine_training: 64
+      n_pts_per_ray_fine_evaluation: 64
+      stratified_sampling_coarse_training: true
+      stratified_sampling_coarse_evaluation: false
+      append_coarse_samples_to_fine: true
+      density_noise_std_train: 0.0
+      return_weights: false
+      blurpool_weights: false
+      sample_pdf_eps: 1.0e-05
+      raymarcher_CumsumRaymarcher_args:
+        surface_thickness: 1
+        bg_color:
+        - 0.0
+        replicate_last_interval: false
+        background_opacity: 0.0
+        density_relu: true
+        blend_output: false
+      raymarcher_EmissionAbsorptionRaymarcher_args:
+        surface_thickness: 1
+        bg_color:
+        - 0.0
+        replicate_last_interval: false
+        background_opacity: 10000000000.0
+        density_relu: true
+        blend_output: false
+    renderer_SignedDistanceFunctionRenderer_args:
+      ray_normal_coloring_network_args:
+        feature_vector_size: 3
+        mode: idr
+        d_in: 9
+        d_out: 3
+        dims:
+        - 512
+        - 512
+        - 512
+        - 512
+        weight_norm: true
+        n_harmonic_functions_dir: 0
+        pooled_feature_dim: 0
+      bg_color:
+      - 0.0
+      soft_mask_alpha: 50.0
+      ray_tracer_args:
+        sdf_threshold: 5.0e-05
+        line_search_step: 0.5
+        line_step_iters: 1
+        sphere_tracing_iters: 10
+        n_steps: 100
+        n_secant_steps: 8
+    implicit_function_IdrFeatureField_args:
+      d_in: 3
+      d_out: 1
+      dims:
+      - 512
+      - 512
+      - 512
+      - 512
+      - 512
+      - 512
+      - 512
+      - 512
+      geometric_init: true
+      bias: 1.0
+      skip_in: []
+      weight_norm: true
+      n_harmonic_functions_xyz: 0
+      pooled_feature_dim: 0
+    implicit_function_NeRFormerImplicitFunction_args:
+      n_harmonic_functions_xyz: 10
+      n_harmonic_functions_dir: 4
+      n_hidden_neurons_dir: 128
+      input_xyz: true
+      xyz_ray_dir_in_camera_coords: false
+      use_integrated_positional_encoding: false
+      transformer_dim_down_factor: 2.0
+      n_hidden_neurons_xyz: 80
+      n_layers_xyz: 2
+      append_xyz:
+      - 1
+    implicit_function_NeuralRadianceFieldImplicitFunction_args:
+      n_harmonic_functions_xyz: 10
+      n_harmonic_functions_dir: 4
+      n_hidden_neurons_dir: 128
+      input_xyz: true
+      xyz_ray_dir_in_camera_coords: false
+      use_integrated_positional_encoding: false
+      transformer_dim_down_factor: 1.0
+      n_hidden_neurons_xyz: 256
+      n_layers_xyz: 8
+      append_xyz:
+      - 5
+    implicit_function_SRNHyperNetImplicitFunction_args:
+      latent_dim_hypernet: 0
+      hypernet_args:
+        n_harmonic_functions: 3
+        n_hidden_units: 256
+        n_layers: 2
+        n_hidden_units_hypernet: 256
+        n_layers_hypernet: 1
+        in_features: 3
+        out_features: 256
+        xyz_in_camera_coords: false
+      pixel_generator_args:
+        n_harmonic_functions: 4
+        n_hidden_units: 256
+        n_hidden_units_color: 128
+        n_layers: 2
+        in_features: 256
+        out_features: 3
+        ray_dir_in_camera_coords: false
+    implicit_function_SRNImplicitFunction_args:
+      raymarch_function_args:
+        n_harmonic_functions: 3
+        n_hidden_units: 256
+        n_layers: 2
+        in_features: 3
+        out_features: 256
+        xyz_in_camera_coords: false
+        raymarch_function: null
+      pixel_generator_args:
+        n_harmonic_functions: 4
+        n_hidden_units: 256
+        n_hidden_units_color: 128
+        n_layers: 2
+        in_features: 256
+        out_features: 3
+        ray_dir_in_camera_coords: false
+    implicit_function_VoxelGridImplicitFunction_args:
+      harmonic_embedder_xyz_density_args:
+        n_harmonic_functions: 6
+        omega_0: 1.0
+        logspace: true
+        append_input: true
+      harmonic_embedder_xyz_color_args:
+        n_harmonic_functions: 6
+        omega_0: 1.0
+        logspace: true
+        append_input: true
+      harmonic_embedder_dir_color_args:
+        n_harmonic_functions: 6
+        omega_0: 1.0
+        logspace: true
+        append_input: true
+      decoder_density_class_type: MLPDecoder
+      decoder_color_class_type: MLPDecoder
+      use_multiple_streams: true
+      xyz_ray_dir_in_camera_coords: false
+      scaffold_calculating_epochs: []
+      scaffold_resolution:
+      - 128
+      - 128
+      - 128
+      scaffold_empty_space_threshold: 0.001
+      scaffold_occupancy_chunk_size: -1
+      scaffold_max_pool_kernel_size: 3
+      scaffold_filter_points: true
+      volume_cropping_epochs: []
+      voxel_grid_density_args:
+        voxel_grid_class_type: FullResolutionVoxelGrid
+        extents:
+        - 2.0
+        - 2.0
+        - 2.0
+        translation:
+        - 0.0
+        - 0.0
+        - 0.0
+        init_std: 0.1
+        init_mean: 0.0
+        hold_voxel_grid_as_parameters: true
+        param_groups: {}
+        voxel_grid_CPFactorizedVoxelGrid_args:
+          align_corners: true
+          padding: zeros
+          mode: bilinear
+          n_features: 1
+          resolution_changes:
+            0:
+            - 128
+            - 128
+            - 128
+          n_components: 24
+          basis_matrix: true
+        voxel_grid_FullResolutionVoxelGrid_args:
+          align_corners: true
+          padding: zeros
+          mode: bilinear
+          n_features: 1
+          resolution_changes:
+            0:
+            - 128
+            - 128
+            - 128
+        voxel_grid_VMFactorizedVoxelGrid_args:
+          align_corners: true
+          padding: zeros
+          mode: bilinear
+          n_features: 1
+          resolution_changes:
+            0:
+            - 128
+            - 128
+            - 128
+          n_components: null
+          distribution_of_components: null
+          basis_matrix: true
+      voxel_grid_color_args:
+        voxel_grid_class_type: FullResolutionVoxelGrid
+        extents:
+        - 2.0
+        - 2.0
+        - 2.0
+        translation:
+        - 0.0
+        - 0.0
+        - 0.0
+        init_std: 0.1
+        init_mean: 0.0
+        hold_voxel_grid_as_parameters: true
+        param_groups: {}
+        voxel_grid_CPFactorizedVoxelGrid_args:
+          align_corners: true
+          padding: zeros
+          mode: bilinear
+          n_features: 1
+          resolution_changes:
+            0:
+            - 128
+            - 128
+            - 128
+          n_components: 24
+          basis_matrix: true
+        voxel_grid_FullResolutionVoxelGrid_args:
+          align_corners: true
+          padding: zeros
+          mode: bilinear
+          n_features: 1
+          resolution_changes:
+            0:
+            - 128
+            - 128
+            - 128
+        voxel_grid_VMFactorizedVoxelGrid_args:
+          align_corners: true
+          padding: zeros
+          mode: bilinear
+          n_features: 1
+          resolution_changes:
+            0:
+            - 128
+            - 128
+            - 128
+          n_components: null
+          distribution_of_components: null
+          basis_matrix: true
+      decoder_density_ElementwiseDecoder_args:
+        scale: 1.0
+        shift: 0.0
+        operation: IDENTITY
+      decoder_density_MLPDecoder_args:
+        param_groups: {}
+        network_args:
+          n_layers: 8
+          output_dim: 256
+          skip_dim: 39
+          hidden_dim: 256
+          input_skips:
+          - 5
+          skip_affine_trans: false
+          last_layer_bias_init: null
+          last_activation: RELU
+          use_xavier_init: true
+      decoder_color_ElementwiseDecoder_args:
+        scale: 1.0
+        shift: 0.0
+        operation: IDENTITY
+      decoder_color_MLPDecoder_args:
+        param_groups: {}
+        network_args:
+          n_layers: 8
+          output_dim: 256
+          skip_dim: 39
+          hidden_dim: 256
+          input_skips:
+          - 5
+          skip_affine_trans: false
+          last_layer_bias_init: null
+          last_activation: RELU
+          use_xavier_init: true
+    coarse_implicit_function_IdrFeatureField_args:
+      d_in: 3
+      d_out: 1
+      dims:
+      - 512
+      - 512
+      - 512
+      - 512
+      - 512
+      - 512
+      - 512
+      - 512
+      geometric_init: true
+      bias: 1.0
+      skip_in: []
+      weight_norm: true
+      n_harmonic_functions_xyz: 0
+      pooled_feature_dim: 0
+    coarse_implicit_function_NeRFormerImplicitFunction_args:
+      n_harmonic_functions_xyz: 10
+      n_harmonic_functions_dir: 4
+      n_hidden_neurons_dir: 128
+      input_xyz: true
+      xyz_ray_dir_in_camera_coords: false
+      use_integrated_positional_encoding: false
+      transformer_dim_down_factor: 2.0
+      n_hidden_neurons_xyz: 80
+      n_layers_xyz: 2
+      append_xyz:
+      - 1
+    coarse_implicit_function_NeuralRadianceFieldImplicitFunction_args:
+      n_harmonic_functions_xyz: 10
+      n_harmonic_functions_dir: 4
+      n_hidden_neurons_dir: 128
+      input_xyz: true
+      xyz_ray_dir_in_camera_coords: false
+      use_integrated_positional_encoding: false
+      transformer_dim_down_factor: 1.0
+      n_hidden_neurons_xyz: 256
+      n_layers_xyz: 8
+      append_xyz:
+      - 5
+    coarse_implicit_function_SRNHyperNetImplicitFunction_args:
+      latent_dim_hypernet: 0
+      hypernet_args:
+        n_harmonic_functions: 3
+        n_hidden_units: 256
+        n_layers: 2
+        n_hidden_units_hypernet: 256
+        n_layers_hypernet: 1
+        in_features: 3
+        out_features: 256
+        xyz_in_camera_coords: false
+      pixel_generator_args:
+        n_harmonic_functions: 4
+        n_hidden_units: 256
+        n_hidden_units_color: 128
+        n_layers: 2
+        in_features: 256
+        out_features: 3
+        ray_dir_in_camera_coords: false
+    coarse_implicit_function_SRNImplicitFunction_args:
+      raymarch_function_args:
+        n_harmonic_functions: 3
+        n_hidden_units: 256
+        n_layers: 2
+        in_features: 3
+        out_features: 256
+        xyz_in_camera_coords: false
+        raymarch_function: null
+      pixel_generator_args:
+        n_harmonic_functions: 4
+        n_hidden_units: 256
+        n_hidden_units_color: 128
+        n_layers: 2
+        in_features: 256
+        out_features: 3
+        ray_dir_in_camera_coords: false
+    coarse_implicit_function_VoxelGridImplicitFunction_args:
+      harmonic_embedder_xyz_density_args:
+        n_harmonic_functions: 6
+        omega_0: 1.0
+        logspace: true
+        append_input: true
+      harmonic_embedder_xyz_color_args:
+        n_harmonic_functions: 6
+        omega_0: 1.0
+        logspace: true
+        append_input: true
+      harmonic_embedder_dir_color_args:
+        n_harmonic_functions: 6
+        omega_0: 1.0
+        logspace: true
+        append_input: true
+      decoder_density_class_type: MLPDecoder
+      decoder_color_class_type: MLPDecoder
+      use_multiple_streams: true
+      xyz_ray_dir_in_camera_coords: false
+      scaffold_calculating_epochs: []
+      scaffold_resolution:
+      - 128
+      - 128
+      - 128
+      scaffold_empty_space_threshold: 0.001
+      scaffold_occupancy_chunk_size: -1
+      scaffold_max_pool_kernel_size: 3
+      scaffold_filter_points: true
+      volume_cropping_epochs: []
+      voxel_grid_density_args:
+        voxel_grid_class_type: FullResolutionVoxelGrid
+        extents:
+        - 2.0
+        - 2.0
+        - 2.0
+        translation:
+        - 0.0
+        - 0.0
+        - 0.0
+        init_std: 0.1
+        init_mean: 0.0
+        hold_voxel_grid_as_parameters: true
+        param_groups: {}
+        voxel_grid_CPFactorizedVoxelGrid_args:
+          align_corners: true
+          padding: zeros
+          mode: bilinear
+          n_features: 1
+          resolution_changes:
+            0:
+            - 128
+            - 128
+            - 128
+          n_components: 24
+          basis_matrix: true
+        voxel_grid_FullResolutionVoxelGrid_args:
+          align_corners: true
+          padding: zeros
+          mode: bilinear
+          n_features: 1
+          resolution_changes:
+            0:
+            - 128
+            - 128
+            - 128
+        voxel_grid_VMFactorizedVoxelGrid_args:
+          align_corners: true
+          padding: zeros
+          mode: bilinear
+          n_features: 1
+          resolution_changes:
+            0:
+            - 128
+            - 128
+            - 128
+          n_components: null
+          distribution_of_components: null
+          basis_matrix: true
+      voxel_grid_color_args:
+        voxel_grid_class_type: FullResolutionVoxelGrid
+        extents:
+        - 2.0
+        - 2.0
+        - 2.0
+        translation:
+        - 0.0
+        - 0.0
+        - 0.0
+        init_std: 0.1
+        init_mean: 0.0
+        hold_voxel_grid_as_parameters: true
+        param_groups: {}
+        voxel_grid_CPFactorizedVoxelGrid_args:
+          align_corners: true
+          padding: zeros
+          mode: bilinear
+          n_features: 1
+          resolution_changes:
+            0:
+            - 128
+            - 128
+            - 128
+          n_components: 24
+          basis_matrix: true
+        voxel_grid_FullResolutionVoxelGrid_args:
+          align_corners: true
+          padding: zeros
+          mode: bilinear
+          n_features: 1
+          resolution_changes:
+            0:
+            - 128
+            - 128
+            - 128
+        voxel_grid_VMFactorizedVoxelGrid_args:
+          align_corners: true
+          padding: zeros
+          mode: bilinear
+          n_features: 1
+          resolution_changes:
+            0:
+            - 128
+            - 128
+            - 128
+          n_components: null
+          distribution_of_components: null
+          basis_matrix: true
+      decoder_density_ElementwiseDecoder_args:
+        scale: 1.0
+        shift: 0.0
+        operation: IDENTITY
+      decoder_density_MLPDecoder_args:
+        param_groups: {}
+        network_args:
+          n_layers: 8
+          output_dim: 256
+          skip_dim: 39
+          hidden_dim: 256
+          input_skips:
+          - 5
+          skip_affine_trans: false
+          last_layer_bias_init: null
+          last_activation: RELU
+          use_xavier_init: true
+      decoder_color_ElementwiseDecoder_args:
+        scale: 1.0
+        shift: 0.0
+        operation: IDENTITY
+      decoder_color_MLPDecoder_args:
+        param_groups: {}
+        network_args:
+          n_layers: 8
+          output_dim: 256
+          skip_dim: 39
+          hidden_dim: 256
+          input_skips:
+          - 5
+          skip_affine_trans: false
+          last_layer_bias_init: null
+          last_activation: RELU
+          use_xavier_init: true
+    view_metrics_ViewMetrics_args: {}
+    regularization_metrics_RegularizationMetrics_args: {}
+optimizer_factory_ImplicitronOptimizerFactory_args:
+  betas:
+  - 0.9
+  - 0.999
+  breed: Adam
+  exponential_lr_step_size: 250
+  gamma: 0.1
+  lr: 0.0005
+  lr_policy: MultiStepLR
+  momentum: 0.9
+  multistep_lr_milestones: []
+  weight_decay: 0.0
+  linear_exponential_lr_milestone: 200
+  linear_exponential_start_gamma: 0.1
+  foreach: true
+  group_learning_rates: {}
+training_loop_ImplicitronTrainingLoop_args:
+  evaluator_class_type: ImplicitronEvaluator
+  evaluator_ImplicitronEvaluator_args:
+    is_multisequence: false
+    camera_difficulty_bin_breaks:
+    - 0.97
+    - 0.98
+  eval_only: false
+  max_epochs: 1000
+  store_checkpoints: true
+  store_checkpoints_purge: 1
+  test_interval: -1
+  test_when_finished: false
+  validation_interval: 1
+  clip_grad: 0.0
+  metric_print_interval: 5
+  visualize_interval: 1000
+  visdom_env: ''
+  visdom_port: 8097
+  visdom_server: http://127.0.0.1

project/ManiSkill3/src/maniskill2_benchmark/cfdp_experiment/cfdp/extern/pytorch3d/projects/implicitron_trainer/tests/test_experiment.py

@@ -0,0 +1,282 @@
+# Copyright (c) Meta Platforms, Inc. and affiliates.
+# All rights reserved.
+#
+# This source code is licensed under the BSD-style license found in the
+# LICENSE file in the root directory of this source tree.
+
+# pyre-unsafe
+
+import os
+import tempfile
+import unittest
+from pathlib import Path
+
+import torch
+
+from hydra import compose, initialize_config_dir
+from omegaconf import OmegaConf
+from projects.implicitron_trainer.impl.optimizer_factory import (
+    ImplicitronOptimizerFactory,
+)
+
+from .. import experiment
+from .utils import interactive_testing_requested, intercept_logs
+
+internal = os.environ.get("FB_TEST", False)
+
+
+DATA_DIR = Path(__file__).resolve().parent
+IMPLICITRON_CONFIGS_DIR = Path(__file__).resolve().parent.parent / "configs"
+DEBUG: bool = False
+
+# TODO:
+# - add enough files to skateboard_first_5 that this works on RE.
+# - share common code with PyTorch3D tests?
+
+
+def _parse_float_from_log(line):
+    return float(line.split()[-1])
+
+
+class TestExperiment(unittest.TestCase):
+    def setUp(self):
+        self.maxDiff = None
+
+    def test_from_defaults(self):
+        # Test making minimal changes to the dataclass defaults.
+        if not interactive_testing_requested() or not internal:
+            return
+
+        # Manually override config values. Note that this is not necessary out-
+        # side of the tests!
+        cfg = OmegaConf.structured(experiment.Experiment)
+        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.category = "skateboard"
+        dataset_args.test_restrict_sequence_id = 0
+        dataset_args.dataset_root = "manifold://co3d/tree/extracted"
+        dataset_args.dataset_JsonIndexDataset_args.limit_sequences_to = 5
+        dataset_args.dataset_JsonIndexDataset_args.image_height = 80
+        dataset_args.dataset_JsonIndexDataset_args.image_width = 80
+        dataloader_args.dataset_length_train = 1
+        dataloader_args.dataset_length_val = 1
+        cfg.training_loop_ImplicitronTrainingLoop_args.max_epochs = 2
+        cfg.training_loop_ImplicitronTrainingLoop_args.store_checkpoints = False
+        cfg.optimizer_factory_ImplicitronOptimizerFactory_args.multistep_lr_milestones = [
+            0,
+            1,
+        ]
+
+        if DEBUG:
+            experiment.dump_cfg(cfg)
+        with intercept_logs(
+            logger_name="projects.implicitron_trainer.impl.training_loop",
+            regexp="LR change!",
+        ) as intercepted_logs:
+            experiment_runner = experiment.Experiment(**cfg)
+            experiment_runner.run()
+
+            # Make sure LR decreased on 0th and 1st epoch 10fold.
+            self.assertEqual(intercepted_logs[0].split()[-1], "5e-06")
+
+    def test_exponential_lr(self):
+        # Test making minimal changes to the dataclass defaults.
+        if not interactive_testing_requested():
+            return
+        cfg = OmegaConf.structured(experiment.Experiment)
+        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.category = "skateboard"
+        dataset_args.test_restrict_sequence_id = 0
+        dataset_args.dataset_root = "manifold://co3d/tree/extracted"
+        dataset_args.dataset_JsonIndexDataset_args.limit_sequences_to = 5
+        dataset_args.dataset_JsonIndexDataset_args.image_height = 80
+        dataset_args.dataset_JsonIndexDataset_args.image_width = 80
+        dataloader_args.dataset_length_train = 1
+        dataloader_args.dataset_length_val = 1
+        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
+        )
+
+        if DEBUG:
+            experiment.dump_cfg(cfg)
+        with intercept_logs(
+            logger_name="projects.implicitron_trainer.impl.training_loop",
+            regexp="LR change!",
+        ) as intercepted_logs:
+            experiment_runner = experiment.Experiment(**cfg)
+            experiment_runner.run()
+
+            # Make sure we followed the exponential lr schedule with gamma=0.1,
+            # exponential_lr_step_size=2 -- so after two epochs, should
+            # decrease lr 10x to 5e-5.
+            self.assertEqual(intercepted_logs[0].split()[-1], "0.00015811388300841897")
+            self.assertEqual(intercepted_logs[1].split()[-1], "5e-05")
+
+    def test_yaml_contents(self):
+        # Check that the default config values, defined by Experiment and its
+        # members, is what we expect it to be.
+        cfg = OmegaConf.structured(experiment.Experiment)
+        # the following removes the possible effect of env variables
+        ds_arg = cfg.data_source_ImplicitronDataSource_args
+        ds_arg.dataset_map_provider_JsonIndexDatasetMapProvider_args.dataset_root = ""
+        ds_arg.dataset_map_provider_JsonIndexDatasetMapProviderV2_args.dataset_root = ""
+        if "dataset_map_provider_SqlIndexDatasetMapProvider_args" in ds_arg:
+            del ds_arg.dataset_map_provider_SqlIndexDatasetMapProvider_args
+        cfg.training_loop_ImplicitronTrainingLoop_args.visdom_port = 8097
+        yaml = OmegaConf.to_yaml(cfg, sort_keys=False)
+        if DEBUG:
+            (DATA_DIR / "experiment.yaml").write_text(yaml)
+        self.assertEqual(yaml, (DATA_DIR / "experiment.yaml").read_text())
+
+    def test_load_configs(self):
+        # Check that all the pre-prepared configs are valid.
+        config_files = []
+
+        for pattern in (
+            "repro_singleseq*.yaml",
+            "repro_multiseq*.yaml",
+            "overfit_singleseq*.yaml",
+        ):
+            config_files.extend(
+                [
+                    f
+                    for f in IMPLICITRON_CONFIGS_DIR.glob(pattern)
+                    if not f.name.endswith("_base.yaml")
+                ]
+            )
+
+        for file in config_files:
+            with self.subTest(file.name):
+                with initialize_config_dir(config_dir=str(IMPLICITRON_CONFIGS_DIR)):
+                    compose(file.name)
+
+    def test_optimizer_factory(self):
+        model = torch.nn.Linear(2, 2)
+
+        adam, sched = ImplicitronOptimizerFactory(breed="Adam")(0, model)
+        self.assertIsInstance(adam, torch.optim.Adam)
+        sgd, sched = ImplicitronOptimizerFactory(breed="SGD")(0, model)
+        self.assertIsInstance(sgd, torch.optim.SGD)
+        adagrad, sched = ImplicitronOptimizerFactory(breed="Adagrad")(0, model)
+        self.assertIsInstance(adagrad, torch.optim.Adagrad)
+
+
+class TestNerfRepro(unittest.TestCase):
+    @unittest.skip("This test runs full blender training.")
+    def test_nerf_blender(self):
+        # Train vanilla NERF.
+        # Set env vars BLENDER_DATASET_ROOT and BLENDER_SINGLESEQ_CLASS first!
+        if not interactive_testing_requested():
+            return
+        with initialize_config_dir(config_dir=str(IMPLICITRON_CONFIGS_DIR)):
+            cfg = compose(config_name="repro_singleseq_nerf_blender", overrides=[])
+            experiment_runner = experiment.Experiment(**cfg)
+            experiment.dump_cfg(cfg)
+            experiment_runner.run()
+
+    @unittest.skip("This test runs full llff training.")
+    def test_nerf_llff(self):
+        # Train vanilla NERF.
+        # Set env vars LLFF_DATASET_ROOT and LLFF_SINGLESEQ_CLASS first!
+        LLFF_SINGLESEQ_CLASS = os.environ["LLFF_SINGLESEQ_CLASS"]
+        if not interactive_testing_requested():
+            return
+        with initialize_config_dir(config_dir=str(IMPLICITRON_CONFIGS_DIR)):
+            cfg = compose(
+                config_name=f"repro_singleseq_nerf_llff_{LLFF_SINGLESEQ_CLASS}",
+                overrides=[],
+            )
+            experiment_runner = experiment.Experiment(**cfg)
+            experiment.dump_cfg(cfg)
+            experiment_runner.run()
+
+    @unittest.skip("This test runs nerf training on co3d v2 - manyview.")
+    def test_nerf_co3dv2_manyview(self):
+        # Train NERF
+        if not interactive_testing_requested():
+            return
+        with initialize_config_dir(config_dir=str(IMPLICITRON_CONFIGS_DIR)):
+            cfg = compose(
+                config_name="repro_singleseq_v2_nerf",
+                overrides=[],
+            )
+            experiment_runner = experiment.Experiment(**cfg)
+            experiment.dump_cfg(cfg)
+            experiment_runner.run()
+
+    @unittest.skip("This test runs nerformer training on co3d v2 - fewview.")
+    def test_nerformer_co3dv2_fewview(self):
+        # Train NeRFormer
+        if not interactive_testing_requested():
+            return
+        with initialize_config_dir(config_dir=str(IMPLICITRON_CONFIGS_DIR)):
+            cfg = compose(
+                config_name="repro_multiseq_v2_nerformer",
+                overrides=[],
+            )
+            experiment_runner = experiment.Experiment(**cfg)
+            experiment.dump_cfg(cfg)
+            experiment_runner.run()
+
+    @unittest.skip("This test checks resuming of the NeRF training.")
+    def test_nerf_blender_resume(self):
+        # Train one train batch of NeRF, then resume for one more batch.
+        # Set env vars BLENDER_DATASET_ROOT and BLENDER_SINGLESEQ_CLASS first!
+        if not interactive_testing_requested():
+            return
+        with initialize_config_dir(config_dir=str(IMPLICITRON_CONFIGS_DIR)):
+            with tempfile.TemporaryDirectory() as exp_dir:
+                cfg = compose(config_name="repro_singleseq_nerf_blender", overrides=[])
+                cfg.exp_dir = exp_dir
+
+                # set dataset len to 1
+
+                # fmt: off
+                (
+                    cfg
+                    .data_source_ImplicitronDataSource_args
+                    .data_loader_map_provider_SequenceDataLoaderMapProvider_args
+                    .dataset_length_train
+                ) = 1
+                # fmt: on
+
+                # run for one epoch
+                cfg.training_loop_ImplicitronTrainingLoop_args.max_epochs = 1
+                experiment_runner = experiment.Experiment(**cfg)
+                experiment.dump_cfg(cfg)
+                experiment_runner.run()
+
+                # update num epochs + 2, let the optimizer resume
+                cfg.training_loop_ImplicitronTrainingLoop_args.max_epochs = 3
+                experiment_runner = experiment.Experiment(**cfg)
+                experiment_runner.run()
+
+                # start from scratch
+                cfg.model_factory_ImplicitronModelFactory_args.resume = False
+                experiment_runner = experiment.Experiment(**cfg)
+                experiment_runner.run()
+
+                # force resume from epoch 1
+                cfg.model_factory_ImplicitronModelFactory_args.resume = True
+                cfg.model_factory_ImplicitronModelFactory_args.force_resume = True
+                cfg.model_factory_ImplicitronModelFactory_args.resume_epoch = 1
+                experiment_runner = experiment.Experiment(**cfg)
+                experiment_runner.run()

project/ManiSkill3/src/maniskill2_benchmark/cfdp_experiment/cfdp/extern/pytorch3d/projects/implicitron_trainer/tests/test_optimizer_factory.py

@@ -0,0 +1,185 @@
+# Copyright (c) Meta Platforms, Inc. and affiliates.
+# All rights reserved.
+#
+# This source code is licensed under the BSD-style license found in the
+# LICENSE file in the root directory of this source tree.
+
+# pyre-unsafe
+
+import logging
+import os
+import unittest
+
+import torch
+from pytorch3d.implicitron.tools.config import expand_args_fields, get_default_args
+
+from ..impl.optimizer_factory import (
+    ImplicitronOptimizerFactory,
+    logger as factory_logger,
+)
+
+internal = os.environ.get("FB_TEST", False)
+
+
+class TestOptimizerFactory(unittest.TestCase):
+    def setUp(self) -> None:
+        torch.manual_seed(42)
+        expand_args_fields(ImplicitronOptimizerFactory)
+
+    def _get_param_groups(self, model):
+        default_cfg = get_default_args(ImplicitronOptimizerFactory)
+        factory = ImplicitronOptimizerFactory(default_cfg)
+        oldlevel = factory_logger.level
+        factory_logger.setLevel(logging.ERROR)
+        out = factory._get_param_groups(model)
+        factory_logger.setLevel(oldlevel)
+        return out
+
+    def _assert_allin(self, a, param_groups, key):
+        """
+        Asserts that all the parameters in a are in the group
+        named by key.
+        """
+        with self.subTest(f"Testing key {key}"):
+            b = param_groups[key]
+            for el in a:
+                if el not in b:
+                    raise ValueError(
+                        f"Element {el}\n\n from:\n\n {a}\n\n not in:\n\n {b}\n\n."
+                        + f" Full param groups = \n\n{param_groups}"
+                    )
+            for el in b:
+                if el not in a:
+                    raise ValueError(
+                        f"Element {el}\n\n from:\n\n {b}\n\n not in:\n\n {a}\n\n."
+                        + f" Full param groups = \n\n{param_groups}"
+                    )
+
+    def test_default_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])
+        root = Node(children=[na, nb], params=[pc])
+        param_groups = self._get_param_groups(root)
+        self._assert_allin([pa, pb, pc], param_groups, "default")
+
+    def test_member_overrides_default_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])
+        root = Node(children=[na, nb], params=[pc], param_groups={"m1": "pb"})
+        param_groups = self._get_param_groups(root)
+        self._assert_allin([pa, pc], param_groups, "default")
+        self._assert_allin([pb], param_groups, "pb")
+
+    def test_self_overrides_member_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"})
+        root = Node(children=[na, nb], params=[pc], param_groups={"m1": "pb_member"})
+        param_groups = self._get_param_groups(root)
+        self._assert_allin([pa, pc], param_groups, "default")
+        self._assert_allin([pb], param_groups, "pb_self")
+        assert len(param_groups["pb_member"]) == 0, param_groups
+
+    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"}
+        )
+        root = Node(children=[na, nb], params=[pc], param_groups={"m1": "pb_member"})
+        param_groups = self._get_param_groups(root)
+        self._assert_allin([pa, pc], param_groups, "default")
+        self._assert_allin([pb], param_groups, "pb_self")
+        assert len(param_groups["pb_member"]) == 0, param_groups
+
+    def test_no_param_groups_defined(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])
+        root = Node(children=[na, nb], params=[pc])
+        param_groups = self._get_param_groups(root)
+        self._assert_allin([pa, pb, pc], param_groups, "default")
+
+    def test_double_dotted(self):
+        pa, pb = [torch.nn.Parameter(data=torch.tensor(i * 1.0)) for i in range(2)]
+        na = Node(params=[pa, pb])
+        nb = Node(children=[na])
+        root = Node(children=[nb], param_groups={"m0.m0.p0": "X", "m0.m0": "Y"})
+        param_groups = self._get_param_groups(root)
+        self._assert_allin([pa], param_groups, "X")
+        self._assert_allin([pb], param_groups, "Y")
+
+    def test_tree_param_groups_defined(self):
+        """
+        Test generic tree assignment.
+
+        A0
+        |---------------------------
+        |              |           |
+        Bb             M           J-
+        |-----                     |-------
+        |     |                    |      |
+        C     Ddg                  K      Ll
+              |--------------
+              |    |    |    |
+              E4   Ff   G    H-
+
+        All nodes have one parameter. Character next to the capital
+        letter means they have added something to their `parameter_groups`:
+            - small letter same as capital means self is set to that letter
+            - small letter different then capital means that member is set
+                (the one that is named like that)
+            - number means parameter's parameter_group is set like that
+            - "-" means it does not have `parameter_groups` member
+        """
+        p = [torch.nn.Parameter(data=torch.tensor(i * 1.0)) for i in range(12)]
+        L = Node(params=[p[11]], param_groups={"self": "l"})
+        K = Node(params=[p[10]], param_groups={})
+        J = Node(params=[p[9]], param_groups=None, children=[K, L])
+        M = Node(params=[p[8]], param_groups={})
+
+        E = Node(params=[p[4]], param_groups={"p0": "4"})
+        F = Node(params=[p[5]], param_groups={"self": "f"})
+        G = Node(params=[p[6]], param_groups={})
+        H = Node(params=[p[7]], param_groups=None)
+
+        D = Node(
+            params=[p[3]], param_groups={"self": "d", "m2": "g"}, children=[E, F, G, H]
+        )
+        C = Node(params=[p[2]], param_groups={})
+
+        B = Node(params=[p[1]], param_groups={"self": "b"}, children=[C, D])
+
+        A = Node(params=[p[0]], param_groups={"p0": "0"}, children=[B, M, J])
+
+        param_groups = self._get_param_groups(A)
+
+        # if parts of the group belong to two different categories assert is repeated
+        # parameter level
+        self._assert_allin([p[0]], param_groups, "0")
+        self._assert_allin([p[4]], param_groups, "4")
+        # self level
+        self._assert_allin([p[5]], param_groups, "f")
+        self._assert_allin([p[11]], param_groups, "l")
+        self._assert_allin([p[2], p[1]], param_groups, "b")
+        self._assert_allin([p[7], p[3]], param_groups, "d")
+        # member level
+        self._assert_allin([p[6]], param_groups, "g")
+        # inherit level
+        self._assert_allin([p[7], p[3]], param_groups, "d")
+        self._assert_allin([p[2], p[1]], param_groups, "b")
+        # default level
+        self._assert_allin([p[8], p[9], p[10]], param_groups, "default")
+
+
+class Node(torch.nn.Module):
+    def __init__(self, children=(), params=(), param_groups=None):
+        super().__init__()
+        for i, child in enumerate(children):
+            self.add_module("m" + str(i), child)
+        for i, param in enumerate(params):
+            setattr(self, "p" + str(i), param)
+        if param_groups is not None:
+            self.param_groups = param_groups
+
+    def __str__(self):
+        return (
+            "modules:\n" + str(self._modules) + "\nparameters\n" + str(self._parameters)
+        )

project/ManiSkill3/src/maniskill2_benchmark/cfdp_experiment/cfdp/extern/pytorch3d/projects/implicitron_trainer/tests/test_visualize.py

@@ -0,0 +1,29 @@
+# Copyright (c) Meta Platforms, Inc. and affiliates.
+# All rights reserved.
+#
+# This source code is licensed under the BSD-style license found in the
+# LICENSE file in the root directory of this source tree.
+
+# pyre-unsafe
+
+import os
+import unittest
+
+from .. import visualize_reconstruction
+from .utils import interactive_testing_requested
+
+internal = os.environ.get("FB_TEST", False)
+
+
+class TestVisualize(unittest.TestCase):
+    def test_from_defaults(self):
+        if not interactive_testing_requested():
+            return
+        checkpoint_dir = os.environ["exp_dir"]
+        argv = [
+            f"exp_dir={checkpoint_dir}",
+            "n_eval_cameras=40",
+            "render_size=[64,64]",
+            "video_size=[256,256]",
+        ]
+        visualize_reconstruction.main(argv)

project/ManiSkill3/src/maniskill2_benchmark/cfdp_experiment/cfdp/extern/pytorch3d/projects/implicitron_trainer/tests/utils.py

@@ -0,0 +1,42 @@
+# Copyright (c) Meta Platforms, Inc. and affiliates.
+# All rights reserved.
+#
+# This source code is licensed under the BSD-style license found in the
+# LICENSE file in the root directory of this source tree.
+
+# pyre-unsafe
+
+import contextlib
+import logging
+import os
+import re
+
+
+@contextlib.contextmanager
+def intercept_logs(logger_name: str, regexp: str):
+    # Intercept logs that match a regexp, from a given logger.
+    intercepted_messages = []
+    logger = logging.getLogger(logger_name)
+
+    class LoggerInterceptor(logging.Filter):
+        def filter(self, record):
+            message = record.getMessage()
+            if re.search(regexp, message):
+                intercepted_messages.append(message)
+            return True
+
+    interceptor = LoggerInterceptor()
+    logger.addFilter(interceptor)
+    try:
+        yield intercepted_messages
+    finally:
+        logger.removeFilter(interceptor)
+
+
+def interactive_testing_requested() -> bool:
+    """
+    Certain tests are only useful when run interactively, and so are not regularly run.
+    These are activated by this funciton returning True, which the user requests by
+    setting the environment variable `PYTORCH3D_INTERACTIVE_TESTING` to 1.
+    """
+    return os.environ.get("PYTORCH3D_INTERACTIVE_TESTING", "") == "1"

project/ManiSkill3/src/maniskill2_benchmark/cfdp_experiment/cfdp/extern/pytorch3d/projects/implicitron_trainer/visualize_reconstruction.py

@@ -0,0 +1,160 @@
+#!/usr/bin/env python3
+# Copyright (c) Meta Platforms, Inc. and affiliates.
+# All rights reserved.
+#
+# This source code is licensed under the BSD-style license found in the
+# LICENSE file in the root directory of this source tree.
+
+# pyre-unsafe
+
+"""
+Script to visualize a previously trained model. Example call:
+
+    pytorch3d_implicitron_visualizer \
+    exp_dir='./exps/checkpoint_dir' visdom_show_preds=True visdom_port=8097 \
+    n_eval_cameras=40 render_size="[64,64]" video_size="[256,256]"
+"""
+
+import os
+import sys
+from typing import Optional, Tuple
+
+import numpy as np
+import torch
+from omegaconf import DictConfig, OmegaConf
+from pytorch3d.implicitron.models.visualization.render_flyaround import render_flyaround
+from pytorch3d.implicitron.tools.config import enable_get_default_args, get_default_args
+
+from .experiment import Experiment
+
+
+def visualize_reconstruction(
+    exp_dir: str = "",
+    restrict_sequence_name: Optional[str] = None,
+    output_directory: Optional[str] = None,
+    render_size: Tuple[int, int] = (512, 512),
+    video_size: Optional[Tuple[int, int]] = None,
+    split: str = "train",
+    n_source_views: int = 9,
+    n_eval_cameras: int = 40,
+    visdom_show_preds: bool = False,
+    visdom_server: str = "http://127.0.0.1",
+    visdom_port: int = 8097,
+    visdom_env: Optional[str] = None,
+    **render_flyaround_kwargs,
+) -> None:
+    """
+    Given an `exp_dir` containing a trained Implicitron model, generates videos consisting
+    of renderes of sequences from the dataset used to train and evaluate the trained
+    Implicitron model.
+
+    Args:
+        exp_dir: Implicitron experiment directory.
+        restrict_sequence_name: If set, defines the list of sequences to visualize.
+        output_directory: If set, defines a custom directory to output visualizations to.
+        render_size: The size (HxW) of the generated renders.
+        video_size: The size (HxW) of the output video.
+        split: The dataset split to use for visualization.
+            Can be "train" / "val" / "test".
+        n_source_views: The number of source views added to each rendered batch. These
+            views are required inputs for models such as NeRFormer / NeRF-WCE.
+        n_eval_cameras: The number of cameras each fly-around trajectory.
+        visdom_show_preds: If `True`, outputs visualizations to visdom.
+        visdom_server: The address of the visdom server.
+        visdom_port: The port of the visdom server.
+        visdom_env: If set, defines a custom name for the visdom environment.
+        render_flyaround_kwargs: Keyword arguments passed to the invoked `render_flyaround`
+            function (see `pytorch3d.implicitron.models.visualization.render_flyaround`).
+    """
+
+    # In case an output directory is specified use it. If no output_directory
+    # is specified create a vis folder inside the experiment directory
+    if output_directory is None:
+        output_directory = os.path.join(exp_dir, "vis")
+    os.makedirs(output_directory, exist_ok=True)
+
+    # Set the random seeds
+    torch.manual_seed(0)
+    np.random.seed(0)
+
+    # Get the config from the experiment_directory,
+    # and overwrite relevant fields
+    config = _get_config_from_experiment_directory(exp_dir)
+    config.exp_dir = exp_dir
+    # important so that the CO3D dataset gets loaded in full
+    data_source_args = config.data_source_ImplicitronDataSource_args
+    if "dataset_map_provider_JsonIndexDatasetMapProvider_args" in data_source_args:
+        dataset_args = (
+            data_source_args.dataset_map_provider_JsonIndexDatasetMapProvider_args
+        )
+        dataset_args.test_on_train = False
+        if restrict_sequence_name is not None:
+            dataset_args.restrict_sequence_name = restrict_sequence_name
+
+    # Set the rendering image size
+    model_factory_args = config.model_factory_ImplicitronModelFactory_args
+    model_factory_args.force_resume = True
+    model_args = model_factory_args.model_GenericModel_args
+    model_args.render_image_width = render_size[0]
+    model_args.render_image_height = render_size[1]
+
+    # Load the previously trained model
+    experiment = Experiment(**config)
+    model = experiment.model_factory(exp_dir=exp_dir)
+    device = torch.device("cuda")
+    model.to(device)
+    model.eval()
+
+    # Setup the dataset
+    data_source = experiment.data_source
+    dataset_map, _ = data_source.get_datasets_and_dataloaders()
+    dataset = dataset_map[split]
+    if dataset is None:
+        raise ValueError(f"{split} dataset not provided")
+
+    if visdom_env is None:
+        visdom_env = (
+            "visualizer_" + config.training_loop_ImplicitronTrainingLoop_args.visdom_env
+        )
+
+    # iterate over the sequences in the dataset
+    for sequence_name in dataset.sequence_names():
+        with torch.no_grad():
+            render_kwargs = {
+                "dataset": dataset,
+                "sequence_name": sequence_name,
+                "model": model,
+                "output_video_path": os.path.join(output_directory, "video"),
+                "n_source_views": n_source_views,
+                "visdom_show_preds": visdom_show_preds,
+                "n_flyaround_poses": n_eval_cameras,
+                "visdom_server": visdom_server,
+                "visdom_port": visdom_port,
+                "visdom_environment": visdom_env,
+                "video_resize": video_size,
+                "device": device,
+                **render_flyaround_kwargs,
+            }
+            render_flyaround(**render_kwargs)
+
+
+enable_get_default_args(visualize_reconstruction)
+
+
+def _get_config_from_experiment_directory(experiment_directory) -> DictConfig:
+    cfg_file = os.path.join(experiment_directory, "expconfig.yaml")
+    config = OmegaConf.load(cfg_file)
+    # pyre-ignore[7]
+    return OmegaConf.merge(get_default_args(Experiment), config)
+
+
+def main(argv=sys.argv) -> None:
+    # automatically parses arguments of visualize_reconstruction
+    cfg = OmegaConf.create(get_default_args(visualize_reconstruction))
+    cfg.update(OmegaConf.from_cli(argv))
+    with torch.no_grad():
+        visualize_reconstruction(**cfg)
+
+
+if __name__ == "__main__":
+    main()

project/ManiSkill3/src/maniskill2_benchmark/cfdp_experiment/cfdp/extern/pytorch3d/projects/nerf/.gitignore

@@ -0,0 +1,5 @@
+checkpoints
+outputs
+data/*.png
+data/*.pth
+data/*_license.txt

project/ManiSkill3/src/maniskill2_benchmark/cfdp_experiment/cfdp/extern/pytorch3d/projects/nerf/README.md

@@ -0,0 +1,91 @@
+Neural Radiance Fields in PyTorch3D
+===================================
+
+This project implements the Neural Radiance Fields (NeRF) from [1].
+
+<img src="https://raw.githubusercontent.com/facebookresearch/pytorch3d/main/.github/nerf_project_logo.gif" width="600" height="338"/>
+
+
+Installation
+------------
+1) [Install PyTorch3D](https://github.com/facebookresearch/pytorch3d/blob/main/INSTALL.md)
+
+2) Install other dependencies:
+    - [`visdom`](https://github.com/facebookresearch/visdom)
+    - [`hydra`](https://github.com/facebookresearch/hydra)
+    - [`Pillow`](https://python-pillow.org/)
+    - [`requests`](https://pypi.org/project/requests/)
+
+    E.g. using `pip`:
+    ```
+    pip install visdom
+    pip install hydra-core --upgrade
+    pip install Pillow
+    pip install requests
+    ```
+
+    Exporting videos further requires a working `ffmpeg`.
+
+Training NeRF
+-------------
+```
+python ./train_nerf.py --config-name lego
+```
+will train the model from [1] on the Lego dataset.
+
+Note that the script outputs visualizations to `Visdom`. In order to enable this, make sure to start the visdom server (before launching the training) with the following command:
+```
+python -m visdom.server
+```
+Note that training on the "lego" scene takes roughly 24 hours on a single Tesla V100.
+
+#### Training data
+Note that the `train_nerf.py` script will automatically download the relevant dataset in case it is missing.
+
+Testing NeRF
+------------
+```
+python ./test_nerf.py --config-name lego
+```
+Will load a trained model from the `./checkpoints` directory and evaluate it on the test split of the corresponding dataset (Lego in the case above).
+
+### Exporting multi-view video of the radiance field
+Furthermore, the codebase supports generating videos of the neural radiance field.
+The following generates a turntable video of the Lego scene:
+```
+python ./test_nerf.py --config-name=lego test.mode='export_video'
+```
+Note that this requires a working `ffmpeg` for generating the video from exported frames.
+
+Additionally, note that generation of the video in the original resolution is quite slow. In order to speed up the process, one can decrease the resolution of the output video by setting the `data.image_size` flag:
+```
+python ./test_nerf.py --config-name=lego test.mode='export_video' data.image_size="[128,128]"
+```
+This will generate the video in a lower `128 x 128` resolution.
+
+
+Training & testing on other datasets
+------------------------------------
+Currently we support the following datasets:
+- lego `python ./train_nerf.py --config-name lego`
+- fern `python ./train_nerf.py --config-name fern`
+- pt3logo `python ./train_nerf.py --config-name pt3logo`
+
+The dataset files are located in the following public S3 bucket:
+https://dl.fbaipublicfiles.com/pytorch3d_nerf_data
+
+Attribution: `lego` and `fern` are data from the original code release of [1] in https://drive.google.com/drive/folders/128yBriW1IG_3NJ5Rp7APSTZsJqdJdfc1, which are hosted under the CC-BY license (https://creativecommons.org/licenses/by/4.0/) The S3 bucket files contains the same images while the camera matrices have been adjusted to follow the PyTorch3D convention.
+
+#### Quantitative results
+Below are the comparisons between our implementation and the official [`TensorFlow code`](https://github.com/bmild/nerf). The speed is measured on NVidia Quadro GP100.
+```
++----------------+------------------+------------------+-----------------+
+| Implementation |  Lego: test PSNR |  Fern: test PSNR |  training speed |
++----------------+------------------+------------------+-----------------+
+| TF (official)  |             31.0 |             27.5 |  0.24 sec/it    |
+| PyTorch3D      |             32.7 |             27.9 |  0.18 sec/it    |
++----------------+------------------+------------------+-----------------+
+```
+
+#### References
+[1] Ben Mildenhall and Pratul P. Srinivasan and Matthew Tancik and Jonathan T. Barron and Ravi Ramamoorthi and Ren Ng, NeRF: Representing Scenes as Neural Radiance Fields for View Synthesis, ECCV2020

project/ManiSkill3/src/maniskill2_benchmark/cfdp_experiment/cfdp/extern/pytorch3d/projects/nerf/__init__.py

@@ -0,0 +1,5 @@
+# Copyright (c) Meta Platforms, Inc. and affiliates.
+# All rights reserved.
+#
+# This source code is licensed under the BSD-style license found in the
+# LICENSE file in the root directory of this source tree.

project/ManiSkill3/src/maniskill2_benchmark/cfdp_experiment/cfdp/extern/pytorch3d/projects/nerf/configs/fern.yaml

@@ -0,0 +1,45 @@
+seed: 3
+resume: True
+stats_print_interval: 10
+validation_epoch_interval: 150
+checkpoint_epoch_interval: 150
+checkpoint_path: 'checkpoints/fern_pt3d.pth'
+data:
+  dataset_name: 'fern'
+  image_size: [378, 504] # [height, width]
+  precache_rays: True
+test:
+  mode: 'evaluation'
+  trajectory_type: 'figure_eight'
+  up: [0.0, 1.0, 0.0]
+  scene_center: [0.0, 0.0, -2.0]
+  n_frames: 100
+  fps: 20
+  trajectory_scale: 1.0
+optimizer:
+  max_epochs: 37500
+  lr: 0.0005
+  lr_scheduler_step_size: 12500
+  lr_scheduler_gamma: 0.1
+visualization:
+  history_size: 10
+  visdom: True
+  visdom_server: 'localhost'
+  visdom_port: 8097
+  visdom_env: 'nerf_pytorch3d'
+raysampler:
+  n_pts_per_ray: 64
+  n_pts_per_ray_fine: 64
+  n_rays_per_image: 1024
+  min_depth: 1.2
+  max_depth: 6.28
+  stratified: True
+  stratified_test: False
+  chunk_size_test: 6000
+implicit_function:
+  n_harmonic_functions_xyz: 10
+  n_harmonic_functions_dir: 4
+  n_hidden_neurons_xyz: 256
+  n_hidden_neurons_dir: 128
+  density_noise_std: 0.0
+  n_layers_xyz: 8

project/ManiSkill3/src/maniskill2_benchmark/cfdp_experiment/cfdp/extern/pytorch3d/projects/nerf/configs/lego.yaml

@@ -0,0 +1,45 @@
+seed: 3
+resume: True
+stats_print_interval: 10
+validation_epoch_interval: 30
+checkpoint_epoch_interval: 30
+checkpoint_path: 'checkpoints/lego_pt3d.pth'
+data:
+  dataset_name: 'lego'
+  image_size: [800, 800] # [height, width]
+  precache_rays: True
+test:
+  mode: 'evaluation'
+  trajectory_type: 'circular'
+  up: [0.0, 0.0, 1.0]
+  scene_center: [0.0, 0.0, 0.0]
+  n_frames: 100
+  fps: 20
+  trajectory_scale: 0.2
+optimizer:
+  max_epochs: 20000
+  lr: 0.0005
+  lr_scheduler_step_size: 5000
+  lr_scheduler_gamma: 0.1
+visualization:
+  history_size: 10
+  visdom: True
+  visdom_server: 'localhost'
+  visdom_port: 8097
+  visdom_env: 'nerf_pytorch3d'
+raysampler:
+  n_pts_per_ray: 64
+  n_pts_per_ray_fine: 64
+  n_rays_per_image: 1024
+  min_depth: 2.0
+  max_depth: 6.0
+  stratified: True
+  stratified_test: False
+  chunk_size_test: 6000
+implicit_function:
+  n_harmonic_functions_xyz: 10
+  n_harmonic_functions_dir: 4
+  n_hidden_neurons_xyz: 256
+  n_hidden_neurons_dir: 128
+  density_noise_std: 0.0
+  n_layers_xyz: 8

project/ManiSkill3/src/maniskill2_benchmark/cfdp_experiment/cfdp/extern/pytorch3d/projects/nerf/configs/pt3logo.yaml

@@ -0,0 +1,45 @@
+seed: 3
+resume: True
+stats_print_interval: 10
+validation_epoch_interval: 30
+checkpoint_epoch_interval: 30
+checkpoint_path: 'checkpoints/pt3logo_pt3d.pth'
+data:
+  dataset_name: 'pt3logo'
+  image_size: [512, 1024] # [height, width]
+  precache_rays: True
+test:
+  mode: 'export_video'
+  trajectory_type: 'figure_eight'
+  up: [0.0, -1.0, 0.0]
+  scene_center: [0.0, 0.0, 0.0]
+  n_frames: 100
+  fps: 20
+  trajectory_scale: 0.2
+optimizer:
+  max_epochs: 100000
+  lr: 0.0005
+  lr_scheduler_step_size: 10000
+  lr_scheduler_gamma: 0.1
+visualization:
+  history_size: 20
+  visdom: True
+  visdom_server: 'localhost'
+  visdom_port: 8097
+  visdom_env: 'nerf_pytorch3d'
+raysampler:
+  n_pts_per_ray: 64
+  n_pts_per_ray_fine: 64
+  n_rays_per_image: 1024
+  min_depth: 8.0
+  max_depth: 23.0
+  stratified: True
+  stratified_test: False
+  chunk_size_test: 6000
+implicit_function:
+  n_harmonic_functions_xyz: 10
+  n_harmonic_functions_dir: 4
+  n_hidden_neurons_xyz: 256
+  n_hidden_neurons_dir: 128
+  density_noise_std: 0.0
+  n_layers_xyz: 8

project/ManiSkill3/src/maniskill2_benchmark/cfdp_experiment/cfdp/extern/pytorch3d/projects/nerf/nerf/__init__.py

@@ -0,0 +1,5 @@
+# Copyright (c) Meta Platforms, Inc. and affiliates.
+# All rights reserved.
+#
+# This source code is licensed under the BSD-style license found in the
+# LICENSE file in the root directory of this source tree.

project/ManiSkill3/src/maniskill2_benchmark/cfdp_experiment/cfdp/extern/pytorch3d/projects/nerf/nerf/dataset.py

@@ -0,0 +1,166 @@
+# Copyright (c) Meta Platforms, Inc. and affiliates.
+# All rights reserved.
+#
+# This source code is licensed under the BSD-style license found in the
+# LICENSE file in the root directory of this source tree.
+
+import os
+from typing import List, Optional, Tuple
+
+import numpy as np
+import requests
+import torch
+from PIL import Image
+from pytorch3d.renderer import PerspectiveCameras
+from torch.utils.data import Dataset
+
+
+DEFAULT_DATA_ROOT = os.path.join(
+    os.path.dirname(os.path.realpath(__file__)), "..", "data"
+)
+
+DEFAULT_URL_ROOT = "https://dl.fbaipublicfiles.com/pytorch3d_nerf_data"
+
+ALL_DATASETS = ("lego", "fern", "pt3logo")
+
+
+def trivial_collate(batch):
+    """
+    A trivial collate function that merely returns the uncollated batch.
+    """
+    return batch
+
+
+class ListDataset(Dataset):
+    """
+    A simple dataset made of a list of entries.
+    """
+
+    def __init__(self, entries: List) -> None:
+        """
+        Args:
+            entries: The list of dataset entries.
+        """
+        self._entries = entries
+
+    def __len__(
+        self,
+    ) -> int:
+        return len(self._entries)
+
+    def __getitem__(self, index):
+        return self._entries[index]
+
+
+def get_nerf_datasets(
+    dataset_name: str,  # 'lego | fern'
+    image_size: Tuple[int, int],
+    data_root: str = DEFAULT_DATA_ROOT,
+    autodownload: bool = True,
+) -> Tuple[Dataset, Dataset, Dataset]:
+    """
+    Obtains the training and validation dataset object for a dataset specified
+    with the `dataset_name` argument.
+
+    Args:
+        dataset_name: The name of the dataset to load.
+        image_size: A tuple (height, width) denoting the sizes of the loaded dataset images.
+        data_root: The root folder at which the data is stored.
+        autodownload: Auto-download the dataset files in case they are missing.
+
+    Returns:
+        train_dataset: The training dataset object.
+        val_dataset: The validation dataset object.
+        test_dataset: The testing dataset object.
+    """
+
+    if dataset_name not in ALL_DATASETS:
+        raise ValueError(f"'{dataset_name}'' does not refer to a known dataset.")
+
+    print(f"Loading dataset {dataset_name}, image size={str(image_size)} ...")
+
+    cameras_path = os.path.join(data_root, dataset_name + ".pth")
+    image_path = cameras_path.replace(".pth", ".png")
+
+    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)
+
+    train_data = torch.load(cameras_path)
+    n_cameras = train_data["cameras"]["R"].shape[0]
+
+    _image_max_image_pixels = Image.MAX_IMAGE_PIXELS
+    Image.MAX_IMAGE_PIXELS = None  # The dataset image is very large ...
+    images = torch.FloatTensor(np.array(Image.open(image_path))) / 255.0
+    images = torch.stack(torch.chunk(images, n_cameras, dim=0))[..., :3]
+    Image.MAX_IMAGE_PIXELS = _image_max_image_pixels
+
+    scale_factors = [s_new / s for s, s_new in zip(images.shape[1:3], image_size)]
+    if abs(scale_factors[0] - scale_factors[1]) > 1e-3:
+        raise ValueError(
+            "Non-isotropic scaling is not allowed. Consider changing the 'image_size' argument."
+        )
+    scale_factor = sum(scale_factors) * 0.5
+
+    if scale_factor != 1.0:
+        print(f"Rescaling dataset (factor={scale_factor})")
+        images = torch.nn.functional.interpolate(
+            images.permute(0, 3, 1, 2),
+            size=tuple(image_size),
+            mode="bilinear",
+        ).permute(0, 2, 3, 1)
+
+    cameras = [
+        PerspectiveCameras(
+            **{k: v[cami][None] for k, v in train_data["cameras"].items()}
+        ).to("cpu")
+        for cami in range(n_cameras)
+    ]
+
+    train_idx, val_idx, test_idx = train_data["split"]
+
+    train_dataset, val_dataset, test_dataset = [
+        ListDataset(
+            [
+                {"image": images[i], "camera": cameras[i], "camera_idx": int(i)}
+                for i in idx
+            ]
+        )
+        for idx in [train_idx, val_idx, test_idx]
+    ]
+
+    return train_dataset, val_dataset, test_dataset
+
+
+def download_data(
+    dataset_names: Optional[List[str]] = None,
+    data_root: str = DEFAULT_DATA_ROOT,
+    url_root: str = DEFAULT_URL_ROOT,
+) -> None:
+    """
+    Downloads the relevant dataset files.
+
+    Args:
+        dataset_names: A list of the names of datasets to download. If `None`,
+            downloads all available datasets.
+    """
+
+    if dataset_names is None:
+        dataset_names = ALL_DATASETS
+
+    os.makedirs(data_root, exist_ok=True)
+
+    for dataset_name in dataset_names:
+        cameras_file = dataset_name + ".pth"
+        images_file = cameras_file.replace(".pth", ".png")
+        license_file = cameras_file.replace(".pth", "_license.txt")
+
+        for fl in (cameras_file, images_file, license_file):
+            local_fl = os.path.join(data_root, fl)
+            remote_fl = os.path.join(url_root, fl)
+
+            print(f"Downloading dataset {dataset_name} from {remote_fl} to {local_fl}.")
+
+            r = requests.get(remote_fl)
+            with open(local_fl, "wb") as f:
+                f.write(r.content)

project/ManiSkill3/src/maniskill2_benchmark/cfdp_experiment/cfdp/extern/pytorch3d/projects/nerf/nerf/eval_video_utils.py

@@ -0,0 +1,158 @@
+# Copyright (c) Meta Platforms, Inc. and affiliates.
+# All rights reserved.
+#
+# This source code is licensed under the BSD-style license found in the
+# LICENSE file in the root directory of this source tree.
+
+import math
+from typing import Tuple
+
+import torch
+from pytorch3d.renderer import look_at_view_transform, PerspectiveCameras
+from torch.utils.data.dataset import Dataset
+
+
+def generate_eval_video_cameras(
+    train_dataset,
+    n_eval_cams: int = 100,
+    trajectory_type: str = "figure_eight",
+    trajectory_scale: float = 0.2,
+    scene_center: Tuple[float, float, float] = (0.0, 0.0, 0.0),
+    up: Tuple[float, float, float] = (0.0, 0.0, 1.0),
+) -> Dataset[torch.Tensor]:
+    """
+    Generate a camera trajectory for visualizing a NeRF model.
+
+    Args:
+        train_dataset: The training dataset object.
+        n_eval_cams: Number of cameras in the trajectory.
+        trajectory_type: The type of the camera trajectory. Can be one of:
+            circular: Rotating around the center of the scene at a fixed radius.
+            figure_eight: Figure-of-8 trajectory around the center of the
+                central camera of the training dataset.
+            trefoil_knot: Same as 'figure_eight', but the trajectory has a shape
+                of a trefoil knot (https://en.wikipedia.org/wiki/Trefoil_knot).
+            figure_eight_knot: Same as 'figure_eight', but the trajectory has a shape
+                of a figure-eight knot
+                (https://en.wikipedia.org/wiki/Figure-eight_knot_(mathematics)).
+        trajectory_scale: The extent of the trajectory.
+        up: The "up" vector of the scene (=the normal of the scene floor).
+            Active for the `trajectory_type="circular"`.
+        scene_center: The center of the scene in world coordinates which all
+            the cameras from the generated trajectory look at.
+    Returns:
+        Dictionary of camera instances which can be used as the test dataset
+    """
+    if trajectory_type in ("figure_eight", "trefoil_knot", "figure_eight_knot"):
+        cam_centers = torch.cat(
+            [e["camera"].get_camera_center() for e in train_dataset]
+        )
+        # get the nearest camera center to the mean of centers
+        mean_camera_idx = (
+            ((cam_centers - cam_centers.mean(dim=0)[None]) ** 2)
+            .sum(dim=1)
+            .min(dim=0)
+            .indices
+        )
+        # generate the knot trajectory in canonical coords
+        time = torch.linspace(0, 2 * math.pi, n_eval_cams + 1)[:n_eval_cams]
+        if trajectory_type == "trefoil_knot":
+            traj = _trefoil_knot(time)
+        elif trajectory_type == "figure_eight_knot":
+            traj = _figure_eight_knot(time)
+        elif trajectory_type == "figure_eight":
+            traj = _figure_eight(time)
+        traj[:, 2] -= traj[:, 2].max()
+
+        # transform the canonical knot to the coord frame of the mean camera
+        traj_trans = (
+            train_dataset[mean_camera_idx]["camera"]
+            .get_world_to_view_transform()
+            .inverse()
+        )
+        traj_trans = traj_trans.scale(cam_centers.std(dim=0).mean() * trajectory_scale)
+        traj = traj_trans.transform_points(traj)
+
+    elif trajectory_type == "circular":
+        cam_centers = torch.cat(
+            [e["camera"].get_camera_center() for e in train_dataset]
+        )
+
+        # fit plane to the camera centers
+        plane_mean = cam_centers.mean(dim=0)
+        cam_centers_c = cam_centers - plane_mean[None]
+
+        if up is not None:
+            # us the up vector instead of the plane through the camera centers
+            plane_normal = torch.FloatTensor(up)
+        else:
+            cov = (cam_centers_c.t() @ cam_centers_c) / cam_centers_c.shape[0]
+            _, e_vec = torch.linalg.eigh(cov, UPLO="U")
+            plane_normal = e_vec[:, 0]
+
+        plane_dist = (plane_normal[None] * cam_centers_c).sum(dim=-1)
+        cam_centers_on_plane = cam_centers_c - plane_dist[:, None] * plane_normal[None]
+
+        cov = (
+            cam_centers_on_plane.t() @ cam_centers_on_plane
+        ) / cam_centers_on_plane.shape[0]
+        _, e_vec = torch.linalg.eigh(cov, UPLO="U")
+        traj_radius = (cam_centers_on_plane**2).sum(dim=1).sqrt().mean()
+        angle = torch.linspace(0, 2.0 * math.pi, n_eval_cams)
+        traj = traj_radius * torch.stack(
+            (torch.zeros_like(angle), angle.cos(), angle.sin()), dim=-1
+        )
+        traj = traj @ e_vec.t() + plane_mean[None]
+
+    else:
+        raise ValueError(f"Unknown trajectory_type {trajectory_type}.")
+
+    # point all cameras towards the center of the scene
+    R, T = look_at_view_transform(
+        eye=traj,
+        at=(scene_center,),  # (1, 3)
+        up=(up,),  # (1, 3)
+        device=traj.device,
+    )
+
+    # get the average focal length and principal point
+    focal = torch.cat([e["camera"].focal_length for e in train_dataset]).mean(dim=0)
+    p0 = torch.cat([e["camera"].principal_point for e in train_dataset]).mean(dim=0)
+
+    # assemble the dataset
+    test_dataset = [
+        {
+            "image": None,
+            "camera": PerspectiveCameras(
+                focal_length=focal[None],
+                principal_point=p0[None],
+                R=R_[None],
+                T=T_[None],
+            ),
+            "camera_idx": i,
+        }
+        for i, (R_, T_) in enumerate(zip(R, T))
+    ]
+
+    return test_dataset
+
+
+def _figure_eight_knot(t: torch.Tensor, z_scale: float = 0.5):
+    x = (2 + (2 * t).cos()) * (3 * t).cos()
+    y = (2 + (2 * t).cos()) * (3 * t).sin()
+    z = (4 * t).sin() * z_scale
+    return torch.stack((x, y, z), dim=-1)
+
+
+def _trefoil_knot(t: torch.Tensor, z_scale: float = 0.5):
+    x = t.sin() + 2 * (2 * t).sin()
+    y = t.cos() - 2 * (2 * t).cos()
+    z = -(3 * t).sin() * z_scale
+    return torch.stack((x, y, z), dim=-1)
+
+
+def _figure_eight(t: torch.Tensor, z_scale: float = 0.5):
+    x = t.cos()
+    y = (2 * t).sin() / 2
+    z = t.sin() * z_scale
+    return torch.stack((x, y, z), dim=-1)

project/ManiSkill3/src/maniskill2_benchmark/cfdp_experiment/cfdp/extern/pytorch3d/projects/nerf/nerf/implicit_function.py

@@ -0,0 +1,301 @@
+# Copyright (c) Meta Platforms, Inc. and affiliates.
+# All rights reserved.
+#
+# This source code is licensed under the BSD-style license found in the
+# LICENSE file in the root directory of this source tree.
+
+from typing import Tuple
+
+import torch
+from pytorch3d.common.linear_with_repeat import LinearWithRepeat
+from pytorch3d.renderer import HarmonicEmbedding, ray_bundle_to_ray_points, RayBundle
+
+
+def _xavier_init(linear):
+    """
+    Performs the Xavier weight initialization of the linear layer `linear`.
+    """
+    torch.nn.init.xavier_uniform_(linear.weight.data)
+
+
+class NeuralRadianceField(torch.nn.Module):
+    def __init__(
+        self,
+        n_harmonic_functions_xyz: int = 6,
+        n_harmonic_functions_dir: int = 4,
+        n_hidden_neurons_xyz: int = 256,
+        n_hidden_neurons_dir: int = 128,
+        n_layers_xyz: int = 8,
+        append_xyz: Tuple[int, ...] = (5,),
+        use_multiple_streams: bool = True,
+        **kwargs,
+    ):
+        """
+        Args:
+            n_harmonic_functions_xyz: The number of harmonic functions
+                used to form the harmonic embedding of 3D point locations.
+            n_harmonic_functions_dir: The number of harmonic functions
+                used to form the harmonic embedding of the ray directions.
+            n_hidden_neurons_xyz: The number of hidden units in the
+                fully connected layers of the MLP that accepts the 3D point
+                locations and outputs the occupancy field with the intermediate
+                features.
+            n_hidden_neurons_dir: The number of hidden units in the
+                fully connected layers of the MLP that accepts the intermediate
+                features and ray directions and outputs the radiance field
+                (per-point colors).
+            n_layers_xyz: The number of layers of the MLP that outputs the
+                occupancy field.
+            append_xyz: The list of indices of the skip layers of the occupancy MLP.
+            use_multiple_streams: Whether density and color should be calculated on
+                separate CUDA streams.
+        """
+        super().__init__()
+
+        # The harmonic embedding layer converts input 3D coordinates
+        # to a representation that is more suitable for
+        # processing with a deep neural network.
+        self.harmonic_embedding_xyz = HarmonicEmbedding(n_harmonic_functions_xyz)
+        self.harmonic_embedding_dir = HarmonicEmbedding(n_harmonic_functions_dir)
+        embedding_dim_xyz = n_harmonic_functions_xyz * 2 * 3 + 3
+        embedding_dim_dir = n_harmonic_functions_dir * 2 * 3 + 3
+
+        self.mlp_xyz = MLPWithInputSkips(
+            n_layers_xyz,
+            embedding_dim_xyz,
+            n_hidden_neurons_xyz,
+            embedding_dim_xyz,
+            n_hidden_neurons_xyz,
+            input_skips=append_xyz,
+        )
+
+        self.intermediate_linear = torch.nn.Linear(
+            n_hidden_neurons_xyz, n_hidden_neurons_xyz
+        )
+        _xavier_init(self.intermediate_linear)
+
+        self.density_layer = torch.nn.Linear(n_hidden_neurons_xyz, 1)
+        _xavier_init(self.density_layer)
+
+        # Zero the bias of the density layer to avoid
+        # a completely transparent initialization.
+        self.density_layer.bias.data[:] = 0.0  # fixme: Sometimes this is not enough
+
+        self.color_layer = torch.nn.Sequential(
+            LinearWithRepeat(
+                n_hidden_neurons_xyz + embedding_dim_dir, n_hidden_neurons_dir
+            ),
+            torch.nn.ReLU(True),
+            torch.nn.Linear(n_hidden_neurons_dir, 3),
+            torch.nn.Sigmoid(),
+        )
+        self.use_multiple_streams = use_multiple_streams
+
+    def _get_densities(
+        self,
+        features: torch.Tensor,
+        depth_values: torch.Tensor,
+        density_noise_std: float,
+    ) -> torch.Tensor:
+        """
+        This function takes `features` predicted by `self.mlp_xyz`
+        and converts them to `raw_densities` with `self.density_layer`.
+        `raw_densities` are later re-weighted using the depth step sizes
+        and mapped to [0-1] range with 1 - inverse exponential of `raw_densities`.
+        """
+        raw_densities = self.density_layer(features)
+        deltas = torch.cat(
+            (
+                depth_values[..., 1:] - depth_values[..., :-1],
+                1e10 * torch.ones_like(depth_values[..., :1]),
+            ),
+            dim=-1,
+        )[..., None]
+        if density_noise_std > 0.0:
+            raw_densities = (
+                raw_densities + torch.randn_like(raw_densities) * density_noise_std
+            )
+        densities = 1 - (-deltas * torch.relu(raw_densities)).exp()
+        return densities
+
+    def _get_colors(
+        self, features: torch.Tensor, rays_directions: torch.Tensor
+    ) -> torch.Tensor:
+        """
+        This function takes per-point `features` predicted by `self.mlp_xyz`
+        and evaluates the color model in order to attach to each
+        point a 3D vector of its RGB color.
+        """
+        # Normalize the ray_directions to unit l2 norm.
+        rays_directions_normed = torch.nn.functional.normalize(rays_directions, dim=-1)
+
+        # Obtain the harmonic embedding of the normalized ray directions.
+        rays_embedding = self.harmonic_embedding_dir(rays_directions_normed)
+
+        return self.color_layer((self.intermediate_linear(features), rays_embedding))
+
+    def _get_densities_and_colors(
+        self, features: torch.Tensor, ray_bundle: RayBundle, density_noise_std: float
+    ) -> Tuple[torch.Tensor, torch.Tensor]:
+        """
+        The second part of the forward calculation.
+
+        Args:
+            features: the output of the common mlp (the prior part of the
+                calculation), shape
+                (minibatch x ... x self.n_hidden_neurons_xyz).
+            ray_bundle: As for forward().
+            density_noise_std:  As for forward().
+
+        Returns:
+            rays_densities: A tensor of shape `(minibatch, ..., num_points_per_ray, 1)`
+                denoting the opacity of each ray point.
+            rays_colors: A tensor of shape `(minibatch, ..., num_points_per_ray, 3)`
+                denoting the color of each ray point.
+        """
+        if self.use_multiple_streams and features.is_cuda:
+            current_stream = torch.cuda.current_stream(features.device)
+            other_stream = torch.cuda.Stream(features.device)
+            other_stream.wait_stream(current_stream)
+
+            with torch.cuda.stream(other_stream):
+                rays_densities = self._get_densities(
+                    features, ray_bundle.lengths, density_noise_std
+                )
+                # rays_densities.shape = [minibatch x ... x 1] in [0-1]
+
+            rays_colors = self._get_colors(features, ray_bundle.directions)
+            # rays_colors.shape = [minibatch x ... x 3] in [0-1]
+
+            current_stream.wait_stream(other_stream)
+        else:
+            # Same calculation as above, just serial.
+            rays_densities = self._get_densities(
+                features, ray_bundle.lengths, density_noise_std
+            )
+            rays_colors = self._get_colors(features, ray_bundle.directions)
+        return rays_densities, rays_colors
+
+    def forward(
+        self,
+        ray_bundle: RayBundle,
+        density_noise_std: float = 0.0,
+        **kwargs,
+    ) -> Tuple[torch.Tensor, torch.Tensor]:
+        """
+        The forward function accepts the parametrizations of
+        3D points sampled along projection rays. The forward
+        pass is responsible for attaching a 3D vector
+        and a 1D scalar representing the point's
+        RGB color and opacity respectively.
+
+        Args:
+            ray_bundle: A RayBundle object containing the following variables:
+                origins: A tensor of shape `(minibatch, ..., 3)` denoting the
+                    origins of the sampling rays in world coords.
+                directions: A tensor of shape `(minibatch, ..., 3)`
+                    containing the direction vectors of sampling rays in world coords.
+                lengths: A tensor of shape `(minibatch, ..., num_points_per_ray)`
+                    containing the lengths at which the rays are sampled.
+            density_noise_std: A floating point value representing the
+                variance of the random normal noise added to the output of
+                the opacity function. This can prevent floating artifacts.
+
+        Returns:
+            rays_densities: A tensor of shape `(minibatch, ..., num_points_per_ray, 1)`
+                denoting the opacity of each ray point.
+            rays_colors: A tensor of shape `(minibatch, ..., num_points_per_ray, 3)`
+                denoting the color of each ray point.
+        """
+        # We first convert the ray parametrizations to world
+        # coordinates with `ray_bundle_to_ray_points`.
+        rays_points_world = ray_bundle_to_ray_points(ray_bundle)
+        # rays_points_world.shape = [minibatch x ... x 3]
+
+        # For each 3D world coordinate, we obtain its harmonic embedding.
+        embeds_xyz = self.harmonic_embedding_xyz(rays_points_world)
+        # embeds_xyz.shape = [minibatch x ... x self.n_harmonic_functions*6 + 3]
+
+        # self.mlp maps each harmonic embedding to a latent feature space.
+        features = self.mlp_xyz(embeds_xyz, embeds_xyz)
+        # features.shape = [minibatch x ... x self.n_hidden_neurons_xyz]
+
+        rays_densities, rays_colors = self._get_densities_and_colors(
+            features, ray_bundle, density_noise_std
+        )
+        return rays_densities, rays_colors
+
+
+class MLPWithInputSkips(torch.nn.Module):
+    """
+    Implements the multi-layer perceptron architecture of the Neural Radiance Field.
+
+    As such, `MLPWithInputSkips` is a multi layer perceptron consisting
+    of a sequence of linear layers with ReLU activations.
+
+    Additionally, for a set of predefined layers `input_skips`, the forward pass
+    appends a skip tensor `z` to the output of the preceding layer.
+
+    Note that this follows the architecture described in the Supplementary
+    Material (Fig. 7) of [1].
+
+    References:
+        [1] Ben Mildenhall and Pratul P. Srinivasan and Matthew Tancik
+            and Jonathan T. Barron and Ravi Ramamoorthi and Ren Ng:
+            NeRF: Representing Scenes as Neural Radiance Fields for View
+            Synthesis, ECCV2020
+    """
+
+    def __init__(
+        self,
+        n_layers: int,
+        input_dim: int,
+        output_dim: int,
+        skip_dim: int,
+        hidden_dim: int,
+        input_skips: Tuple[int, ...] = (),
+    ):
+        """
+        Args:
+            n_layers: The number of linear layers of the MLP.
+            input_dim: The number of channels of the input tensor.
+            output_dim: The number of channels of the output.
+            skip_dim: The number of channels of the tensor `z` appended when
+                evaluating the skip layers.
+            hidden_dim: The number of hidden units of the MLP.
+            input_skips: The list of layer indices at which we append the skip
+                tensor `z`.
+        """
+        super().__init__()
+        layers = []
+        for layeri in range(n_layers):
+            if layeri == 0:
+                dimin = input_dim
+                dimout = hidden_dim
+            elif layeri in input_skips:
+                dimin = hidden_dim + skip_dim
+                dimout = hidden_dim
+            else:
+                dimin = hidden_dim
+                dimout = hidden_dim
+            linear = torch.nn.Linear(dimin, dimout)
+            _xavier_init(linear)
+            layers.append(torch.nn.Sequential(linear, torch.nn.ReLU(True)))
+        self.mlp = torch.nn.ModuleList(layers)
+        self._input_skips = set(input_skips)
+
+    def forward(self, x: torch.Tensor, z: torch.Tensor) -> torch.Tensor:
+        """
+        Args:
+            x: The input tensor of shape `(..., input_dim)`.
+            z: The input skip tensor of shape `(..., skip_dim)` which is appended
+                to layers whose indices are specified by `input_skips`.
+        Returns:
+            y: The output tensor of shape `(..., output_dim)`.
+        """
+        y = x
+        for li, layer in enumerate(self.mlp):
+            if li in self._input_skips:
+                y = torch.cat((y, z), dim=-1)
+            y = layer(y)
+        return y

project/ManiSkill3/src/maniskill2_benchmark/cfdp_experiment/cfdp/extern/pytorch3d/projects/nerf/nerf/nerf_renderer.py

@@ -0,0 +1,436 @@
+# Copyright (c) Meta Platforms, Inc. and affiliates.
+# All rights reserved.
+#
+# This source code is licensed under the BSD-style license found in the
+# LICENSE file in the root directory of this source tree.
+
+from typing import List, Optional, Tuple
+
+import torch
+from pytorch3d.renderer import ImplicitRenderer, ray_bundle_to_ray_points
+from pytorch3d.renderer.cameras import CamerasBase
+from pytorch3d.structures import Pointclouds
+from pytorch3d.vis.plotly_vis import plot_scene
+from visdom import Visdom
+
+from .implicit_function import NeuralRadianceField
+from .raymarcher import EmissionAbsorptionNeRFRaymarcher
+from .raysampler import NeRFRaysampler, ProbabilisticRaysampler
+from .utils import calc_mse, calc_psnr, sample_images_at_mc_locs
+
+
+class RadianceFieldRenderer(torch.nn.Module):
+    """
+    Implements a renderer of a Neural Radiance Field.
+
+    This class holds pointers to the fine and coarse renderer objects, which are
+    instances of `pytorch3d.renderer.ImplicitRenderer`, and pointers to the
+    neural networks representing the fine and coarse Neural Radiance Fields,
+    which are instances of `NeuralRadianceField`.
+
+    The rendering forward pass proceeds as follows:
+        1) For a given input camera, rendering rays are generated with the
+            `NeRFRaysampler` object of `self._renderer['coarse']`.
+            In the training mode (`self.training==True`), the rays are a set
+                of `n_rays_per_image` random 2D locations of the image grid.
+            In the evaluation mode (`self.training==False`), the rays correspond
+                to the full image grid. The rays are further split to
+                `chunk_size_test`-sized chunks to prevent out-of-memory errors.
+        2) For each ray point, the coarse `NeuralRadianceField` MLP is evaluated.
+            The pointer to this MLP is stored in `self._implicit_function['coarse']`
+        3) The coarse radiance field is rendered with the
+            `EmissionAbsorptionNeRFRaymarcher` object of `self._renderer['coarse']`.
+        4) The coarse raymarcher outputs a probability distribution that guides
+            the importance raysampling of the fine rendering pass. The
+            `ProbabilisticRaysampler` stored in `self._renderer['fine'].raysampler`
+            implements the importance ray-sampling.
+        5) Similar to 2) the fine MLP in `self._implicit_function['fine']`
+            labels the ray points with occupancies and colors.
+        6) self._renderer['fine'].raymarcher` generates the final fine render.
+        7) The fine and coarse renders are compared to the ground truth input image
+            with PSNR and MSE metrics.
+    """
+
+    def __init__(
+        self,
+        image_size: Tuple[int, int],
+        n_pts_per_ray: int,
+        n_pts_per_ray_fine: int,
+        n_rays_per_image: int,
+        min_depth: float,
+        max_depth: float,
+        stratified: bool,
+        stratified_test: bool,
+        chunk_size_test: int,
+        n_harmonic_functions_xyz: int = 6,
+        n_harmonic_functions_dir: int = 4,
+        n_hidden_neurons_xyz: int = 256,
+        n_hidden_neurons_dir: int = 128,
+        n_layers_xyz: int = 8,
+        append_xyz: Tuple[int, ...] = (5,),
+        density_noise_std: float = 0.0,
+        visualization: bool = False,
+    ):
+        """
+        Args:
+            image_size: The size of the rendered image (`[height, width]`).
+            n_pts_per_ray: The number of points sampled along each ray for the
+                coarse rendering pass.
+            n_pts_per_ray_fine: The number of points sampled along each ray for the
+                fine rendering pass.
+            n_rays_per_image: Number of Monte Carlo ray samples when training
+                (`self.training==True`).
+            min_depth: The minimum depth of a sampled ray-point for the coarse rendering.
+            max_depth: The maximum depth of a sampled ray-point for the coarse rendering.
+            stratified: If `True`, stratifies (=randomly offsets) the depths
+                of each ray point during training (`self.training==True`).
+            stratified_test: If `True`, stratifies (=randomly offsets) the depths
+                of each ray point during evaluation (`self.training==False`).
+            chunk_size_test: The number of rays in each chunk of image rays.
+                Active only when `self.training==True`.
+            n_harmonic_functions_xyz: The number of harmonic functions
+                used to form the harmonic embedding of 3D point locations.
+            n_harmonic_functions_dir: The number of harmonic functions
+                used to form the harmonic embedding of the ray directions.
+            n_hidden_neurons_xyz: The number of hidden units in the
+                fully connected layers of the MLP that accepts the 3D point
+                locations and outputs the occupancy field with the intermediate
+                features.
+            n_hidden_neurons_dir: The number of hidden units in the
+                fully connected layers of the MLP that accepts the intermediate
+                features and ray directions and outputs the radiance field
+                (per-point colors).
+            n_layers_xyz: The number of layers of the MLP that outputs the
+                occupancy field.
+            append_xyz: The list of indices of the skip layers of the occupancy MLP.
+                Prior to evaluating the skip layers, the tensor which was input to MLP
+                is appended to the skip layer input.
+            density_noise_std: The standard deviation of the random normal noise
+                added to the output of the occupancy MLP.
+                Active only when `self.training==True`.
+            visualization: whether to store extra output for visualization.
+        """
+
+        super().__init__()
+
+        # The renderers and implicit functions are stored under the fine/coarse
+        # keys in ModuleDict PyTorch modules.
+        self._renderer = torch.nn.ModuleDict()
+        self._implicit_function = torch.nn.ModuleDict()
+
+        # Init the EA raymarcher used by both passes.
+        raymarcher = EmissionAbsorptionNeRFRaymarcher()
+
+        # Parse out image dimensions.
+        image_height, image_width = image_size
+
+        for render_pass in ("coarse", "fine"):
+            if render_pass == "coarse":
+                # Initialize the coarse raysampler.
+                raysampler = NeRFRaysampler(
+                    n_pts_per_ray=n_pts_per_ray,
+                    min_depth=min_depth,
+                    max_depth=max_depth,
+                    stratified=stratified,
+                    stratified_test=stratified_test,
+                    n_rays_per_image=n_rays_per_image,
+                    image_height=image_height,
+                    image_width=image_width,
+                )
+            elif render_pass == "fine":
+                # Initialize the fine raysampler.
+                raysampler = ProbabilisticRaysampler(
+                    n_pts_per_ray=n_pts_per_ray_fine,
+                    stratified=stratified,
+                    stratified_test=stratified_test,
+                )
+            else:
+                raise ValueError(f"No such rendering pass {render_pass}")
+
+            # Initialize the fine/coarse renderer.
+            self._renderer[render_pass] = ImplicitRenderer(
+                raysampler=raysampler,
+                raymarcher=raymarcher,
+            )
+
+            # Instantiate the fine/coarse NeuralRadianceField module.
+            self._implicit_function[render_pass] = NeuralRadianceField(
+                n_harmonic_functions_xyz=n_harmonic_functions_xyz,
+                n_harmonic_functions_dir=n_harmonic_functions_dir,
+                n_hidden_neurons_xyz=n_hidden_neurons_xyz,
+                n_hidden_neurons_dir=n_hidden_neurons_dir,
+                n_layers_xyz=n_layers_xyz,
+                append_xyz=append_xyz,
+            )
+
+        self._density_noise_std = density_noise_std
+        self._chunk_size_test = chunk_size_test
+        self._image_size = image_size
+        self.visualization = visualization
+
+    def precache_rays(
+        self,
+        cache_cameras: List[CamerasBase],
+        cache_camera_hashes: List[str],
+    ):
+        """
+        Precaches the rays emitted from the list of cameras `cache_cameras`,
+        where each camera is uniquely identified with the corresponding hash
+        from `cache_camera_hashes`.
+
+        The cached rays are moved to cpu and stored in
+        `self._renderer['coarse']._ray_cache`.
+
+        Raises `ValueError` when caching two cameras with the same hash.
+
+        Args:
+            cache_cameras: A list of `N` cameras for which the rays are pre-cached.
+            cache_camera_hashes: A list of `N` unique identifiers for each
+                camera from `cameras`.
+        """
+        self._renderer["coarse"].raysampler.precache_rays(
+            cache_cameras,
+            cache_camera_hashes,
+        )
+
+    def _process_ray_chunk(
+        self,
+        camera_hash: Optional[str],
+        camera: CamerasBase,
+        image: torch.Tensor,
+        chunk_idx: int,
+    ) -> dict:
+        """
+        Samples and renders a chunk of rays.
+
+        Args:
+            camera_hash: A unique identifier of a pre-cached camera.
+                If `None`, the cache is not searched and the sampled rays are
+                calculated from scratch.
+            camera: A batch of cameras from which the scene is rendered.
+            image: A batch of corresponding ground truth images of shape
+                ('batch_size', ·, ·, 3).
+            chunk_idx: The index of the currently rendered ray chunk.
+        Returns:
+            out: `dict` containing the outputs of the rendering:
+                `rgb_coarse`: The result of the coarse rendering pass.
+                `rgb_fine`: The result of the fine rendering pass.
+                `rgb_gt`: The corresponding ground-truth RGB values.
+        """
+        # Initialize the outputs of the coarse rendering to None.
+        coarse_ray_bundle = None
+        coarse_weights = None
+
+        # First evaluate the coarse rendering pass, then the fine one.
+        for renderer_pass in ("coarse", "fine"):
+            (rgb, weights), ray_bundle_out = self._renderer[renderer_pass](
+                cameras=camera,
+                volumetric_function=self._implicit_function[renderer_pass],
+                chunksize=self._chunk_size_test,
+                chunk_idx=chunk_idx,
+                density_noise_std=(self._density_noise_std if self.training else 0.0),
+                input_ray_bundle=coarse_ray_bundle,
+                ray_weights=coarse_weights,
+                camera_hash=camera_hash,
+            )
+
+            if renderer_pass == "coarse":
+                rgb_coarse = rgb
+                # Store the weights and the rays of the first rendering pass
+                # for the ensuing importance ray-sampling of the fine render.
+                coarse_ray_bundle = ray_bundle_out
+                coarse_weights = weights
+                if image is not None:
+                    # Sample the ground truth images at the xy locations of the
+                    # rendering ray pixels.
+                    rgb_gt = sample_images_at_mc_locs(
+                        image[..., :3][None],
+                        ray_bundle_out.xys,
+                    )
+                else:
+                    rgb_gt = None
+
+            elif renderer_pass == "fine":
+                rgb_fine = rgb
+
+            else:
+                raise ValueError(f"No such rendering pass {renderer_pass}")
+
+        out = {"rgb_fine": rgb_fine, "rgb_coarse": rgb_coarse, "rgb_gt": rgb_gt}
+        if self.visualization:
+            # Store the coarse rays/weights only for visualization purposes.
+            out["coarse_ray_bundle"] = type(coarse_ray_bundle)(
+                *[v.detach().cpu() for k, v in coarse_ray_bundle._asdict().items()]
+            )
+            out["coarse_weights"] = coarse_weights.detach().cpu()
+
+        return out
+
+    def forward(
+        self,
+        camera_hash: Optional[str],
+        camera: CamerasBase,
+        image: torch.Tensor,
+    ) -> Tuple[dict, dict]:
+        """
+        Performs the coarse and fine rendering passes of the radiance field
+        from the viewpoint of the input `camera`.
+        Afterwards, both renders are compared to the input ground truth `image`
+        by evaluating the peak signal-to-noise ratio and the mean-squared error.
+
+        The rendering result depends on the `self.training` flag:
+            - In the training mode (`self.training==True`), the function renders
+              a random subset of image rays (Monte Carlo rendering).
+            - In evaluation mode (`self.training==False`), the function renders
+              the full image. In order to prevent out-of-memory errors,
+              when `self.training==False`, the rays are sampled and rendered
+              in batches of size `chunksize`.
+
+        Args:
+            camera_hash: A unique identifier of a pre-cached camera.
+                If `None`, the cache is not searched and the sampled rays are
+                calculated from scratch.
+            camera: A batch of cameras from which the scene is rendered.
+            image: A batch of corresponding ground truth images of shape
+                ('batch_size', ·, ·, 3).
+        Returns:
+            out: `dict` containing the outputs of the rendering:
+                `rgb_coarse`: The result of the coarse rendering pass.
+                `rgb_fine`: The result of the fine rendering pass.
+                `rgb_gt`: The corresponding ground-truth RGB values.
+
+                The shape of `rgb_coarse`, `rgb_fine`, `rgb_gt` depends on the
+                `self.training` flag:
+                    If `==True`, all 3 tensors are of shape
+                    `(batch_size, n_rays_per_image, 3)` and contain the result
+                    of the Monte Carlo training rendering pass.
+                    If `==False`, all 3 tensors are of shape
+                    `(batch_size, image_size[0], image_size[1], 3)` and contain
+                    the result of the full image rendering pass.
+            metrics: `dict` containing the error metrics comparing the fine and
+                coarse renders to the ground truth:
+                `mse_coarse`: Mean-squared error between the coarse render and
+                    the input `image`
+                `mse_fine`: Mean-squared error between the fine render and
+                    the input `image`
+                `psnr_coarse`: Peak signal-to-noise ratio between the coarse render and
+                    the input `image`
+                `psnr_fine`: Peak signal-to-noise ratio between the fine render and
+                    the input `image`
+        """
+        if not self.training:
+            # Full evaluation pass.
+            n_chunks = self._renderer["coarse"].raysampler.get_n_chunks(
+                self._chunk_size_test,
+                camera.R.shape[0],
+            )
+        else:
+            # MonteCarlo ray sampling.
+            n_chunks = 1
+
+        # Process the chunks of rays.
+        chunk_outputs = [
+            self._process_ray_chunk(
+                camera_hash,
+                camera,
+                image,
+                chunk_idx,
+            )
+            for chunk_idx in range(n_chunks)
+        ]
+
+        if not self.training:
+            # 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
+                )
+                for k in ("rgb_fine", "rgb_coarse", "rgb_gt")
+            }
+        else:
+            out = chunk_outputs[0]
+
+        # Calc the error metrics.
+        metrics = {}
+        if image is not None:
+            for render_pass in ("coarse", "fine"):
+                for metric_name, metric_fun in zip(
+                    ("mse", "psnr"), (calc_mse, calc_psnr)
+                ):
+                    metrics[f"{metric_name}_{render_pass}"] = metric_fun(
+                        out["rgb_" + render_pass][..., :3],
+                        out["rgb_gt"][..., :3],
+                    )
+
+        return out, metrics
+
+
+def visualize_nerf_outputs(
+    nerf_out: dict, output_cache: List, viz: Visdom, visdom_env: str
+):
+    """
+    Visualizes the outputs of the `RadianceFieldRenderer`.
+
+    Args:
+        nerf_out: An output of the validation rendering pass.
+        output_cache: A list with outputs of several training render passes.
+        viz: A visdom connection object.
+        visdom_env: The name of visdom environment for visualization.
+    """
+
+    # Show the training images.
+    ims = torch.stack([o["image"] for o in output_cache])
+    ims = torch.cat(list(ims), dim=1)
+    viz.image(
+        ims.permute(2, 0, 1),
+        env=visdom_env,
+        win="images",
+        opts={"title": "train_images"},
+    )
+
+    # Show the coarse and fine renders together with the ground truth images.
+    ims_full = torch.cat(
+        [
+            nerf_out[imvar][0].permute(2, 0, 1).detach().cpu().clamp(0.0, 1.0)
+            for imvar in ("rgb_coarse", "rgb_fine", "rgb_gt")
+        ],
+        dim=2,
+    )
+    viz.image(
+        ims_full,
+        env=visdom_env,
+        win="images_full",
+        opts={"title": "coarse | fine | target"},
+    )
+
+    # Make a 3D plot of training cameras and their emitted rays.
+    camera_trace = {
+        f"camera_{ci:03d}": o["camera"].cpu() for ci, o in enumerate(output_cache)
+    }
+    ray_pts_trace = {
+        f"ray_pts_{ci:03d}": Pointclouds(
+            ray_bundle_to_ray_points(o["coarse_ray_bundle"])
+            .detach()
+            .cpu()
+            .view(1, -1, 3)
+        )
+        for ci, o in enumerate(output_cache)
+    }
+    plotly_plot = plot_scene(
+        {
+            "training_scene": {
+                **camera_trace,
+                **ray_pts_trace,
+            },
+        },
+        pointcloud_max_points=5000,
+        pointcloud_marker_size=1,
+        camera_scale=0.3,
+    )
+    viz.plotlyplot(plotly_plot, env=visdom_env, win="scenes")

project/ManiSkill3/src/maniskill2_benchmark/cfdp_experiment/cfdp/extern/pytorch3d/projects/nerf/nerf/raymarcher.py

@@ -0,0 +1,73 @@
+# Copyright (c) Meta Platforms, Inc. and affiliates.
+# All rights reserved.
+#
+# This source code is licensed under the BSD-style license found in the
+# LICENSE file in the root directory of this source tree.
+
+import torch
+from pytorch3d.renderer import EmissionAbsorptionRaymarcher
+from pytorch3d.renderer.implicit.raymarching import (
+    _check_density_bounds,
+    _check_raymarcher_inputs,
+    _shifted_cumprod,
+)
+
+
+class EmissionAbsorptionNeRFRaymarcher(EmissionAbsorptionRaymarcher):
+    """
+    This is essentially the `pytorch3d.renderer.EmissionAbsorptionRaymarcher`
+    which additionally returns the rendering weights. It also skips returning
+    the computation of the alpha-mask which is, in case of NeRF, equal to 1
+    everywhere.
+
+    The weights are later used in the NeRF pipeline to carry out the importance
+    ray-sampling for the fine rendering pass.
+
+    For more details about the EmissionAbsorptionRaymarcher please refer to
+    the documentation of `pytorch3d.renderer.EmissionAbsorptionRaymarcher`.
+    """
+
+    def forward(
+        self,
+        rays_densities: torch.Tensor,
+        rays_features: torch.Tensor,
+        eps: float = 1e-10,
+        **kwargs,
+    ) -> torch.Tensor:
+        """
+        Args:
+            rays_densities: Per-ray density values represented with a tensor
+                of shape `(..., n_points_per_ray, 1)` whose values range in [0, 1].
+            rays_features: Per-ray feature values represented with a tensor
+                of shape `(..., n_points_per_ray, feature_dim)`.
+            eps: A lower bound added to `rays_densities` before computing
+                the absorption function (cumprod of `1-rays_densities` along
+                each ray). This prevents the cumprod to yield exact 0
+                which would inhibit any gradient-based learning.
+
+        Returns:
+            features: A tensor of shape `(..., feature_dim)` containing
+                the rendered features for each ray.
+            weights: A tensor of shape `(..., n_points_per_ray)` containing
+                the ray-specific emission-absorption distribution.
+                Each ray distribution `(..., :)` is a valid probability
+                distribution, i.e. it contains non-negative values that integrate
+                to 1, such that `weights.sum(dim=-1)==1).all()` yields `True`.
+        """
+        _check_raymarcher_inputs(
+            rays_densities,
+            rays_features,
+            None,
+            z_can_be_none=True,
+            features_can_be_none=False,
+            density_1d=True,
+        )
+        _check_density_bounds(rays_densities)
+        rays_densities = rays_densities[..., 0]
+        absorption = _shifted_cumprod(
+            (1.0 + eps) - rays_densities, shift=self.surface_thickness
+        )
+        weights = rays_densities * absorption
+        features = (weights[..., None] * rays_features).sum(dim=-2)
+
+        return features, weights

project/ManiSkill3/src/maniskill2_benchmark/cfdp_experiment/cfdp/extern/pytorch3d/projects/nerf/nerf/raysampler.py

@@ -0,0 +1,365 @@
+# Copyright (c) Meta Platforms, Inc. and affiliates.
+# All rights reserved.
+#
+# This source code is licensed under the BSD-style license found in the
+# LICENSE file in the root directory of this source tree.
+
+import math
+from typing import List
+
+import torch
+from pytorch3d.renderer import MonteCarloRaysampler, NDCMultinomialRaysampler, RayBundle
+from pytorch3d.renderer.cameras import CamerasBase
+from pytorch3d.renderer.implicit.sample_pdf import sample_pdf
+
+
+class ProbabilisticRaysampler(torch.nn.Module):
+    """
+    Implements the importance sampling of points along rays.
+    The input is a `RayBundle` object with a `ray_weights` tensor
+    which specifies the probabilities of sampling a point along each ray.
+
+    This raysampler is used for the fine rendering pass of NeRF.
+    As such, the forward pass accepts the RayBundle output by the
+    raysampling of the coarse rendering pass. Hence, it does not
+    take cameras as input.
+    """
+
+    def __init__(
+        self,
+        n_pts_per_ray: int,
+        stratified: bool,
+        stratified_test: bool,
+        add_input_samples: bool = True,
+    ):
+        """
+        Args:
+            n_pts_per_ray: The number of points to sample along each ray.
+            stratified: If `True`, the input `ray_weights` are assumed to be
+                sampled at equidistant intervals.
+            stratified_test: Same as `stratified` with the difference that this
+                setting is applied when the module is in the `eval` mode
+                (`self.training==False`).
+            add_input_samples: Concatenates and returns the sampled values
+                together with the input samples.
+        """
+        super().__init__()
+        self._n_pts_per_ray = n_pts_per_ray
+        self._stratified = stratified
+        self._stratified_test = stratified_test
+        self._add_input_samples = add_input_samples
+
+    def forward(
+        self,
+        input_ray_bundle: RayBundle,
+        ray_weights: torch.Tensor,
+        **kwargs,
+    ) -> RayBundle:
+        """
+        Args:
+            input_ray_bundle: An instance of `RayBundle` specifying the
+                source rays for sampling of the probability distribution.
+            ray_weights: A tensor of shape
+                `(..., input_ray_bundle.legths.shape[-1])` with non-negative
+                elements defining the probability distribution to sample
+                ray points from.
+
+        Returns:
+            ray_bundle: A new `RayBundle` instance containing the input ray
+                points together with `n_pts_per_ray` additional sampled
+                points per ray.
+        """
+
+        # Calculate the mid-points between the ray depths.
+        z_vals = input_ray_bundle.lengths
+        batch_size = z_vals.shape[0]
+
+        # Carry out the importance sampling.
+        with torch.no_grad():
+            z_vals_mid = 0.5 * (z_vals[..., 1:] + z_vals[..., :-1])
+            z_samples = sample_pdf(
+                z_vals_mid.view(-1, z_vals_mid.shape[-1]),
+                ray_weights.view(-1, ray_weights.shape[-1])[..., 1:-1],
+                self._n_pts_per_ray,
+                det=not (
+                    (self._stratified and self.training)
+                    or (self._stratified_test and not self.training)
+                ),
+            ).view(batch_size, z_vals.shape[1], self._n_pts_per_ray)
+
+        if self._add_input_samples:
+            # Add the new samples to the input ones.
+            z_vals = torch.cat((z_vals, z_samples), dim=-1)
+        else:
+            z_vals = z_samples
+        # Resort by depth.
+        z_vals, _ = torch.sort(z_vals, dim=-1)
+
+        return RayBundle(
+            origins=input_ray_bundle.origins,
+            directions=input_ray_bundle.directions,
+            lengths=z_vals,
+            xys=input_ray_bundle.xys,
+        )
+
+
+class NeRFRaysampler(torch.nn.Module):
+    """
+    Implements the raysampler of NeRF.
+
+    Depending on the `self.training` flag, the raysampler either samples
+    a chunk of random rays (`self.training==True`), or returns a subset of rays
+    of the full image grid (`self.training==False`).
+    The chunking of rays allows for efficient evaluation of the NeRF implicit
+    surface function without encountering out-of-GPU-memory errors.
+
+    Additionally, this raysampler supports pre-caching of the ray bundles
+    for a set of input cameras (`self.precache_rays`).
+    Pre-caching the rays before training greatly speeds-up the ensuing
+    raysampling step of the training NeRF iterations.
+    """
+
+    def __init__(
+        self,
+        n_pts_per_ray: int,
+        min_depth: float,
+        max_depth: float,
+        n_rays_per_image: int,
+        image_width: int,
+        image_height: int,
+        stratified: bool = False,
+        stratified_test: bool = False,
+    ):
+        """
+        Args:
+            n_pts_per_ray: The number of points sampled along each ray.
+            min_depth: The minimum depth of a ray-point.
+            max_depth: The maximum depth of a ray-point.
+            n_rays_per_image: Number of Monte Carlo ray samples when training
+                (`self.training==True`).
+            image_width: The horizontal size of the image grid.
+            image_height: The vertical size of the image grid.
+            stratified: If `True`, stratifies (=randomly offsets) the depths
+                of each ray point during training (`self.training==True`).
+            stratified_test: If `True`, stratifies (=randomly offsets) the depths
+                of each ray point during evaluation (`self.training==False`).
+        """
+
+        super().__init__()
+        self._stratified = stratified
+        self._stratified_test = stratified_test
+
+        # Initialize the grid ray sampler.
+        self._grid_raysampler = NDCMultinomialRaysampler(
+            image_width=image_width,
+            image_height=image_height,
+            n_pts_per_ray=n_pts_per_ray,
+            min_depth=min_depth,
+            max_depth=max_depth,
+        )
+
+        # Initialize the Monte Carlo ray sampler.
+        self._mc_raysampler = MonteCarloRaysampler(
+            min_x=-1.0,
+            max_x=1.0,
+            min_y=-1.0,
+            max_y=1.0,
+            n_rays_per_image=n_rays_per_image,
+            n_pts_per_ray=n_pts_per_ray,
+            min_depth=min_depth,
+            max_depth=max_depth,
+        )
+
+        # create empty ray cache
+        self._ray_cache = {}
+
+    def get_n_chunks(self, chunksize: int, batch_size: int):
+        """
+        Returns the total number of `chunksize`-sized chunks
+        of the raysampler's rays.
+
+        Args:
+            chunksize: The number of rays per chunk.
+            batch_size: The size of the batch of the raysampler.
+
+        Returns:
+            n_chunks: The total number of chunks.
+        """
+        return int(
+            math.ceil(
+                (self._grid_raysampler._xy_grid.numel() * 0.5 * batch_size) / chunksize
+            )
+        )
+
+    def _print_precaching_progress(self, i, total, bar_len=30):
+        """
+        Print a progress bar for ray precaching.
+        """
+        position = round((i + 1) / total * bar_len)
+        pbar = "[" + "█" * position + " " * (bar_len - position) + "]"
+        print(pbar, end="\r")
+
+    def precache_rays(self, cameras: List[CamerasBase], camera_hashes: List):
+        """
+        Precaches the rays emitted from the list of cameras `cameras`,
+        where each camera is uniquely identified with the corresponding hash
+        from `camera_hashes`.
+
+        The cached rays are moved to cpu and stored in `self._ray_cache`.
+        Raises `ValueError` when caching two cameras with the same hash.
+
+        Args:
+            cameras: A list of `N` cameras for which the rays are pre-cached.
+            camera_hashes: A list of `N` unique identifiers of each
+                camera from `cameras`.
+        """
+        print(f"Precaching {len(cameras)} ray bundles ...")
+        full_chunksize = (
+            self._grid_raysampler._xy_grid.numel()
+            // 2
+            * self._grid_raysampler._n_pts_per_ray
+        )
+        if self.get_n_chunks(full_chunksize, 1) != 1:
+            raise ValueError("There has to be one chunk for precaching rays!")
+        for camera_i, (camera, camera_hash) in enumerate(zip(cameras, camera_hashes)):
+            ray_bundle = self.forward(
+                camera,
+                caching=True,
+                chunksize=full_chunksize,
+            )
+            if camera_hash in self._ray_cache:
+                raise ValueError("There are redundant cameras!")
+            self._ray_cache[camera_hash] = RayBundle(
+                *[v.to("cpu").detach() for v in ray_bundle]
+            )
+            self._print_precaching_progress(camera_i, len(cameras))
+        print("")
+
+    def _stratify_ray_bundle(self, ray_bundle: RayBundle):
+        """
+        Stratifies the lengths of the input `ray_bundle`.
+
+        More specifically, the stratification replaces each ray points' depth `z`
+        with a sample from a uniform random distribution on
+        `[z - delta_depth, z+delta_depth]`, where `delta_depth` is the difference
+        of depths of the consecutive ray depth values.
+
+        Args:
+            `ray_bundle`: The input `RayBundle`.
+
+        Returns:
+            `stratified_ray_bundle`: `ray_bundle` whose `lengths` field is replaced
+                with the stratified samples.
+        """
+        z_vals = ray_bundle.lengths
+        # Get intervals between samples.
+        mids = 0.5 * (z_vals[..., 1:] + z_vals[..., :-1])
+        upper = torch.cat((mids, z_vals[..., -1:]), dim=-1)
+        lower = torch.cat((z_vals[..., :1], mids), dim=-1)
+        # Stratified samples in those intervals.
+        z_vals = lower + (upper - lower) * torch.rand_like(lower)
+        return ray_bundle._replace(lengths=z_vals)
+
+    def _normalize_raybundle(self, ray_bundle: RayBundle):
+        """
+        Normalizes the ray directions of the input `RayBundle` to unit norm.
+        """
+        ray_bundle = ray_bundle._replace(
+            directions=torch.nn.functional.normalize(ray_bundle.directions, dim=-1)
+        )
+        return ray_bundle
+
+    def forward(
+        self,
+        cameras: CamerasBase,
+        chunksize: int = None,
+        chunk_idx: int = 0,
+        camera_hash: str = None,
+        caching: bool = False,
+        **kwargs,
+    ) -> RayBundle:
+        """
+        Args:
+            cameras: A batch of `batch_size` cameras from which the rays are emitted.
+            chunksize: The number of rays per chunk.
+                Active only when `self.training==False`.
+            chunk_idx: The index of the ray chunk. The number has to be in
+                `[0, self.get_n_chunks(chunksize, batch_size)-1]`.
+                Active only when `self.training==False`.
+            camera_hash: A unique identifier of a pre-cached camera. If `None`,
+                the cache is not searched and the rays are calculated from scratch.
+            caching: If `True`, activates the caching mode that returns the `RayBundle`
+                that should be stored into the cache.
+        Returns:
+            A named tuple `RayBundle` with the following fields:
+                origins: A tensor of shape
+                    `(batch_size, n_rays_per_image, 3)`
+                    denoting the locations of ray origins in the world coordinates.
+                directions: A tensor of shape
+                    `(batch_size, n_rays_per_image, 3)`
+                    denoting the directions of each ray in the world coordinates.
+                lengths: A tensor of shape
+                    `(batch_size, n_rays_per_image, n_pts_per_ray)`
+                    containing the z-coordinate (=depth) of each ray in world units.
+                xys: A tensor of shape
+                    `(batch_size, n_rays_per_image, 2)`
+                    containing the 2D image coordinates of each ray.
+        """
+
+        batch_size = cameras.R.shape[0]  # pyre-ignore
+        device = cameras.device
+
+        if (camera_hash is None) and (not caching) and self.training:
+            # Sample random rays from scratch.
+            ray_bundle = self._mc_raysampler(cameras)
+            ray_bundle = self._normalize_raybundle(ray_bundle)
+        else:
+            if camera_hash is not None:
+                # The case where we retrieve a camera from cache.
+                if batch_size != 1:
+                    raise NotImplementedError(
+                        "Ray caching works only for batches with a single camera!"
+                    )
+                full_ray_bundle = self._ray_cache[camera_hash]
+            else:
+                # We generate a full ray grid from scratch.
+                full_ray_bundle = self._grid_raysampler(cameras)
+                full_ray_bundle = self._normalize_raybundle(full_ray_bundle)
+
+            n_pixels = full_ray_bundle.directions.shape[:-1].numel()
+
+            if self.training:
+                # During training we randomly subsample rays.
+                sel_rays = torch.randperm(
+                    n_pixels, device=full_ray_bundle.lengths.device
+                )[: self._mc_raysampler._n_rays_per_image]
+            else:
+                # In case we test, we take only the requested chunk.
+                if chunksize is None:
+                    chunksize = n_pixels * batch_size
+                start = chunk_idx * chunksize * batch_size
+                end = min(start + chunksize, n_pixels)
+                sel_rays = torch.arange(
+                    start,
+                    end,
+                    dtype=torch.long,
+                    device=full_ray_bundle.lengths.device,
+                )
+
+            # Take the "sel_rays" rays from the full ray bundle.
+            ray_bundle = RayBundle(
+                *[
+                    v.view(n_pixels, -1)[sel_rays]
+                    .view(batch_size, sel_rays.numel() // batch_size, -1)
+                    .to(device)
+                    for v in full_ray_bundle
+                ]
+            )
+
+        if (
+            (self._stratified and self.training)
+            or (self._stratified_test and not self.training)
+        ) and not caching:  # Make sure not to stratify when caching!
+            ray_bundle = self._stratify_ray_bundle(ray_bundle)
+
+        return ray_bundle

project/ManiSkill3/src/maniskill2_benchmark/cfdp_experiment/cfdp/extern/pytorch3d/projects/nerf/nerf/stats.py

@@ -0,0 +1,346 @@
+# Copyright (c) Meta Platforms, Inc. and affiliates.
+# All rights reserved.
+#
+# This source code is licensed under the BSD-style license found in the
+# LICENSE file in the root directory of this source tree.
+
+import time
+import warnings
+from itertools import cycle
+from typing import List, Optional
+
+import matplotlib
+import matplotlib.pyplot as plt
+import numpy as np
+from matplotlib import colors as mcolors
+from visdom import Visdom
+
+
+class AverageMeter:
+    """
+    Computes and stores the average and current value.
+    Tracks the exact history of the added values in every epoch.
+    """
+
+    def __init__(self) -> None:
+        """
+        Initialize the structure with empty history and zero-ed moving average.
+        """
+        self.history = []
+        self.reset()
+
+    def reset(self) -> None:
+        """
+        Reset the running average meter.
+        """
+        self.val = 0
+        self.avg = 0
+        self.sum = 0
+        self.count = 0
+
+    def update(self, val: float, n: int = 1, epoch: int = 0) -> None:
+        """
+        Updates the average meter with a value `val`.
+
+        Args:
+            val: A float to be added to the meter.
+            n: Represents the number of entities to be added.
+            epoch: The epoch to which the number should be added.
+        """
+        # make sure the history is of the same len as epoch
+        while len(self.history) <= epoch:
+            self.history.append([])
+        self.history[epoch].append(val / n)
+        self.val = val
+        self.sum += val * n
+        self.count += n
+        self.avg = self.sum / self.count
+
+    def get_epoch_averages(self):
+        """
+        Returns:
+            averages: A list of average values of the metric for each epoch
+                in the history buffer.
+        """
+        if len(self.history) == 0:
+            return None
+        return [
+            (float(np.array(h).mean()) if len(h) > 0 else float("NaN"))
+            for h in self.history
+        ]
+
+
+class Stats:
+    """
+    Stats logging object useful for gathering statistics of training
+    a deep network in PyTorch.
+
+    Example:
+        ```
+        # Init stats structure that logs statistics 'objective' and 'top1e'.
+        stats = Stats( ('objective','top1e') )
+
+        network = init_net()  # init a pytorch module (=neural network)
+        dataloader = init_dataloader()  # init a dataloader
+
+        for epoch in range(10):
+
+            # start of epoch -> call new_epoch
+            stats.new_epoch()
+
+            # Iterate over batches.
+            for batch in dataloader:
+                # Run a model and save into a dict of output variables "output"
+                output = network(batch)
+
+                # stats.update() automatically parses the 'objective' and 'top1e'
+                # from the "output" dict and stores this into the db.
+                stats.update(output)
+                stats.print() # prints the averages over given epoch
+
+            # Stores the training plots into '/tmp/epoch_stats.pdf'
+            # and plots into a visdom server running at localhost (if running).
+            stats.plot_stats(plot_file='/tmp/epoch_stats.pdf')
+        ```
+    """
+
+    def __init__(
+        self,
+        log_vars: List[str],
+        verbose: bool = False,
+        epoch: int = -1,
+        plot_file: Optional[str] = None,
+    ) -> None:
+        """
+        Args:
+            log_vars: The list of variable names to be logged.
+            verbose: Print status messages.
+            epoch: The initial epoch of the object.
+            plot_file: The path to the file that will hold the training plots.
+        """
+        self.verbose = verbose
+        self.log_vars = log_vars
+        self.plot_file = plot_file
+        self.hard_reset(epoch=epoch)
+
+    def reset(self) -> None:
+        """
+        Called before an epoch to clear current epoch buffers.
+        """
+        stat_sets = list(self.stats.keys())
+        if self.verbose:
+            print("stats: epoch %d - reset" % self.epoch)
+        self.it = {k: -1 for k in stat_sets}
+        for stat_set in stat_sets:
+            for stat in self.stats[stat_set]:
+                self.stats[stat_set][stat].reset()
+
+        # Set a new timestamp.
+        self._epoch_start = time.time()
+
+    def hard_reset(self, epoch: int = -1) -> None:
+        """
+        Erases all logged data.
+        """
+        self._epoch_start = None
+        self.epoch = epoch
+        if self.verbose:
+            print("stats: epoch %d - hard reset" % self.epoch)
+        self.stats = {}
+        self.reset()
+
+    def new_epoch(self) -> None:
+        """
+        Initializes a new epoch.
+        """
+        if self.verbose:
+            print("stats: new epoch %d" % (self.epoch + 1))
+        self.epoch += 1  # increase epoch counter
+        self.reset()  # zero the stats
+
+    def _gather_value(self, val):
+        if isinstance(val, float):
+            pass
+        else:
+            val = val.data.cpu().numpy()
+            val = float(val.sum())
+        return val
+
+    def update(self, preds: dict, stat_set: str = "train") -> None:
+        """
+        Update the internal logs with metrics of a training step.
+
+        Each metric is stored as an instance of an AverageMeter.
+
+        Args:
+            preds: Dict of values to be added to the logs.
+            stat_set: The set of statistics to be updated (e.g. "train", "val").
+        """
+
+        if self.epoch == -1:  # uninitialized
+            warnings.warn(
+                "self.epoch==-1 means uninitialized stats structure"
+                " -> new_epoch() called"
+            )
+            self.new_epoch()
+
+        if stat_set not in self.stats:
+            self.stats[stat_set] = {}
+            self.it[stat_set] = -1
+
+        self.it[stat_set] += 1
+
+        epoch = self.epoch
+        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()
+
+            if stat == "sec/it":  # compute speed
+                elapsed = time.time() - self._epoch_start
+                time_per_it = float(elapsed) / float(it + 1)
+                val = time_per_it
+            else:
+                if stat in preds:
+                    val = self._gather_value(preds[stat])
+                else:
+                    val = None
+
+            if val is not None:
+                self.stats[stat_set][stat].update(val, epoch=epoch, n=1)
+
+    def print(self, max_it: Optional[int] = None, stat_set: str = "train") -> None:
+        """
+        Print the current values of all stored stats.
+
+        Args:
+            max_it: Maximum iteration number to be displayed.
+                If None, the maximum iteration number is not displayed.
+            stat_set: The set of statistics to be printed.
+        """
+
+        epoch = self.epoch
+        stats = self.stats
+
+        str_out = ""
+
+        it = self.it[stat_set]
+        stat_str = ""
+        stats_print = sorted(stats[stat_set].keys())
+        for stat in stats_print:
+            if stats[stat_set][stat].count == 0:
+                continue
+            stat_str += " {0:.12}: {1:1.3f} |".format(stat, stats[stat_set][stat].avg)
+
+        head_str = f"[{stat_set}] | epoch {epoch} | it {it}"
+        if max_it:
+            head_str += f"/ {max_it}"
+
+        str_out = f"{head_str} | {stat_str}"
+
+        print(str_out)
+
+    def plot_stats(
+        self,
+        viz: Visdom = None,
+        visdom_env: Optional[str] = None,
+        plot_file: Optional[str] = None,
+    ) -> None:
+        """
+        Plot the line charts of the history of the stats.
+
+        Args:
+            viz: The Visdom object holding the connection to a Visdom server.
+            visdom_env: The visdom environment for storing the graphs.
+            plot_file: The path to a file with training plots.
+        """
+
+        stat_sets = list(self.stats.keys())
+
+        if viz is None:
+            withvisdom = False
+        elif not viz.check_connection():
+            warnings.warn("Cannot connect to the visdom server! Skipping visdom plots.")
+            withvisdom = False
+        else:
+            withvisdom = True
+
+        lines = []
+
+        for stat in self.log_vars:
+            vals = []
+            stat_sets_now = []
+            for stat_set in stat_sets:
+                val = self.stats[stat_set][stat].get_epoch_averages()
+                if val is None:
+                    continue
+                else:
+                    val = np.array(val).reshape(-1)
+                    stat_sets_now.append(stat_set)
+                vals.append(val)
+
+            if len(vals) == 0:
+                continue
+
+            vals = np.stack(vals, axis=1)
+            x = np.arange(vals.shape[0])
+
+            lines.append((stat_sets_now, stat, x, vals))
+
+        if withvisdom:
+            for tmodes, stat, x, vals in lines:
+                title = "%s" % stat
+                opts = {"title": title, "legend": list(tmodes)}
+                for i, (tmode, val) in enumerate(zip(tmodes, vals.T)):
+                    update = "append" if i > 0 else None
+                    valid = np.where(np.isfinite(val))
+                    if len(valid) == 0:
+                        continue
+                    viz.line(
+                        Y=val[valid],
+                        X=x[valid],
+                        env=visdom_env,
+                        opts=opts,
+                        win=f"stat_plot_{title}",
+                        name=tmode,
+                        update=update,
+                    )
+
+        if plot_file is None:
+            plot_file = self.plot_file
+
+        if plot_file is not None:
+            print("Exporting stats to %s" % plot_file)
+            ncol = 3
+            nrow = int(np.ceil(float(len(lines)) / ncol))
+            matplotlib.rcParams.update({"font.size": 5})
+            color = cycle(plt.cm.tab10(np.linspace(0, 1, 10)))
+            fig = plt.figure(1)
+            plt.clf()
+            for idx, (tmodes, stat, x, vals) in enumerate(lines):
+                c = next(color)
+                plt.subplot(nrow, ncol, idx + 1)
+                for vali, vals_ in enumerate(vals.T):
+                    c_ = c * (1.0 - float(vali) * 0.3)
+                    valid = np.where(np.isfinite(vals_))
+                    if len(valid) == 0:
+                        continue
+                    plt.plot(x[valid], vals_[valid], c=c_, linewidth=1)
+                plt.ylabel(stat)
+                plt.xlabel("epoch")
+                plt.gca().yaxis.label.set_color(c[0:3] * 0.75)
+                plt.legend(tmodes)
+                gcolor = np.array(mcolors.to_rgba("lightgray"))
+                plt.grid(
+                    b=True, which="major", color=gcolor, linestyle="-", linewidth=0.4
+                )
+                plt.grid(
+                    b=True, which="minor", color=gcolor, linestyle="--", linewidth=0.2
+                )
+                plt.minorticks_on()
+
+            plt.tight_layout()
+            plt.show()
+            fig.savefig(plot_file)

project/ManiSkill3/src/maniskill2_benchmark/cfdp_experiment/cfdp/extern/pytorch3d/projects/nerf/nerf/utils.py

@@ -0,0 +1,59 @@
+# Copyright (c) Meta Platforms, Inc. and affiliates.
+# All rights reserved.
+#
+# This source code is licensed under the BSD-style license found in the
+# LICENSE file in the root directory of this source tree.
+
+import torch
+
+
+def calc_mse(x: torch.Tensor, y: torch.Tensor):
+    """
+    Calculates the mean square error between tensors `x` and `y`.
+    """
+    return torch.mean((x - y) ** 2)
+
+
+def calc_psnr(x: torch.Tensor, y: torch.Tensor):
+    """
+    Calculates the Peak-signal-to-noise ratio between tensors `x` and `y`.
+    """
+    mse = calc_mse(x, y)
+    psnr = -10.0 * torch.log10(mse)
+    return psnr
+
+
+def sample_images_at_mc_locs(
+    target_images: torch.Tensor,
+    sampled_rays_xy: torch.Tensor,
+):
+    """
+    Given a set of pixel locations `sampled_rays_xy` this method samples the tensor
+    `target_images` at the respective 2D locations.
+
+    This function is used in order to extract the colors from ground truth images
+    that correspond to the colors rendered using a Monte Carlo rendering.
+
+    Args:
+        target_images: A tensor of shape `(batch_size, ..., 3)`.
+        sampled_rays_xy: A tensor of shape `(batch_size, S_1, ..., S_N, 2)`.
+
+    Returns:
+        images_sampled: A tensor of shape `(batch_size, S_1, ..., S_N, 3)`
+            containing `target_images` sampled at `sampled_rays_xy`.
+    """
+    ba = target_images.shape[0]
+    dim = target_images.shape[-1]
+    spatial_size = sampled_rays_xy.shape[1:-1]
+
+    # The coordinate grid convention for grid_sample has both x and y
+    # directions inverted.
+    xy_sample = -sampled_rays_xy.view(ba, -1, 1, 2).clone()
+
+    images_sampled = torch.nn.functional.grid_sample(
+        target_images.permute(0, 3, 1, 2),
+        xy_sample,
+        align_corners=True,
+        mode="bilinear",
+    )
+    return images_sampled.permute(0, 2, 3, 1).view(ba, *spatial_size, dim)

project/ManiSkill3/src/maniskill2_benchmark/cfdp_experiment/cfdp/extern/pytorch3d/projects/nerf/test_nerf.py

@@ -0,0 +1,172 @@
+#!/usr/bin/env python3
+# Copyright (c) Meta Platforms, Inc. and affiliates.
+# All rights reserved.
+#
+# This source code is licensed under the BSD-style license found in the
+# LICENSE file in the root directory of this source tree.
+
+import os
+import warnings
+
+import hydra
+import numpy as np
+import torch
+from nerf.dataset import get_nerf_datasets, trivial_collate
+from nerf.eval_video_utils import generate_eval_video_cameras
+from nerf.nerf_renderer import RadianceFieldRenderer
+from nerf.stats import Stats
+from omegaconf import DictConfig
+from PIL import Image
+
+
+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"
+    else:
+        warnings.warn(
+            "Please note that although executing on CPU is supported,"
+            + "the testing is unlikely to finish in reasonable time."
+        )
+        device = "cpu"
+
+    # Initialize the Radiance Field model.
+    model = RadianceFieldRenderer(
+        image_size=cfg.data.image_size,
+        n_pts_per_ray=cfg.raysampler.n_pts_per_ray,
+        n_pts_per_ray_fine=cfg.raysampler.n_pts_per_ray,
+        n_rays_per_image=cfg.raysampler.n_rays_per_image,
+        min_depth=cfg.raysampler.min_depth,
+        max_depth=cfg.raysampler.max_depth,
+        stratified=cfg.raysampler.stratified,
+        stratified_test=cfg.raysampler.stratified_test,
+        chunk_size_test=cfg.raysampler.chunk_size_test,
+        n_harmonic_functions_xyz=cfg.implicit_function.n_harmonic_functions_xyz,
+        n_harmonic_functions_dir=cfg.implicit_function.n_harmonic_functions_dir,
+        n_hidden_neurons_xyz=cfg.implicit_function.n_hidden_neurons_xyz,
+        n_hidden_neurons_dir=cfg.implicit_function.n_hidden_neurons_dir,
+        n_layers_xyz=cfg.implicit_function.n_layers_xyz,
+        density_noise_std=cfg.implicit_function.density_noise_std,
+    )
+
+    # Move the model to the relevant device.
+    model.to(device)
+
+    # Resume from the checkpoint.
+    checkpoint_path = os.path.join(hydra.utils.get_original_cwd(), cfg.checkpoint_path)
+    if not os.path.isfile(checkpoint_path):
+        raise ValueError(f"Model checkpoint {checkpoint_path} does not exist!")
+
+    print(f"Loading checkpoint {checkpoint_path}.")
+    loaded_data = torch.load(checkpoint_path)
+    # Do not load the cached xy grid.
+    # - this allows setting an arbitrary evaluation image size.
+    state_dict = {
+        k: v
+        for k, v in loaded_data["model"].items()
+        if "_grid_raysampler._xy_grid" not in k
+    }
+    model.load_state_dict(state_dict, strict=False)
+
+    # Load the test data.
+    if cfg.test.mode == "evaluation":
+        _, _, test_dataset = get_nerf_datasets(
+            dataset_name=cfg.data.dataset_name,
+            image_size=cfg.data.image_size,
+        )
+    elif cfg.test.mode == "export_video":
+        train_dataset, _, _ = get_nerf_datasets(
+            dataset_name=cfg.data.dataset_name,
+            image_size=cfg.data.image_size,
+        )
+        test_dataset = generate_eval_video_cameras(
+            train_dataset,
+            trajectory_type=cfg.test.trajectory_type,
+            up=cfg.test.up,
+            scene_center=cfg.test.scene_center,
+            n_eval_cams=cfg.test.n_frames,
+            trajectory_scale=cfg.test.trajectory_scale,
+        )
+        # store the video in directory (checkpoint_file - extension + '_video')
+        export_dir = os.path.splitext(checkpoint_path)[0] + "_video"
+        os.makedirs(export_dir, exist_ok=True)
+    else:
+        raise ValueError(f"Unknown test mode {cfg.test_mode}.")
+
+    # Init the test dataloader.
+    test_dataloader = torch.utils.data.DataLoader(
+        test_dataset,
+        batch_size=1,
+        shuffle=False,
+        num_workers=0,
+        collate_fn=trivial_collate,
+    )
+
+    if cfg.test.mode == "evaluation":
+        # Init the test stats object.
+        eval_stats = ["mse_coarse", "mse_fine", "psnr_coarse", "psnr_fine", "sec/it"]
+        stats = Stats(eval_stats)
+        stats.new_epoch()
+    elif cfg.test.mode == "export_video":
+        # Init the frame buffer.
+        frame_paths = []
+
+    # Set the model to the eval mode.
+    model.eval()
+
+    # Run the main testing loop.
+    for batch_idx, test_batch in enumerate(test_dataloader):
+        test_image, test_camera, camera_idx = test_batch[0].values()
+        if test_image is not None:
+            test_image = test_image.to(device)
+        test_camera = test_camera.to(device)
+
+        # Activate eval mode of the model (lets us do a full rendering pass).
+        model.eval()
+        with torch.no_grad():
+            test_nerf_out, test_metrics = model(
+                None,  # we do not use pre-cached cameras
+                test_camera,
+                test_image,
+            )
+
+        if cfg.test.mode == "evaluation":
+            # Update stats with the validation metrics.
+            stats.update(test_metrics, stat_set="test")
+            stats.print(stat_set="test")
+
+        elif cfg.test.mode == "export_video":
+            # Store the video frame.
+            frame = test_nerf_out["rgb_fine"][0].detach().cpu()
+            frame_path = os.path.join(export_dir, f"frame_{batch_idx:05d}.png")
+            print(f"Writing {frame_path}.")
+            Image.fromarray((frame.numpy() * 255.0).astype(np.uint8)).save(frame_path)
+            frame_paths.append(frame_path)
+
+    if cfg.test.mode == "evaluation":
+        print(f"Final evaluation metrics on '{cfg.data.dataset_name}':")
+        for stat in eval_stats:
+            stat_value = stats.stats["test"][stat].get_epoch_averages()[0]
+            print(f"{stat:15s}: {stat_value:1.4f}")
+
+    elif cfg.test.mode == "export_video":
+        # Convert the exported frames to a video.
+        video_path = os.path.join(export_dir, "video.mp4")
+        ffmpeg_bin = "ffmpeg"
+        frame_regexp = os.path.join(export_dir, "frame_%05d.png")
+        ffmcmd = (
+            "%s -r %d -i %s -vcodec h264 -f mp4 -y -b 2000k -pix_fmt yuv420p %s"
+            % (ffmpeg_bin, cfg.test.fps, frame_regexp, video_path)
+        )
+        ret = os.system(ffmcmd)
+        if ret != 0:
+            raise RuntimeError("ffmpeg failed!")
+
+
+if __name__ == "__main__":
+    main()

project/ManiSkill3/src/maniskill2_benchmark/cfdp_experiment/cfdp/extern/pytorch3d/projects/nerf/tests/__init__.py

@@ -0,0 +1,5 @@
+# Copyright (c) Meta Platforms, Inc. and affiliates.
+# All rights reserved.
+#
+# This source code is licensed under the BSD-style license found in the
+# LICENSE file in the root directory of this source tree.

project/ManiSkill3/src/maniskill2_benchmark/cfdp_experiment/cfdp/extern/pytorch3d/projects/nerf/tests/test_raymarcher.py

@@ -0,0 +1,38 @@
+# Copyright (c) Meta Platforms, Inc. and affiliates.
+# All rights reserved.
+#
+# This source code is licensed under the BSD-style license found in the
+# LICENSE file in the root directory of this source tree.
+
+import unittest
+
+import torch
+from nerf.raymarcher import EmissionAbsorptionNeRFRaymarcher
+from pytorch3d.renderer import EmissionAbsorptionRaymarcher
+
+
+class TestRaymarcher(unittest.TestCase):
+    def setUp(self) -> None:
+        torch.manual_seed(42)
+
+    def test_raymarcher(self):
+        """
+        Checks that the nerf raymarcher outputs are identical to the
+        EmissionAbsorptionRaymarcher.
+        """
+
+        feat_dim = 3
+        rays_densities = torch.rand(100, 10, 1)
+        rays_features = torch.randn(100, 10, feat_dim)
+
+        out, out_nerf = [
+            raymarcher(rays_densities, rays_features)
+            for raymarcher in (
+                EmissionAbsorptionRaymarcher(),
+                EmissionAbsorptionNeRFRaymarcher(),
+            )
+        ]
+
+        self.assertTrue(
+            torch.allclose(out[..., :feat_dim], out_nerf[0][..., :feat_dim])
+        )

project/ManiSkill3/src/maniskill2_benchmark/cfdp_experiment/cfdp/extern/pytorch3d/projects/nerf/tests/test_raysampler.py

@@ -0,0 +1,126 @@
+# Copyright (c) Meta Platforms, Inc. and affiliates.
+# All rights reserved.
+#
+# This source code is licensed under the BSD-style license found in the
+# LICENSE file in the root directory of this source tree.
+
+import unittest
+
+import torch
+from nerf.raysampler import NeRFRaysampler, ProbabilisticRaysampler
+from pytorch3d.renderer import PerspectiveCameras
+from pytorch3d.transforms.rotation_conversions import random_rotations
+
+
+class TestRaysampler(unittest.TestCase):
+    def setUp(self) -> None:
+        torch.manual_seed(42)
+
+    def test_raysampler_caching(self, batch_size=10):
+        """
+        Tests the consistency of the NeRF raysampler caching.
+        """
+
+        raysampler = NeRFRaysampler(
+            min_x=0.0,
+            max_x=10.0,
+            min_y=0.0,
+            max_y=10.0,
+            n_pts_per_ray=10,
+            min_depth=0.1,
+            max_depth=10.0,
+            n_rays_per_image=12,
+            image_width=10,
+            image_height=10,
+            stratified=False,
+            stratified_test=False,
+            invert_directions=True,
+        )
+
+        raysampler.eval()
+
+        cameras, rays = [], []
+
+        for _ in range(batch_size):
+
+            R = random_rotations(1)
+            T = torch.randn(1, 3)
+            focal_length = torch.rand(1, 2) + 0.5
+            principal_point = torch.randn(1, 2)
+
+            camera = PerspectiveCameras(
+                focal_length=focal_length,
+                principal_point=principal_point,
+                R=R,
+                T=T,
+            )
+
+            cameras.append(camera)
+            rays.append(raysampler(camera))
+
+        raysampler.precache_rays(cameras, list(range(batch_size)))
+
+        for cam_index, rays_ in enumerate(rays):
+            rays_cached_ = raysampler(
+                cameras=cameras[cam_index],
+                chunksize=None,
+                chunk_idx=0,
+                camera_hash=cam_index,
+                caching=False,
+            )
+
+            for v, v_cached in zip(rays_, rays_cached_):
+                self.assertTrue(torch.allclose(v, v_cached))
+
+    def test_probabilistic_raysampler(self, batch_size=1, n_pts_per_ray=60):
+        """
+        Check that the probabilistic ray sampler does not crash for various
+        settings.
+        """
+
+        raysampler_grid = NeRFRaysampler(
+            min_x=0.0,
+            max_x=10.0,
+            min_y=0.0,
+            max_y=10.0,
+            n_pts_per_ray=n_pts_per_ray,
+            min_depth=1.0,
+            max_depth=10.0,
+            n_rays_per_image=12,
+            image_width=10,
+            image_height=10,
+            stratified=False,
+            stratified_test=False,
+            invert_directions=True,
+        )
+
+        R = random_rotations(batch_size)
+        T = torch.randn(batch_size, 3)
+        focal_length = torch.rand(batch_size, 2) + 0.5
+        principal_point = torch.randn(batch_size, 2)
+        camera = PerspectiveCameras(
+            focal_length=focal_length,
+            principal_point=principal_point,
+            R=R,
+            T=T,
+        )
+
+        raysampler_grid.eval()
+
+        ray_bundle = raysampler_grid(cameras=camera)
+
+        ray_weights = torch.rand_like(ray_bundle.lengths)
+
+        # Just check that we dont crash for all possible settings.
+        for stratified_test in (True, False):
+            for stratified in (True, False):
+                raysampler_prob = ProbabilisticRaysampler(
+                    n_pts_per_ray=n_pts_per_ray,
+                    stratified=stratified,
+                    stratified_test=stratified_test,
+                    add_input_samples=True,
+                )
+                for mode in ("train", "eval"):
+                    getattr(raysampler_prob, mode)()
+                    for _ in range(10):
+                        raysampler_prob(ray_bundle, ray_weights)

project/ManiSkill3/src/maniskill2_benchmark/cfdp_experiment/cfdp/extern/pytorch3d/projects/nerf/train_nerf.py

@@ -0,0 +1,273 @@
+#!/usr/bin/env python3
+# Copyright (c) Meta Platforms, Inc. and affiliates.
+# All rights reserved.
+#
+# This source code is licensed under the BSD-style license found in the
+# LICENSE file in the root directory of this source tree.
+
+import collections
+import os
+import pickle
+import warnings
+
+import hydra
+import numpy as np
+import torch
+from nerf.dataset import get_nerf_datasets, trivial_collate
+from nerf.nerf_renderer import RadianceFieldRenderer, visualize_nerf_outputs
+from nerf.stats import Stats
+from omegaconf import DictConfig
+from visdom import Visdom
+
+
+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)
+
+    # Device on which to run.
+    if torch.cuda.is_available():
+        device = "cuda"
+    else:
+        warnings.warn(
+            "Please note that although executing on CPU is supported,"
+            + "the training is unlikely to finish in reasonable time."
+        )
+        device = "cpu"
+
+    # Initialize the Radiance Field model.
+    model = RadianceFieldRenderer(
+        image_size=cfg.data.image_size,
+        n_pts_per_ray=cfg.raysampler.n_pts_per_ray,
+        n_pts_per_ray_fine=cfg.raysampler.n_pts_per_ray,
+        n_rays_per_image=cfg.raysampler.n_rays_per_image,
+        min_depth=cfg.raysampler.min_depth,
+        max_depth=cfg.raysampler.max_depth,
+        stratified=cfg.raysampler.stratified,
+        stratified_test=cfg.raysampler.stratified_test,
+        chunk_size_test=cfg.raysampler.chunk_size_test,
+        n_harmonic_functions_xyz=cfg.implicit_function.n_harmonic_functions_xyz,
+        n_harmonic_functions_dir=cfg.implicit_function.n_harmonic_functions_dir,
+        n_hidden_neurons_xyz=cfg.implicit_function.n_hidden_neurons_xyz,
+        n_hidden_neurons_dir=cfg.implicit_function.n_hidden_neurons_dir,
+        n_layers_xyz=cfg.implicit_function.n_layers_xyz,
+        density_noise_std=cfg.implicit_function.density_noise_std,
+        visualization=cfg.visualization.visdom,
+    )
+
+    # Move the model to the relevant device.
+    model.to(device)
+
+    # Init stats to None before loading.
+    stats = None
+    optimizer_state_dict = None
+    start_epoch = 0
+
+    checkpoint_path = os.path.join(hydra.utils.get_original_cwd(), cfg.checkpoint_path)
+    if len(cfg.checkpoint_path) > 0:
+        # Make the root of the experiment directory.
+        checkpoint_dir = os.path.split(checkpoint_path)[0]
+        os.makedirs(checkpoint_dir, exist_ok=True)
+
+        # 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)
+            model.load_state_dict(loaded_data["model"])
+            stats = pickle.loads(loaded_data["stats"])
+            print(f"   => resuming from epoch {stats.epoch}.")
+            optimizer_state_dict = loaded_data["optimizer"]
+            start_epoch = stats.epoch
+
+    # Initialize the optimizer.
+    optimizer = torch.optim.Adam(
+        model.parameters(),
+        lr=cfg.optimizer.lr,
+    )
+
+    # Load the optimizer state dict in case we are resuming.
+    if optimizer_state_dict is not None:
+        optimizer.load_state_dict(optimizer_state_dict)
+        optimizer.last_epoch = start_epoch
+
+    # Init the stats object.
+    if stats is None:
+        stats = Stats(
+            ["loss", "mse_coarse", "mse_fine", "psnr_coarse", "psnr_fine", "sec/it"],
+        )
+
+    # Learning rate scheduler setup.
+
+    # Following the original code, we use exponential decay of the
+    # learning rate: current_lr = base_lr * gamma ** (epoch / step_size)
+    def lr_lambda(epoch):
+        return cfg.optimizer.lr_scheduler_gamma ** (
+            epoch / cfg.optimizer.lr_scheduler_step_size
+        )
+
+    # The learning rate scheduling is implemented with LambdaLR PyTorch scheduler.
+    lr_scheduler = torch.optim.lr_scheduler.LambdaLR(
+        optimizer, lr_lambda, last_epoch=start_epoch - 1, verbose=False
+    )
+
+    # Initialize the cache for storing variables needed for visualization.
+    visuals_cache = collections.deque(maxlen=cfg.visualization.history_size)
+
+    # Init the visualization visdom env.
+    if cfg.visualization.visdom:
+        viz = Visdom(
+            server=cfg.visualization.visdom_server,
+            port=cfg.visualization.visdom_port,
+            use_incoming_socket=False,
+        )
+    else:
+        viz = None
+
+    # Load the training/validation data.
+    train_dataset, val_dataset, _ = get_nerf_datasets(
+        dataset_name=cfg.data.dataset_name,
+        image_size=cfg.data.image_size,
+    )
+
+    if cfg.data.precache_rays:
+        # Precache the projection rays.
+        model.eval()
+        with torch.no_grad():
+            for dataset in (train_dataset, val_dataset):
+                cache_cameras = [e["camera"].to(device) for e in dataset]
+                cache_camera_hashes = [e["camera_idx"] for e in dataset]
+                model.precache_rays(cache_cameras, cache_camera_hashes)
+
+    train_dataloader = torch.utils.data.DataLoader(
+        train_dataset,
+        batch_size=1,
+        shuffle=True,
+        num_workers=0,
+        collate_fn=trivial_collate,
+    )
+
+    # The validation dataloader is just an endless stream of random samples.
+    val_dataloader = torch.utils.data.DataLoader(
+        val_dataset,
+        batch_size=1,
+        num_workers=0,
+        collate_fn=trivial_collate,
+        sampler=torch.utils.data.RandomSampler(
+            val_dataset,
+            replacement=True,
+            num_samples=cfg.optimizer.max_epochs,
+        ),
+    )
+
+    # Set the model to the training mode.
+    model.train()
+
+    # Run the main training loop.
+    for epoch in range(start_epoch, cfg.optimizer.max_epochs):
+        stats.new_epoch()  # Init a new epoch.
+        for iteration, batch in enumerate(train_dataloader):
+            image, camera, camera_idx = batch[0].values()
+            image = image.to(device)
+            camera = camera.to(device)
+
+            optimizer.zero_grad()
+
+            # Run the forward pass of the model.
+            nerf_out, metrics = model(
+                camera_idx if cfg.data.precache_rays else None,
+                camera,
+                image,
+            )
+
+            # The loss is a sum of coarse and fine MSEs
+            loss = metrics["mse_coarse"] + metrics["mse_fine"]
+
+            # Take the training step.
+            loss.backward()
+            optimizer.step()
+
+            # Update stats with the current metrics.
+            stats.update(
+                {"loss": float(loss), **metrics},
+                stat_set="train",
+            )
+
+            if iteration % cfg.stats_print_interval == 0:
+                stats.print(stat_set="train")
+
+            # Update the visualization cache.
+            if viz is not None:
+                visuals_cache.append(
+                    {
+                        "camera": camera.cpu(),
+                        "camera_idx": camera_idx,
+                        "image": image.cpu().detach(),
+                        "rgb_fine": nerf_out["rgb_fine"].cpu().detach(),
+                        "rgb_coarse": nerf_out["rgb_coarse"].cpu().detach(),
+                        "rgb_gt": nerf_out["rgb_gt"].cpu().detach(),
+                        "coarse_ray_bundle": nerf_out["coarse_ray_bundle"],
+                    }
+                )
+
+        # Adjust the learning rate.
+        lr_scheduler.step()
+
+        # 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()
+            val_image = val_image.to(device)
+            val_camera = val_camera.to(device)
+
+            # Activate eval mode of the model (lets us do a full rendering pass).
+            model.eval()
+            with torch.no_grad():
+                val_nerf_out, val_metrics = model(
+                    camera_idx if cfg.data.precache_rays else None,
+                    val_camera,
+                    val_image,
+                )
+
+            # Update stats with the validation metrics.
+            stats.update(val_metrics, stat_set="val")
+            stats.print(stat_set="val")
+
+            if viz is not None:
+                # Plot that loss curves into visdom.
+                stats.plot_stats(
+                    viz=viz,
+                    visdom_env=cfg.visualization.visdom_env,
+                    plot_file=None,
+                )
+                # Visualize the intermediate results.
+                visualize_nerf_outputs(
+                    val_nerf_out, visuals_cache, viz, cfg.visualization.visdom_env
+                )
+
+            # Set the model back to train mode.
+            model.train()
+
+        # Checkpoint.
+        if (
+            epoch % cfg.checkpoint_epoch_interval == 0
+            and len(cfg.checkpoint_path) > 0
+            and epoch > 0
+        ):
+            print(f"Storing checkpoint {checkpoint_path}.")
+            data_to_store = {
+                "model": model.state_dict(),
+                "optimizer": optimizer.state_dict(),
+                "stats": pickle.dumps(stats),
+            }
+            torch.save(data_to_store, checkpoint_path)
+
+
+if __name__ == "__main__":
+    main()

project/ManiSkill3/src/maniskill2_benchmark/cfdp_experiment/cfdp/extern/pytorch3d/pytorch3d/__init__.py

@@ -0,0 +1,9 @@
+# Copyright (c) Meta Platforms, Inc. and affiliates.
+# All rights reserved.
+#
+# This source code is licensed under the BSD-style license found in the
+# LICENSE file in the root directory of this source tree.
+
+# pyre-unsafe
+
+__version__ = "0.7.8"

project/ManiSkill3/src/maniskill2_benchmark/cfdp_experiment/cfdp/extern/pytorch3d/pytorch3d/datasets/__init__.py

@@ -0,0 +1,14 @@
+# Copyright (c) Meta Platforms, Inc. and affiliates.
+# All rights reserved.
+#
+# This source code is licensed under the BSD-style license found in the
+# LICENSE file in the root directory of this source tree.
+
+# pyre-unsafe
+
+from .r2n2 import BlenderCamera, collate_batched_R2N2, R2N2, render_cubified_voxels
+from .shapenet import ShapeNetCore
+from .utils import collate_batched_meshes
+
+
+__all__ = [k for k in globals().keys() if not k.startswith("_")]

project/ManiSkill3/src/maniskill2_benchmark/cfdp_experiment/cfdp/extern/pytorch3d/pytorch3d/datasets/r2n2/__init__.py

@@ -0,0 +1,13 @@
+# Copyright (c) Meta Platforms, Inc. and affiliates.
+# All rights reserved.
+#
+# This source code is licensed under the BSD-style license found in the
+# LICENSE file in the root directory of this source tree.
+
+# pyre-unsafe
+
+from .r2n2 import R2N2
+from .utils import BlenderCamera, collate_batched_R2N2, render_cubified_voxels
+
+
+__all__ = [k for k in globals().keys() if not k.startswith("_")]

project/ManiSkill3/src/maniskill2_benchmark/cfdp_experiment/cfdp/extern/pytorch3d/pytorch3d/datasets/r2n2/r2n2.py

@@ -0,0 +1,427 @@
+# Copyright (c) Meta Platforms, Inc. and affiliates.
+# All rights reserved.
+#
+# This source code is licensed under the BSD-style license found in the
+# LICENSE file in the root directory of this source tree.
+
+# pyre-unsafe
+
+import json
+import warnings
+from os import path
+from pathlib import Path
+from typing import Dict, List, Optional
+
+import numpy as np
+import torch
+from PIL import Image
+from pytorch3d.common.datatypes import Device
+from pytorch3d.datasets.shapenet_base import ShapeNetBase
+from pytorch3d.renderer import HardPhongShader
+from tabulate import tabulate
+
+from .utils import (
+    align_bbox,
+    BlenderCamera,
+    compute_extrinsic_matrix,
+    read_binvox_coords,
+    voxelize,
+)
+
+
+SYNSET_DICT_DIR = Path(__file__).resolve().parent
+MAX_CAMERA_DISTANCE = 1.75  # Constant from R2N2.
+VOXEL_SIZE = 128
+# Intrinsic matrix extracted from Blender. Taken from meshrcnn codebase:
+# https://github.com/facebookresearch/meshrcnn/blob/main/shapenet/utils/coords.py
+BLENDER_INTRINSIC = torch.tensor(
+    [
+        [2.1875, 0.0, 0.0, 0.0],
+        [0.0, 2.1875, 0.0, 0.0],
+        [0.0, 0.0, -1.002002, -0.2002002],
+        [0.0, 0.0, -1.0, 0.0],
+    ]
+)
+
+
+class R2N2(ShapeNetBase):  # pragma: no cover
+    """
+    This class loads the R2N2 dataset from a given directory into a Dataset object.
+    The R2N2 dataset contains 13 categories that are a subset of the ShapeNetCore v.1
+    dataset. The R2N2 dataset also contains its own 24 renderings of each object and
+    voxelized models. Most of the models have all 24 views in the same split, but there
+    are eight of them that divide their views between train and test splits.
+
+    """
+
+    def __init__(
+        self,
+        split: str,
+        shapenet_dir: str,
+        r2n2_dir: str,
+        splits_file: str,
+        return_all_views: bool = True,
+        return_voxels: bool = False,
+        views_rel_path: str = "ShapeNetRendering",
+        voxels_rel_path: str = "ShapeNetVoxels",
+        load_textures: bool = True,
+        texture_resolution: int = 4,
+    ) -> None:
+        """
+        Store each object's synset id and models id the given directories.
+
+        Args:
+            split (str): One of (train, val, test).
+            shapenet_dir (str): Path to ShapeNet core v1.
+            r2n2_dir (str): Path to the R2N2 dataset.
+            splits_file (str): File containing the train/val/test splits.
+            return_all_views (bool): Indicator of whether or not to load all the views in
+                the split. If set to False, one of the views in the split will be randomly
+                selected and loaded.
+            return_voxels(bool): Indicator of whether or not to return voxels as a tensor
+                of shape (D, D, D) where D is the number of voxels along each dimension.
+            views_rel_path: path to rendered views within the r2n2_dir. If not specified,
+                the renderings are assumed to be at os.path.join(rn2n_dir, "ShapeNetRendering").
+            voxels_rel_path: path to rendered views within the r2n2_dir. If not specified,
+                the renderings are assumed to be at os.path.join(rn2n_dir, "ShapeNetVoxels").
+            load_textures: Boolean indicating whether textures should loaded for the model.
+                Textures will be of type TexturesAtlas i.e. a texture map per face.
+            texture_resolution: Int specifying the resolution of the texture map per face
+                created using the textures in the obj file. A
+                (texture_resolution, texture_resolution, 3) map is created per face.
+
+        """
+        super().__init__()
+        self.shapenet_dir = shapenet_dir
+        self.r2n2_dir = r2n2_dir
+        self.views_rel_path = views_rel_path
+        self.voxels_rel_path = voxels_rel_path
+        self.load_textures = load_textures
+        self.texture_resolution = texture_resolution
+        # Examine if split is valid.
+        if split not in ["train", "val", "test"]:
+            raise ValueError("split has to be one of (train, val, test).")
+        # Synset dictionary mapping synset offsets in R2N2 to corresponding labels.
+        with open(
+            path.join(SYNSET_DICT_DIR, "r2n2_synset_dict.json"), "r"
+        ) as read_dict:
+            self.synset_dict = json.load(read_dict)
+        # Inverse dictionary mapping synset labels to corresponding offsets.
+        self.synset_inv = {label: offset for offset, label in self.synset_dict.items()}
+
+        # Store synset and model ids of objects mentioned in the splits_file.
+        with open(splits_file) as splits:
+            split_dict = json.load(splits)[split]
+
+        self.return_images = True
+        # Check if the folder containing R2N2 renderings is included in r2n2_dir.
+        if not path.isdir(path.join(r2n2_dir, views_rel_path)):
+            self.return_images = False
+            msg = (
+                "%s not found in %s. R2N2 renderings will "
+                "be skipped when returning models."
+            ) % (views_rel_path, r2n2_dir)
+            warnings.warn(msg)
+
+        self.return_voxels = return_voxels
+        # Check if the folder containing voxel coordinates is included in r2n2_dir.
+        if not path.isdir(path.join(r2n2_dir, voxels_rel_path)):
+            self.return_voxels = False
+            msg = (
+                "%s not found in %s. Voxel coordinates will "
+                "be skipped when returning models."
+            ) % (voxels_rel_path, r2n2_dir)
+            warnings.warn(msg)
+
+        synset_set = set()
+        # Store lists of views of each model in a list.
+        self.views_per_model_list = []
+        # Store tuples of synset label and total number of views in each category in a list.
+        synset_num_instances = []
+        for synset in split_dict.keys():
+            # Examine if the given synset is present in the ShapeNetCore dataset
+            # and is also part of the standard R2N2 dataset.
+            if not (
+                path.isdir(path.join(shapenet_dir, synset))
+                and synset in self.synset_dict
+            ):
+                msg = (
+                    "Synset category %s from the splits file is either not "
+                    "present in %s or not part of the standard R2N2 dataset."
+                ) % (synset, shapenet_dir)
+                warnings.warn(msg)
+                continue
+
+            synset_set.add(synset)
+            self.synset_start_idxs[synset] = len(self.synset_ids)
+            # Start counting total number of views in the current category.
+            synset_view_count = 0
+            for model in split_dict[synset]:
+                # Examine if the given model is present in the ShapeNetCore path.
+                shapenet_path = path.join(shapenet_dir, synset, model)
+                if not path.isdir(shapenet_path):
+                    msg = "Model %s from category %s is not present in %s." % (
+                        model,
+                        synset,
+                        shapenet_dir,
+                    )
+                    warnings.warn(msg)
+                    continue
+                self.synset_ids.append(synset)
+                self.model_ids.append(model)
+
+                model_views = split_dict[synset][model]
+                # Randomly select a view index if return_all_views set to False.
+                if not return_all_views:
+                    rand_idx = torch.randint(len(model_views), (1,))
+                    model_views = [model_views[rand_idx]]
+                self.views_per_model_list.append(model_views)
+                synset_view_count += len(model_views)
+            synset_num_instances.append((self.synset_dict[synset], synset_view_count))
+            model_count = len(self.synset_ids) - self.synset_start_idxs[synset]
+            self.synset_num_models[synset] = model_count
+        headers = ["category", "#instances"]
+        synset_num_instances.append(("total", sum(n for _, n in synset_num_instances)))
+        print(
+            tabulate(synset_num_instances, headers, numalign="left", stralign="center")
+        )
+
+        # Examine if all the synsets in the standard R2N2 mapping are present.
+        # Update self.synset_inv so that it only includes the loaded categories.
+        synset_not_present = [
+            self.synset_inv.pop(self.synset_dict[synset])
+            for synset in self.synset_dict
+            if synset not in synset_set
+        ]
+        if len(synset_not_present) > 0:
+            msg = (
+                "The following categories are included in R2N2's"
+                "official mapping but not found in the dataset location %s: %s"
+            ) % (shapenet_dir, ", ".join(synset_not_present))
+            warnings.warn(msg)
+
+    def __getitem__(self, model_idx, view_idxs: Optional[List[int]] = None) -> Dict:
+        """
+        Read a model by the given index.
+
+        Args:
+            model_idx: The idx of the model to be retrieved in the dataset.
+            view_idx: List of indices of the view to be returned. Each index needs to be
+                contained in the loaded split (always between 0 and 23, inclusive). If
+                an invalid index is supplied, view_idx will be ignored and all the loaded
+                views will be returned.
+
+        Returns:
+            dictionary with following keys:
+            - verts: FloatTensor of shape (V, 3).
+            - faces: faces.verts_idx, LongTensor of shape (F, 3).
+            - synset_id (str): synset id.
+            - model_id (str): model id.
+            - label (str): synset label.
+            - images: FloatTensor of shape (V, H, W, C), where V is number of views
+                returned. Returns a batch of the renderings of the models from the R2N2 dataset.
+            - R: Rotation matrix of shape (V, 3, 3), where V is number of views returned.
+            - T: Translation matrix of shape (V, 3), where V is number of views returned.
+            - K: Intrinsic matrix of shape (V, 4, 4), where V is number of views returned.
+            - voxels: Voxels of shape (D, D, D), where D is the number of voxels along each
+                dimension.
+        """
+        if isinstance(model_idx, tuple):
+            model_idx, view_idxs = model_idx
+        if view_idxs is not None:
+            if isinstance(view_idxs, int):
+                view_idxs = [view_idxs]
+            if not isinstance(view_idxs, list) and not torch.is_tensor(view_idxs):
+                raise TypeError(
+                    "view_idxs is of type %s but it needs to be a list."
+                    % type(view_idxs)
+                )
+
+        model_views = self.views_per_model_list[model_idx]
+        if view_idxs is not None and any(
+            idx not in self.views_per_model_list[model_idx] for idx in view_idxs
+        ):
+            msg = """At least one of the indices in view_idxs is not available.
+                Specified view of the model needs to be contained in the
+                loaded split. If return_all_views is set to False, only one
+                random view is loaded. Try accessing the specified view(s)
+                after loading the dataset with self.return_all_views set to True.
+                Now returning all view(s) in the loaded dataset."""
+            warnings.warn(msg)
+        elif view_idxs is not None:
+            model_views = view_idxs
+
+        model = self._get_item_ids(model_idx)
+        model_path = path.join(
+            self.shapenet_dir, model["synset_id"], model["model_id"], "model.obj"
+        )
+
+        verts, faces, textures = self._load_mesh(model_path)
+        model["verts"] = verts
+        model["faces"] = faces
+        model["textures"] = textures
+        model["label"] = self.synset_dict[model["synset_id"]]
+
+        model["images"] = None
+        images, Rs, Ts, voxel_RTs = [], [], [], []
+        # Retrieve R2N2's renderings if required.
+        if self.return_images:
+            rendering_path = path.join(
+                self.r2n2_dir,
+                self.views_rel_path,
+                model["synset_id"],
+                model["model_id"],
+                "rendering",
+            )
+            # Read metadata file to obtain params for calibration matrices.
+            with open(path.join(rendering_path, "rendering_metadata.txt"), "r") as f:
+                metadata_lines = f.readlines()
+            for i in model_views:
+                # Read image.
+                image_path = path.join(rendering_path, "%02d.png" % i)
+                raw_img = Image.open(image_path)
+                image = torch.from_numpy(np.array(raw_img) / 255.0)[..., :3]
+                images.append(image.to(dtype=torch.float32))
+
+                # Get camera calibration.
+                azim, elev, yaw, dist_ratio, fov = [
+                    float(v) for v in metadata_lines[i].strip().split(" ")
+                ]
+                dist = dist_ratio * MAX_CAMERA_DISTANCE
+                # Extrinsic matrix before transformation to PyTorch3D world space.
+                RT = compute_extrinsic_matrix(azim, elev, dist)
+                R, T = self._compute_camera_calibration(RT)
+                Rs.append(R)
+                Ts.append(T)
+                voxel_RTs.append(RT)
+
+            # Intrinsic matrix extracted from the Blender with slight modification to work with
+            # PyTorch3D world space. Taken from meshrcnn codebase:
+            # https://github.com/facebookresearch/meshrcnn/blob/main/shapenet/utils/coords.py
+            K = torch.tensor(
+                [
+                    [2.1875, 0.0, 0.0, 0.0],
+                    [0.0, 2.1875, 0.0, 0.0],
+                    [0.0, 0.0, -1.002002, -0.2002002],
+                    [0.0, 0.0, 1.0, 0.0],
+                ]
+            )
+            model["images"] = torch.stack(images)
+            model["R"] = torch.stack(Rs)
+            model["T"] = torch.stack(Ts)
+            model["K"] = K.expand(len(model_views), 4, 4)
+
+        voxels_list = []
+
+        # Read voxels if required.
+        voxel_path = path.join(
+            self.r2n2_dir,
+            self.voxels_rel_path,
+            model["synset_id"],
+            model["model_id"],
+            "model.binvox",
+        )
+        if self.return_voxels:
+            if not path.isfile(voxel_path):
+                msg = "Voxel file not found for model %s from category %s."
+                raise FileNotFoundError(msg % (model["model_id"], model["synset_id"]))
+
+            with open(voxel_path, "rb") as f:
+                # Read voxel coordinates as a tensor of shape (N, 3).
+                voxel_coords = read_binvox_coords(f)
+            # Align voxels to the same coordinate system as mesh verts.
+            voxel_coords = align_bbox(voxel_coords, model["verts"])
+            for RT in voxel_RTs:
+                # Compute projection matrix.
+                P = BLENDER_INTRINSIC.mm(RT)
+                # Convert voxel coordinates of shape (N, 3) to voxels of shape (D, D, D).
+                voxels = voxelize(voxel_coords, P, VOXEL_SIZE)
+                voxels_list.append(voxels)
+            model["voxels"] = torch.stack(voxels_list)
+
+        return model
+
+    def _compute_camera_calibration(self, RT):
+        """
+        Helper function for calculating rotation and translation matrices from ShapeNet
+        to camera transformation and ShapeNet to PyTorch3D transformation.
+
+        Args:
+            RT: Extrinsic matrix that performs ShapeNet world view to camera view
+                transformation.
+
+        Returns:
+            R: Rotation matrix of shape (3, 3).
+            T: Translation matrix of shape (3).
+        """
+        # Transform the mesh vertices from shapenet world to pytorch3d world.
+        shapenet_to_pytorch3d = torch.tensor(
+            [
+                [-1.0, 0.0, 0.0, 0.0],
+                [0.0, 1.0, 0.0, 0.0],
+                [0.0, 0.0, -1.0, 0.0],
+                [0.0, 0.0, 0.0, 1.0],
+            ],
+            dtype=torch.float32,
+        )
+        RT = torch.transpose(RT, 0, 1).mm(shapenet_to_pytorch3d)  # (4, 4)
+        # Extract rotation and translation matrices from RT.
+        R = RT[:3, :3]
+        T = RT[3, :3]
+        return R, T
+
+    def render(
+        self,
+        model_ids: Optional[List[str]] = None,
+        categories: Optional[List[str]] = None,
+        sample_nums: Optional[List[int]] = None,
+        idxs: Optional[List[int]] = None,
+        view_idxs: Optional[List[int]] = None,
+        shader_type=HardPhongShader,
+        device: Device = "cpu",
+        **kwargs,
+    ) -> torch.Tensor:
+        """
+        Render models with BlenderCamera by default to achieve the same orientations as the
+        R2N2 renderings. Also accepts other types of cameras and any of the args that the
+        render function in the ShapeNetBase class accepts.
+
+        Args:
+            view_idxs: each model will be rendered with the orientation(s) of the specified
+                views. Only render by view_idxs if no camera or args for BlenderCamera is
+                supplied.
+            Accepts any of the args of the render function in ShapeNetBase:
+            model_ids: List[str] of model_ids of models intended to be rendered.
+            categories: List[str] of categories intended to be rendered. categories
+                and sample_nums must be specified at the same time. categories can be given
+                in the form of synset offsets or labels, or a combination of both.
+            sample_nums: List[int] of number of models to be randomly sampled from
+                each category. Could also contain one single integer, in which case it
+                will be broadcasted for every category.
+            idxs: List[int] of indices of models to be rendered in the dataset.
+            shader_type: Shader to use for rendering. Examples include HardPhongShader
+            (default), SoftPhongShader etc or any other type of valid Shader class.
+            device: Device (as str or torch.device) on which the tensors should be located.
+            **kwargs: Accepts any of the kwargs that the renderer supports and any of the
+                args that BlenderCamera supports.
+
+        Returns:
+            Batch of rendered images of shape (N, H, W, 3).
+        """
+        idxs = self._handle_render_inputs(model_ids, categories, sample_nums, idxs)
+        r = torch.cat([self[idxs[i], view_idxs]["R"] for i in range(len(idxs))])
+        t = torch.cat([self[idxs[i], view_idxs]["T"] for i in range(len(idxs))])
+        k = torch.cat([self[idxs[i], view_idxs]["K"] for i in range(len(idxs))])
+        # Initialize default camera using R, T, K from kwargs or R, T, K of the specified views.
+        blend_cameras = BlenderCamera(
+            R=kwargs.get("R", r),
+            T=kwargs.get("T", t),
+            K=kwargs.get("K", k),
+            device=device,
+        )
+        cameras = kwargs.get("cameras", blend_cameras).to(device)
+        kwargs.pop("cameras", None)
+        # pass down all the same inputs
+        return super().render(
+            idxs=idxs, shader_type=shader_type, device=device, cameras=cameras, **kwargs
+        )

project/ManiSkill3/src/maniskill2_benchmark/cfdp_experiment/cfdp/extern/pytorch3d/pytorch3d/datasets/r2n2/r2n2_synset_dict.json

@@ -0,0 +1,15 @@
+{
+    "04256520": "sofa",
+    "02933112": "cabinet",
+    "02828884": "bench",
+    "03001627": "chair",
+    "03211117": "display",
+    "04090263": "rifle",
+    "03691459": "loudspeaker",
+    "03636649": "lamp",
+    "04401088": "telephone",
+    "02691156": "airplane",
+    "04379243": "table",
+    "02958343": "car",
+    "04530566": "watercraft"
+}

project/ManiSkill3/src/maniskill2_benchmark/cfdp_experiment/cfdp/extern/pytorch3d/pytorch3d/datasets/r2n2/utils.py

@@ -0,0 +1,504 @@
+# Copyright (c) Meta Platforms, Inc. and affiliates.
+# All rights reserved.
+#
+# This source code is licensed under the BSD-style license found in the
+# LICENSE file in the root directory of this source tree.
+
+# pyre-unsafe
+
+import math
+from typing import Dict, List
+
+import numpy as np
+import torch
+from pytorch3d.common.datatypes import Device
+from pytorch3d.datasets.utils import collate_batched_meshes
+from pytorch3d.ops import cubify
+from pytorch3d.renderer import (
+    HardPhongShader,
+    MeshRasterizer,
+    MeshRenderer,
+    PointLights,
+    RasterizationSettings,
+    TexturesVertex,
+)
+from pytorch3d.renderer.cameras import CamerasBase
+from pytorch3d.transforms import Transform3d
+
+
+# Empirical min and max over the dataset from meshrcnn.
+# https://github.com/facebookresearch/meshrcnn/blob/main/shapenet/utils/coords.py#L9
+SHAPENET_MIN_ZMIN = 0.67
+SHAPENET_MAX_ZMAX = 0.92
+# Threshold for cubify from meshrcnn:
+# https://github.com/facebookresearch/meshrcnn/blob/main/configs/shapenet/voxmesh_R50.yaml#L11
+CUBIFY_THRESH = 0.2
+
+# Default values of rotation, translation and intrinsic matrices for BlenderCamera.
+r = np.expand_dims(np.eye(3), axis=0)  # (1, 3, 3)
+t = np.expand_dims(np.zeros(3), axis=0)  # (1, 3)
+k = np.expand_dims(np.eye(4), axis=0)  # (1, 4, 4)
+
+
+def collate_batched_R2N2(batch: List[Dict]):  # pragma: no cover
+    """
+    Take a list of objects in the form of dictionaries and merge them
+    into a single dictionary. This function can be used with a Dataset
+    object to create a torch.utils.data.Dataloader which directly
+    returns Meshes objects.
+    TODO: Add support for textures.
+
+    Args:
+        batch: List of dictionaries containing information about objects
+            in the dataset.
+
+    Returns:
+        collated_dict: Dictionary of collated lists. If batch contains both
+            verts and faces, a collated mesh batch is also returned.
+    """
+    collated_dict = collate_batched_meshes(batch)
+
+    # If collate_batched_meshes receives R2N2 items with images and that
+    # all models have the same number of views V, stack the batches of
+    # views of each model into a new batch of shape (N, V, H, W, 3).
+    # Otherwise leave it as a list.
+    if "images" in collated_dict:
+        try:
+            collated_dict["images"] = torch.stack(collated_dict["images"])
+        except RuntimeError:
+            print(
+                "Models don't have the same number of views. Now returning "
+                "lists of images instead of batches."
+            )
+
+    # If collate_batched_meshes receives R2N2 items with camera calibration
+    # matrices and that all models have the same number of views V, stack each
+    # type of matrices into a new batch of shape (N, V, ...).
+    # Otherwise leave them as lists.
+    if all(x in collated_dict for x in ["R", "T", "K"]):
+        try:
+            collated_dict["R"] = torch.stack(collated_dict["R"])  # (N, V, 3, 3)
+            collated_dict["T"] = torch.stack(collated_dict["T"])  # (N, V, 3)
+            collated_dict["K"] = torch.stack(collated_dict["K"])  # (N, V, 4, 4)
+        except RuntimeError:
+            print(
+                "Models don't have the same number of views. Now returning "
+                "lists of calibration matrices instead of a batched tensor."
+            )
+
+    # If collate_batched_meshes receives voxels and all models have the same
+    # number of views V, stack the batches of voxels into a new batch of shape
+    # (N, V, S, S, S), where S is the voxel size.
+    if "voxels" in collated_dict:
+        try:
+            collated_dict["voxels"] = torch.stack(collated_dict["voxels"])
+        except RuntimeError:
+            print(
+                "Models don't have the same number of views. Now returning "
+                "lists of voxels instead of a batched tensor."
+            )
+    return collated_dict
+
+
+def compute_extrinsic_matrix(
+    azimuth: float, elevation: float, distance: float
+):  # pragma: no cover
+    """
+    Copied from meshrcnn codebase:
+    https://github.com/facebookresearch/meshrcnn/blob/main/shapenet/utils/coords.py#L96
+
+    Compute 4x4 extrinsic matrix that converts from homogeneous world coordinates
+    to homogeneous camera coordinates. We assume that the camera is looking at the
+    origin.
+    Used in R2N2 Dataset when computing calibration matrices.
+
+    Args:
+        azimuth: Rotation about the z-axis, in degrees.
+        elevation: Rotation above the xy-plane, in degrees.
+        distance: Distance from the origin.
+
+    Returns:
+        FloatTensor of shape (4, 4).
+    """
+    azimuth, elevation, distance = float(azimuth), float(elevation), float(distance)
+
+    az_rad = -math.pi * azimuth / 180.0
+    el_rad = -math.pi * elevation / 180.0
+    sa = math.sin(az_rad)
+    ca = math.cos(az_rad)
+    se = math.sin(el_rad)
+    ce = math.cos(el_rad)
+    R_world2obj = torch.tensor(
+        [[ca * ce, sa * ce, -se], [-sa, ca, 0], [ca * se, sa * se, ce]]
+    )
+    R_obj2cam = torch.tensor([[0.0, 1.0, 0.0], [0.0, 0.0, 1.0], [1.0, 0.0, 0.0]])
+    R_world2cam = R_obj2cam.mm(R_world2obj)
+    cam_location = torch.tensor([[distance, 0, 0]]).t()
+    T_world2cam = -(R_obj2cam.mm(cam_location))
+    RT = torch.cat([R_world2cam, T_world2cam], dim=1)
+    RT = torch.cat([RT, torch.tensor([[0.0, 0, 0, 1]])])
+
+    # Georgia: For some reason I cannot fathom, when Blender loads a .obj file it
+    # rotates the model 90 degrees about the x axis. To compensate for this quirk we
+    # roll that rotation into the extrinsic matrix here
+    rot = torch.tensor([[1, 0, 0, 0], [0, 0, -1, 0], [0, 1, 0, 0], [0, 0, 0, 1]])
+    RT = RT.mm(rot.to(RT))
+
+    return RT
+
+
+def read_binvox_coords(
+    f,
+    integer_division: bool = True,
+    dtype: torch.dtype = torch.float32,
+):  # pragma: no cover
+    """
+    Copied from meshrcnn codebase:
+    https://github.com/facebookresearch/meshrcnn/blob/main/shapenet/utils/binvox_torch.py#L5
+
+    Read a binvox file and return the indices of all nonzero voxels.
+
+    This matches the behavior of binvox_rw.read_as_coord_array
+    (https://github.com/dimatura/binvox-rw-py/blob/public/binvox_rw.py#L153)
+    but this implementation uses torch rather than numpy, and is more efficient
+    due to improved vectorization.
+
+    Georgia: I think that binvox_rw.read_as_coord_array actually has a bug; when converting
+    linear indices into three-dimensional indices, they use floating-point
+    division instead of integer division. We can reproduce their incorrect
+    implementation by passing integer_division=False.
+
+    Args:
+      f (str): A file pointer to the binvox file to read
+      integer_division (bool): If False, then match the buggy implementation from binvox_rw
+      dtype: Datatype of the output tensor. Use float64 to match binvox_rw
+
+    Returns:
+      coords (tensor): A tensor of shape (N, 3) where N is the number of nonzero voxels,
+           and coords[i] = (x, y, z) gives the index of the ith nonzero voxel. If the
+           voxel grid has shape (V, V, V) then we have 0 <= x, y, z < V.
+    """
+    size, translation, scale = _read_binvox_header(f)
+    storage = torch.ByteStorage.from_buffer(f.read())
+    data = torch.tensor([], dtype=torch.uint8)
+    # pyre-fixme[28]: Unexpected keyword argument `source`.
+    data.set_(source=storage)
+    vals, counts = data[::2], data[1::2]
+    idxs = _compute_idxs(vals, counts)
+    if not integer_division:
+        idxs = idxs.to(dtype)
+    x_idxs = idxs // (size * size)
+    zy_idxs = idxs % (size * size)
+    z_idxs = zy_idxs // size
+    y_idxs = zy_idxs % size
+    coords = torch.stack([x_idxs, y_idxs, z_idxs], dim=1)
+    return coords.to(dtype)
+
+
+def _compute_idxs(vals, counts):  # pragma: no cover
+    """
+    Copied from meshrcnn codebase:
+    https://github.com/facebookresearch/meshrcnn/blob/main/shapenet/utils/binvox_torch.py#L58
+
+    Fast vectorized version of index computation.
+
+    Args:
+        vals: tensor of binary values indicating voxel presence in a dense format.
+        counts: tensor of number of occurrence of each value in vals.
+
+    Returns:
+        idxs: A tensor of shape (N), where N is the number of nonzero voxels.
+    """
+    # Consider an example where:
+    # vals   = [0, 1, 0, 1, 1]
+    # counts = [2, 3, 3, 2, 1]
+    #
+    # These values of counts and vals mean that the dense binary grid is:
+    # [0, 0, 1, 1, 1, 0, 0, 0, 1, 1, 1]
+    #
+    # So the nonzero indices we want to return are:
+    # [2, 3, 4, 8, 9, 10]
+
+    # After the cumsum we will have:
+    # end_idxs = [2, 5, 8, 10, 11]
+    end_idxs = counts.cumsum(dim=0)
+
+    # After masking and computing start_idx we have:
+    # end_idxs   = [5, 10, 11]
+    # counts     = [3,  2,  1]
+    # start_idxs = [2,  8, 10]
+    mask = vals == 1
+    end_idxs = end_idxs[mask]
+    counts = counts[mask].to(end_idxs)
+    start_idxs = end_idxs - counts
+
+    # We initialize delta as:
+    # [2, 1, 1, 1, 1, 1]
+    delta = torch.ones(counts.sum().item(), dtype=torch.int64)
+    delta[0] = start_idxs[0]
+
+    # We compute pos = [3, 5], val = [3, 0]; then delta is
+    # [2, 1, 1, 4, 1, 1]
+    pos = counts.cumsum(dim=0)[:-1]
+    val = start_idxs[1:] - end_idxs[:-1]
+    delta[pos] += val
+
+    # A final cumsum gives the idx we want: [2, 3, 4, 8, 9, 10]
+    idxs = delta.cumsum(dim=0)
+    return idxs
+
+
+def _read_binvox_header(f):  # pragma: no cover
+    """
+    Copied from meshrcnn codebase:
+    https://github.com/facebookresearch/meshrcnn/blob/main/shapenet/utils/binvox_torch.py#L99
+
+    Read binvox header and extract information regarding voxel sizes and translations
+    to original voxel coordinates.
+
+    Args:
+        f (str): A file pointer to the binvox file to read.
+
+    Returns:
+        size (int): size of voxel.
+        translation (tuple(float)): translation to original voxel coordinates.
+        scale (float): scale to original voxel coordinates.
+    """
+    # First line of the header should be "#binvox 1"
+    line = f.readline().strip()
+    if line != b"#binvox 1":
+        raise ValueError("Invalid header (line 1)")
+
+    # Second line of the header should be "dim [int] [int] [int]"
+    # and all three int should be the same
+    line = f.readline().strip()
+    if not line.startswith(b"dim "):
+        raise ValueError("Invalid header (line 2)")
+    dims = line.split(b" ")
+    try:
+        dims = [int(d) for d in dims[1:]]
+    except ValueError:
+        raise ValueError("Invalid header (line 2)") from None
+    if len(dims) != 3 or dims[0] != dims[1] or dims[0] != dims[2]:
+        raise ValueError("Invalid header (line 2)")
+    size = dims[0]
+
+    # Third line of the header should be "translate [float] [float] [float]"
+    line = f.readline().strip()
+    if not line.startswith(b"translate "):
+        raise ValueError("Invalid header (line 3)")
+    translation = line.split(b" ")
+    if len(translation) != 4:
+        raise ValueError("Invalid header (line 3)")
+    try:
+        translation = tuple(float(t) for t in translation[1:])
+    except ValueError:
+        raise ValueError("Invalid header (line 3)") from None
+
+    # Fourth line of the header should be "scale [float]"
+    line = f.readline().strip()
+    if not line.startswith(b"scale "):
+        raise ValueError("Invalid header (line 4)")
+    line = line.split(b" ")
+    if not len(line) == 2:
+        raise ValueError("Invalid header (line 4)")
+    scale = float(line[1])
+
+    # Fifth line of the header should be "data"
+    line = f.readline().strip()
+    if not line == b"data":
+        raise ValueError("Invalid header (line 5)")
+
+    return size, translation, scale
+
+
+def align_bbox(src, tgt):  # pragma: no cover
+    """
+    Copied from meshrcnn codebase:
+    https://github.com/facebookresearch/meshrcnn/blob/main/tools/preprocess_shapenet.py#L263
+
+    Return a copy of src points in the coordinate system of tgt by applying a
+    scale and shift along each coordinate axis to make the min / max values align.
+
+    Args:
+        src, tgt: Torch Tensor of shape (N, 3)
+
+    Returns:
+        out: Torch Tensor of shape (N, 3)
+    """
+    if src.ndim != 2 or tgt.ndim != 2:
+        raise ValueError("Both src and tgt need to have dimensions of 2.")
+    if src.shape[-1] != 3 or tgt.shape[-1] != 3:
+        raise ValueError(
+            "Both src and tgt need to have sizes of 3 along the second dimension."
+        )
+    src_min = src.min(dim=0)[0]
+    src_max = src.max(dim=0)[0]
+    tgt_min = tgt.min(dim=0)[0]
+    tgt_max = tgt.max(dim=0)[0]
+    scale = (tgt_max - tgt_min) / (src_max - src_min)
+    shift = tgt_min - scale * src_min
+    out = scale * src + shift
+    return out
+
+
+def voxelize(voxel_coords, P, V):  # pragma: no cover
+    """
+    Copied from meshrcnn codebase:
+    https://github.com/facebookresearch/meshrcnn/blob/main/tools/preprocess_shapenet.py#L284
+    but changing flip y to flip x.
+
+    Creating voxels of shape (D, D, D) from voxel_coords and projection matrix.
+
+    Args:
+        voxel_coords: FloatTensor of shape (V, 3) giving voxel's coordinates aligned to
+            the vertices.
+        P: FloatTensor of shape (4, 4) giving the projection matrix.
+        V: Voxel size of the output.
+
+    Returns:
+        voxels: Tensor of shape (D, D, D) giving the voxelized result.
+    """
+    device = voxel_coords.device
+    voxel_coords = project_verts(voxel_coords, P)
+
+    # Using the actual zmin and zmax of the model is bad because we need them
+    # to perform the inverse transform, which transform voxels back into world
+    # space for refinement or evaluation. Instead we use an empirical min and
+    # max over the dataset; that way it is consistent for all images.
+    zmin = SHAPENET_MIN_ZMIN
+    zmax = SHAPENET_MAX_ZMAX
+
+    # Once we know zmin and zmax, we need to adjust the z coordinates so the
+    # range [zmin, zmax] instead runs from [-1, 1]
+    m = 2.0 / (zmax - zmin)
+    b = -2.0 * zmin / (zmax - zmin) - 1
+    voxel_coords[:, 2].mul_(m).add_(b)
+    voxel_coords[:, 0].mul_(-1)  # Flip x
+
+    # Now voxels are in [-1, 1]^3; map to [0, V-1)^3
+    voxel_coords = 0.5 * (V - 1) * (voxel_coords + 1.0)
+    voxel_coords = voxel_coords.round().to(torch.int64)
+    valid = (0 <= voxel_coords) * (voxel_coords < V)
+    valid = valid[:, 0] * valid[:, 1] * valid[:, 2]
+    x, y, z = voxel_coords.unbind(dim=1)
+    x, y, z = x[valid], y[valid], z[valid]
+    voxels = torch.zeros(V, V, V, dtype=torch.uint8, device=device)
+    voxels[z, y, x] = 1
+
+    return voxels
+
+
+def project_verts(verts, P, eps: float = 1e-1):  # pragma: no cover
+    """
+    Copied from meshrcnn codebase:
+    https://github.com/facebookresearch/meshrcnn/blob/main/shapenet/utils/coords.py#L159
+
+    Project vertices using a 4x4 transformation matrix.
+
+    Args:
+        verts: FloatTensor of shape (N, V, 3) giving a batch of vertex positions or of
+            shape (V, 3) giving a single set of vertex positions.
+        P: FloatTensor of shape (N, 4, 4) giving projection matrices or of shape (4, 4)
+            giving a single projection matrix.
+
+    Returns:
+        verts_out: FloatTensor of shape (N, V, 3) giving vertex positions (x, y, z)
+            where verts_out[i] is the result of transforming verts[i] by P[i].
+    """
+    # Handle unbatched inputs
+    singleton = False
+    if verts.dim() == 2:
+        assert P.dim() == 2
+        singleton = True
+        verts, P = verts[None], P[None]
+
+    N, V = verts.shape[0], verts.shape[1]
+    dtype, device = verts.dtype, verts.device
+
+    # Add an extra row of ones to the world-space coordinates of verts before
+    # multiplying by the projection matrix. We could avoid this allocation by
+    # instead multiplying by a 4x3 submatrix of the projection matrix, then
+    # adding the remaining 4x1 vector. Not sure whether there will be much
+    # performance difference between the two.
+    ones = torch.ones(N, V, 1, dtype=dtype, device=device)
+    verts_hom = torch.cat([verts, ones], dim=2)
+    verts_cam_hom = torch.bmm(verts_hom, P.transpose(1, 2))
+
+    # Avoid division by zero by clamping the absolute value
+    w = verts_cam_hom[:, :, 3:]
+    w_sign = w.sign()
+    w_sign[w == 0] = 1
+    w = w_sign * w.abs().clamp(min=eps)
+
+    verts_proj = verts_cam_hom[:, :, :3] / w
+
+    if singleton:
+        return verts_proj[0]
+    return verts_proj
+
+
+class BlenderCamera(CamerasBase):  # pragma: no cover
+    """
+    Camera for rendering objects with calibration matrices from the R2N2 dataset
+    (which uses Blender for rendering the views for each model).
+    """
+
+    def __init__(self, R=r, T=t, K=k, device: Device = "cpu") -> None:
+        """
+        Args:
+            R: Rotation matrix of shape (N, 3, 3).
+            T: Translation matrix of shape (N, 3).
+            K: Intrinsic matrix of shape (N, 4, 4).
+            device: Device (as str or torch.device).
+        """
+        # The initializer formats all inputs to torch tensors and broadcasts
+        # all the inputs to have the same batch dimension where necessary.
+        super().__init__(device=device, R=R, T=T, K=K)
+
+    def get_projection_transform(self, **kwargs) -> Transform3d:
+        transform = Transform3d(device=self.device)
+        transform._matrix = self.K.transpose(1, 2).contiguous()
+        return transform
+
+    def is_perspective(self):
+        return False
+
+    def in_ndc(self):
+        return True
+
+
+def render_cubified_voxels(
+    voxels: torch.Tensor, shader_type=HardPhongShader, device: Device = "cpu", **kwargs
+):  # pragma: no cover
+    """
+    Use the Cubify operator to convert inputs voxels to a mesh and then render that mesh.
+
+    Args:
+        voxels: FloatTensor of shape (N, D, D, D) where N is the batch size and
+            D is the number of voxels along each dimension.
+        shader_type: shader_type: shader_type: Shader to use for rendering. Examples
+            include HardPhongShader (default), SoftPhongShader etc or any other type
+            of valid Shader class.
+        device: Device (as str or torch.device) on which the tensors should be located.
+        **kwargs: Accepts any of the kwargs that the renderer supports.
+    Returns:
+        Batch of rendered images of shape (N, H, W, 3).
+    """
+    cubified_voxels = cubify(voxels, CUBIFY_THRESH).to(device)
+    cubified_voxels.textures = TexturesVertex(
+        verts_features=torch.ones_like(cubified_voxels.verts_padded(), device=device)
+    )
+    cameras = BlenderCamera(device=device)
+    renderer = MeshRenderer(
+        rasterizer=MeshRasterizer(
+            cameras=cameras,
+            raster_settings=kwargs.get("raster_settings", RasterizationSettings()),
+        ),
+        shader=shader_type(
+            device=device,
+            cameras=cameras,
+            lights=kwargs.get("lights", PointLights()).to(device),
+        ),
+    )
+    return renderer(cubified_voxels)

project/ManiSkill3/src/maniskill2_benchmark/cfdp_experiment/cfdp/extern/pytorch3d/pytorch3d/datasets/shapenet_base.py

@@ -0,0 +1,291 @@
+# Copyright (c) Meta Platforms, Inc. and affiliates.
+# All rights reserved.
+#
+# This source code is licensed under the BSD-style license found in the
+# LICENSE file in the root directory of this source tree.
+
+# pyre-unsafe
+
+import warnings
+from typing import Dict, List, Optional, Tuple
+
+import torch
+from pytorch3d.common.datatypes import Device
+from pytorch3d.io import load_obj
+from pytorch3d.renderer import (
+    FoVPerspectiveCameras,
+    HardPhongShader,
+    MeshRasterizer,
+    MeshRenderer,
+    PointLights,
+    RasterizationSettings,
+    TexturesVertex,
+)
+
+from .utils import collate_batched_meshes
+
+
+class ShapeNetBase(torch.utils.data.Dataset):  # pragma: no cover
+    """
+    'ShapeNetBase' implements a base Dataset for ShapeNet and R2N2 with helper methods.
+    It is not intended to be used on its own as a Dataset for a Dataloader. Both __init__
+    and __getitem__ need to be implemented.
+    """
+
+    def __init__(self) -> None:
+        """
+        Set up lists of synset_ids and model_ids.
+        """
+        self.synset_ids = []
+        self.model_ids = []
+        self.synset_inv = {}
+        self.synset_start_idxs = {}
+        self.synset_num_models = {}
+        self.shapenet_dir = ""
+        self.model_dir = "model.obj"
+        self.load_textures = True
+        self.texture_resolution = 4
+
+    def __len__(self) -> int:
+        """
+        Return number of total models in the loaded dataset.
+        """
+        return len(self.model_ids)
+
+    def __getitem__(self, idx) -> Dict:
+        """
+        Read a model by the given index. Need to be implemented for every child class
+        of ShapeNetBase.
+
+        Args:
+            idx: The idx of the model to be retrieved in the dataset.
+
+        Returns:
+            dictionary containing information about the model.
+        """
+        raise NotImplementedError(
+            "__getitem__ should be implemented in the child class of ShapeNetBase"
+        )
+
+    def _get_item_ids(self, idx) -> Dict:
+        """
+        Read a model by the given index.
+
+        Args:
+            idx: The idx of the model to be retrieved in the dataset.
+
+        Returns:
+            dictionary with following keys:
+            - synset_id (str): synset id
+            - model_id (str): model id
+        """
+        model = {}
+        model["synset_id"] = self.synset_ids[idx]
+        model["model_id"] = self.model_ids[idx]
+        return model
+
+    def _load_mesh(self, model_path) -> Tuple:
+        verts, faces, aux = load_obj(
+            model_path,
+            create_texture_atlas=self.load_textures,
+            load_textures=self.load_textures,
+            texture_atlas_size=self.texture_resolution,
+        )
+        if self.load_textures:
+            textures = aux.texture_atlas
+            # Some meshes don't have textures. In this case
+            # create a white texture map
+            if textures is None:
+                textures = verts.new_ones(
+                    faces.verts_idx.shape[0],
+                    self.texture_resolution,
+                    self.texture_resolution,
+                    3,
+                )
+        else:
+            textures = None
+
+        return verts, faces.verts_idx, textures
+
+    def render(
+        self,
+        model_ids: Optional[List[str]] = None,
+        categories: Optional[List[str]] = None,
+        sample_nums: Optional[List[int]] = None,
+        idxs: Optional[List[int]] = None,
+        shader_type=HardPhongShader,
+        device: Device = "cpu",
+        **kwargs,
+    ) -> torch.Tensor:
+        """
+        If a list of model_ids are supplied, render all the objects by the given model_ids.
+        If no model_ids are supplied, but categories and sample_nums are specified, randomly
+        select a number of objects (number specified in sample_nums) in the given categories
+        and render these objects. If instead a list of idxs is specified, check if the idxs
+        are all valid and render models by the given idxs. Otherwise, randomly select a number
+        (first number in sample_nums, default is set to be 1) of models from the loaded dataset
+        and render these models.
+
+        Args:
+            model_ids: List[str] of model_ids of models intended to be rendered.
+            categories: List[str] of categories intended to be rendered. categories
+                and sample_nums must be specified at the same time. categories can be given
+                in the form of synset offsets or labels, or a combination of both.
+            sample_nums: List[int] of number of models to be randomly sampled from
+                each category. Could also contain one single integer, in which case it
+                will be broadcasted for every category.
+            idxs: List[int] of indices of models to be rendered in the dataset.
+            shader_type: Select shading. Valid options include HardPhongShader (default),
+                SoftPhongShader, HardGouraudShader, SoftGouraudShader, HardFlatShader,
+                SoftSilhouetteShader.
+            device: Device (as str or torch.device) on which the tensors should be located.
+            **kwargs: Accepts any of the kwargs that the renderer supports.
+
+        Returns:
+            Batch of rendered images of shape (N, H, W, 3).
+        """
+        idxs = self._handle_render_inputs(model_ids, categories, sample_nums, idxs)
+        # Use the getitem method which loads mesh + texture
+        models = [self[idx] for idx in idxs]
+        meshes = collate_batched_meshes(models)["mesh"]
+        if meshes.textures is None:
+            meshes.textures = TexturesVertex(
+                verts_features=torch.ones_like(meshes.verts_padded(), device=device)
+            )
+
+        meshes = meshes.to(device)
+        cameras = kwargs.get("cameras", FoVPerspectiveCameras()).to(device)
+        if len(cameras) != 1 and len(cameras) % len(meshes) != 0:
+            raise ValueError("Mismatch between batch dims of cameras and meshes.")
+        if len(cameras) > 1:
+            # When rendering R2N2 models, if more than one views are provided, broadcast
+            # the meshes so that each mesh can be rendered for each of the views.
+            meshes = meshes.extend(len(cameras) // len(meshes))
+        renderer = MeshRenderer(
+            rasterizer=MeshRasterizer(
+                cameras=cameras,
+                raster_settings=kwargs.get("raster_settings", RasterizationSettings()),
+            ),
+            shader=shader_type(
+                device=device,
+                cameras=cameras,
+                lights=kwargs.get("lights", PointLights()).to(device),
+            ),
+        )
+        return renderer(meshes)
+
+    def _handle_render_inputs(
+        self,
+        model_ids: Optional[List[str]] = None,
+        categories: Optional[List[str]] = None,
+        sample_nums: Optional[List[int]] = None,
+        idxs: Optional[List[int]] = None,
+    ) -> List[int]:
+        """
+        Helper function for converting user provided model_ids, categories and sample_nums
+        to indices of models in the loaded dataset. If model idxs are provided, we check if
+        the idxs are valid. If no models are specified, the first model in the loaded dataset
+        is chosen. The function returns the file paths to the selected models.
+
+        Args:
+            model_ids: List[str] of model_ids of models to be rendered.
+            categories: List[str] of categories to be rendered.
+            sample_nums: List[int] of number of models to be randomly sampled from
+                each category.
+            idxs: List[int] of indices of models to be rendered in the dataset.
+
+        Returns:
+            List of paths of models to be rendered.
+        """
+        # Get corresponding indices if model_ids are supplied.
+        if model_ids is not None and len(model_ids) > 0:
+            idxs = []
+            for model_id in model_ids:
+                if model_id not in self.model_ids:
+                    raise ValueError(
+                        "model_id %s not found in the loaded dataset." % model_id
+                    )
+                idxs.append(self.model_ids.index(model_id))
+
+        # Sample random models if categories and sample_nums are supplied and get
+        # the corresponding indices.
+        elif categories is not None and len(categories) > 0:
+            sample_nums = [1] if sample_nums is None else sample_nums
+            if len(categories) != len(sample_nums) and len(sample_nums) != 1:
+                raise ValueError(
+                    "categories and sample_nums needs to be of the same length or "
+                    "sample_nums needs to be of length 1."
+                )
+
+            idxs_tensor = torch.empty(0, dtype=torch.int32)
+            for i in range(len(categories)):
+                category = self.synset_inv.get(categories[i], categories[i])
+                if category not in self.synset_inv.values():
+                    raise ValueError(
+                        "Category %s is not in the loaded dataset." % category
+                    )
+                # Broadcast if sample_nums has length of 1.
+                sample_num = sample_nums[i] if len(sample_nums) > 1 else sample_nums[0]
+                sampled_idxs = self._sample_idxs_from_category(
+                    sample_num=sample_num, category=category
+                )
+                # pyre-fixme[6]: For 1st param expected `Union[List[Tensor],
+                #  typing.Tuple[Tensor, ...]]` but got `Tuple[Tensor, List[int]]`.
+                idxs_tensor = torch.cat((idxs_tensor, sampled_idxs))
+            idxs = idxs_tensor.tolist()
+        # Check if the indices are valid if idxs are supplied.
+        elif idxs is not None and len(idxs) > 0:
+            if any(idx < 0 or idx >= len(self.model_ids) for idx in idxs):
+                raise IndexError(
+                    "One or more idx values are out of bounds. Indices need to be"
+                    "between 0 and %s." % (len(self.model_ids) - 1)
+                )
+        # Check if sample_nums is specified, if so sample sample_nums[0] number
+        # of indices from the entire loaded dataset. Otherwise randomly select one
+        # index from the dataset.
+        else:
+            sample_nums = [1] if sample_nums is None else sample_nums
+            if len(sample_nums) > 1:
+                msg = (
+                    "More than one sample sizes specified, now sampling "
+                    "%d models from the dataset." % sample_nums[0]
+                )
+                warnings.warn(msg)
+            idxs = self._sample_idxs_from_category(sample_nums[0])
+        return idxs
+
+    def _sample_idxs_from_category(
+        self, sample_num: int = 1, category: Optional[str] = None
+    ) -> List[int]:
+        """
+        Helper function for sampling a number of indices from the given category.
+
+        Args:
+            sample_num: number of indices to be sampled from the given category.
+            category: category synset of the category to be sampled from. If not
+                specified, sample from all models in the loaded dataset.
+        """
+        start = self.synset_start_idxs[category] if category is not None else 0
+        range_len = (
+            self.synset_num_models[category] if category is not None else self.__len__()
+        )
+        replacement = sample_num > range_len
+        sampled_idxs = (
+            torch.multinomial(
+                torch.ones((range_len), dtype=torch.float32),
+                sample_num,
+                replacement=replacement,
+            )
+            + start
+        )
+        if replacement:
+            msg = (
+                "Sample size %d is larger than the number of objects in %s, "
+                "values sampled with replacement."
+            ) % (
+                sample_num,
+                "category " + category if category is not None else "all categories",
+            )
+            warnings.warn(msg)
+        # pyre-fixme[7]: Expected `List[int]` but got `Tensor`.
+        return sampled_idxs

project/ManiSkill3/src/maniskill2_benchmark/cfdp_experiment/cfdp/extern/pytorch3d/pytorch3d/datasets/utils.py

@@ -0,0 +1,50 @@
+# Copyright (c) Meta Platforms, Inc. and affiliates.
+# All rights reserved.
+#
+# This source code is licensed under the BSD-style license found in the
+# LICENSE file in the root directory of this source tree.
+
+# pyre-unsafe
+
+from typing import Dict, List
+
+from pytorch3d.renderer.mesh import TexturesAtlas
+from pytorch3d.structures import Meshes
+
+
+def collate_batched_meshes(batch: List[Dict]):  # pragma: no cover
+    """
+    Take a list of objects in the form of dictionaries and merge them
+    into a single dictionary. This function can be used with a Dataset
+    object to create a torch.utils.data.Dataloader which directly
+    returns Meshes objects.
+    TODO: Add support for textures.
+
+    Args:
+        batch: List of dictionaries containing information about objects
+            in the dataset.
+
+    Returns:
+        collated_dict: Dictionary of collated lists. If batch contains both
+            verts and faces, a collated mesh batch is also returned.
+    """
+    if batch is None or len(batch) == 0:
+        return None
+    collated_dict = {}
+    for k in batch[0].keys():
+        collated_dict[k] = [d[k] for d in batch]
+
+    collated_dict["mesh"] = None
+    if {"verts", "faces"}.issubset(collated_dict.keys()):
+
+        textures = None
+        if "textures" in collated_dict:
+            textures = TexturesAtlas(atlas=collated_dict["textures"])
+
+        collated_dict["mesh"] = Meshes(
+            verts=collated_dict["verts"],
+            faces=collated_dict["faces"],
+            textures=textures,
+        )
+
+    return collated_dict

project/ManiSkill3/src/maniskill2_benchmark/cfdp_experiment/cfdp/extern/pytorch3d/pytorch3d/implicitron/__init__.py

@@ -0,0 +1,7 @@
+# Copyright (c) Meta Platforms, Inc. and affiliates.
+# All rights reserved.
+#
+# This source code is licensed under the BSD-style license found in the
+# LICENSE file in the root directory of this source tree.
+
+# pyre-unsafe

project/ManiSkill3/src/maniskill2_benchmark/cfdp_experiment/cfdp/extern/pytorch3d/pytorch3d/implicitron/eval_demo.py

@@ -0,0 +1,183 @@
+# Copyright (c) Meta Platforms, Inc. and affiliates.
+# All rights reserved.
+#
+# This source code is licensed under the BSD-style license found in the
+# LICENSE file in the root directory of this source tree.
+
+# pyre-unsafe
+
+
+import dataclasses
+import os
+from enum import Enum
+from typing import Any, cast, Dict, List, Optional, Tuple
+
+import lpips
+import torch
+from pytorch3d.implicitron.dataset.data_source import ImplicitronDataSource
+from pytorch3d.implicitron.dataset.json_index_dataset import JsonIndexDataset
+from pytorch3d.implicitron.dataset.json_index_dataset_map_provider import (
+    CO3D_CATEGORIES,
+)
+from pytorch3d.implicitron.evaluation.evaluate_new_view_synthesis import (
+    aggregate_nvs_results,
+    eval_batch,
+    pretty_print_nvs_metrics,
+    summarize_nvs_eval_results,
+)
+from pytorch3d.implicitron.models.model_dbir import ModelDBIR
+from pytorch3d.implicitron.tools.utils import dataclass_to_cuda_
+from tqdm import tqdm
+
+
+class Task(Enum):
+    SINGLE_SEQUENCE = "singlesequence"
+    MULTI_SEQUENCE = "multisequence"
+
+
+def main() -> None:
+    """
+    Evaluates new view synthesis metrics of a simple depth-based image rendering
+    (DBIR) model for multisequence/singlesequence tasks for several categories.
+
+    The evaluation is conducted on the same data as in [1] and, hence, the results
+    are directly comparable to the numbers reported in [1].
+
+    References:
+        [1] J. Reizenstein, R. Shapovalov, P. Henzler, L. Sbordone,
+                P. Labatut, D. Novotny:
+            Common Objects in 3D: Large-Scale Learning
+                and Evaluation of Real-life 3D Category Reconstruction
+    """
+
+    task_results = {}
+    for task in (Task.SINGLE_SEQUENCE, Task.MULTI_SEQUENCE):
+        task_results[task] = []
+        for category in CO3D_CATEGORIES[: (20 if task == Task.SINGLE_SEQUENCE else 10)]:
+            for single_sequence_id in (
+                (0, 1) if task == Task.SINGLE_SEQUENCE else (None,)
+            ):
+                category_result = evaluate_dbir_for_category(
+                    category, task=task, single_sequence_id=single_sequence_id
+                )
+                print("")
+                print(
+                    f"Results for task={task}; category={category};"
+                    + (
+                        f" sequence={single_sequence_id}:"
+                        if single_sequence_id is not None
+                        else ":"
+                    )
+                )
+                pretty_print_nvs_metrics(category_result)
+                print("")
+
+                task_results[task].append(category_result)
+            _print_aggregate_results(task, task_results)
+
+    for task in task_results:
+        _print_aggregate_results(task, task_results)
+
+
+def evaluate_dbir_for_category(
+    category: str,
+    task: Task,
+    bg_color: Tuple[float, float, float] = (0.0, 0.0, 0.0),
+    single_sequence_id: Optional[int] = None,
+    num_workers: int = 16,
+):
+    """
+    Evaluates new view synthesis metrics of a simple depth-based image rendering
+    (DBIR) model for a given task, category, and sequence (in case task=='singlesequence').
+
+    Args:
+        category: Object category.
+        bg_color: Background color of the renders.
+        task: Evaluation task. Either singlesequence or multisequence.
+        single_sequence_id: The ID of the evaluiation sequence for the singlesequence task.
+        num_workers: The number of workers for the employed dataloaders.
+        path_manager: (optional) Used for interpreting paths.
+
+    Returns:
+        category_result: A dictionary of quantitative metrics.
+    """
+
+    single_sequence_id = single_sequence_id if single_sequence_id is not None else -1
+
+    torch.manual_seed(42)
+
+    dataset_map_provider_args = {
+        "category": category,
+        "dataset_root": os.environ["CO3D_DATASET_ROOT"],
+        "assert_single_seq": task == Task.SINGLE_SEQUENCE,
+        "task_str": task.value,
+        "test_on_train": False,
+        "test_restrict_sequence_id": single_sequence_id,
+        "dataset_JsonIndexDataset_args": {"load_point_clouds": True},
+    }
+    data_source = ImplicitronDataSource(
+        dataset_map_provider_JsonIndexDatasetMapProvider_args=dataset_map_provider_args
+    )
+
+    datasets, dataloaders = data_source.get_datasets_and_dataloaders()
+
+    test_dataset = datasets.test
+    test_dataloader = dataloaders.test
+    if test_dataset is None or test_dataloader is None:
+        raise ValueError("must have a test dataset.")
+
+    image_size = cast(JsonIndexDataset, test_dataset).image_width
+
+    if image_size is None:
+        raise ValueError("Image size should be set in the dataset")
+
+    # init the simple DBIR model
+    model = ModelDBIR(
+        render_image_width=image_size,
+        render_image_height=image_size,
+        bg_color=bg_color,
+        max_points=int(1e5),
+    )
+    model.cuda()
+
+    # init the lpips model for eval
+    lpips_model = lpips.LPIPS(net="vgg")
+    lpips_model = lpips_model.cuda()
+
+    per_batch_eval_results = []
+    print("Evaluating DBIR model ...")
+    for frame_data in tqdm(test_dataloader):
+        frame_data = dataclass_to_cuda_(frame_data)
+        preds = model(**dataclasses.asdict(frame_data))
+        per_batch_eval_results.append(
+            eval_batch(
+                frame_data,
+                preds["implicitron_render"],
+                bg_color=bg_color,
+                lpips_model=lpips_model,
+            )
+        )
+
+    category_result_flat, category_result = summarize_nvs_eval_results(
+        per_batch_eval_results,
+        is_multisequence=task != Task.SINGLE_SEQUENCE,
+    )
+
+    return category_result["results"]
+
+
+def _print_aggregate_results(
+    task: Task, task_results: Dict[Task, List[List[Dict[str, Any]]]]
+) -> None:
+    """
+    Prints the aggregate metrics for a given task.
+    """
+    aggregate_task_result = aggregate_nvs_results(task_results[task])
+    print("")
+    print(f"Aggregate results for task={task}:")
+    pretty_print_nvs_metrics(aggregate_task_result)
+    print("")
+
+
+if __name__ == "__main__":
+    main()

project/ManiSkill3/src/maniskill2_benchmark/cfdp_experiment/cfdp/extern/pytorch3d/pytorch3d/vis/__init__.py

@@ -0,0 +1,23 @@
+# Copyright (c) Meta Platforms, Inc. and affiliates.
+# All rights reserved.
+#
+# This source code is licensed under the BSD-style license found in the
+# LICENSE file in the root directory of this source tree.
+
+# pyre-unsafe
+
+import warnings
+
+
+try:
+    from .plotly_vis import get_camera_wireframe, plot_batch_individually, plot_scene
+except ModuleNotFoundError as err:
+    if "plotly" in str(err):
+        warnings.warn(
+            "Cannot import plotly-based visualization code."
+            " Please install plotly to enable (pip install plotly)."
+        )
+    else:
+        raise
+
+from .texture_vis import texturesuv_image_matplotlib, texturesuv_image_PIL

project/ManiSkill3/src/maniskill2_benchmark/cfdp_experiment/cfdp/extern/pytorch3d/pytorch3d/vis/plotly_vis.py

@@ -0,0 +1,1057 @@
+# Copyright (c) Meta Platforms, Inc. and affiliates.
+# All rights reserved.
+#
+# This source code is licensed under the BSD-style license found in the
+# LICENSE file in the root directory of this source tree.
+
+# pyre-unsafe
+
+import warnings
+from typing import Dict, List, NamedTuple, Optional, Tuple, Union
+
+import plotly.graph_objects as go
+import torch
+from plotly.subplots import make_subplots
+from pytorch3d.renderer import (
+    HeterogeneousRayBundle,
+    ray_bundle_to_ray_points,
+    RayBundle,
+    TexturesAtlas,
+    TexturesVertex,
+)
+from pytorch3d.renderer.camera_utils import camera_to_eye_at_up
+from pytorch3d.renderer.cameras import CamerasBase
+from pytorch3d.structures import join_meshes_as_scene, Meshes, Pointclouds
+
+
+Struct = Union[CamerasBase, Meshes, Pointclouds, RayBundle, HeterogeneousRayBundle]
+
+
+def _get_len(struct: Union[Struct, List[Struct]]) -> int:  # pragma: no cover
+    """
+    Returns the length (usually corresponds to the batch size) of the input structure.
+    """
+    # pyre-ignore[6]
+    if not _is_ray_bundle(struct):
+        # pyre-ignore[6]
+        return len(struct)
+    if _is_heterogeneous_ray_bundle(struct):
+        # pyre-ignore[16]
+        return len(struct.camera_counts)
+    # pyre-ignore[16]
+    return len(struct.directions)
+
+
+def _is_ray_bundle(struct: Struct) -> bool:
+    """
+    Args:
+        struct: Struct object to test
+    Returns:
+        True if something is a RayBundle, HeterogeneousRayBundle or
+        ImplicitronRayBundle, else False
+    """
+    return hasattr(struct, "directions")
+
+
+def _is_heterogeneous_ray_bundle(struct: Union[List[Struct], Struct]) -> bool:
+    """
+    Args:
+        struct :object to test
+    Returns:
+        True if something is a HeterogeneousRayBundle or ImplicitronRayBundle
+        and cant be reduced to RayBundle else False
+    """
+    # pyre-ignore[16]
+    return hasattr(struct, "camera_counts") and struct.camera_counts is not None
+
+
+def get_camera_wireframe(scale: float = 0.3):  # pragma: no cover
+    """
+    Returns a wireframe of a 3D line-plot of a camera symbol.
+    """
+    a = 0.5 * torch.tensor([-2, 1.5, 4])
+    up1 = 0.5 * torch.tensor([0, 1.5, 4])
+    up2 = 0.5 * torch.tensor([0, 2, 4])
+    b = 0.5 * torch.tensor([2, 1.5, 4])
+    c = 0.5 * torch.tensor([-2, -1.5, 4])
+    d = 0.5 * torch.tensor([2, -1.5, 4])
+    C = torch.zeros(3)
+    F = torch.tensor([0, 0, 3])
+    camera_points = [a, up1, up2, up1, b, d, c, a, C, b, d, C, c, C, F]
+    lines = torch.stack([x.float() for x in camera_points]) * scale
+    return lines
+
+
+class AxisArgs(NamedTuple):  # pragma: no cover
+    showgrid: bool = False
+    zeroline: bool = False
+    showline: bool = False
+    ticks: str = ""
+    showticklabels: bool = False
+    backgroundcolor: str = "#fff"
+    showaxeslabels: bool = False
+
+
+class Lighting(NamedTuple):  # pragma: no cover
+    ambient: float = 0.8
+    diffuse: float = 1.0
+    fresnel: float = 0.0
+    specular: float = 0.0
+    roughness: float = 0.5
+    facenormalsepsilon: float = 1e-6
+    vertexnormalsepsilon: float = 1e-12
+
+
+@torch.no_grad()
+def plot_scene(
+    plots: Dict[str, Dict[str, Struct]],
+    *,
+    viewpoint_cameras: Optional[CamerasBase] = None,
+    ncols: int = 1,
+    camera_scale: float = 0.3,
+    pointcloud_max_points: int = 20000,
+    pointcloud_marker_size: int = 1,
+    raybundle_max_rays: int = 20000,
+    raybundle_max_points_per_ray: int = 1000,
+    raybundle_ray_point_marker_size: int = 1,
+    raybundle_ray_line_width: int = 1,
+    **kwargs,
+):  # pragma: no cover
+    """
+    Main function to visualize Cameras, Meshes, Pointclouds, and RayBundle.
+    Plots input Cameras, Meshes, Pointclouds, and RayBundle data into named subplots,
+    with named traces based on the dictionary keys. Cameras are
+    rendered at the camera center location using a wireframe.
+
+    Args:
+        plots: A dict containing subplot and trace names,
+            as well as the Meshes, Cameras and Pointclouds objects to be rendered.
+            See below for examples of the format.
+        viewpoint_cameras: an instance of a Cameras object providing a location
+            to view the plotly plot from. If the batch size is equal
+            to the number of subplots, it is a one to one mapping.
+            If the batch size is 1, then that viewpoint will be used
+            for all the subplots will be viewed from that point.
+            Otherwise, the viewpoint_cameras will not be used.
+        ncols: the number of subplots per row
+        camera_scale: determines the size of the wireframe used to render cameras.
+        pointcloud_max_points: the maximum number of points to plot from
+            a pointcloud. If more are present, a random sample of size
+            pointcloud_max_points is used.
+        pointcloud_marker_size: the size of the points rendered by plotly
+            when plotting a pointcloud.
+        raybundle_max_rays: maximum number of rays of a RayBundle to visualize. Randomly
+            subsamples without replacement in case the number of rays is bigger than max_rays.
+        raybundle_max_points_per_ray: the maximum number of points per ray in RayBundle
+            to visualize. If more are present, a random sample of size
+            max_points_per_ray is used.
+        raybundle_ray_point_marker_size: the size of the ray points of a plotted RayBundle
+        raybundle_ray_line_width: the width of the plotted rays of a RayBundle
+        **kwargs: Accepts lighting (a Lighting object) and any of the args xaxis,
+            yaxis and zaxis which Plotly's scene accepts. Accepts axis_args,
+            which is an AxisArgs object that is applied to all 3 axes.
+            Example settings for axis_args and lighting are given at the
+            top of this file.
+
+    Example:
+
+    ..code-block::python
+
+        mesh = ...
+        point_cloud = ...
+        fig = plot_scene({
+            "subplot_title": {
+                "mesh_trace_title": mesh,
+                "pointcloud_trace_title": point_cloud
+            }
+        })
+        fig.show()
+
+    The above example will render one subplot which has both a mesh and pointcloud.
+
+    If the Meshes, Pointclouds, or Cameras objects are batched, then every object in that batch
+    will be plotted in a single trace.
+
+    ..code-block::python
+        mesh = ... # batch size 2
+        point_cloud = ... # batch size 2
+        fig = plot_scene({
+            "subplot_title": {
+                "mesh_trace_title": mesh,
+                "pointcloud_trace_title": point_cloud
+            }
+        })
+        fig.show()
+
+    The above example renders one subplot with 2 traces, each of which renders
+    both objects from their respective batched data.
+
+    Multiple subplots follow the same pattern:
+    ..code-block::python
+        mesh = ... # batch size 2
+        point_cloud = ... # batch size 2
+        fig = plot_scene({
+            "subplot1_title": {
+                "mesh_trace_title": mesh[0],
+                "pointcloud_trace_title": point_cloud[0]
+            },
+            "subplot2_title": {
+                "mesh_trace_title": mesh[1],
+                "pointcloud_trace_title": point_cloud[1]
+            }
+        },
+        ncols=2)  # specify the number of subplots per row
+        fig.show()
+
+    The above example will render two subplots, each containing a mesh
+    and a pointcloud. The ncols argument will render two subplots in one row
+    instead of having them vertically stacked because the default is one subplot
+    per row.
+
+    To view plotly plots from a PyTorch3D camera's point of view, we can use
+    viewpoint_cameras:
+    ..code-block::python
+        mesh = ... # batch size 2
+        R, T = look_at_view_transform(2.7, 0, [0, 180]) # 2 camera angles, front and back
+        # Any instance of CamerasBase works, here we use FoVPerspectiveCameras
+        cameras = FoVPerspectiveCameras(device=device, R=R, T=T)
+        fig = plot_scene({
+            "subplot1_title": {
+                "mesh_trace_title": mesh[0]
+            },
+            "subplot2_title": {
+                "mesh_trace_title": mesh[1]
+            }
+        },
+        viewpoint_cameras=cameras)
+        fig.show()
+
+    The above example will render the first subplot seen from the camera on the +z axis,
+    and the second subplot from the viewpoint of the camera on the -z axis.
+
+    We can visualize these cameras as well:
+    ..code-block::python
+        mesh = ...
+        R, T = look_at_view_transform(2.7, 0, [0, 180]) # 2 camera angles, front and back
+        # Any instance of CamerasBase works, here we use FoVPerspectiveCameras
+        cameras = FoVPerspectiveCameras(device=device, R=R, T=T)
+        fig = plot_scene({
+            "subplot1_title": {
+                "mesh_trace_title": mesh,
+                "cameras_trace_title": cameras,
+            },
+        })
+        fig.show()
+
+    The above example will render one subplot with the mesh object
+    and two cameras.
+
+    RayBundle visualization is also supproted:
+    ..code-block::python
+        cameras = PerspectiveCameras(...)
+        ray_bundle = RayBundle(origins=..., lengths=..., directions=..., xys=...)
+        fig = plot_scene({
+            "subplot1_title": {
+                "ray_bundle_trace_title": ray_bundle,
+                "cameras_trace_title": cameras,
+            },
+        })
+        fig.show()
+
+    For an example of using kwargs, see below:
+    ..code-block::python
+        mesh = ...
+        point_cloud = ...
+        fig = plot_scene({
+            "subplot_title": {
+                "mesh_trace_title": mesh,
+                "pointcloud_trace_title": point_cloud
+            }
+        },
+        axis_args=AxisArgs(backgroundcolor="rgb(200,230,200)")) # kwarg axis_args
+        fig.show()
+
+    The above example will render each axis with the input background color.
+
+    See the tutorials in pytorch3d/docs/tutorials for more examples
+    (namely rendered_color_points.ipynb and rendered_textured_meshes.ipynb).
+    """
+
+    subplots = list(plots.keys())
+    fig = _gen_fig_with_subplots(len(subplots), ncols, subplots)
+    lighting = kwargs.get("lighting", Lighting())._asdict()
+    axis_args_dict = kwargs.get("axis_args", AxisArgs())._asdict()
+
+    # Set axis arguments to defaults defined at the top of this file
+    x_settings = {**axis_args_dict}
+    y_settings = {**axis_args_dict}
+    z_settings = {**axis_args_dict}
+
+    # Update the axes with any axis settings passed in as kwargs.
+    x_settings.update(**kwargs.get("xaxis", {}))
+    y_settings.update(**kwargs.get("yaxis", {}))
+    z_settings.update(**kwargs.get("zaxis", {}))
+
+    camera = {
+        "up": {
+            "x": 0.0,
+            "y": 1.0,
+            "z": 0.0,
+        }  # set the up vector to match PyTorch3D world coordinates conventions
+    }
+    viewpoints_eye_at_up_world = None
+    if viewpoint_cameras:
+        n_viewpoint_cameras = len(viewpoint_cameras)
+        if n_viewpoint_cameras == len(subplots) or n_viewpoint_cameras == 1:
+            # Calculate the vectors eye, at, up in world space
+            # to initialize the position of the camera in
+            # the plotly figure
+            viewpoints_eye_at_up_world = camera_to_eye_at_up(
+                viewpoint_cameras.get_world_to_view_transform().cpu()
+            )
+        else:
+            msg = "Invalid number {} of viewpoint cameras were provided. Either 1 \
+            or {} cameras are required".format(
+                len(viewpoint_cameras), len(subplots)
+            )
+            warnings.warn(msg)
+
+    for subplot_idx in range(len(subplots)):
+        subplot_name = subplots[subplot_idx]
+        traces = plots[subplot_name]
+        for trace_name, struct in traces.items():
+            if isinstance(struct, Meshes):
+                _add_mesh_trace(fig, struct, trace_name, subplot_idx, ncols, lighting)
+            elif isinstance(struct, Pointclouds):
+                _add_pointcloud_trace(
+                    fig,
+                    struct,
+                    trace_name,
+                    subplot_idx,
+                    ncols,
+                    pointcloud_max_points,
+                    pointcloud_marker_size,
+                )
+            elif isinstance(struct, CamerasBase):
+                _add_camera_trace(
+                    fig, struct, trace_name, subplot_idx, ncols, camera_scale
+                )
+            elif _is_ray_bundle(struct):
+                _add_ray_bundle_trace(
+                    fig,
+                    struct,
+                    trace_name,
+                    subplot_idx,
+                    ncols,
+                    raybundle_max_rays,
+                    raybundle_max_points_per_ray,
+                    raybundle_ray_point_marker_size,
+                    raybundle_ray_line_width,
+                )
+            else:
+                raise ValueError(
+                    "struct {} is not a Cameras, Meshes, Pointclouds,".format(struct)
+                    + " , RayBundle or HeterogeneousRayBundle object."
+                )
+
+        # Ensure update for every subplot.
+        plot_scene = "scene" + str(subplot_idx + 1)
+        current_layout = fig["layout"][plot_scene]
+        xaxis = current_layout["xaxis"]
+        yaxis = current_layout["yaxis"]
+        zaxis = current_layout["zaxis"]
+
+        # Update the axes with our above default and provided settings.
+        xaxis.update(**x_settings)
+        yaxis.update(**y_settings)
+        zaxis.update(**z_settings)
+
+        # update camera viewpoint if provided
+        if viewpoints_eye_at_up_world is not None:
+            # Use camera params for batch index or the first camera if only one provided.
+            # pyre-fixme[61]: `n_viewpoint_cameras` is undefined, or not always defined.
+            viewpoint_idx = min(n_viewpoint_cameras - 1, subplot_idx)
+
+            eye, at, up = (i[viewpoint_idx] for i in viewpoints_eye_at_up_world)
+            eye_x, eye_y, eye_z = eye.tolist()
+            at_x, at_y, at_z = at.tolist()
+            up_x, up_y, up_z = up.tolist()
+
+            # scale camera eye to plotly [-1, 1] ranges
+            x_range = xaxis["range"]
+            y_range = yaxis["range"]
+            z_range = zaxis["range"]
+
+            eye_x = _scale_camera_to_bounds(eye_x, x_range, True)
+            eye_y = _scale_camera_to_bounds(eye_y, y_range, True)
+            eye_z = _scale_camera_to_bounds(eye_z, z_range, True)
+
+            at_x = _scale_camera_to_bounds(at_x, x_range, True)
+            at_y = _scale_camera_to_bounds(at_y, y_range, True)
+            at_z = _scale_camera_to_bounds(at_z, z_range, True)
+
+            up_x = _scale_camera_to_bounds(up_x, x_range, False)
+            up_y = _scale_camera_to_bounds(up_y, y_range, False)
+            up_z = _scale_camera_to_bounds(up_z, z_range, False)
+
+            camera["eye"] = {"x": eye_x, "y": eye_y, "z": eye_z}
+            camera["center"] = {"x": at_x, "y": at_y, "z": at_z}
+            camera["up"] = {"x": up_x, "y": up_y, "z": up_z}
+
+        current_layout.update(
+            {
+                "xaxis": xaxis,
+                "yaxis": yaxis,
+                "zaxis": zaxis,
+                "aspectmode": "cube",
+                "camera": camera,
+            }
+        )
+
+    return fig
+
+
+@torch.no_grad()
+def plot_batch_individually(
+    batched_structs: Union[
+        List[Struct],
+        Struct,
+    ],
+    *,
+    viewpoint_cameras: Optional[CamerasBase] = None,
+    ncols: int = 1,
+    extend_struct: bool = True,
+    subplot_titles: Optional[List[str]] = None,
+    **kwargs,
+):  # pragma: no cover
+    """
+    This is a higher level plotting function than plot_scene, for plotting
+    Cameras, Meshes, Pointclouds, and RayBundle in simple cases. The simplest use
+    is to plot a single Cameras, Meshes, Pointclouds, or a RayBundle object,
+    where you just pass it in as a one element list. This will plot each batch
+    element in a separate subplot.
+
+    More generally, you can supply multiple Cameras, Meshes, Pointclouds, or RayBundle
+    having the same batch size `n`. In this case, there will be `n` subplots,
+    each depicting the corresponding batch element of all the inputs.
+
+    In addition, you can include Cameras, Meshes, Pointclouds, or RayBundle of size 1 in
+    the input. These will either be rendered in the first subplot
+    (if extend_struct is False), or in every subplot.
+    RayBundle includes ImplicitronRayBundle and HeterogeneousRaybundle.
+
+    Args:
+        batched_structs: a list of Cameras, Meshes, Pointclouds and RayBundle to be
+            rendered. Each structure's corresponding batch element will be plotted in a
+            single subplot, resulting in n subplots for a batch of size n. Every struct
+            should either have the same batch size or be of batch size 1. See extend_struct
+            and the description above for how batch size 1 structs are handled. Also accepts
+            a single Cameras, Meshes, Pointclouds, and RayBundle object, which will have
+            each individual element plotted in its own subplot.
+        viewpoint_cameras: an instance of a Cameras object providing a location
+            to view the plotly plot from. If the batch size is equal
+            to the number of subplots, it is a one to one mapping.
+            If the batch size is 1, then that viewpoint will be used
+            for all the subplots will be viewed from that point.
+            Otherwise, the viewpoint_cameras will not be used.
+        ncols: the number of subplots per row
+        extend_struct: if True, indicates that structs of batch size 1
+            should be plotted in every subplot.
+        subplot_titles: strings to name each subplot
+        **kwargs: keyword arguments which are passed to plot_scene.
+            See plot_scene documentation for details.
+
+    Example:
+
+    ..code-block::python
+
+        mesh = ...  # mesh of batch size 2
+        point_cloud = ... # point_cloud of batch size 2
+        fig = plot_batch_individually([mesh, point_cloud], subplot_titles=["plot1", "plot2"])
+        fig.show()
+
+        # this is equivalent to the below figure
+        fig = plot_scene({
+            "plot1": {
+                "trace1-1": mesh[0],
+                "trace1-2": point_cloud[0]
+            },
+            "plot2":{
+                "trace2-1": mesh[1],
+                "trace2-2": point_cloud[1]
+            }
+        })
+        fig.show()
+
+    The above example will render two subplots which each have both a mesh and pointcloud.
+    For more examples look at the pytorch3d tutorials at `pytorch3d/docs/tutorials`,
+    in particular the files rendered_color_points.ipynb and rendered_textured_meshes.ipynb.
+    """
+
+    # check that every batch is the same size or is size 1
+    if _get_len(batched_structs) == 0:
+        msg = "No structs to plot"
+        warnings.warn(msg)
+        return
+    max_size = 0
+    if isinstance(batched_structs, list):
+        max_size = max(_get_len(s) for s in batched_structs)
+        for struct in batched_structs:
+            struct_len = _get_len(struct)
+            if struct_len not in (1, max_size):
+                msg = "invalid batch size {} provided: {}".format(struct_len, struct)
+                raise ValueError(msg)
+    else:
+        max_size = _get_len(batched_structs)
+
+    if max_size == 0:
+        msg = "No data is provided with at least one element"
+        raise ValueError(msg)
+
+    if subplot_titles:
+        if len(subplot_titles) != max_size:
+            msg = "invalid number of subplot titles"
+            raise ValueError(msg)
+
+    # if we are dealing with HeterogeneousRayBundle of ImplicitronRayBundle create
+    # first indexes for faster
+    first_idxs = None
+    if _is_heterogeneous_ray_bundle(batched_structs):
+        # pyre-ignore[16]
+        cumsum = batched_structs.camera_counts.cumsum(dim=0)
+        first_idxs = torch.cat((cumsum.new_zeros((1,)), cumsum))
+
+    scene_dictionary = {}
+    # construct the scene dictionary
+    for scene_num in range(max_size):
+        subplot_title = (
+            subplot_titles[scene_num]
+            if subplot_titles
+            else "subplot " + str(scene_num + 1)
+        )
+        scene_dictionary[subplot_title] = {}
+
+        if isinstance(batched_structs, list):
+            for i, batched_struct in enumerate(batched_structs):
+                first_idxs = None
+                if _is_heterogeneous_ray_bundle(batched_structs[i]):
+                    # pyre-ignore[16]
+                    cumsum = batched_struct.camera_counts.cumsum(dim=0)
+                    first_idxs = torch.cat((cumsum.new_zeros((1,)), cumsum))
+                # check for whether this struct needs to be extended
+                batched_struct_len = _get_len(batched_struct)
+                if i >= batched_struct_len and not extend_struct:
+                    continue
+                _add_struct_from_batch(
+                    batched_struct,
+                    scene_num,
+                    subplot_title,
+                    scene_dictionary,
+                    i + 1,
+                    first_idxs=first_idxs,
+                )
+        else:  # batched_structs is a single struct
+            _add_struct_from_batch(
+                batched_structs,
+                scene_num,
+                subplot_title,
+                scene_dictionary,
+                first_idxs=first_idxs,
+            )
+
+    return plot_scene(
+        scene_dictionary, viewpoint_cameras=viewpoint_cameras, ncols=ncols, **kwargs
+    )
+
+
+def _add_struct_from_batch(
+    batched_struct: Struct,
+    scene_num: int,
+    subplot_title: str,
+    scene_dictionary: Dict[str, Dict[str, Struct]],
+    trace_idx: int = 1,
+    first_idxs: Optional[torch.Tensor] = None,
+) -> None:  # pragma: no cover
+    """
+    Adds the struct corresponding to the given scene_num index to
+    a provided scene_dictionary to be passed in to plot_scene
+
+    Args:
+        batched_struct: the batched data structure to add to the dict
+        scene_num: the subplot from plot_batch_individually which this struct
+            should be added to
+        subplot_title: the title of the subplot
+        scene_dictionary: the dictionary to add the indexed struct to
+        trace_idx: the trace number, starting at 1 for this struct's trace
+    """
+    struct = None
+    if isinstance(batched_struct, CamerasBase):
+        # we can't index directly into camera batches
+        R, T = batched_struct.R, batched_struct.T
+        r_idx = min(scene_num, len(R) - 1)
+        t_idx = min(scene_num, len(T) - 1)
+        R = R[r_idx].unsqueeze(0)
+        T = T[t_idx].unsqueeze(0)
+        struct = CamerasBase(device=batched_struct.device, R=R, T=T)
+    elif _is_ray_bundle(batched_struct) and not _is_heterogeneous_ray_bundle(
+        batched_struct
+    ):
+        # for RayBundle we treat the camera count as the batch index
+        struct_idx = min(scene_num, _get_len(batched_struct) - 1)
+
+        struct = RayBundle(
+            **{
+                attr: getattr(batched_struct, attr)[struct_idx]
+                for attr in ["origins", "directions", "lengths", "xys"]
+            }
+        )
+    elif _is_heterogeneous_ray_bundle(batched_struct):
+        # for RayBundle we treat the camera count as the batch index
+        struct_idx = min(scene_num, _get_len(batched_struct) - 1)
+
+        struct = RayBundle(
+            **{
+                attr: getattr(batched_struct, attr)[
+                    # pyre-ignore[16]
+                    first_idxs[struct_idx] : first_idxs[struct_idx + 1]
+                ]
+                for attr in ["origins", "directions", "lengths", "xys"]
+            }
+        )
+
+    else:  # batched meshes and pointclouds are indexable
+        struct_idx = min(scene_num, _get_len(batched_struct) - 1)
+        # pyre-ignore[16]
+        struct = batched_struct[struct_idx]
+    trace_name = "trace{}-{}".format(scene_num + 1, trace_idx)
+    scene_dictionary[subplot_title][trace_name] = struct
+
+
+def _add_mesh_trace(
+    fig: go.Figure,
+    meshes: Meshes,
+    trace_name: str,
+    subplot_idx: int,
+    ncols: int,
+    lighting: Lighting,
+) -> None:  # pragma: no cover
+    """
+    Adds a trace rendering a Meshes object to the passed in figure, with
+    a given name and in a specific subplot.
+
+    Args:
+        fig: plotly figure to add the trace within.
+        meshes: Meshes object to render. It can be batched.
+        trace_name: name to label the trace with.
+        subplot_idx: identifies the subplot, with 0 being the top left.
+        ncols: the number of subplots per row.
+        lighting: a Lighting object that specifies the Mesh3D lighting.
+    """
+
+    mesh = join_meshes_as_scene(meshes)
+    mesh = mesh.detach().cpu()
+    verts = mesh.verts_packed()
+    faces = mesh.faces_packed()
+    # If mesh has vertex colors or face colors, use them
+    # for figure, otherwise use plotly's default colors.
+    verts_rgb = None
+    faces_rgb = None
+    if isinstance(mesh.textures, TexturesVertex):
+        verts_rgb = mesh.textures.verts_features_packed()
+        verts_rgb.clamp_(min=0.0, max=1.0)
+        verts_rgb = torch.tensor(255.0) * verts_rgb
+    if isinstance(mesh.textures, TexturesAtlas):
+        atlas = mesh.textures.atlas_packed()
+        # If K==1
+        if atlas.shape[1] == 1 and atlas.shape[3] == 3:
+            faces_rgb = atlas[:, 0, 0]
+
+    # Reposition the unused vertices to be "inside" the object
+    # (i.e. they won't be visible in the plot).
+    verts_used = torch.zeros((verts.shape[0],), dtype=torch.bool)
+    verts_used[torch.unique(faces)] = True
+    verts_center = verts[verts_used].mean(0)
+    verts[~verts_used] = verts_center
+
+    row, col = subplot_idx // ncols + 1, subplot_idx % ncols + 1
+    # pyre-fixme[16]: `Figure` has no attribute `add_trace`.
+    fig.add_trace(
+        go.Mesh3d(
+            x=verts[:, 0],
+            y=verts[:, 1],
+            z=verts[:, 2],
+            vertexcolor=verts_rgb,
+            facecolor=faces_rgb,
+            i=faces[:, 0],
+            j=faces[:, 1],
+            k=faces[:, 2],
+            lighting=lighting,
+            name=trace_name,
+        ),
+        row=row,
+        col=col,
+    )
+
+    # Access the current subplot's scene configuration
+    plot_scene = "scene" + str(subplot_idx + 1)
+    current_layout = fig["layout"][plot_scene]
+
+    # update the bounds of the axes for the current trace
+    max_expand = (verts.max(0)[0] - verts.min(0)[0]).max()
+    _update_axes_bounds(verts_center, max_expand, current_layout)
+
+
+def _add_pointcloud_trace(
+    fig: go.Figure,
+    pointclouds: Pointclouds,
+    trace_name: str,
+    subplot_idx: int,
+    ncols: int,
+    max_points_per_pointcloud: int,
+    marker_size: int,
+) -> None:  # pragma: no cover
+    """
+    Adds a trace rendering a Pointclouds object to the passed in figure, with
+    a given name and in a specific subplot.
+
+    Args:
+        fig: plotly figure to add the trace within.
+        pointclouds: Pointclouds object to render. It can be batched.
+        trace_name: name to label the trace with.
+        subplot_idx: identifies the subplot, with 0 being the top left.
+        ncols: the number of subplots per row.
+        max_points_per_pointcloud: the number of points to render, which are randomly sampled.
+        marker_size: the size of the rendered points
+    """
+    pointclouds = pointclouds.detach().cpu().subsample(max_points_per_pointcloud)
+    verts = pointclouds.points_packed()
+    features = pointclouds.features_packed()
+
+    color = None
+    if features is not None:
+        if features.shape[1] == 4:  # rgba
+            template = "rgb(%d, %d, %d, %f)"
+            rgb = (features[:, :3].clamp(0.0, 1.0) * 255).int()
+            color = [template % (*rgb_, a_) for rgb_, a_ in zip(rgb, features[:, 3])]
+
+        if features.shape[1] == 3:
+            template = "rgb(%d, %d, %d)"
+            rgb = (features.clamp(0.0, 1.0) * 255).int()
+            color = [template % (r, g, b) for r, g, b in rgb]
+
+    row = subplot_idx // ncols + 1
+    col = subplot_idx % ncols + 1
+    # pyre-fixme[16]: `Figure` has no attribute `add_trace`.
+    fig.add_trace(
+        go.Scatter3d(
+            x=verts[:, 0],
+            y=verts[:, 1],
+            z=verts[:, 2],
+            marker={"color": color, "size": marker_size},
+            mode="markers",
+            name=trace_name,
+        ),
+        row=row,
+        col=col,
+    )
+
+    # Access the current subplot's scene configuration
+    plot_scene = "scene" + str(subplot_idx + 1)
+    current_layout = fig["layout"][plot_scene]
+
+    # update the bounds of the axes for the current trace
+    verts_center = verts.mean(0)
+    max_expand = (verts.max(0)[0] - verts.min(0)[0]).max()
+    _update_axes_bounds(verts_center, max_expand, current_layout)
+
+
+def _add_camera_trace(
+    fig: go.Figure,
+    cameras: CamerasBase,
+    trace_name: str,
+    subplot_idx: int,
+    ncols: int,
+    camera_scale: float,
+) -> None:  # pragma: no cover
+    """
+    Adds a trace rendering a Cameras object to the passed in figure, with
+    a given name and in a specific subplot.
+
+    Args:
+        fig: plotly figure to add the trace within.
+        cameras: the Cameras object to render. It can be batched.
+        trace_name: name to label the trace with.
+        subplot_idx: identifies the subplot, with 0 being the top left.
+        ncols: the number of subplots per row.
+        camera_scale: the size of the wireframe used to render the Cameras object.
+    """
+    cam_wires = get_camera_wireframe(camera_scale).to(cameras.device)
+    cam_trans = cameras.get_world_to_view_transform().inverse()
+    cam_wires_trans = cam_trans.transform_points(cam_wires).detach().cpu()
+    # if batch size is 1, unsqueeze to add dimension
+    if len(cam_wires_trans.shape) < 3:
+        cam_wires_trans = cam_wires_trans.unsqueeze(0)
+
+    nan_tensor = torch.Tensor([[float("NaN")] * 3])
+    all_cam_wires = cam_wires_trans[0]
+    for wire in cam_wires_trans[1:]:
+        # We combine camera points into a single tensor to plot them in a
+        # single trace. The NaNs are inserted between sets of camera
+        # points so that the lines drawn by Plotly are not drawn between
+        # points that belong to different cameras.
+        all_cam_wires = torch.cat((all_cam_wires, nan_tensor, wire))
+    x, y, z = all_cam_wires.detach().cpu().numpy().T.astype(float)
+
+    row, col = subplot_idx // ncols + 1, subplot_idx % ncols + 1
+    # pyre-fixme[16]: `Figure` has no attribute `add_trace`.
+    fig.add_trace(
+        go.Scatter3d(x=x, y=y, z=z, marker={"size": 1}, name=trace_name),
+        row=row,
+        col=col,
+    )
+
+    # Access the current subplot's scene configuration
+    plot_scene = "scene" + str(subplot_idx + 1)
+    current_layout = fig["layout"][plot_scene]
+
+    # flatten for bounds calculations
+    flattened_wires = cam_wires_trans.flatten(0, 1)
+    verts_center = flattened_wires.mean(0)
+    max_expand = (flattened_wires.max(0)[0] - flattened_wires.min(0)[0]).max()
+    _update_axes_bounds(verts_center, max_expand, current_layout)
+
+
+def _add_ray_bundle_trace(
+    fig: go.Figure,
+    ray_bundle: Union[RayBundle, HeterogeneousRayBundle],
+    trace_name: str,
+    subplot_idx: int,
+    ncols: int,
+    max_rays: int,
+    max_points_per_ray: int,
+    marker_size: int,
+    line_width: int,
+) -> None:  # pragma: no cover
+    """
+    Adds a trace rendering a ray bundle object
+    to the passed in figure, with a given name and in a specific subplot.
+
+    Args:
+        fig: plotly figure to add the trace within.
+        ray_bundle: the RayBundle, ImplicitronRayBundle or HeterogeneousRaybundle to render.
+            It can be batched.
+        trace_name: name to label the trace with.
+        subplot_idx: identifies the subplot, with 0 being the top left.
+        ncols: the number of subplots per row.
+        max_rays: maximum number of plotted rays in total. Randomly subsamples
+            without replacement in case the number of rays is bigger than max_rays.
+        max_points_per_ray: maximum number of points plotted per ray.
+        marker_size: the size of the ray point markers.
+        line_width: the width of the ray lines.
+    """
+
+    n_pts_per_ray = ray_bundle.lengths.shape[-1]
+    n_rays = ray_bundle.lengths.shape[:-1].numel()
+
+    # flatten all batches of rays into a single big bundle
+    ray_bundle_flat = RayBundle(
+        **{
+            attr: torch.flatten(getattr(ray_bundle, attr), start_dim=0, end_dim=-2)
+            for attr in ["origins", "directions", "lengths", "xys"]
+        }
+    )
+
+    # subsample the rays (if needed)
+    if n_rays > max_rays:
+        indices_rays = torch.randperm(n_rays)[:max_rays]
+        ray_bundle_flat = RayBundle(
+            **{
+                attr: getattr(ray_bundle_flat, attr)[indices_rays]
+                for attr in ["origins", "directions", "lengths", "xys"]
+            }
+        )
+
+    # make ray line endpoints
+    min_max_ray_depth = torch.stack(
+        [
+            ray_bundle_flat.lengths.min(dim=1).values,
+            ray_bundle_flat.lengths.max(dim=1).values,
+        ],
+        dim=-1,
+    )
+    ray_lines_endpoints = ray_bundle_to_ray_points(
+        ray_bundle_flat._replace(lengths=min_max_ray_depth)
+    )
+
+    # make the ray lines for plotly plotting
+    nan_tensor = torch.tensor(
+        [[float("NaN")] * 3],
+        device=ray_lines_endpoints.device,
+        dtype=ray_lines_endpoints.dtype,
+    )
+    ray_lines = torch.empty(size=(1, 3), device=ray_lines_endpoints.device)
+    for ray_line in ray_lines_endpoints:
+        # We combine the ray lines into a single tensor to plot them in a
+        # single trace. The NaNs are inserted between sets of ray lines
+        # so that the lines drawn by Plotly are not drawn between
+        # lines that belong to different rays.
+        ray_lines = torch.cat((ray_lines, nan_tensor, ray_line))
+    x, y, z = ray_lines.detach().cpu().numpy().T.astype(float)
+    row, col = subplot_idx // ncols + 1, subplot_idx % ncols + 1
+    # pyre-fixme[16]: `Figure` has no attribute `add_trace`.
+    fig.add_trace(
+        go.Scatter3d(
+            x=x,
+            y=y,
+            z=z,
+            marker={"size": 0.1},
+            line={"width": line_width},
+            name=trace_name,
+        ),
+        row=row,
+        col=col,
+    )
+
+    # subsample the ray points (if needed)
+    if n_pts_per_ray > max_points_per_ray:
+        indices_ray_pts = torch.cat(
+            [
+                torch.randperm(n_pts_per_ray)[:max_points_per_ray] + ri * n_pts_per_ray
+                for ri in range(ray_bundle_flat.lengths.shape[0])
+            ]
+        )
+        ray_bundle_flat = ray_bundle_flat._replace(
+            lengths=ray_bundle_flat.lengths.reshape(-1)[indices_ray_pts].reshape(
+                ray_bundle_flat.lengths.shape[0], -1
+            )
+        )
+
+    # plot the ray points
+    ray_points = (
+        ray_bundle_to_ray_points(ray_bundle_flat)
+        .view(-1, 3)
+        .detach()
+        .cpu()
+        .numpy()
+        .astype(float)
+    )
+    fig.add_trace(
+        go.Scatter3d(
+            x=ray_points[:, 0],
+            y=ray_points[:, 1],
+            z=ray_points[:, 2],
+            mode="markers",
+            name=trace_name + "_points",
+            marker={"size": marker_size},
+        ),
+        row=row,
+        col=col,
+    )
+
+    # Access the current subplot's scene configuration
+    plot_scene = "scene" + str(subplot_idx + 1)
+    current_layout = fig["layout"][plot_scene]
+
+    # update the bounds of the axes for the current trace
+    all_ray_points = ray_bundle_to_ray_points(ray_bundle).reshape(-1, 3)
+    ray_points_center = all_ray_points.mean(dim=0)
+    max_expand = (all_ray_points.max(0)[0] - all_ray_points.min(0)[0]).max().item()
+    _update_axes_bounds(ray_points_center, float(max_expand), current_layout)
+
+
+def _gen_fig_with_subplots(
+    batch_size: int, ncols: int, subplot_titles: List[str]
+):  # pragma: no cover
+    """
+    Takes in the number of objects to be plotted and generate a plotly figure
+    with the appropriate number and orientation of titled subplots.
+    Args:
+        batch_size: the number of elements in the batch of objects to be visualized.
+        ncols: number of subplots in the same row.
+        subplot_titles: titles for the subplot(s). list of strings of length batch_size.
+
+    Returns:
+        Plotly figure with ncols subplots per row, and batch_size subplots.
+    """
+    fig_rows = batch_size // ncols
+    if batch_size % ncols != 0:
+        fig_rows += 1  # allow for non-uniform rows
+    fig_cols = ncols
+    fig_type = [{"type": "scene"}]
+    specs = [fig_type * fig_cols] * fig_rows
+    # subplot_titles must have one title per subplot
+    fig = make_subplots(
+        rows=fig_rows,
+        cols=fig_cols,
+        specs=specs,
+        subplot_titles=subplot_titles,
+        column_widths=[1.0] * fig_cols,
+    )
+    return fig
+
+
+def _update_axes_bounds(
+    verts_center: torch.Tensor,
+    max_expand: float,
+    current_layout: go.Scene,
+) -> None:  # pragma: no cover
+    """
+    Takes in the vertices' center point and max spread, and the current plotly figure
+    layout and updates the layout to have bounds that include all traces for that subplot.
+    Args:
+        verts_center: tensor of size (3) corresponding to a trace's vertices' center point.
+        max_expand: the maximum spread in any dimension of the trace's vertices.
+        current_layout: the plotly figure layout scene corresponding to the referenced trace.
+    """
+    verts_center = verts_center.detach().cpu()
+    verts_min = verts_center - max_expand
+    verts_max = verts_center + max_expand
+    bounds = torch.t(torch.stack((verts_min, verts_max)))
+
+    # Ensure that within a subplot, the bounds capture all traces
+    old_xrange, old_yrange, old_zrange = (
+        # pyre-fixme[16]: `Scene` has no attribute `__getitem__`.
+        current_layout["xaxis"]["range"],
+        current_layout["yaxis"]["range"],
+        current_layout["zaxis"]["range"],
+    )
+    x_range, y_range, z_range = bounds
+    if old_xrange is not None:
+        x_range[0] = min(x_range[0], old_xrange[0])
+        x_range[1] = max(x_range[1], old_xrange[1])
+    if old_yrange is not None:
+        y_range[0] = min(y_range[0], old_yrange[0])
+        y_range[1] = max(y_range[1], old_yrange[1])
+    if old_zrange is not None:
+        z_range[0] = min(z_range[0], old_zrange[0])
+        z_range[1] = max(z_range[1], old_zrange[1])
+
+    xaxis = {"range": x_range}
+    yaxis = {"range": y_range}
+    zaxis = {"range": z_range}
+    # pyre-fixme[16]: `Scene` has no attribute `update`.
+    current_layout.update({"xaxis": xaxis, "yaxis": yaxis, "zaxis": zaxis})
+
+
+def _scale_camera_to_bounds(
+    coordinate: float, axis_bounds: Tuple[float, float], is_position: bool
+) -> float:  # pragma: no cover
+    """
+    We set our plotly plot's axes' bounding box to [-1,1]x[-1,1]x[-1,1]. As such,
+    the plotly camera location has to be scaled accordingly to have its world coordinates
+    correspond to its relative plotted coordinates for viewing the plotly plot.
+    This function does the scaling and offset to transform the coordinates.
+
+    Args:
+        coordinate: the float value to be transformed
+        axis_bounds: the bounds of the plotly plot for the axis which
+            the coordinate argument refers to
+        is_position: If true, the float value is the coordinate of a position, and so must
+            be moved in to [-1,1]. Otherwise it is a component of a direction, and so needs only
+            to be scaled.
+    """
+    scale = (axis_bounds[1] - axis_bounds[0]) / 2
+    if not is_position:
+        return coordinate / scale
+    offset = (axis_bounds[1] / scale) - 1
+    return coordinate / scale - offset