tink/nerfstudio
4
0 Fork 0
mirror of https://github.com/nerfstudio-project/nerfstudio.git synced 2026-11-14 11:54:01 +08:00
Code Activity

rename files and add project scripts (#566)

Browse Source 
* scripts

* b

* fix file
This commit is contained in:
Ethan Weber authored and GitHub committed 2022-09-27 15:02:55 -07:00
1 parent 8af3a7a385
commit cf34ef4bd0
26 files changed
+384 -355
Download Patch File Download Diff File Expand all files Collapse all files

No files matched your search

docs/tutorials/data/creating_dataset.md
+1 -1
View File
@@ -25,7 +25,7 @@ If your data was captured with a fisheye camera add `--camera-type fisheye`.
Simply specify that you are using the `nerfactory` dataparser and point the data directory to your processed data.
```bash
python scripts/run_train.py instant-ngp nerfactory --pipeline.datamanager.dataparser.data-directory PROCESSED_DATA_DIR
python scripts/train.py instant-ngp nerfactory --pipeline.datamanager.dataparser.data-directory PROCESSED_DATA_DIR
```
### Installing COLMAP
docs/tutorials/pipelines/creating_models.ipynb
+228 -228
View File
@@ -1,229 +1,229 @@
{
"cells": [
{
"cell_type": "markdown",
"metadata": {},
"source": [
"# Developing Custom Models\n",
"\n",
"In this quick tour, we will walk you through the core of training and building any NeRFs with nerfactory.\n",
"\n",
"The entry point for training starts at `scripts/run_train.py`, which spawns instances of our `Trainer()` class (in `engine/trainer.py`). The `Trainer()` is responsible for setting up the datasets and NeRF graph depending on the config specified. It will then run the usual train/val routine for a config-specified number of iterations. If you are planning on using our codebase to build a new NeRF method or to use an existing implementation, we've abstracted away the training routine in these two files and chances are you will not need to think of them again.\n",
"\n",
"### Graphs, Modules, and Fields\n",
"\n",
"If you are looking to implemnet a new NeRF method or extend an existing one, you may need to set up a new graph (in `graphs/`).\n",
"\n",
"All NeRF graph definitions can be found in `graphs/`. The graph encapsulates all the modules in the NeRF method- from the MLP's to the samplers to the losses and optimizers. All graphs are composed of modules and fields.\n",
"\n",
"### Modules\n",
"\n",
"We can decompose all graphs into respective modules. For instance, we have {ref}`optimizers` which contains modules related to the loss, {ref}`renderers` which contains all rendering modules, {`graph/modules/`}, which includes samplers and ray generators. Additionally, we have {ref}`field_modules`, which will be discussed below.\n",
"In general, modules can be thought of as individual component parts of the graph that can be swapped in/out. We provide most of the standard modules, but if you are creating a new NeRF graph, you may have to define new modules.\n",
"\n",
"### Fields\n",
"\n",
"{ref}`fields` represents the \"space\", aka. the radiance field of the NeRF. Here, we define the field as the part of the network that takes in point samples and any other conditioning, and outputs any of the `FieldHeadNames` (`nerf/field_modules/field_heads.py`).\n",
"\n",
"All fields are composed of modules continained within the `fields/` directory (e.g. `fields/modules/` or `fields/density_fields/`). We can think of field modules as modules that actually define or interact with the field.\n",
"\n",
"To build a NeRF field, we therefore follow these steps:\n",
"\n",
"1. define any relevant field modules\n",
"2. create a new class that extends the {ref}`fields` base class and use these field modules to compose the full field\n",
"3. implement the abstract functions `get_density()` and `get_outputs()`."
]
},
{
"cell_type": "code",
"execution_count": 1,
"metadata": {},
"outputs": [
{
"ename": "SyntaxError",
"evalue": "invalid syntax (383175768.py, line 4)",
"output_type": "error",
"traceback": [
"\u001b[0;36m Input \u001b[0;32mIn [1]\u001b[0;36m\u001b[0m\n\u001b[0;31m def __init__(self, ...) -> None:\u001b[0m\n\u001b[0m ^\u001b[0m\n\u001b[0;31mSyntaxError\u001b[0m\u001b[0;31m:\u001b[0m invalid syntax\n"
]
}
],
"source": [
"class NeRFField(Field):\n",
" \"\"\"NeRF Field\"\"\"\n",
"\n",
" def __init__(self, ...) -> None:\n",
" \"\"\"Create boilerplate NeRF field.\"\"\"\n",
"\n",
" super().__init__()\n",
"\n",
" # In the init method, we are instantiating all relevant field modules\n",
" self.position_encoding = position_encoding\n",
" self.direction_encoding = direction_encoding\n",
"\n",
" self.mlp_base = MLP(\n",
" in_dim=self.position_encoding.get_out_dim(),\n",
" num_layers=base_mlp_num_layers,\n",
" layer_width=base_mlp_layer_width,\n",
" skip_connections=skip_connections,\n",
" )\n",
" ...\n",
"\n",
" def get_density(self, point_samples: PointSamples):\n",
" \"\"\"\n",
" Computes and returns the densities.\n",
" \"\"\"\n",
"\n",
" def get_outputs(\n",
" self, point_samples: PointSamples, density_embedding: Optional[TensorType] = None\n",
" ) -> Dict[FieldHeadNames, TensorType]:\n",
" \"\"\"\n",
" Computes and returns the outputs.\n",
" \"\"\""
]
},
{
"cell_type": "markdown",
"metadata": {},
"source": [
"### Putting it together\n",
"\n",
"Now that we've gone over what modules and fields are, we are ready to create the graph!\n",
"\n",
"To implement the vanilla NeRF, we create a new class that inherits the abstract Graph class. Similar to composing a new field, we can pull from all pre-defined fields and modules and use them to compose a new Graph.\n",
"We will then need to define the following abstract methods as seen in the skeleton code below. See also `graphs/vanilla_nerf.py` for the full implementation."
]
},
{
"cell_type": "code",
"execution_count": 2,
"metadata": {},
"outputs": [
{
"ename": "NameError",
"evalue": "name 'Graph' is not defined",
"output_type": "error",
"traceback": [
"\u001b[0;31m---------------------------------------------------------------------------\u001b[0m",
"\u001b[0;31mNameError\u001b[0m Traceback (most recent call last)",
"\u001b[1;32m/shared/ethanweber/nerfactory/docs/tutorials/pipelines/creating_models.ipynb Cell 4\u001b[0m in \u001b[0;36m<cell line: 1>\u001b[0;34m()\u001b[0m\n\u001b[0;32m----> <a href='vscode-notebook-cell://ssh-remote%2Bbirman/shared/ethanweber/nerfactory/docs/tutorials/pipelines/creating_models.ipynb#W6sdnNjb2RlLXJlbW90ZQ%3D%3D?line=0'>1</a>\u001b[0m \u001b[39mclass\u001b[39;00m \u001b[39mNeRFGraph\u001b[39;00m(Graph):\n\u001b[1;32m <a href='vscode-notebook-cell://ssh-remote%2Bbirman/shared/ethanweber/nerfactory/docs/tutorials/pipelines/creating_models.ipynb#W6sdnNjb2RlLXJlbW90ZQ%3D%3D?line=1'>2</a>\u001b[0m \u001b[39m\"\"\"Vanilla NeRF graph\"\"\"\u001b[39;00m\n\u001b[1;32m <a href='vscode-notebook-cell://ssh-remote%2Bbirman/shared/ethanweber/nerfactory/docs/tutorials/pipelines/creating_models.ipynb#W6sdnNjb2RlLXJlbW90ZQ%3D%3D?line=3'>4</a>\u001b[0m \u001b[39mdef\u001b[39;00m \u001b[39m__init__\u001b[39m(\u001b[39mself\u001b[39m, intrinsics\u001b[39m=\u001b[39m\u001b[39mNone\u001b[39;00m, camera_to_world\u001b[39m=\u001b[39m\u001b[39mNone\u001b[39;00m, \u001b[39m*\u001b[39m\u001b[39m*\u001b[39mkwargs) \u001b[39m-\u001b[39m\u001b[39m>\u001b[39m \u001b[39mNone\u001b[39;00m:\n",
"\u001b[0;31mNameError\u001b[0m: name 'Graph' is not defined"
]
}
],
"source": [
"class NeRFGraph(Graph):\n",
" \"\"\"Vanilla NeRF graph\"\"\"\n",
"\n",
" def __init__(self, intrinsics=None, camera_to_world=None, **kwargs) -> None:\n",
" super().__init__(intrinsics=intrinsics, camera_to_world=camera_to_world, **kwargs)\n",
"\n",
" def populate_fields(self):\n",
" \"\"\"\n",
" Set all field related modules here\n",
" \"\"\"\n",
"\n",
" def populate_misc_modules(self):\n",
" \"\"\"\n",
" Set all remaining modules here including: samplers, renderers, losses, and metrics\n",
" \"\"\"\n",
"\n",
" def get_param_groups(self) -> Dict[str, List[Parameter]]:\n",
" \"\"\"\n",
" Create a dictionary of parameters that are grouped according to different optimizers\n",
" \"\"\"\n",
"\n",
" def get_outputs(self, ray_bundle: RayBundle):\n",
" \"\"\"\n",
" Takes in a Ray Bundle and returns a dictionary of outputs.\n",
" \"\"\"\n",
"\n",
" def get_loss_dict(self, outputs, batch):\n",
" \"\"\"\n",
" Computes and returns the losses.\n",
" \"\"\"\n",
"\n",
" def log_test_image_outputs(self, image_idx, step, batch, outputs):\n",
" \"\"\"\n",
" Writes the test image outputs.\n",
" \"\"\""
]
},
{
"cell_type": "markdown",
"metadata": {},
"source": [
"### Creating the config\n",
"\n",
"Now that you have the graph and dataset all set up, you'll need to create the config that you pass into our run train routine. Our config system is powered by [Hydra](https://hydra.cc/). All Hydra and machine related arguments are stored in `configs/default_setup.yaml`, as well as the defaults list.\n",
"To set up the graph config, create a new yaml under `configs/`.\n",
"\n",
"```yaml\n",
"# configs/vanilla_nerf.yaml\n",
"\n",
"defaults:\n",
" - graph_default # inherit the basic yaml heirarchy\n",
" - _self_\n",
"\n",
"logging:\n",
" # <insert logging definitions here>\n",
"\n",
"trainer:\n",
" # <override configurations for loading/training/saving model here>\n",
"\n",
"experiment_name: blender_lego\n",
"method_name: vanilla_nerf\n",
"\n",
"data:\n",
" # <insert any dataset related overrides here>\n",
"\n",
"graph:\n",
" _target_: nerfactory.graph.vanilla_nerf.NeRFGraph # set the target to the graph you defined\n",
" # <insert any graph related overrides here>\n",
"\n",
"optimizers:\n",
" # <insert any optimizer related overrides here>\n",
"```\n",
"\n",
"### Training and testing\n",
"\n",
"Once you have the config properly set up, you can begin training! To begin the training process, just pass in the name of your new config to the training script:\n",
"\n",
"```bash\n",
"python scripts/run_train.py --config-name vanilla_nerf\n",
"```\n",
"\n",
"And now you have a brand-new NeRF in training! For testing and visualizing, simply refer to steps 4-5 in the [quickstart guide](https://github.com/plenoptix/nerfactory#quickstart).\n",
"\n",
"To help you get started, we also provide additional training tools such as profiling, logging, and debugging. Please refer to our [features guide](../../tooling/index.rst)."
]
}
],
"metadata": {
"kernelspec": {
"display_name": "Python 3.8.13 ('nerfactory')",
"language": "python",
"name": "python3"
},
"language_info": {
"codemirror_mode": {
"name": "ipython",
"version": 3
},
"file_extension": ".py",
"mimetype": "text/x-python",
"name": "python",
"nbconvert_exporter": "python",
"pygments_lexer": "ipython3",
"version": "3.8.13"
},
"orig_nbformat": 4,
"vscode": {
"interpreter": {
"hash": "e691f033e0f2f1b9c0a11e7e81375a1e27aec87a71fd1b1eaa545f7a5e61b3f6"
}
}
},
"nbformat": 4,
"nbformat_minor": 2
}
"cells": [
{
"cell_type": "markdown",
"metadata": {},
"source": [
"# Developing Custom Models\n",
"\n",
"In this quick tour, we will walk you through the core of training and building any NeRFs with nerfactory.\n",
"\n",
"The entry point for training starts at `scripts/train.py`, which spawns instances of our `Trainer()` class (in `engine/trainer.py`). The `Trainer()` is responsible for setting up the datasets and NeRF graph depending on the config specified. It will then run the usual train/val routine for a config-specified number of iterations. If you are planning on using our codebase to build a new NeRF method or to use an existing implementation, we've abstracted away the training routine in these two files and chances are you will not need to think of them again.\n",
"\n",
"### Graphs, Modules, and Fields\n",
"\n",
"If you are looking to implemnet a new NeRF method or extend an existing one, you may need to set up a new graph (in `graphs/`).\n",
"\n",
"All NeRF graph definitions can be found in `graphs/`. The graph encapsulates all the modules in the NeRF method- from the MLP's to the samplers to the losses and optimizers. All graphs are composed of modules and fields.\n",
"\n",
"### Modules\n",
"\n",
"We can decompose all graphs into respective modules. For instance, we have {ref}`optimizers` which contains modules related to the loss, {ref}`renderers` which contains all rendering modules, {`graph/modules/`}, which includes samplers and ray generators. Additionally, we have {ref}`field_modules`, which will be discussed below.\n",
"In general, modules can be thought of as individual component parts of the graph that can be swapped in/out. We provide most of the standard modules, but if you are creating a new NeRF graph, you may have to define new modules.\n",
"\n",
"### Fields\n",
"\n",
"{ref}`fields` represents the \"space\", aka. the radiance field of the NeRF. Here, we define the field as the part of the network that takes in point samples and any other conditioning, and outputs any of the `FieldHeadNames` (`nerf/field_modules/field_heads.py`).\n",
"\n",
"All fields are composed of modules continained within the `fields/` directory (e.g. `fields/modules/` or `fields/density_fields/`). We can think of field modules as modules that actually define or interact with the field.\n",
"\n",
"To build a NeRF field, we therefore follow these steps:\n",
"\n",
"1. define any relevant field modules\n",
"2. create a new class that extends the {ref}`fields` base class and use these field modules to compose the full field\n",
"3. implement the abstract functions `get_density()` and `get_outputs()`."
]
},
{
"cell_type": "code",
"execution_count": 1,
"metadata": {},
"outputs": [
{
"ename": "SyntaxError",
"evalue": "invalid syntax (383175768.py, line 4)",
"output_type": "error",
"traceback": [
"\u001b[0;36m Input \u001b[0;32mIn [1]\u001b[0;36m\u001b[0m\n\u001b[0;31m def __init__(self, ...) -> None:\u001b[0m\n\u001b[0m ^\u001b[0m\n\u001b[0;31mSyntaxError\u001b[0m\u001b[0;31m:\u001b[0m invalid syntax\n"
]
}
],
"source": [
"class NeRFField(Field):\n",
" \"\"\"NeRF Field\"\"\"\n",
"\n",
" def __init__(self, ...) -> None:\n",
" \"\"\"Create boilerplate NeRF field.\"\"\"\n",
"\n",
" super().__init__()\n",
"\n",
" # In the init method, we are instantiating all relevant field modules\n",
" self.position_encoding = position_encoding\n",
" self.direction_encoding = direction_encoding\n",
"\n",
" self.mlp_base = MLP(\n",
" in_dim=self.position_encoding.get_out_dim(),\n",
" num_layers=base_mlp_num_layers,\n",
" layer_width=base_mlp_layer_width,\n",
" skip_connections=skip_connections,\n",
" )\n",
" ...\n",
"\n",
" def get_density(self, point_samples: PointSamples):\n",
" \"\"\"\n",
" Computes and returns the densities.\n",
" \"\"\"\n",
"\n",
" def get_outputs(\n",
" self, point_samples: PointSamples, density_embedding: Optional[TensorType] = None\n",
" ) -> Dict[FieldHeadNames, TensorType]:\n",
" \"\"\"\n",
" Computes and returns the outputs.\n",
" \"\"\""
]
},
{
"cell_type": "markdown",
"metadata": {},
"source": [
"### Putting it together\n",
"\n",
"Now that we've gone over what modules and fields are, we are ready to create the graph!\n",
"\n",
"To implement the vanilla NeRF, we create a new class that inherits the abstract Graph class. Similar to composing a new field, we can pull from all pre-defined fields and modules and use them to compose a new Graph.\n",
"We will then need to define the following abstract methods as seen in the skeleton code below. See also `graphs/vanilla_nerf.py` for the full implementation."
]
},
{
"cell_type": "code",
"execution_count": 2,
"metadata": {},
"outputs": [
{
"ename": "NameError",
"evalue": "name 'Graph' is not defined",
"output_type": "error",
"traceback": [
"\u001b[0;31m---------------------------------------------------------------------------\u001b[0m",
"\u001b[0;31mNameError\u001b[0m Traceback (most recent call last)",
"\u001b[1;32m/shared/ethanweber/nerfactory/docs/tutorials/pipelines/creating_models.ipynb Cell 4\u001b[0m in \u001b[0;36m<cell line: 1>\u001b[0;34m()\u001b[0m\n\u001b[0;32m----> <a href='vscode-notebook-cell://ssh-remote%2Bbirman/shared/ethanweber/nerfactory/docs/tutorials/pipelines/creating_models.ipynb#W6sdnNjb2RlLXJlbW90ZQ%3D%3D?line=0'>1</a>\u001b[0m \u001b[39mclass\u001b[39;00m \u001b[39mNeRFGraph\u001b[39;00m(Graph):\n\u001b[1;32m <a href='vscode-notebook-cell://ssh-remote%2Bbirman/shared/ethanweber/nerfactory/docs/tutorials/pipelines/creating_models.ipynb#W6sdnNjb2RlLXJlbW90ZQ%3D%3D?line=1'>2</a>\u001b[0m \u001b[39m\"\"\"Vanilla NeRF graph\"\"\"\u001b[39;00m\n\u001b[1;32m <a href='vscode-notebook-cell://ssh-remote%2Bbirman/shared/ethanweber/nerfactory/docs/tutorials/pipelines/creating_models.ipynb#W6sdnNjb2RlLXJlbW90ZQ%3D%3D?line=3'>4</a>\u001b[0m \u001b[39mdef\u001b[39;00m \u001b[39m__init__\u001b[39m(\u001b[39mself\u001b[39m, intrinsics\u001b[39m=\u001b[39m\u001b[39mNone\u001b[39;00m, camera_to_world\u001b[39m=\u001b[39m\u001b[39mNone\u001b[39;00m, \u001b[39m*\u001b[39m\u001b[39m*\u001b[39mkwargs) \u001b[39m-\u001b[39m\u001b[39m>\u001b[39m \u001b[39mNone\u001b[39;00m:\n",
"\u001b[0;31mNameError\u001b[0m: name 'Graph' is not defined"
]
}
],
"source": [
"class NeRFGraph(Graph):\n",
" \"\"\"Vanilla NeRF graph\"\"\"\n",
"\n",
" def __init__(self, intrinsics=None, camera_to_world=None, **kwargs) -> None:\n",
" super().__init__(intrinsics=intrinsics, camera_to_world=camera_to_world, **kwargs)\n",
"\n",
" def populate_fields(self):\n",
" \"\"\"\n",
" Set all field related modules here\n",
" \"\"\"\n",
"\n",
" def populate_misc_modules(self):\n",
" \"\"\"\n",
" Set all remaining modules here including: samplers, renderers, losses, and metrics\n",
" \"\"\"\n",
"\n",
" def get_param_groups(self) -> Dict[str, List[Parameter]]:\n",
" \"\"\"\n",
" Create a dictionary of parameters that are grouped according to different optimizers\n",
" \"\"\"\n",
"\n",
" def get_outputs(self, ray_bundle: RayBundle):\n",
" \"\"\"\n",
" Takes in a Ray Bundle and returns a dictionary of outputs.\n",
" \"\"\"\n",
"\n",
" def get_loss_dict(self, outputs, batch):\n",
" \"\"\"\n",
" Computes and returns the losses.\n",
" \"\"\"\n",
"\n",
" def log_test_image_outputs(self, image_idx, step, batch, outputs):\n",
" \"\"\"\n",
" Writes the test image outputs.\n",
" \"\"\""
]
},
{
"cell_type": "markdown",
"metadata": {},
"source": [
"### Creating the config\n",
"\n",
"Now that you have the graph and dataset all set up, you'll need to create the config that you pass into our run train routine. Our config system is powered by [Hydra](https://hydra.cc/). All Hydra and machine related arguments are stored in `configs/default_setup.yaml`, as well as the defaults list.\n",
"To set up the graph config, create a new yaml under `configs/`.\n",
"\n",
"```yaml\n",
"# configs/vanilla_nerf.yaml\n",
"\n",
"defaults:\n",
" - graph_default # inherit the basic yaml heirarchy\n",
" - _self_\n",
"\n",
"logging:\n",
" # <insert logging definitions here>\n",
"\n",
"trainer:\n",
" # <override configurations for loading/training/saving model here>\n",
"\n",
"experiment_name: blender_lego\n",
"method_name: vanilla_nerf\n",
"\n",
"data:\n",
" # <insert any dataset related overrides here>\n",
"\n",
"graph:\n",
" _target_: nerfactory.graph.vanilla_nerf.NeRFGraph # set the target to the graph you defined\n",
" # <insert any graph related overrides here>\n",
"\n",
"optimizers:\n",
" # <insert any optimizer related overrides here>\n",
"```\n",
"\n",
"### Training and testing\n",
"\n",
"Once you have the config properly set up, you can begin training! To begin the training process, just pass in the name of your new config to the training script:\n",
"\n",
"```bash\n",
"python scripts/train.py --config-name vanilla_nerf\n",
"```\n",
"\n",
"And now you have a brand-new NeRF in training! For testing and visualizing, simply refer to steps 4-5 in the [quickstart guide](https://github.com/plenoptix/nerfactory#quickstart).\n",
"\n",
"To help you get started, we also provide additional training tools such as profiling, logging, and debugging. Please refer to our [features guide](../../tooling/index.rst)."
]
}
],
"metadata": {
"kernelspec": {
"display_name": "Python 3.8.13 ('nerfactory')",
"language": "python",
"name": "python3"
},
"language_info": {
"codemirror_mode": {
"name": "ipython",
"version": 3
},
"file_extension": ".py",
"mimetype": "text/x-python",
"name": "python",
"nbconvert_exporter": "python",
"pygments_lexer": "ipython3",
"version": "3.8.13"
},
"orig_nbformat": 4,
"vscode": {
"interpreter": {
"hash": "e691f033e0f2f1b9c0a11e7e81375a1e27aec87a71fd1b1eaa545f7a5e61b3f6"
}
}
},
"nbformat": 4,
"nbformat_minor": 2
}
docs/tutorials/quickstart.md
+6 -6
View File
@@ -68,19 +68,19 @@ To run with all the defaults, e.g. vanilla nerf method with the blender lego ima
Run a vanilla nerf model.
```bash
python scripts/run_train.py
python scripts/train.py
```
Run a faster version with instant ngp using tcnn (without the viewer).
```bash
python scripts/run_train.py --config-name=graph_instant_ngp.yaml
python scripts/train.py --config-name=graph_instant_ngp.yaml
```
Run with the viewer. However, you'll have to start the viewer server first. (See [viewer docs](../tutorials/viewer/viewer_quickstart.md))
```bash
python scripts/run_train.py --config-name=graph_instant_ngp.yaml viewer.enable=true
python scripts/train.py --config-name=graph_instant_ngp.yaml viewer.enable=true
```
With support for [Hydra](https://hydra.cc/), you can run with other configurations by changing appropriate configs defined in `configs/` or by setting flags via command-line arguments.
@@ -100,7 +100,7 @@ tensorboard --logdir outputs
To evaluate the trained NeRF, we provide an evaluation script that allows you to do benchmarking (see our [benchmarking workflow](../tooling/benchmarking.md)) or to render out the scene with a custom trajectory and save the output to a video.
```bash
python scripts/run_eval.py render-trajectory --load-config=outputs/blender_lego/instant_ngp/2022-07-07_230905/config.yml --traj=spiral --output-path=output.mp4
python scripts/eval.py render-trajectory --load-config=outputs/blender_lego/instant_ngp/2022-07-07_230905/config.yml --traj=spiral --output-path=output.mp4
```
Please note, this quickstart allows you to preform everything in a headless manner. We also provide a web-based viewer that allows you to easily monitor training or render out trajectories. See our [viewer docs](../tutorials/viewer/viewer_quickstart.md) for more.
@@ -142,7 +142,7 @@ python -m pip install --upgrade pip
#### Runtime errors, "len(sources) > 0".
When running `run_train.py `, an error occurs when installing cuda files in the backend code.
When running `train.py `, an error occurs when installing cuda files in the backend code.
**Solution**:
This is a problem with not being able to detect the correct CUDA version, and can be fixed by updating the CUDA path environment variables:
@@ -151,4 +151,4 @@ This is a problem with not being able to detect the correct CUDA version, and ca
export CUDA_HOME=/usr/local/cuda
export LD_LIBRARY_PATH=$LD_LIBRARY_PATH:/usr/local/cuda/lib64:/usr/local/cuda/extras/CUPTI/lib64
export PATH=$PATH:$CUDA_HOME/bin
```
```
docs/tutorials/viewer/for_developers.md
+3 -9
View File
@@ -2,12 +2,10 @@
The tutorial below shows you how to host the viewer yourself and how you can use it to visualize training.
#### Connection between nerfactory and the Bridge Server
In the center, we have the Bridge Server, which facilitates the connection between nerfactory code and the Client App. This server runs on the same machine that you are using nerfactory. It has a TCP Request/Reply (REQ/REP) connection that nerfactory can connect to with the Viewer object (left). We use [ZeroMQ](https://zeromq.org/), an open-sourced messaging library, to implement this lightweight TCP connection. The Viewer class can send commands to the Bridge Server and receive replies. The Bridge Server will either dispatch commands to the Client App via a websocket or it will return information stored in the Bridge Server state.
#### Connection between the Bridge Server and the Client App
The connection between the Bridge Server and the Client App works with WebSockets and WebRTC.
@@ -16,10 +14,8 @@ The connection between the Bridge Server and the Client App works with WebSocket
- **WebRTC connection** - We use WebRTC to stream images being rendered from nerfactory. The websocket connection if first used to establish the WebRTC connection. Then, the Client App constantly publishes camera pose information to the Bridge Server and stores the camera information (intrinsics and extrinsics). This information is then queried from the nerfactory code, used to render an image with some Graph, and then the image is send over the TCP connection and dispatched via WebRTC to render the stream of images.
## Getting started
#### Running the Bridge Server
The viewer server runs on the same machine that you use for training. The training code will connect to the server with a lightweight TCP connection.
@@ -35,7 +31,6 @@ It should print out something of the form:
"ZMQWebSocketBridge using zmq_url=tcp://127.0.0.1:6000 and websocket_port=8051"
```
#### Running the Client App
> We will host the viewer online in the future, but for now we have to run it locally.
@@ -67,6 +62,7 @@ yarn start
```
Forward port and open in your local browser. The URL takes the following form, `http://localhost:<forwarded_react_port>?localhost:<forwarded_backend_tcp_port>`. Notice the "?" character.
- http://localhost:4000?localhost:8051
Possibly edit the port in `app/.env.development` file with the following to adjust the PORT, for example.
@@ -79,18 +75,16 @@ PORT=4000
ESLINT_NO_DEV_ERRORS=true
```
#### Running the nerfactory Code
You can now simply run a training job and visualize progress by enabling the viewer during training:
```bash
python scripts/run_train.py --config-name=graph_instant_ngp.yaml viewer.enable=true
python scripts/train.py --config-name=graph_instant_ngp.yaml viewer.enable=true
```
- **Notebook demo** - See [Programming the viewer](viewer_notebook.ipynb) for an overview for how to interact with the viewer with the Viewer object from nerfactory.
## Acknowledgements and references
We thank [Robin Deits](https://github.com/rdeits) and other contributors to the following repos, which we've started with and modified and extended for our use.
@@ -106,4 +100,4 @@ Here are other resources that we've used and/or have found helpful while buildin
```
```
```
docs/tutorials/viewer/viewer_quickstart.md
+1 -1
View File
@@ -12,7 +12,7 @@ The viewer is built using [ThreeJS](https://threejs.org/) and packaged into a [R
2. Run training script with viewer enabled. Note that you should only use the viewer with a fast pipeline, such as instant ngp.
```shell
python scripts/run_train.py --config-name=graph_instant_ngp.yaml viewer.enable=True
python scripts/train.py --config-name=graph_instant_ngp.yaml viewer.enable=True
```
This pulls up a hosted web-viewer which is the fastest way to get started with visualizing your nerfactory training progress!